Cloud Logging-Logs für Google Kubernetes Engine mit Fluentd anpassen

Last reviewed 2022-10-03 UTC

---

In dieser Anleitung wird beschrieben, wie Sie Fluentd-Logging für einen Google Kubernetes Engine-Cluster anpassen. Sie erfahren hier, wie Sie Ihr eigenes konfigurierbares Fluentd-DaemonSet zum Senden von Logs an Cloud Logging hosten, anstatt beim Erstellen des Google Kubernetes Engine-Clusters (GKE) die Cloud Logging-Option zu aktivieren. Mit dieser Option kann der Fluentd-Daemon nicht konfiguriert werden.

Hinweis: Diese Anleitung bezieht sich auf den Fluentd-basierten Legacy-Logging-Agent. Informationen zum Anpassen des Fluent Bit-basierten Ops-Agents auf virtuellen Maschinen finden Sie unter Ops-Agent konfigurieren. Informationen zum Anpassen von Fluent Bit in GKE finden Sie unter fluentbit anpassen.

Ziele

• Eigenes Fluentd-DaemonSet in einem Google Kubernetes Engine-Cluster bereitstellen, der Logdaten an Cloud Logging sendet. Es wird davon ausgegangen, dass Sie mit Kubernetes vertraut sind.
• GKE-Logging so konfigurieren, dass vertrauliche Daten aus den Cloud Logging-Logs entfernt werden.
• GKE-Logging so konfigurieren, dass den Cloud Logging-Logs Ereignisse auf Knotenebene hinzugefügt werden.

Kosten

In dieser Anleitung werden kostenpflichtige Komponenten von Google Cloud verwendet, darunter:

• Ein Google Kubernetes Engine-Cluster mit drei Knoten.

Laut Preisrechner liegen die geschätzten Kosten für diese Umgebung bei ca. 1,14 $ für 8 Stunden.

Vorbereitung

1. Melden Sie sich bei Ihrem Google Cloud-Konto an. Wenn Sie mit Google Cloud noch nicht vertraut sind, erstellen Sie ein Konto, um die Leistungsfähigkeit unserer Produkte in der Praxis sehen und bewerten zu können. Neukunden erhalten außerdem ein Guthaben von 300 $, um Arbeitslasten auszuführen, zu testen und bereitzustellen.

2. Wählen Sie in der Google Cloud Console auf der Seite der Projektauswahl ein Google Cloud-Projekt aus oder erstellen Sie eines.

   Hinweis: Wenn Sie die Ressourcen, die Sie in diesem Verfahren erstellen, nicht behalten möchten, erstellen Sie ein Projekt, anstatt ein vorhandenes Projekt auszuwählen. Wenn Sie fertig sind, können Sie das Projekt löschen und dadurch alle mit dem Projekt verknüpften Ressourcen entfernen.

   Zur Projektauswahl

3. Die Abrechnung für das Google Cloud-Projekt muss aktiviert sein.

4. Google Kubernetes Engine, Compute Engine APIs aktivieren.

   Aktivieren Sie die APIs

5. Wählen Sie in der Google Cloud Console auf der Seite der Projektauswahl ein Google Cloud-Projekt aus oder erstellen Sie eines.

   Hinweis: Wenn Sie die Ressourcen, die Sie in diesem Verfahren erstellen, nicht behalten möchten, erstellen Sie ein Projekt, anstatt ein vorhandenes Projekt auszuwählen. Wenn Sie fertig sind, können Sie das Projekt löschen und dadurch alle mit dem Projekt verknüpften Ressourcen entfernen.

   Zur Projektauswahl

6. Die Abrechnung für das Google Cloud-Projekt muss aktiviert sein.

7. Google Kubernetes Engine, Compute Engine APIs aktivieren.

   Aktivieren Sie die APIs

Gemeinsame Variablen initialisieren

Sie müssen mehrere Variablen definieren, die steuern, wo Elemente der Infrastruktur bereitgestellt werden.

1. Öffnen Sie das folgende Skript in einem Texteditor und ersetzen Sie [YOUR_PROJECT_ID] durch Ihre Projekt-ID. Die Region wird im Skript auf us-east-1 gesetzt. Achten Sie bei Änderungen am Skript darauf, dass sich die Zonenwerte auf die angegebene Region beziehen.

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

2. Rufen Sie Cloud Shell auf.

   Cloud Shell öffnen

