Creare audit log di backup e ripristino

I backup degli audit log nell'appliance Google Distributed Cloud (GDC) con air gap conservano i record storici nei bucket di archiviazione remoti per la conformità, l'analisi della sicurezza e il disaster recovery. Configura le credenziali del bucket remoto e i job di trasferimento per eseguire il backup degli audit log o esegui il deployment di un'istanza di ripristino per eseguire query sui log recuperati in Grafana.

Prima di iniziare

Assicurati di avere accesso alle seguenti risorse:

  • Un bucket remoto per i backup con un endpoint, una chiave di accesso segreta e un ID della chiave di accesso.
  • Un certificato dell'autorità di certificazione (CA) per il sistema di archiviazione.
  • Un cluster Kubernetes funzionante.

Per ottenere le autorizzazioni necessarie per gestire i backup, chiedi all'amministratore IAM del progetto di concederti uno dei seguenti ruoli nello spazio dei nomi del progetto:

  • Audit Logs Platform Restore Bucket Creator
  • Audit Logs Platform Bucket Viewer

A seconda del livello di accesso e delle autorizzazioni di cui hai bisogno, potresti ottenere ruoli di creator o visualizzatore per le risorse dei bucket di backup nello spazio dei nomi del progetto. Per saperne di più su questi ruoli, consulta Prepara le autorizzazioni IAM.

Imposta le variabili di ambiente: imposta le seguenti variabili di ambiente per eseguire i comandi da questa pagina:

* The path of the kubeconfig file:

    ```sh
    export KUBECONFIG=KUBECONFIG_PATH
    ```

    Replace `KUBECONFIG_PATH` with the path to the
    kubeconfig file for the Management API server.

* Your project namespace:

    ```sh
    export PROJECT_NAMESPACE=PROJECT_NAMESPACE
    ```

Proteggi gli audit log in un backup

Questa sezione contiene i passaggi per creare un backup degli audit log in un bucket remoto.

Imposta le credenziali del bucket

Devi impostare le credenziali di accesso per i seguenti bucket:

  • Bucket di origine: il bucket GDC locale che contiene gli audit log originali che vuoi proteggere.
  • Bucket di destinazione: il bucket remoto in cui vuoi creare il backup per gli audit log.

Imposta le credenziali per entrambi i bucket:

Bucket di origine

  1. Elenca i bucket nello spazio dei nomi del progetto dal server dell'API di gestione:

    kubectl --kubeconfig=${KUBECONFIG} get bucket -n ${PROJECT_NAMESPACE}
    

    Il campo DESCRIPTION nell'output indica quali bucket contengono audit log. Seleziona il bucket che contiene i log che vuoi proteggere.

  2. In base alle informazioni dell'output, imposta le seguenti variabili di ambiente:

    SRC_BUCKET= BUCKET_NAME
    SRC_ENDPOINT = ENDPOINT
    SRC_PATH= FULLY_QUALIFIED_BUCKET_NAME
    

    Sostituisci quanto segue:

    • BUCKET_NAME: il valore BUCKET NAME dell'output.
    • ENDPOINT: il valore ENDPOINT dell'output.
    • FULLY_QUALIFIED_BUCKET_NAME: il valore FULLY-QUALIFIED-BUCKET-NAME dell'output.
  3. Recupera il nome del secret del bucket:

    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'
    
  4. Imposta la variabile delle credenziali:

    SRC_CREDENTIALS="PROJECT_NAMESPACE/SECRET_NAME"
    

    Sostituisci SECRET_NAME con il nome del secret che hai ottenuto.

  5. Crea il secret del certificato CA:

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

    Sostituisci CERTIFICATE con il certificato CA del sistema di archiviazione.

  6. Imposta la variabile del certificato CA:

    SRC_CA_CERTIFICATE=PROJECT_NAMESPACE/audit-log-loki-ca
    

Bucket di destinazione

  1. Imposta le seguenti variabili di ambiente per il bucket di destinazione remoto:

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

    Sostituisci quanto segue:

    • ACCESS_KEY: la chiave di accesso del bucket.
    • ACCESS_SECRET: il secret di accesso del bucket.
    • REMOTE_ENDPOINT: l'endpoint del bucket.
    • REMOTE_BUCKET_NAME: il nome del bucket.
  2. Crea un secret del bucket remoto:

    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
    

    Sostituisci PROJECT_NAMESPACE con lo spazio dei nomi del progetto.

  3. Imposta la variabile delle credenziali:

    DST_CREDENTIALS=PROJECT_NAMESPACE/s3-bucket-credentials
    
  4. Se necessario, crea un secret con il certificato CA del bucket e imposta la variabile del certificato CA:

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

    Sostituisci REMOTE_CERTIFICATE con il certificato CA del bucket di destinazione.

    Imposta la variabile del certificato CA:

    DST_CA_CERTIFICATE=PROJECT_NAMESPACE/s3-bucket-ca
    

