Créer des journaux d'audit de sauvegarde et de restauration

Cette page explique comment installer et configurer les composants nécessaires pour créer une sauvegarde. Elle explique également comment restaurer et récupérer l'accès aux journaux d'audit historiques à partir de la sauvegarde.

Remarque : Remplacez PROJECT_NAMESPACE par l'espace de noms de votre projet tout au long de ce document.

Configurer une sauvegarde dans un bucket distant

Cette section explique comment créer une sauvegarde des journaux d'audit dans un bucket compatible avec S3.

Avant de commencer

Avant de pouvoir créer une sauvegarde de vos journaux d'audit, vous devez avoir accès aux ressources suivantes :

• Un bucket S3 distant avec un point de terminaison, une clé d'accès secrète et un ID de clé d'accès.
• Certificat d'autorité de certification (CA) pour le système de stockage.
• Un cluster opérationnel.

Obtenir les identifiants pour accéder au bucket source

Suivez les étapes ci-dessous pour trouver les identifiants du bucket contenant les journaux d'audit :

1. Sur le cluster d'administrateur racine, listez les buckets dans l'espace de noms de votre projet :

   kubectl get bucket -n PROJECT_NAMESPACE
   

   Le résultat doit ressembler à l'exemple suivant, où les buckets de journaux d'audit affichent un nom et un point de terminaison :

   NAME                          BUCKET NAME                   DESCRIPTION                                                         STORAGE CLASS   FULLY-QUALIFIED-BUCKET-NAME         ENDPOINT                                       REGION   BUCKETREADY   REASON                    MESSAGE
   audit-logs-loki-all           audit-logs-loki-all           Bucket for storing audit-logs-loki-all logs                         Standard        wwq2y-audit-logs-loki-all           https://appliance-objectstorage.zone1.google.gdch.test   zone1    True          BucketCreationSucceeded   Bucket successfully created.
   cortex-metrics-alertmanager   cortex-metrics-alertmanager   storage bucket for cortex metrics alertmanager configuration data   Standard        wwq2y-cortex-metrics-alertmanager   https://appliance-objectstorage.zone1.google.gdch.test   zone1    True          BucketCreationSucceeded   Bucket successfully created.
   cortex-metrics-blocks         cortex-metrics-blocks         storage bucket for cortex metrics data                              Standard        wwq2y-cortex-metrics-blocks         https://appliance-objectstorage.zone1.google.gdch.test   zone1    True          BucketCreationSucceeded   Bucket successfully created.
   cortex-metrics-ruler          cortex-metrics-ruler          storage bucket for cortex metrics rules data                        Standard        wwq2y-cortex-metrics-ruler          https://appliance-objectstorage.zone1.google.gdch.test   zone1    True          BucketCreationSucceeded   Bucket successfully created.
   ops-logs-loki-all             ops-logs-loki-all             Bucket for storing ops-logs-loki-all logs                           Standard        wwq2y-ops-logs-loki-all             https://appliance-objectstorage.zone1.google.gdch.test```
   

2. À l'aide des informations de la sortie que vous avez obtenue, définissez les variables d'environnement suivantes pour le transfert :

   SRC_BUCKET= BUCKET_NAME
   SRC_ENDPOINT = ENDPOINT
   SRC_PATH= FULLY_QUALIFIED_BUCKET_NAME
   

   Remplacez les éléments suivants :

   • BUCKET_NAME : nom du bucket contenant les journaux d'audit pour lesquels vous souhaitez créer la sauvegarde. Cette valeur se trouve dans le champ BUCKET NAME de la sortie.
   • ENDPOINT : point de terminaison du bucket contenant les journaux d'audit pour lesquels vous souhaitez créer la sauvegarde. Cette valeur se trouve dans le champ ENDPOINT de la sortie.
   • FULLY_QUALIFIED_BUCKET_NAME : nom complet du bucket contenant les journaux d'audit pour lesquels vous souhaitez créer la sauvegarde. Cette valeur se trouve dans le champ FULLY-QUALIFIED-BUCKET-NAME de la sortie.