3. Kopieren Sie das Skript in das Cloud Shell-Fenster und führen Sie es aus.

4. Legen Sie mit den folgenden Befehlen die Standardzone und die Projekt-ID fest, damit Sie diese Werte nicht in jedem nachfolgenden Befehl angeben müssen:

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

GKE-Cluster erstellen

1. Klonen Sie in Cloud Shell das Beispiel-Repository:

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

   Das Beispiel-Repository enthält die Kubernetes-Manifeste für das Fluentd-DaemonSet und ein Test-Logging-Programm, das Sie später in dieser Anleitung bereitstellen.

2. Ändern Sie das Arbeitsverzeichnis in das geklonte Repository:

   cd kubernetes-engine-customize-fluentd
   

3. Erstellen Sie den GKE-Cluster nur mit System-Logging und -Monitoring:

   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
   

Test-Logger-Anwendung bereitstellen

Die von Ihnen bereitgestellte Beispielanwendung gibt standardmäßig kontinuierlich nach dem Zufallsprinzip Log-Berichte aus. Der Docker-Container wird aus dem Quellcode im Unterverzeichnis test-logger erstellt.

1. Erstellen Sie in Cloud Shell das Container-Image test-logger:

   docker build -t test-logger test-logger
   

2. Taggen Sie den Container, bevor Sie ihn in die Registry hochladen:

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

3. Übertragen Sie das Container-Image per Push:

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

4. Aktualisieren Sie die Bereitstellungsdatei:

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

5. Stellen Sie die Anwendung test-logger im GKE-Cluster bereit:

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

6. Rufen Sie den Status der test-logger-Pods auf:

   kubectl get pods
   

7. Wiederholen Sie diesen Befehl, bis die Ausgabe so aussieht und alle drei test-logger-Pods ausgeführt werden:

   

Fluentd-DaemonSet im Cluster bereitstellen

Im nächsten Schritt konfigurieren und erstellen Sie das Fluentd-DaemonSet.

Hinweis: Da Sie die Logging-Option "Nur System" aktiviert haben, wurde ein von GKE verwaltetes Fluentd-DaemonSet bereitgestellt, das für das System-Logging verantwortlich ist. Die in dieser Anleitung bereitgestellten Kubernetes-Manifeste für Fluentd sind geänderte Versionen der Manifeste aus dem Fluentd-Daemonset für das Kubernetes-Repository auf GitHub.

1. Stellen Sie in Cloud Shell die Fluentd-Konfiguration bereit:

   kubectl apply -f kubernetes/fluentd-configmap.yaml
   

2. Stellen Sie das Fluentd-DaemonSet bereit:

   kubectl apply -f kubernetes/fluentd-daemonset.yaml
   

3. Prüfen Sie, ob die Fluentd-Pods gestartet wurden:

   kubectl get pods --namespace=kube-system
   

   Wenn sie ausgeführt werden, sehen Sie die folgende Ausgabe:

   

4. Prüfen Sie, ob in Logging Logs angezeigt werden. Wählen Sie in der Konsole auf der linken Seite Logging > Log-Explorer und dann Kubernetes-Container als Ressourcentyp in der Liste Ressource aus.

5. Klicken Sie auf Abfrage ausführen.

6. Wählen Sie im Logfeld-Explorer für CONTAINER_NAME die Option test-logger aus:

   

Informationen aus der Logdatei filtern

Geben Sie als Nächstes an, dass Fluentd bestimmte Daten filtern soll, um sie von der Protokollierung auszuschließen. Für diese Anleitung filtern Sie die Sozialversicherungsnummern, Kreditkartennummern und E-Mail-Adressen heraus. Legen Sie hierfür fest, dass das DaemonSet eine andere ConfigMap mit diesen Filtern verwendet. Verwenden Sie die Rolling Update-Funktion von Kubernetes und behalten Sie die alte ConfigMap-Version bei.

1. Öffnen Sie die Datei kubernetes/fluentd-configmap.yaml in einem Editor.

2. Entfernen Sie die zwischenliegenden Zeilen und schließen Sie die Zeilen ### sample log scrubbing filters und ### end sample log scrubbing filters aus:

   ############################################################################################################
   #  ### 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. Ändern Sie den Namen der ConfigMap von fluentd-gcp-config in fluentd-gcp-config-filtered im Feld metadata.name:

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

4. Speichern und schließen Sie die Datei.