Trasferisci gli audit log

L'operatore dell'infrastruttura (IO) deve creare un job di trasferimento per esportare gli audit log dal bucket di origine al bucket di destinazione per il backup. L'IO utilizza il account di servizio audit-log-pa-backup-restore-sa preconfigurato per configurare il Transfer Service per i bucket predefiniti degli audit log della piattaforma.

Utilizza il seguente job per trasferire gli audit log:

apiVersion: batch/v1
kind: Job
metadata:
  name: audit-log-transfer-job
  namespace: PROJECT_NAMESPACE
spec:
  template:
    spec:
      serviceAccountName: audit-log-pa-backup-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 # 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.

Monitora il trasferimento di dati utilizzando il nome del job (audit-log-transfer-job) e lo spazio dei nomi del progetto.

Il job termina quando tutti i dati vengono trasferiti nel bucket di destinazione.

Ripristina gli audit log da un backup

Questa sezione contiene i passaggi per ripristinare gli audit log da un backup in un bucket remoto.

Crea un bucket per i log ripristinati

Crea un bucket per archiviare gli audit log ripristinati:

  1. Crea il bucket di ripristino:

    apiVersion: object.gdc.goog/v1
    kind: Bucket
    metadata:
      annotations:
        object.gdc.goog/audit-logs: PA
      labels:
        logging.private.gdch.goog/loggingpipeline-name: default
      name: audit-logs-loki-restore-pa
      namespace: PROJECT_NAMESPACE
    spec:
      bucketPolicy:
        lockingPolicy:
          defaultObjectRetentionDays: 1
      description: Bucket for storing audit-logs-loki logs restore
      storageClass: Standard
    

    Sostituisci PROJECT_NAMESPACE con lo spazio dei nomi del progetto.

  2. Visualizza il bucket:

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

    La creazione del bucket potrebbe richiedere alcuni minuti.

  3. In base alle informazioni dell'output, imposta le seguenti variabili di ambiente:

    DST_BUCKET= RESTORE_BUCKET_NAME
    DST_ENDPOINT = RESTORE_ENDPOINT
    DST_PATH= RESTORE_FULLY_QUALIFIED_BUCKET_NAME
    

    Sostituisci quanto segue:

    • RESTORE_BUCKET_NAME: il valore BUCKET NAME dell'output.
    • RESTORE_ENDPOINT: il valore ENDPOINT dell'output.
    • RESTORE_FULLY_QUALIFIED_BUCKET_NAME: il valore FULLY-QUALIFIED-BUCKET-NAME dell'output.
  4. Recupera il nome del secret del bucket:

    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'
    
  5. Imposta le variabili delle credenziali:

    DST_SECRET_NAME=RESTORE_SECRET_NAME
    DST_CREDENTIALS="PROJECT_NAMESPACE/RESTORE_SECRET_NAME"
    

    Sostituisci RESTORE_SECRET_NAME con il nome del secret che hai ottenuto.

  6. Crea il secret del certificato CA:

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

    Sostituisci CERTIFICATE con il certificato CA del sistema di archiviazione.

  7. Imposta la variabile del certificato CA:

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

Imposta le credenziali del bucket di origine

Imposta le credenziali del bucket che contiene il backup per gli audit log:

  1. Imposta le seguenti variabili di ambiente:

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

    Sostituisci quanto segue:

    • ACCESS_KEY: la chiave di accesso del bucket di backup.
    • ACCESS_SECRET: il secret di accesso del bucket di backup.
    • REMOTE_ENDPOINT: l'endpoint del bucket di backup.
    • REMOTE_BUCKET_NAME: il nome del bucket di backup.
  2. Crea un secret del bucket di backup:

    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. Imposta la variabile delle credenziali:

    SRC_CREDENTIALS=PROJECT_NAMESPACE/s3-backup-bucket-credentials
    
  4. Crea un secret con il certificato CA del bucket:

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

    Sostituisci BACKUP_CERTIFICATE con il certificato CA del bucket di backup.

  5. Imposta la variabile del certificato CA:

    SRC_CA_CERTIFICATE=PROJECT_NAMESPACE/s3-backup-bucket-ca
    