3. Obtenez le secret du bucket que vous avez sélectionné à l'étape précédente :

   kubectl get secret -n PROJECT_NAMESPACE -o json| jq --arg jq_src $SRC_BUCKET '.items[].metadata|select(.annotations."object.gdc.goog/subject"==$jq_src)|.name'
   

   Le résultat doit ressembler à l'exemple suivant, où le nom secret du bucket est affiché :

   "object-storage-key-sysstd-sa-olxv4dnwrwul4bshu37ikebgovrnvl773owaw3arx225rfi56swa"
   

4. À l'aide du nom secret obtenu dans le résultat, définissez la variable d'environnement suivante :

   SRC_CREDENTIALS="PROJECT_NAMESPACE/SECRET_NAME"
   

   Remplacez SECRET_NAME par le nom du secret que vous avez obtenu dans le résultat précédent.

5. Créez le secret pour le certificat CA du système de stockage :

   kubectl create secret generic -n PROJECT_NAMESPACE audit-log-loki-ca \
   --from-literal=ca.crt=CERTIFICATE
   

   Remplacez CERTIFICATE par le certificat d'autorité de certification du système de stockage.

6. Définissez la variable d'environnement suivante :

   SRC_CA_CERTIFICATE=PROJECT_NAMESPACE/audit-log-loki-ca
   

Obtenir les identifiants pour accéder au bucket distant

Suivez les étapes ci-dessous pour trouver les identifiants du bucket dans lequel vous souhaitez créer la sauvegarde :

1. Définissez les variables d'environnement suivantes :

   DST_ACCESS_KEY_ID= ACCESS_KEY
   DST_SECRET_ACCESS_KEY= ACCESS_SECRET
   DST_ENDPOINT= REMOTE_ENDPOINT
   DST_PATH= REMOTE_BUCKET_NAME
   

   Remplacez les éléments suivants :

   • ACCESS_KEY : clé d'accès au bucket distant de destination.
   • ACCESS_SECRET : secret d'accès au bucket distant de destination.
   • REMOTE_ENDPOINT : point de terminaison du bucket distant de destination.
   • REMOTE_BUCKET_NAME : nom du bucket distant de destination.

2. Créez un secret pour le bucket distant :

   kubectl create secret generic -n PROJECT_NAMESPACE s3-bucket-credentials \
     --from-literal=access-key-id=$DST_ACCESS_KEY_ID \
     --from-literal=secret-access-key=$DST_SECRET_ACCESS_KEY
   

3. Définissez la variable d'environnement suivante avec l'emplacement du secret :

   DST_CREDENTIALS=PROJECT_NAMESPACE/s3-bucket-credentials
   

4. Si le bucket de destination nécessite la configuration d'un certificat CA, créez un secret avec le certificat CA du bucket :

   kubectl create secret generic -n PROJECT_NAMESPACE s3-bucket-ca \
   --from-literal=ca.crt=REMOTE_CERTIFICATE
   

   Remplacez REMOTE_CERTIFICATE par le certificat d'autorité de certification du bucket distant de destination.

5. Définissez la variable d'environnement suivante avec l'emplacement du certificat :

   DST_CA_CERTIFICATE=PROJECT_NAMESPACE/s3-bucket-ca
   

Configurer le transfert des journaux d'audit

Suivez les étapes ci-dessous pour configurer le transfert des journaux d'audit du bucket source vers le bucket de destination pour la sauvegarde :