Fluentd-DaemonSet mit der neuen Konfiguration aktualisieren

Ändern Sie jetzt kubernetes/fluentd-daemonset.yaml für die Bereitstellung der ConfigMap fluentd-gcp-config-filtered anstelle von fluentd-gcp-config.

1. Öffnen Sie die Datei kubernetes/fluentd-daemonset.yaml in einem Editor.

2. Ändern Sie den Namen der ConfigMap von fluentd-gcp-config in fluentd-gcp-config-filtered im Feld configMap.name:

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

3. Stellen Sie die neue Version der ConfigMap in Ihrem Cluster bereit:

   kubectl apply -f kubernetes/fluentd-configmap.yaml
   

4. Implementieren Sie die neue daemonset-Version:

   kubectl apply -f kubernetes/fluentd-daemonset.yaml

5. Implementieren Sie die Aktualisierung und warten Sie, bis diese abgeschlossen ist:

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

   

6. Aktualisieren Sie nach Abschluss der Implementierung die Logging-Logs. Prüfen Sie, ob die Sozialversicherungsnummern, die Kreditkartennummern und E-Mail-Adressdaten herausgefiltert wurden.

   

Ereignisse auf Knotenebene protokollieren

Damit Ereignisse auf Ihren GKE-Knoten auch in Logging angezeigt werden, fügen Sie Ihrer ConfigMap die folgenden Zeilen hinzu und folgen Sie der Anleitung im letzten Abschnitt:

<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>

Hinweis: Während eines Clusterupgrades ist es normal, dass die CPU-Auslastung in Fluentd stark ansteigt, wenn die Anzahl der Logs auf einem Knoten zunimmt. Fluentd versucht, alle Logs so schnell wie möglich zu verarbeiten, damit sie an das Ziel (Cloud Logging API) gesendet werden können. Wenn die Zahl der generierten Logs stark ansteigt, kann die CPU-Auslastung bis zum Limit des Pods steigen. Mit diesem Limit wird sichergestellt, dass nicht die verfügbaren Ressourcen des gesamten Knoten verwendet werden.

Bereinigen

Nach Abschluss der Anleitung können Sie die von Ihnen in Google Cloud erstellten Ressourcen entfernen, damit Ihnen diese nicht weiter in Rechnung gestellt werden.

Projekt löschen

Am einfachsten vermeiden Sie weitere Kosten, wenn Sie das zum Ausführen der Anleitung erstellte Projekt löschen.

So löschen Sie das Projekt:

Achtung: Das Löschen von Projekten hat folgende Auswirkungen:

• Alle Inhalte des Projekts werden gelöscht. Wenn Sie für die Aufgaben in diesem Dokument ein bereits bestehendes Projekt verwendet haben und dieses löschen, werden auch alle anderen im Rahmen des Projekts erstellten Daten gelöscht.
• Benutzerdefinierte Projekt-IDs gehen verloren. Beim Erstellen dieses Projekts haben Sie möglicherweise eine benutzerdefinierte Projekt-ID erstellt, die Sie weiterhin verwenden möchten. Damit die URLs, die die Projekt-ID nutzen, z. B. eine appspot.com-URL, erhalten bleiben, sollten Sie ausgewählte Ressourcen innerhalb des Projekts löschen, statt das gesamte Projekt.

Wenn Sie mehrere Architekturen, Anleitungen und Kurzanleitungen durcharbeiten möchten, können Sie die Überschreitung von Projektkontingenten verhindern, indem Sie Projekte wiederverwenden.

1. Wechseln Sie in der Google Cloud Console zur Seite Ressourcen verwalten.

   Zur Seite „Ressourcen verwalten“

2. Wählen Sie in der Projektliste das Projekt aus, das Sie löschen möchten, und klicken Sie dann auf Löschen.
3. Geben Sie im Dialogfeld die Projekt-ID ein und klicken Sie auf Shut down (Beenden), um das Projekt zu löschen.

GKE-Cluster löschen

Wenn Sie nicht das gesamte Projekt löschen möchten, können Sie den folgenden Befehl ausführen, um nur den GKE-Cluster zu löschen:

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

Weitere Informationen

• Die Fluentd-Dokumentation eingehender erkunden
• Die Google Kubernetes Engine-Dokumentation lesen
• Referenzarchitekturen, Diagramme und Best Practices zu Google Cloud kennenlernen. Weitere Informationen zu Cloud Architecture Center