Trasferisci gli audit log ripristinati

L'operatore dell'infrastruttura (IO) deve creare un job di trasferimento per ripristinare gli audit log dal bucket di backup al bucket di ripristino. L'IO utilizza il account di servizio audit-log-pa-backup-restore-sa preconfigurato per configurare il Transfer Service per i bucket predefiniti degli audit log della piattaforma.

Utilizza il seguente job per trasferire gli audit log:

apiVersion: batch/v1
kind: Job
metadata:
  name: audit-log-restore-job
  namespace: PROJECT_NAMESPACE
spec:
  template:
    spec:
      serviceAccountName: audit-log-pa-backup-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.

Monitora il trasferimento di dati utilizzando il nome del job (audit-log-restore-job) e lo spazio dei nomi del progetto.

Il job termina quando tutti i dati vengono trasferiti nel bucket di ripristino.

Accedi ai log ripristinati

Esegui il deployment di un'istanza Loki per accedere ai log ripristinati utilizzando i manifest di configurazione e deployment forniti:

  1. Crea un oggetto ConfigMap per la configurazione dell'istanza.

    Di seguito è riportato un esempio di oggetto ConfigMap:

    apiVersion: v1
    kind: ConfigMap
    metadata:
      name: audit-logs-loki-restore-pa
      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
    
  2. Esegui il deployment dell'istanza come oggetto StatefulSet con un Service per accedere ai log.

    Di seguito è riportato un esempio di oggetti StatefulSet e Service:

    apiVersion: apps/v1
    kind: StatefulSet
    metadata:
      labels:
        app: audit-logs-loki-restore-pa
        logging.private.gdch.goog/loggingpipeline-name: default
      name: audit-logs-loki-restore-pa
      namespace: PROJECT_NAMESPACE
    spec:
      persistentVolumeClaimRetentionPolicy:
        whenDeleted: Retain
        whenScaled: Retain
      podManagementPolicy: OrderedReady
      replicas: 1
      revisionHistoryLimit: 10
      selector:
        matchLabels:
          app: audit-logs-loki-restore-pa
      serviceName: audit-logs-loki-restore-pa
      template:
        metadata:
          labels:
            app: audit-logs-loki-restore-pa
            app.kubernetes.io/part-of: audit-logs-loki-restore-pa
            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-pa
                  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-pa
            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-log-pa-backup-restore-sa
          serviceAccountName: audit-log-pa-backup-restore-sa
          terminationGracePeriodSeconds: 4800
          volumes:
          - emptyDir: {}
            name: temp
          - configMap:
              defaultMode: 420
              name: audit-logs-loki-restore-pa
            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-pa
      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-pa
      sessionAffinity: None
      type: ClusterIP
    

Visualizza i log ripristinati

Configura Grafana per visualizzare gli audit log ripristinati dall'istanza Loki:

  1. Apri l'endpoint Grafana del tuo progetto. Per saperne di più, consulta Esegui query e visualizza i log.
  2. Nel menu di navigazione dell'interfaccia utente, fai clic su Amministrazione > Origini dati.
  3. Fai clic su Aggiungi nuova origine dati.
  4. Nella pagina Aggiungi origine dati, seleziona Loki.
  5. Nella pagina Impostazioni, inserisci Audit Logs - Restore nel campo Nome.
  6. Nella sezione HTTP, inserisci il seguente valore nel campo URL:

    http://audit-logs-loki-restore-pa.PROJECT_NAMESPACE.svc:3100
    
  7. Nella sezione Intestazioni HTTP personalizzate, inserisci i seguenti valori nei campi corrispondenti:

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

Nella figura 1, Loki viene visualizzato come opzione nella pagina Aggiungi origine dati.

L'opzione Loki viene visualizzata come origine dati nella pagina Aggiungi origine dati della UI.

Figura 1. La pagina Aggiungi origine dati nell'interfaccia utente dell'istanza di monitoraggio.

I campi pertinenti per configurare Loki come origine dati vengono visualizzati nella pagina Impostazioni

Figura 2. La pagina Impostazioni nell'interfaccia utente dell'istanza di monitoraggio.

L'opzione Audit Logs - Restore è ora disponibile come origine dati in Esplora log.