Personalizzazione dei log di Cloud Logging per Google Kubernetes Engine con Fluentd

Last reviewed 2022-10-03 UTC

---

Questo tutorial descrive come personalizzare il logging Fluentd per un cluster Google Kubernetes Engine. Imparerai a ospitare il tuo daemonset Fluentd configurabile per inviare log a Cloud Logging, invece di selezionare l'opzione di Cloud Logging durante la creazione del cluster Google Kubernetes Engine (GKE), che non consente la configurazione del daemon Fluentd.

Nota: questo tutorial è per l'agente Logging legacy basato su Fluentd. Per personalizzare Fluent Ops Agent basato su bit sulle macchine virtuali, consulta Configurare Ops Agent. Per personalizzare Fluent Bit su GKE, consulta la pagina relativa alla personalizzazione di fluentbit.

Obiettivi

• Esegui il deployment del tuo daemonset Fluentd su un cluster Google Kubernetes Engine, configurato per registrare i dati in Cloud Logging. Supponiamo che tu abbia già familiarità con Kubernetes.
• Personalizza il logging di GKE per rimuovere dati sensibili dai log di Cloud Logging.
• Personalizza il logging di GKE per aggiungere eventi a livello di nodo ai log di Cloud Logging.

Costi

Questo tutorial utilizza i componenti fatturabili di Google Cloud, tra cui:

• Un cluster Google Kubernetes Engine a tre nodi.

Il Calcolatore prezzi stima il costo di questo ambiente a circa 1,14 $per 8 ore.

Prima di iniziare

1. Accedi al tuo account Google Cloud. Se non conosci Google Cloud, crea un account per valutare le prestazioni dei nostri prodotti in scenari reali. I nuovi clienti ricevono anche 300 $di crediti gratuiti per l'esecuzione, il test e il deployment dei carichi di lavoro.

2. Nella pagina del selettore di progetti della console Google Cloud, seleziona o crea un progetto Google Cloud.

   Nota: se non prevedi di conservare le risorse create in questa procedura, crea un progetto anziché selezionarne uno esistente. Dopo aver completato questi passaggi, puoi eliminare il progetto, rimuovendo tutte le risorse associate.

   Vai al selettore progetti

3. Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

4. Abilita le API Google Kubernetes Engine, Compute Engine.

   Abilita le API

5. Nella pagina del selettore di progetti della console Google Cloud, seleziona o crea un progetto Google Cloud.

   Nota: se non prevedi di conservare le risorse create in questa procedura, crea un progetto anziché selezionarne uno esistente. Dopo aver completato questi passaggi, puoi eliminare il progetto, rimuovendo tutte le risorse associate.

   Vai al selettore progetti

6. Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

7. Abilita le API Google Kubernetes Engine, Compute Engine.

   Abilita le API

Inizializzazione delle variabili comuni

Devi definire diverse variabili che controllano dove viene eseguito il deployment degli elementi dell'infrastruttura.

1. Utilizza un editor di testo per modificare lo script seguente, sostituendo il tuo ID progetto con [YOUR_PROJECT_ID]. Lo script imposta la regione su us-east-1. Se apporti modifiche allo script, assicurati che i valori della zona facciano riferimento all'area geografica specificata.

   export region=us-east1
   export zone=${region}-b
   export project_id=[YOUR_PROJECT_ID]
   

2. Vai a Cloud Shell.

   Apri Cloud Shell

3. Copia lo script nella finestra di Cloud Shell ed eseguilo.

4. Esegui questi comandi per impostare la zona e l'ID progetto predefiniti in modo da non dover specificare questi valori in ogni comando successivo:

   gcloud config set compute/zone ${zone}
   gcloud config set project ${project_id}
   

Creazione del cluster GKE

1. In Cloud Shell, clona il repository di esempio:

   git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-customize-fluentd
   

   Il repository di esempio include i manifest Kubernetes per il daemonset Fluentd e un programma di logging di test di cui eseguirai il deployment in questo tutorial.

2. Cambia la directory di lavoro nel repository clonato:

   cd kubernetes-engine-customize-fluentd
   

3. Crea il cluster GKE solo con logging e monitoraggio del sistema:

   gcloud container clusters create gke-with-custom-fluentd \
      --zone us-east1-b \
      --logging=SYSTEM \
      --tags=gke-cluster-with-customized-fluentd \
      --scopes=logging-write,storage-rw
   

Deployment dell'applicazione di logger di test