1. Créez un compte de service pour le job de transfert des journaux d'audit. Vous devez autoriser le compte de service à lire le bucket source et les secrets dans l'espace de noms du projet.

   kubectl apply -f - <<EOF
   ---
   apiVersion: v1
   kind: ServiceAccount
   metadata:
     name: audit-log-transfer-sa
     namespace: PROJECT_NAMESPACE
   ---
   apiVersion: rbac.authorization.k8s.io/v1
   kind: Role
   metadata:
     name: read-secrets-role
     namespace: PROJECT_NAMESPACE
   rules:
   - apiGroups: [""]
     resources: ["secrets"]
     verbs: ["get", "watch", "list"]
   ---
   apiVersion: rbac.authorization.k8s.io/v1
   kind: RoleBinding
   metadata:
     name: read-secrets-rolebinding
     namespace: PROJECT_NAMESPACE
   subjects:
   - kind: ServiceAccount
     name: audit-log-transfer-sa
     namespace: PROJECT_NAMESPACE
   roleRef:
     kind: Role
     name: read-secrets-role
     apiGroup: rbac.authorization.k8s.io
   ---
   apiVersion: rbac.authorization.k8s.io/v1
   kind: Role
   metadata:
     name: audit-log-read-bucket-role
     namespace: PROJECT_NAMESPACE
   rules:
   - apiGroups:
     - object.gdc.goog
     resourceNames:
     - $SRC_BUCKET # Source bucket name
     resources:
     - buckets
     verbs:
     - read-object
   ---
   apiVersion: rbac.authorization.k8s.io/v1
   kind: RoleBinding
   metadata:
     name: audit-log-transfer-role-binding
     namespace: PROJECT_NAMESPACE
   roleRef:
     apiGroup: rbac.authorization.k8s.io
     kind: Role
     name: audit-log-read-bucket-role
   subjects:
   - kind: ServiceAccount
     name: audit-log-transfer-sa
     namespace: PROJECT_NAMESPACE
   ---
   EOF
   

2. Créez une tâche de transfert pour exporter les journaux vers le bucket distant :

   kubectl apply -f - <<EOF
   ---
   apiVersion: batch/v1
   kind: Job
   metadata:
     name: audit-log-transfer-job
     namespace: PROJECT_NAMESPACE
   spec:
     template:
       spec:
         serviceAccountName: audit-log-transfer-sa
         containers:
           - name: storage-transfer-pod
             image: gcr.io/private-cloud-staging/storage-transfer:latest
             imagePullPolicy: Always
             command:
               - /storage-transfer
             args:
               - '--src_endpoint=$SRC_ENDPOINT
               - '--dst_endpoint=$DST_ENDPOINT
               - '--src_path=\$SRC_PATH
               - '--dst_path=\$DST_PATH
               - '--src_credentials=$SRC_CREDENTIALS
               - '--dst_credentials=$DST_CREDENTIALS
               - '--dst_ca_certificate_reference=$DST_CA_CERTIFICATE # Optional. Based on destination type.
               - '--src_ca_certificate_reference=$SRC_CA_CERTIFICATE
               - '--src_type=s3'
               - '--dst_type=s3'
               - '--bandwidth_limit=100M' # Optional of the form '10K', '100M', '1G' bytes per second
         restartPolicy: OnFailure # Will restart on failure.
   ---
   EOF
   

Une fois la tâche planifiée, vous pouvez surveiller le transfert de vos données en fournissant le nom de la tâche sous la forme audit-log-transfer-job et l'espace de noms de votre projet.

Le job se termine lorsque toutes les données ont été transférées vers le bucket de destination.

Restaurer les journaux d'audit à partir de la sauvegarde

Cette section décrit la procédure de restauration des journaux d'audit à partir de la sauvegarde.

Avant de commencer

Avant de pouvoir restaurer vos journaux d'audit, vous devez avoir accès aux ressources suivantes :

• Bucket de sauvegarde des journaux d'audit avec un point de terminaison, une clé d'accès secrète et un ID de clé d'accès.
• Certificat d'autorité de certification (CA) pour le système de stockage.
• Un cluster opérationnel.

Créer un bucket pour restaurer les journaux d'audit

Pour créer un bucket dans lequel stocker les journaux d'audit restaurés, procédez comme suit :