Per impostazione predefinita, l'applicazione di esempio di cui esegui il deployment emette continuamente istruzioni di logging casuali. Il container Docker viene creato a partire dal codice sorgente nella sottodirectory test-logger.

1. In Cloud Shell, crea l'immagine container test-logger:

   docker build -t test-logger test-logger
   

2. Tagga il container prima di eseguirne il push al registro:

   docker tag test-logger gcr.io/${project_id}/test-logger
   

3. Esegui il push dell'immagine container:

   docker push gcr.io/${project_id}/test-logger
   

4. Aggiorna il file di deployment:

   envsubst < kubernetes/test-logger.yaml > kubernetes/test-logger-deploy.yaml
   

5. Esegui il deployment dell'applicazione test-logger nel cluster GKE:

   kubectl apply -f kubernetes/test-logger-deploy.yaml
   

6. Visualizza lo stato di test-logger pod:

   kubectl get pods
   

7. Ripeti questo comando finché l'output non è simile al seguente, con tutti e tre i pod test-logger in esecuzione:

   

Deployment del daemonset Fluentd nel cluster

Successivamente, configurerai ed eseguirai il deployment del daemonset Fluentd.

Nota: poiché hai attivato il logging solo del sistema, è stato eseguito il deployment di un daemonset Fluentd gestito da GKE responsabile del logging del sistema. I manifest Kubernetes per Fluentd di cui esegui il deployment in questa procedura sono versioni modificate di quelle disponibili nel repository Fluentd Daemonset per Kubernetes su GitHub.

1. In Cloud Shell, esegui il deployment della configurazione Fluentd:

   kubectl apply -f kubernetes/fluentd-configmap.yaml
   

2. Esegui il deployment del daemonset Fluentd:

   kubectl apply -f kubernetes/fluentd-daemonset.yaml
   

3. Verifica che i pod fluidi siano stati avviati:

   kubectl get pods --namespace=kube-system
   

   Se sono in esecuzione, vedrai un output simile al seguente:

   

4. Verifica di visualizzare i log in Logging. Nella console, sul lato sinistro, seleziona Logging > Esplora log, quindi seleziona Container Kubernetes come tipo di risorsa nell'elenco Risorsa.

5. Fai clic su Esegui query.

6. Nell'Explorer campi dei log, seleziona test-logger per CONTAINER_NAME:

   

Filtraggio delle informazioni dal file di log

Il passaggio successivo consiste nello specificare che Fluentd deve filtrare determinati dati in modo che non vengano registrati. Per questo tutorial, filtrerai i codici fiscali, i numeri di carte di credito e gli indirizzi email. Per eseguire questo aggiornamento, modifica il daemonset in modo da utilizzare un ConfigMap diverso che contenga questi filtri. Utilizzi gli aggiornamenti in sequenza di Kubernetes e conservi la versione precedente del ConfigMap.

1. Apri il file kubernetes/fluentd-configmap.yaml in un editor.

2. Rimuovi il commento dalle righe tra le righe ### sample log scrubbing filters e ### end sample log scrubbing filters escluse:

   ############################################################################################################
   #  ### sample log scrubbing filters
   #  #replace social security numbers
   # <filter reform.**>
   #   @type record_transformer
   #   enable_ruby true
   #   <record>
   #     log ${record["log"].gsub(/[0-9]{3}-*[0-9]{2}-*[0-9]{4}/,"xxx-xx-xxxx")}
   #   </record>
   # </filter>
   # # replace credit card numbers that appear in the logs
   # <filter reform.**>
   #   @type record_transformer
   #   enable_ruby true
   #   <record>
   #      log ${record["log"].gsub(/[0-9]{4} *[0-9]{4} *[0-9]{4} *[0-9]{4}/,"xxxx xxxx xxxx xxxx")}
   #   </record>
   # </filter>
   # # replace email addresses that appear in the logs
   # <filter reform.**>
   #   @type record_transformer
   #   enable_ruby true
   #   <record>
   #     log ${record["log"].gsub(/[\w+\-]+@[a-z\d\-]+(\.[a-z\d\-]+)*\.[a-z]+/i,"[e-mail]")}
   #   </record>
   # </filter>
   # ### end sample log scrubbing filters
   #############################################################################################################

3. Cambia il nome del ConfigMap da fluentd-gcp-config a fluentd-gcp-config-filtered modificando il campo metadata.name:

   name: fluentd-gcp-config
   namespace: kube-system
   labels:
     k8s-app: fluentd-gcp-custom