1. Créez la ressource de bucket et le compte de service :

   kubectl apply -f - <<EOF
   ---
   apiVersion: object.gdc.goog/v1
   kind: Bucket
   metadata:
     annotations:
       object.gdc.goog/audit-logs: IO
     labels:
       logging.private.gdch.goog/loggingpipeline-name: default
     name: audit-logs-loki-restore
     namespace: PROJECT_NAMESPACE
   spec:
     bucketPolicy:
       lockingPolicy:
         defaultObjectRetentionDays: 1
     description: Bucket for storing audit-logs-loki logs restore
     storageClass: Standard
   ---
   apiVersion: rbac.authorization.k8s.io/v1
   kind: Role
   metadata:
     name: audit-logs-loki-restore-buckets-role
     namespace: PROJECT_NAMESPACE
   rules:
   - apiGroups:
     - object.gdc.goog
     resourceNames:
     - audit-logs-loki-restore
     resources:
     - buckets
     verbs:
     - read-object
     - write-object
   ---
   apiVersion: v1
   automountServiceAccountToken: false
   kind: ServiceAccount
   metadata:
     labels:
       logging.private.gdch.goog/loggingpipeline-name: default
     name: audit-logs-loki-restore-sa
     namespace: PROJECT_NAMESPACE
   ---
   apiVersion: rbac.authorization.k8s.io/v1
   kind: RoleBinding
   metadata:
     name: audit-logs-loki-restore
     namespace: PROJECT_NAMESPACE
   roleRef:
     apiGroup: rbac.authorization.k8s.io
     kind: Role
     name: audit-logs-loki-restore-buckets-role
   subjects:
   - kind: ServiceAccount
     name: audit-logs-loki-restore-sa
     namespace: PROJECT_NAMESPACE
   EOF
   

   Le bucket et le secret sont créés.

2. Affichez le bucket créé :

   kubectl get bucket audit-logs-loki-restore -n PROJECT_NAMESPACE
   

   Le résultat doit ressembler à l'exemple ci-dessous. La création du bucket peut prendre quelques minutes.

   NAME                      BUCKET NAME               DESCRIPTION                                       STORAGE CLASS   FULLY-QUALIFIED-BUCKET-NAME     ENDPOINT                                       REGION   BUCKETREADY   REASON                    MESSAGE
   audit-logs-loki-restore   audit-logs-loki-restore   Bucket for storing audit-logs-loki logs restore   Standard        dzbl6-audit-logs-loki-restore   https://objectstorage.zone1.google.gdch.test   zone1    True          BucketCreationSucceeded   Bucket successfully created.
   

   Le résultat doit afficher le bucket que vous avez créé. La création du bucket peut prendre quelques minutes.

3. À l'aide des informations de la sortie que vous avez obtenue, définissez les variables d'environnement suivantes :

   DST_BUCKET= RESTORE_BUCKET_NAME
   DST_ENDPOINT = RESTORE_ENDPOINT
   DST_PATH= RESTORE_FULLY_QUALIFIED_BUCKET_NAME
   

   Remplacez les éléments suivants :

   • RESTORE_BUCKET_NAME : nom du bucket pour la restauration des journaux d'audit. Cette valeur se trouve dans le champ BUCKET NAME de la sortie.
   • RESTORE_ENDPOINT : point de terminaison du bucket pour la restauration des journaux d'audit. Cette valeur se trouve dans le champ ENDPOINT de la sortie.
   • RESTORE_FULLY_QUALIFIED_BUCKET_NAME : nom complet du bucket pour la restauration des journaux d'audit. Cette valeur se trouve dans le champ FULLY-QUALIFIED-BUCKET-NAME de la sortie.

4. Récupérez le secret du bucket créé :

   kubectl get secret -n PROJECT_NAMESPACE -o json| jq --arg jq_src $DST_BUCKET '.items[].metadata|select(.annotations."object.gdc.goog/subject"==$jq_src)|.name'
   

   Le résultat doit ressembler à l'exemple suivant, où le nom secret du bucket est affiché :

   "object-storage-key-sysstd-sa-olxv4dnwrwul4bshu37ikebgovrnvl773owaw3arx225rfi56swa"
   

5. À l'aide du nom secret obtenu dans le résultat, définissez les variables d'environnement suivantes :

   DST_SECRET_NAME=RESTORE_SECRET_NAME
   DST_CREDENTIALS="PROJECT_NAMESPACE/RESTORE_SECRET_NAME"
   

   Remplacez RESTORE_SECRET_NAME par le nom du secret que vous avez obtenu dans le résultat précédent.

6. Créez le secret pour le certificat CA du système de stockage :

   kubectl create secret generic -n PROJECT_NAMESPACE audit-log-loki-restore-ca \
   --from-literal=ca.crt=CERTIFICATE
   

   Remplacez CERTIFICATE par le certificat d'autorité de certification du système de stockage.

7. Définissez la variable d'environnement suivante pour l'emplacement du certificat :

   DST_CA_CERTIFICATE=PROJECT_NAMESPACE/audit-log-loki-restore-ca
   

Obtenir les identifiants pour accéder au bucket de sauvegarde

Suivez les étapes ci-dessous pour trouver les identifiants du bucket contenant la sauvegarde des journaux d'audit :

1. Définissez les variables d'environnement suivantes :

   SRC_ACCESS_KEY_ID= ACCESS_KEY
   SRC_SECRET_ACCESS_KEY= ACCESS_SECRET
   SRC_ENDPOINT= REMOTE_ENDPOINT
   SRC_PATH= REMOTE_BUCKET_NAME
   

   Remplacez les éléments suivants :

   • ACCESS_KEY : clé d'accès au bucket de sauvegarde.
   • ACCESS_SECRET : secret d'accès au bucket de sauvegarde.
   • REMOTE_ENDPOINT : point de terminaison du bucket de sauvegarde.
   • REMOTE_BUCKET_NAME : nom du bucket de sauvegarde.

2. Créez un secret pour le bucket de sauvegarde :

   kubectl create secret generic -n PROJECT_NAMESPACE s3-backup-bucket-credentials \
     --from-literal=access-key-id=$SRC_ACCESS_KEY_ID \
     --from-literal=secret-access-key=$SRC_SECRET_ACCESS_KEY
   

3. Définissez la variable d'environnement suivante avec l'emplacement du secret :

   SRC_CREDENTIALS=PROJECT_NAMESPACE/s3-backup-bucket-credentials
   

4. Créez un secret avec le certificat CA du bucket :

   kubectl create secret generic -n PROJECT_NAMESPACE s3-backup-bucket-ca \
   --from-literal=ca.crt=BACKUP_CERTIFICATE
   

   Remplacez BACKUP_CERTIFICATE par le certificat d'autorité de certification du bucket de sauvegarde.

5. Définissez la variable d'environnement suivante avec l'emplacement du certificat :

   SRC_CA_CERTIFICATE=PROJECT_NAMESPACE/s3-backup-bucket-ca
   

Configurer la restauration des journaux d'audit

Pour configurer le transfert des journaux d'audit du bucket de sauvegarde vers le bucket de restauration, procédez comme suit :

1. Créez un compte de service pour le job de transfert des journaux d'audit. Vous devez autoriser le compte de service à lire et à écrire dans le bucket et les secrets de l'espace de noms du projet.

   kubectl apply -f - <<EOF
   ---
   apiVersion: v1
   kind: ServiceAccount
   metadata:
     name: audit-log-restore-sa
     namespace: PROJECT_NAMESPACE
   ---
   apiVersion: rbac.authorization.k8s.io/v1
   kind: Role
   metadata:
     name: read-secrets-role
     namespace: PROJECT_NAMESPACE
   rules:
   - apiGroups: [""]
     resources: ["secrets"]
     verbs: ["get", "watch", "list"]
   ---
   apiVersion: rbac.authorization.k8s.io/v1
   kind: RoleBinding
   metadata:
     name: read-secrets-rolebinding-restore
     namespace: PROJECT_NAMESPACE
   subjects:
   - kind: ServiceAccount
     name: audit-log-restore-sa
     namespace: PROJECT_NAMESPACE
   roleRef:
     kind: Role
     name: read-secrets-role
     apiGroup: rbac.authorization.k8s.io
   ---
   apiVersion: rbac.authorization.k8s.io/v1
   kind: Role
   metadata:
     name: audit-log-restore-bucket-role
     namespace: PROJECT_NAMESPACE
   rules:
   - apiGroups:
     - object.gdc.goog
     resourceNames:
     - $DST_BUCKET # Source bucket name
     resources:
     - buckets
     verbs:
     - read-object
     - write-object
   ---
   apiVersion: rbac.authorization.k8s.io/v1
   kind: RoleBinding
   metadata:
     name: audit-log-restore-role-binding
     namespace: PROJECT_NAMESPACE
   roleRef:
     apiGroup: rbac.authorization.k8s.io
     kind: Role
     name: audit-log-restore-bucket-role
   subjects:
   - kind: ServiceAccount
     name: audit-log-restore-sa
     namespace: PROJECT_NAMESPACE
   ---
   EOF
   