4. Salva e chiudi il file.

Aggiornamento del daemonset Fluentd per utilizzare la nuova configurazione

Ora modifichi kubernetes/fluentd-daemonset.yaml per montare ConfigMap fluentd-gcp-config-filtered anziché fluentd-gcp-config.

1. Apri il file kubernetes/fluentd-daemonset.yaml in un editor.

2. Cambia il nome del ConfigMap da fluentd-gcp-config a fluentd-gcp-config-filtered modificando il campo configMap.name:

   - configMap:
       defaultMode: 420
       name: fluentd-gcp-config
     name: config-volume

3. Esegui il deployment della nuova versione di ConfigMap nel cluster:

   kubectl apply -f kubernetes/fluentd-configmap.yaml
   

4. Implementa la nuova versione del daemonset:

   kubectl apply -f kubernetes/fluentd-daemonset.yaml

5. Implementa l'aggiornamento e attendi che venga completato:

   kubectl rollout status ds/fluentd-gcp --namespace=kube-system
   

   

6. Al termine dell'implementazione, aggiorna i log di Logging e assicurati che i dati relativi al codice fiscale, al numero della carta di credito e all'indirizzo email siano stati filtrati.

   

Logging degli eventi a livello di nodo

Se vuoi che gli eventi che si verificano sui tuoi nodi GKE vengano visualizzati anche in Logging, aggiungi le seguenti righe a ConfigMap e segui le istruzioni descritte nell'ultima sezione:

<source>
  @type systemd
  filters [{ "SYSLOG_IDENTIFIER": "sshd" }]
  pos_file /var/log/journal/gcp-journald-ssh.pos
  read_from_head true
  tag sshd
</source>

<source>
  @type systemd
  filters [{ "SYSLOG_IDENTIFIER": "sudo" }]
  pos_file /var/log/journal/gcp-journald-sudo.pos
  read_from_head true
  tag sudo
</source>

Nota: durante l'upgrade di un cluster, è normale che l'utilizzo della CPU su Fluentd superi i picchi di numero maggiore di log su un nodo. Fluentd cerca di elaborare tutti i log il più rapidamente possibile per inviarli alla sua destinazione (API Cloud Logging). Qualsiasi picco significativo nei log generati può causare un aumento dell'utilizzo della CPU fino al limite del pod. Impostiamo questo limite per assicurarci che non utilizzi le risorse disponibili dell'intero nodo.

Esegui la pulizia

Dopo aver completato il tutorial, puoi eseguire la pulizia delle risorse che hai creato in Google Cloud in modo che non ti vengano addebitati costi in futuro.

Elimina il progetto

Il modo più semplice per eliminare la fatturazione è eliminare il progetto che hai creato per il tutorial.

Per eliminare il progetto:

Attenzione: l'eliminazione di un progetto ha i seguenti effetti:

• L'intero contenuto del progetto viene eliminato. Se hai utilizzato un progetto esistente per le attività in questo documento, quando lo elimini elimini anche qualsiasi altro lavoro svolto nel progetto.
• Gli ID progetto personalizzati non sono più disponibili. Quando hai creato questo progetto, potresti aver creato un ID progetto personalizzato che vuoi utilizzare in futuro. Per conservare gli URL che utilizzano l'ID progetto, ad esempio un URL appspot.com, elimina le risorse selezionate all'interno del progetto anziché eliminare l'intero progetto.

Se intendi esplorare più architetture, tutorial o guide rapide, puoi riutilizzare i progetti ed evitare così di superare i limiti di quota.

1. Nella console Google Cloud, vai alla pagina Gestisci risorse.

   Vai a Gestisci risorse

2. Nell'elenco dei progetti, seleziona il progetto che vuoi eliminare, quindi fai clic su Elimina.
3. Nella finestra di dialogo, digita l'ID del progetto e fai clic su Chiudi per eliminare il progetto.

Eliminazione del cluster GKE

Se non vuoi eliminare l'intero progetto, esegui questo comando per eliminare il cluster GKE:

gcloud container clusters delete gke-with-custom-fluentd --zone us-east1-b

Passaggi successivi

• Consulta in dettaglio la documentazione di Fluentd.
• Consulta in maggiore dettaglio la documentazione di Google Kubernetes Engine.
• Esplora le architetture di riferimento, i diagrammi e le best practice su Google Cloud. Visita il nostro Cloud Architecture Center.