2. Créez un job de transfert pour restaurer les journaux à partir du bucket de sauvegarde distant :

   kubectl apply -f - <<EOF
   ---
   apiVersion: batch/v1
   kind: Job
   metadata:
     name: audit-log-restore-job
     namespace: PROJECT_NAMESPACE
   spec:
     template:
       spec:
         serviceAccountName: audit-log-restore-sa
         containers:
           - name: storage-transfer-pod
             image: gcr.io/private-cloud-staging/storage-transfer:latest
             imagePullPolicy: Always
             command:
               - /storage-transfer
             args:
               - '--src_endpoint=$SRC_ENDPOINT
               - '--dst_endpoint=$DST_ENDPOINT
               - '--src_path=\$SRC_PATH
               - '--dst_path=\$DST_PATH
               - '--src_credentials=$SRC_CREDENTIALS
               - '--dst_credentials=$DST_CREDENTIALS
               - '--dst_ca_certificate_reference=$DST_CA_CERTIFICATE
               - '--src_ca_certificate_reference=$SRC_CA_CERTIFICATE # Optional. Based on destination type
               - '--src_type=s3'
               - '--dst_type=s3'
               - '--bandwidth_limit=100M' # Optional of the form '10K', '100M', '1G' bytes per second
         restartPolicy: OnFailure # Will restart on failure.
   ---
   EOF
   

Une fois la tâche planifiée, vous pouvez surveiller le transfert de vos données en fournissant le nom de la tâche sous la forme audit-log-restore-job et l'espace de noms de votre projet.

Le job se termine lorsque toutes les données ont été transférées vers le bucket de destination.

Déployer une instance de journal d'audit pour accéder aux journaux

Vous devez déployer une instance Loki, également appelée instance de journaux d'audit, pour accéder aux journaux restaurés.

Pour configurer l'instance de journal d'audit, utilisez le compte de service audit-log-restore-sa que vous avez créé pour le job de restauration. Pour déployer l'instance, procédez comme suit :

1. Créez un objet ConfigMap pour la configuration de l'instance :

   kubectl apply -f - <<EOF
   apiVersion: v1
   kind: ConfigMap
   metadata:
     name: audit-logs-loki-restore
     namespace: PROJECT_NAMESPACE
   data:
     loki.yaml: |-
       auth_enabled: true
       common:
         ring:
           kvstore:
             store: inmemory
       chunk_store_config:
         max_look_back_period: 0s
       compactor:
         shared_store: s3
         working_directory: /data/loki/boltdb-shipper-compactor
         compaction_interval: 10m
         retention_enabled: true
         retention_delete_delay: 2h
         retention_delete_worker_count: 150
       ingester:
         chunk_target_size: 1572864
         chunk_encoding: snappy
         max_chunk_age: 2h
         chunk_idle_period: 90m
         chunk_retain_period: 30s
         autoforget_unhealthy: true
         lifecycler:
           ring:
             kvstore:
               store: inmemory
             replication_factor: 1
             heartbeat_timeout: 10m
         max_transfer_retries: 0
         wal:
           enabled: true
           flush_on_shutdown: true
           dir: /wal
           checkpoint_duration: 1m
           replay_memory_ceiling: 20GB
       limits_config:
         retention_period: 48h
         enforce_metric_name: false
         reject_old_samples: false
         ingestion_rate_mb: 256
         ingestion_burst_size_mb: 256
         max_streams_per_user: 20000
         max_global_streams_per_user: 20000
         per_stream_rate_limit: 256MB
         per_stream_rate_limit_burst: 256MB
         shard_streams:
           enabled: false
           desired_rate: 3MB
       schema_config:
         configs:
         - from: "2020-10-24"
           index:
             period: 24h
             prefix: index_
           object_store: s3
           schema: v11
           store: boltdb-shipper
       server:
         http_listen_port: 3100
         grpc_server_max_recv_msg_size: 104857600
         grpc_server_max_send_msg_size: 104857600
       analytics:
         reporting_enabled: false
       storage_config:
         boltdb_shipper:
           active_index_directory: /data/loki/boltdb-shipper-active
           cache_location: /data/loki/boltdb-shipper-cache
           cache_ttl: 24h
           shared_store: s3
         aws:
           endpoint: $DST_ENDPOINT
           bucketnames: $DST_PATH
           access_key_id: ${S3_ACCESS_KEY_ID}
           secret_access_key: ${S3_SECRET_ACCESS_KEY}
           s3forcepathstyle: true
   EOF
   

2. Déployez l'instance avec un service permettant d'accéder aux journaux du bucket de restauration :

   kubectl apply -f - <<EOF
   ---
   apiVersion: apps/v1
   kind: StatefulSet
   metadata:
     labels:
       app: audit-logs-loki-restore
       logging.private.gdch.goog/loggingpipeline-name: default
     name: audit-logs-loki-restore
     namespace: PROJECT_NAMESPACE
   spec:
     persistentVolumeClaimRetentionPolicy:
       whenDeleted: Retain
       whenScaled: Retain
     podManagementPolicy: OrderedReady
     replicas: 1
     revisionHistoryLimit: 10
     selector:
       matchLabels:
         app: audit-logs-loki-restore
     serviceName: audit-logs-loki-restore
     template:
       metadata:
         labels:
           app: audit-logs-loki-restore
           app.kubernetes.io/part-of: audit-logs-loki-restore
           egress.networking.gke.io/enabled: "true"
           istio.io/rev: default
           logging.private.gdch.goog/log-type: audit
       spec:
         affinity:
           nodeAffinity:
             preferredDuringSchedulingIgnoredDuringExecution:
             - preference:
                 matchExpressions:
                 - key: node-role.kubernetes.io/control-plane
                   operator: DoesNotExist
                 - key: node-role.kubernetes.io/master
                   operator: DoesNotExist
               weight: 1
           podAntiAffinity:
             preferredDuringSchedulingIgnoredDuringExecution:
             - podAffinityTerm:
                 labelSelector:
                   matchExpressions:
                   - key: app
                     operator: In
                     values:
                     - audit-logs-loki-restore
                 topologyKey: kubernetes.io/hostname
               weight: 100
         containers:
         - args:
           - -config.file=/etc/loki/loki.yaml
           - -config.expand-env=true
           - -target=all
           env:
           - name: S3_ACCESS_KEY_ID
             valueFrom:
               secretKeyRef:
                 key: access-key-id
                 name: $DST_SECRET_NAME
                 optional: false
           - name: S3_SECRET_ACCESS_KEY
             valueFrom:
                 secretKeyRef:
                   key: secret-access-key
                   name: $DST_SECRET_NAME
                   optional: false
           image: gcr.io/private-cloud-staging/loki:v2.8.4-gke.2
           imagePullPolicy: Always
           livenessProbe:
             failureThreshold: 3
             httpGet:
               path: /ready
               port: http-metrics
               scheme: HTTP
             initialDelaySeconds: 330
             periodSeconds: 10
             successThreshold: 1
             timeoutSeconds: 1
           name: audit-logs-loki-restore
           ports:
           - containerPort: 3100
             name: http-metrics
             protocol: TCP
           - containerPort: 7946
             name: gossip-ring
             protocol: TCP
           readinessProbe:
             failureThreshold: 3
             httpGet:
               path: /ready
               port: http-metrics
               scheme: HTTP
             initialDelaySeconds: 45
             periodSeconds: 10
             successThreshold: 1
             timeoutSeconds: 1
           resources:
             limits:
               ephemeral-storage: 2000Mi
               memory: 8000Mi
             requests:
               cpu: 300m
               ephemeral-storage: 2000Mi
               memory: 1000Mi
           securityContext:
             readOnlyRootFilesystem: true
           terminationMessagePath: /dev/termination-log
           terminationMessagePolicy: File
           volumeMounts:
           - mountPath: /etc/loki
             name: config
           - mountPath: /data
             name: loki-storage
           - mountPath: /tmp
             name: temp
           - mountPath: /tmp/loki/rules-temp
             name: tmprulepath
           - mountPath: /etc/ssl/certs/storage-cert.crt
             name: storage-cert
             subPath: ca.crt
           - mountPath: /wal
             name: loki-storage
         dnsPolicy: ClusterFirst
         priorityClassName: audit-logs-loki-priority
         restartPolicy: Always
         schedulerName: default-scheduler
         securityContext:
           fsGroup: 10001
           runAsGroup: 10001
           runAsUser: 10001
         serviceAccount: audit-logs-loki-restore-sa
         serviceAccountName: audit-logs-loki-restore-sa
         terminationGracePeriodSeconds: 4800
         volumes:
         - emptyDir: {}
           name: temp
         - configMap:
             defaultMode: 420
             name: audit-logs-loki-restore
           name: config
         - emptyDir: {}
           name: tmprulepath
         - name: storage-cert
           secret:
             defaultMode: 420
             secretName: web-tls
     updateStrategy:
       type: RollingUpdate
     volumeClaimTemplates:
     - apiVersion: v1
       kind: PersistentVolumeClaim
       metadata:
         creationTimestamp: null
         name: loki-storage
       spec:
         accessModes:
         - ReadWriteOnce
         resources:
           requests:
             storage: 50Gi
         storageClassName: standard-rwo
         volumeMode: Filesystem
   ---
   apiVersion: v1
   kind: Service
   metadata:
     name: audit-logs-loki-restore
     namespace: PROJECT_NAMESPACE
   spec:
     internalTrafficPolicy: Cluster
     ipFamilies:
     - IPv4
     ipFamilyPolicy: SingleStack
     ports:
     - name: http-metrics
       port: 3100
       protocol: TCP
       targetPort: http-metrics
     selector:
       app: audit-logs-loki-restore
     sessionAffinity: None
     type: ClusterIP
   ---
   EOF
   

Configurer l'instance de surveillance pour afficher les journaux de la source de données

Remarque : Le système peut rétablir la configuration de l'instance de journaux d'audit en tant que source de données.

Suivez les étapes ci-dessous pour configurer Grafana, également appelé instance de surveillance, afin d'afficher les journaux d'audit restaurés à partir de l'instance de journaux d'audit :

1. Accédez au point de terminaison de l'instance de surveillance de votre projet.
2. Dans le menu de navigation de l'interface utilisateur, cliquez sur Administration > Sources de données.
3. Cliquez sur Ajouter une source de données.
4. Sur la page Ajouter une source de données, sélectionnez Loki.
5. Sur la page Paramètres, saisissez Audit Logs - Restore comme valeur pour le champ Nom.

6. Dans la section HTTP, saisissez la valeur suivante dans le champ URL :

   http://audit-logs-loki-restore.PROJECT_NAMESPACE.svc:3100
   

7. Dans la section En-têtes HTTP personnalisés, saisissez les valeurs suivantes dans les champs correspondants :

   • Header: X-Scope-OrgID
   • Valeur : infra-obs

Dans la figure 1, Loki est affiché comme option sur la page Ajouter une source de données de l'interface utilisateur de l'instance de surveillance. Sur la page Paramètres de la figure 2, vous trouverez les champs à remplir pour configurer la source de données.

Figure 1 : Page Ajouter une source de données dans l'UI de l'instance de surveillance.

Figure 2. Page Paramètres de l'interface utilisateur de l'instance de surveillance.

L'option Audit Logs - Restore est désormais disponible en tant que source de données dans l'explorateur de journaux.