Das in dieser Dokumentation beschriebene Produkt Anthos-Cluster in AWS (vorherige Generation) befindet sich jetzt im Wartungsmodus. Alle neuen Installationen müssen Anthos-Cluster in AWS der aktuellen Generation verwenden.

Logging und Monitoring für Anthos-Cluster in AWS

In diesem Thema erfahren Sie, wie Sie Logs und Messwerte von einem Anthos-Cluster auf einem AWS-Nutzercluster nach Cloud Logging und Cloud Monitoring exportieren.

Übersicht

Es gibt mehrere Optionen zum Logging und Monitoring mit Anthos-Clustern in AWS. Anthos kann in Cloud Logging und Cloud Monitoring eingebunden werden. Da Anthos auf Open-Source-Kubernetes basiert, sind viele Open-Source- und Drittanbietertools kompatibel.

Logging- und Monitoring-Optionen

Sie haben mehrere Logging- und Monitoring-Optionen für Ihren Anthos-Cluster:

Stellen Sie die Cloud Logging- und Cloud Monitoring-Agents bereit, um die Logs Ihrer Arbeitslasten in der Google Cloud Console zu beobachten und anzusehen. In diesem Thema wird diese Lösung erläutert.
Nutzen Sie Open-Source-Tools wie Prometheus, Grafana und Elasticsearch. Diese Lösung wird in diesem Thema nicht beschrieben.
Verwenden Sie Lösungen von Drittanbietern wie Datadog. In diesem Thema wird diese Lösung nicht beschrieben.

Cloud Logging und Cloud Monitoring

Mit Anthos, Cloud Logging und Cloud Monitoring können Sie Dashboards erstellen, Warnungen senden, Logs für die auf Ihrem Cluster laufenden Arbeitslasten beobachten und überprüfen. Sie müssen die Cloud Logging- und Cloud Monitoring-Agents konfigurieren, um Logs und Messwerte in Ihrem Google Cloud-Projekt zu erfassen. Wenn Sie diese Agents nicht konfigurieren, erfasst Anthos-Cluster in AWS keine Logging- oder Monitoringdaten.

Welche Daten werden erhoben?

Nach ihrer Konfiguration erfassen die Agents Logs und Messwertdaten von Ihrem Cluster und den auf Ihrem Cluster ausgeführten Arbeitslasten. Diese Daten werden in Ihrem Google Cloud-Projekt gespeichert. Sie konfigurieren die Projekt-ID im Feld project_id in einer Konfigurationsdatei, wenn Sie Log Forwarder installieren.

Die erhobenen Daten umfassen Folgendes:

Logs für Systemdienste auf jedem Worker-Knoten.
Anwendungslogs für alle auf dem Cluster ausgeführten Arbeitslasten.
Messwerte für die Cluster- und Systemdienste. Weitere Informationen zu bestimmten Messwerten finden Sie unter Anthos-Messwerte.
Anwendungsmesswerte für Pods, wenn Ihre Anwendungen mit Prometheus-Extraktionszielen konfiguriert sind, und mit Konfigurationen wie prometheus.io/scrape, prometheus.io/path und prometheus.io/port annotiert sind.

Die Agents können jederzeit deaktiviert werden. Weitere Informationen finden Sie unter Bereinigen. Die von den Agents erfassten Daten können wie alle anderen Messwert- und Logdaten verwaltet und gelöscht werden, wie in der Dokumentation Cloud Monitoring und Cloud Logging beschrieben.

Logdaten werden gemäß den konfigurierten Aufbewahrungsregeln gespeichert. Die Aufbewahrung der Messwertdaten hängt vom Typ ab.

Logging und Monitoringkomponenten

Stellen Sie die folgenden Komponenten in Ihrem Cluster bereit, um Telemetriedaten von Anthos-Clustern in AWS in Google Cloud zu exportieren:

Stackdriver Log Forwarder (stackdriver-log-forwarder-*). Ein Fluentbit-DaemonSet, das Logs von jedem Kubernetes-Knoten an Cloud Logging weiterleitet.
GKE Metrics Agent (gke-metrics-agent-*). Ein auf OpenTelemetry Collector basierendes DaemonSet, das Messwertdaten erfasst und an Cloud Monitoring weiterleitet.

Die Manifeste für diese Komponenten befinden sich im Repository anthos-samples auf GitHub.

Vorbereitung

Google Cloud-Projekt mit aktivierter Abrechnungsfunktion. Weitere Informationen zu den Kosten finden Sie unter Preise für die Operations Suite von Google Cloud.

Für das Projekt müssen außerdem die Cloud Logging und Cloud Monitoring APIs aktiviert sein. Aktivieren Sie die APIs mit folgenden Befehlen:
```
gcloud services enable logging.googleapis.com
gcloud services enable monitoring.googleapis.com
```
Eine Anthos-Cluster in AWS-Umgebung, einschließlich eines bei Connect registrierten Nutzerclusters. Prüfen Sie mit dem folgenden Befehl, ob der Cluster registriert ist:
```
gcloud container fleet memberships list
```
Wenn Ihr Cluster registriert ist, gibt die Google Cloud CLI den Namen und die ID des Clusters aus.
```
NAME       EXTERNAL_ID
cluster-0  1abcdef-1234-4266-90ab-123456abcdef
```
Wenn Ihr Cluster nicht aufgeführt ist, finden Sie weitere Informationen unter Verbindung zu einem Cluster mit Connect herstellen.
Installieren Sie das git-Befehlszeilentool auf Ihrem Computer.

Berechtigungen für die Operations-Suite von Google Cloud einrichten

Logging- und Monitoring-Agents verwenden Fleet Workload Identity für die Kommunikation mit Cloud Logging und Cloud Monitoring. Die Identität benötigt Berechtigungen zum Schreiben von Logs und Messwerten in Ihrem Projekt. Führen Sie die folgenden Befehle aus, um die Berechtigungen hinzuzufügen:

gcloud projects add-iam-policy-binding PROJECT_ID \
  --member="serviceAccount:PROJECT_ID.svc.id.goog[kube-system/stackdriver]" \
  --role=roles/logging.logWriter
gcloud projects add-iam-policy-binding PROJECT_ID \
  --member="serviceAccount:PROJECT_ID.svc.id.goog[kube-system/stackdriver]" \
  --role=roles/monitoring.metricWriter

Ersetzen Sie PROJECT_ID durch Ihr Google Cloud-Projekt.

Verbindung zum Bastion Host herstellen

Führen Sie die folgenden Schritte aus, um eine Verbindung zu Ihren Anthos-Cluster auf AWS-Ressourcen herzustellen. Wählen Sie aus, ob Sie eine bestehende AWS-VPC (oder eine direkte Verbindung zu Ihrer VPC) verwenden oder beim Erstellen Ihres Verwaltungsdienstes eine dedizierte VPC angelegt haben.

Vorhandene VPC

Wenn Sie eine direkte Verbindung oder eine VPN-Verbindung zu einer vorhandenen VPC verwenden, lassen Sie die Zeile env HTTP_PROXY=http://localhost:8118 in den Befehlen in diesem Thema weg.

Dedizierte VPC

Wenn Sie einen Verwaltungsdienst in einer dedizierten VPC erstellen, enthält Anthos-Cluster auf AWS einen Bastion-Host in einem öffentlichen Subnetz.

So stellen Sie eine Verbindung zu Ihrem Verwaltungsdienst her:

Wechseln Sie in das Verzeichnis mit Ihrer Anthos-Cluster auf AWS-Konfiguration. Sie haben dieses Verzeichnis bei der Installation des Verwaltungsdienstes erstellt.
```
cd anthos-aws
```
Führen Sie das Skript bastion-tunnel.sh aus, um den Tunnel zu öffnen. Über den Tunnel erfolgt eine Weiterleitung zu localhost:8118.

Führen Sie den folgenden Befehl aus, um einen Tunnel zum Bastion Host zu öffnen:
```
./bastion-tunnel.sh -N
```
In diesem Fenster werden Nachrichten aus dem SSH-Tunnel angezeigt. Wenn Sie bereit sind, die Verbindung zu trennen, beenden Sie den Vorgang mit Strg+C oder schließen Sie das Fenster.
Öffnen Sie ein neues Terminal und wechseln Sie in das Verzeichnis anthos-aws:
```
cd anthos-aws
```
Prüfen Sie, ob Sie mit kubectl eine Verbindung zum Cluster herstellen können.
```
env HTTPS_PROXY=http://localhost:8118 \
kubectl cluster-info
```
Die Ausgabe enthält die URL für den API-Server des Verwaltungsdiensts.

Cloud Logging und Cloud Monitoring auf Steuerungsebenenknoten

Mit Anthos-Clustern in AWS 1.8.0 und höher können Cloud Logging- und Cloud Monitoring-Knoten für die Steuerungsebene automatisch beim Erstellen neuer Nutzercluster konfiguriert werden. Um Cloud Logging oder Cloud Monitoring zu aktivieren, ergänzen Sie den Abschnitt controlPlane.cloudOperations Ihrer AWSCluster-Konfiguration.

cloudOperations:
  projectID: PROJECT_ID
  location: GC_REGION
  enableLogging: ENABLE_LOGGING
  enableMonitoring: ENABLE_MONITORING

Dabei gilt:

PROJECT_ID: Ihre Projekt-ID.
GC_REGION: Die Google Cloud-Region, in der Sie Logs speichern möchten. Wählen Sie eine Region in der Nähe der AWS-Region aus. Weitere Informationen finden Sie unter Globale Standorte: Regionen und Zonen, z. B. us-central1.
ENABLE_LOGGING: true oder false, abhängig davon, ob Cloud Logging auf Knoten der Steuerungsebene aktiviert ist.
ENABLE_MONITORING: true oder false, abhängig davon, ob Cloud Monitoring auf Knoten der Steuerungsebene aktiviert ist.

Führen Sie anschließend die Schritte unter Benutzerdefinierten Nutzercluster erstellen aus.

Cloud Logging und Cloud Monitoring auf Worker-Knoten

Vorherige Version entfernen

Wenn Sie eine frühere Version der Logging- und Monitoring-Agents eingerichtet haben, die stackdriver-log-aggregator (Fluentd) und stackdriver-prometheus-k8s (Prometheus) enthalten, deinstallieren Sie die Version, bevor Sie fortfahren.

Klicken Sie, um Befehle zum Deinstallieren der früheren Version anzuzeigen.

    kubectl delete -n kube-system statefulset stackdriver-log-aggregator
    kubectl delete -n kube-system configmap stackdriver-log-aggregator-input-config
    kubectl delete -n kube-system configmap stackdriver-log-aggregator-output-config
    kubectl delete -n kube-system networkpolicy stackdriver-log-aggregator-in-forward
    kubectl delete -n kube-system networkpolicy stackdriver-log-aggregator-prometheus-scrape
    kubectl delete -n kube-system serviceaccount stackdriver-log-aggregator
    kubectl delete -n kube-system service stackdriver-log-aggregator-in-forward
    kubectl delete -n kube-system statefulset stackdriver-prometheus-k8s
    kubectl delete -n kube-system service stackdriver-prometheus-k8s
    kubectl delete -n kube-system secret stackdriver-prometheus-scrape
    kubectl delete -n kube-system clusterrolebinding stackdriver-prometheus-scrape
    kubectl delete -n kube-system clusterrole stackdriver-prometheus-scrape
    kubectl delete -n kube-system serviceaccount stackdriver-prometheus-scrape
    kubectl delete -n kube-system clusterrolebinding stackdriver-user:prometheus
    kubectl delete -n kube-system clusterrole stackdriver-user:prometheus
    kubectl delete -n kube-system serviceaccount stackdriver-prometheus
    kubectl delete -n kube-system configmap stackdriver-prometheus-k8s
    kubectl delete -n kube-system configmap stackdriver-prometheus-sidecar-config
    kubectl delete -n kube-system pvc/stackdriver-log-aggregator-persistent-volume-claim-stackdriver-log-aggregator-0
    kubectl delete -n kube-system pvc/stackdriver-log-aggregator-persistent-volume-claim-stackdriver-log-aggregator-1
    kubectl delete -n kube-system pvc/stackdriver-prometheus-data-stackdriver-prometheus-k8s-0
    kubectl delete secret google-cloud-credentials -n kube-system

Logging-Weiterleitung installieren

In diesem Abschnitt installieren Sie den Stackdriver Log Forwarder in Ihrem Cluster.

Wechseln Sie vom Verzeichnis anthos-samples/aws-logging-monitoring/ in das Verzeichnis logging/.
```
cd logging/
```
Ändern Sie die Datei forwarder.yaml entsprechend Ihrer Projektkonfiguration:
```
sed -i "s/PROJECT_ID/PROJECT_ID/g" forwarder.yaml
sed -i "s/CLUSTER_NAME/CLUSTER_NAME/g" forwarder.yaml
sed -i "s/CLUSTER_LOCATION/GC_REGION/g" forwarder.yaml
```
Dabei gilt:
- PROJECT_ID: Ihre Projekt-ID.
- CLUSTER_NAME: Der Name Ihres Clusters, z. B. cluster-0
- GC_REGION: Die Google Cloud-Region, in der Sie Logs speichern möchten. Wählen Sie eine Region in der Nähe der AWS-Region aus. Weitere Informationen finden Sie unter Globale Standorte: Regionen und Zonen, z. B. us-central1.
(Optional) Basierend auf Ihren Arbeitslasten, der Anzahl der Knoten in Ihrem Cluster und der Anzahl der Pods pro Knoten müssen Sie möglicherweise Speicher- und CPU-Ressourcenanfragen festlegen. Weitere Informationen finden Sie unter Empfohlene CPU- und Speicherzuweisungen.
Verwenden Sie anthos-gke im Verzeichnis anthos-aws, um den Kontext zu Ihrem Nutzercluster zu wechseln.
```
cd anthos-aws
env HTTPS_PROXY=http://localhost:8118 \
  anthos-gke aws clusters get-credentials CLUSTER_NAME
```
Ersetzen Sie CLUSTER_NAME durch den Nutzerclusternamen.

Erstellen Sie das Dienstkonto stackdriver, falls es nicht vorhanden ist, und stellen Sie Log Forwarder für den Cluster bereit.

env HTTPS_PROXY=http://localhost:8118 \
  kubectl create serviceaccount stackdriver -n kube-system
env HTTPS_PROXY=http://localhost:8118 \
  kubectl apply -f forwarder.yaml

Prüfen Sie mit kubectl, ob die Pods gestartet wurden.

env HTTPS_PROXY=http://localhost:8118 \
  kubectl get pods -n kube-system | grep stackdriver-log

In einem Knotenpool sollte ein Forwarder-Pod pro Knoten angezeigt werden. In einem Cluster mit sechs Knoten sollten beispielsweise sechs Forwarder-Pods angezeigt werden.

stackdriver-log-forwarder-2vlxb              2/2     Running   0          21s
stackdriver-log-forwarder-dwgb7              2/2     Running   0          21s
stackdriver-log-forwarder-rfrdk              2/2     Running   0          21s
stackdriver-log-forwarder-sqz7b              2/2     Running   0          21s
stackdriver-log-forwarder-w4dhn              2/2     Running   0          21s
stackdriver-log-forwarder-wrfg4              2/2     Running   0          21s

Logweiterleitung testen

In diesem Abschnitt stellen Sie eine Arbeitslast mit einem einfachen HTTP-Webserver mit einem Load Generator für Ihren Cluster bereit. Anschließend testen Sie, ob die Logs in Cloud Logging vorhanden sind.

Vor der Installation dieser Arbeitslast können Sie die Manifeste für den Webserver und den Load Generator überprüfen.

Stellen Sie den Webserver und den Load Generator für Ihren Cluster bereit.

env HTTPS_PROXY=http://localhost:8118 \
  kubectl apply -f  https://raw.githubusercontent.com/GoogleCloudPlatform/istio-samples/master/sample-apps/helloserver/server/server.yaml
env HTTPS_PROXY=http://localhost:8118 \
  kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/istio-samples/master/sample-apps/helloserver/loadgen/loadgen.yaml

Um zu überprüfen, ob Sie sich Logs aus Ihrem Cluster im Cloud Logging-Dashboard ansehen können, rufen Sie in der Google Cloud Console den Log-Explorer auf:

Zum Log-Explorer
Kopieren Sie die folgende Beispielabfrage in das Feld Query Builder.
```
resource.type="k8s_container" resource.labels.cluster_name="CLUSTER_NAME"
```
Ersetzen Sie CLUSTER_NAME durch den Clusternamen.
Klicken Sie auf Abfrage ausführen. Unter Abfrageergebnisse sollten aktuelle Clusterlogs angezeigt werden.

Nachdem Sie bestätigt haben, dass die Logs in den Abfrageergebnissen angezeigt werden, entfernen Sie den Load Generator und den Webserver.

env HTTPS_PROXY=http://localhost:8118 \
  kubectl delete -f https://raw.githubusercontent.com/GoogleCloudPlatform/istio-samples/master/sample-apps/helloserver/loadgen/loadgen.yaml

env HTTPS_PROXY=http://localhost:8118 \
  kubectl delete -f https://raw.githubusercontent.com/GoogleCloudPlatform/istio-samples/master/sample-apps/helloserver/server/server.yaml

Messwert-Collector installieren

In diesem Abschnitt installieren Sie einen Agent, um Daten an Cloud Monitoring zu senden.

Wechseln Sie vom Verzeichnis anthos-samples/aws-logging-monitoring/logging/ in das Verzeichnis anthos-samples/aws-logging-monitoring/monitoring/.
```
cd ../monitoring
```
Ändern Sie die Datei gke-metrics-agent.yaml entsprechend Ihrer Projektkonfiguration:
```
sed -i "s/PROJECT_ID/PROJECT_ID/g" gke-metrics-agent.yaml
sed -i "s/CLUSTER_NAME/CLUSTER_NAME/g" gke-metrics-agent.yaml
sed -i "s/CLUSTER_LOCATION/GC_REGION/g" gke-metrics-agent.yaml
```
Dabei gilt:
- PROJECT_ID: Ihre Projekt-ID.
- CLUSTER_NAME: Der Name Ihres Clusters, z. B. cluster-0
- GC_REGION: Die Google Cloud-Region, in der Sie Logs speichern möchten. Wählen Sie eine Region in der Nähe der AWS-Region aus. Weitere Informationen finden Sie unter Globale Standorte: Regionen und Zonen, z. B. us-central1.
(Optional) Basierend auf Ihren Arbeitslasten, der Anzahl der Knoten in Ihrem Cluster und der Anzahl der Pods pro Knoten müssen Sie möglicherweise Speicher- und CPU-Ressourcenanfragen festlegen. Weitere Informationen finden Sie unter Empfohlene CPU- und Speicherzuweisungen.

Erstellen Sie das Dienstkonto stackdriver, falls es nicht vorhanden ist, und stellen Sie den Messwert-Agent im Cluster bereit.

env HTTPS_PROXY=http://localhost:8118 \
  kubectl create serviceaccount stackdriver -n kube-system
env HTTPS_PROXY=http://localhost:8118 \
  kubectl apply -f gke-metrics-agent.yaml

Prüfen Sie mit dem kubectl-Tool, ob der Pod gke-metrics-agent ausgeführt wird.

env HTTPS_PROXY=http://localhost:8118 \
  kubectl get pods -n kube-system | grep gke-metrics-agent

In einem Knotenpool sollte jeweils ein Agent-Pod pro Knoten angezeigt werden. Beispiel: In einem Cluster mit drei Knoten sollten drei Agent-Pods angezeigt werden.

gke-metrics-agent-gjxdj                    2/2     Running   0          102s
gke-metrics-agent-lrnzl                    2/2     Running   0          102s
gke-metrics-agent-s6p47                    2/2     Running   0          102s

Rufen Sie in der Google Cloud Console den Metrics Explorer auf, um zu prüfen, ob Ihre Clustermesswerte in Cloud Monitoring exportiert werden:

Zum Metrics Explorer
Klicken Sie im Metrics Explorer auf Abfrageeditor und kopieren Sie dann den folgenden Befehl:
```
fetch k8s_container
| metric 'kubernetes.io/anthos/otelcol_exporter_sent_metric_points'
| filter
    resource.project_id == 'PROJECT_ID'
    && (resource.cluster_name =='CLUSTER_NAME')
| align rate(1m)
| every 1m
```
Dabei gilt:
- PROJECT_ID: Ihre Projekt-ID.
- CLUSTER_NAME: der Clustername, den Sie beim Erstellen eines Nutzerclusters verwendet haben, z. B. cluster-0
Klicken Sie auf Abfrage ausführen. Die Rate der Messwertpunkte, die von jedem gke-metrics-agent-Pod im Cluster an Cloud Monitoring gesendet werden, wird angezeigt.

Hinweis: Es kann einige Minuten dauern, bis Messwerte im Metrics Explorer sichtbar sind.

Hier einige weitere interessante Messwerte:
- kubernetes.io/anthos/container_memory_working_set_bytes: Container-Speichernutzung;
- kubernetes.io/anthos/container_cpu_usage_seconds_total: Container-CPU-Nutzung;
- kubernetes.io/anthos/apiserver_aggregated_request_total: Anzahl der kube-apiserver-Anfragen. Nur verfügbar, wenn Cloud Monitoring auf der Steuerungsebene aktiviert ist.
Eine vollständige Liste der verfügbaren Messwerte finden Sie unter Anthos-Messwerte. Weitere Informationen zur Verwendung der Benutzeroberfläche finden Sie unter Metrics Explorer.

Dashboard in Cloud Monitoring erstellen

In diesem Abschnitt erstellen Sie ein Cloud Monitoring-Dashboard, das den Containerstatus in Ihrem Cluster überwacht.

Wechseln Sie vom Verzeichnis anthos-samples/aws-logging-monitoring/monitoring/ in das Verzeichnis anthos-samples/aws-logging-monitoring/monitoring/dashboards.
```
cd dashboards
```
Ersetzen Sie Instanzen des CLUSTER_NAME-Strings in pod-status.json durch Ihren Clusternamen.
```
sed -i "s/CLUSTER_NAME/CLUSTER_NAME/g" pod-status.json
```
Ersetzen Sie CLUSTER_NAME durch den Clusternamen.
Erstellen Sie mithilfe des folgenden Befehls ein benutzerdefiniertes Dashboard mit der Konfigurationsdatei:
```
gcloud monitoring dashboards create --config-from-file=pod-status.json
```
Rufen Sie in der Google Cloud Console die Cloud Monitoring-Dashboards auf, um zu überprüfen, ob das Dashboard erstellt wurde.

Dashboards aufrufen

Öffnen Sie das neu erstellte Dashboard mit einem Namen im Format CLUSTER_NAME (Anthos cluster on AWS) pod status.

Bereinigen

In diesem Abschnitt entfernen Sie die Logging- und Monitoring-Komponenten aus dem Cluster.

Löschen Sie das Monitoring-Dashboard in der Dashboard-Listenansicht der Google Cloud Console, indem Sie auf die Schaltfläche "Löschen" klicken, die dem Dashboard-Namen zugeordnet ist.
Wechseln Sie in das Verzeichnis anthos-samples/aws-logging-monitoring/:
```
cd anthos-samples/aws-logging-monitoring
```

Führen Sie die folgenden Befehle aus, um alle in diesem Leitfaden erstellten Ressourcen zu entfernen:

env HTTPS_PROXY=http://localhost:8118 \
  kubectl delete -f logging/
env HTTPS_PROXY=http://localhost:8118 \
  kubectl delete -f monitoring/

Empfohlene CPU- und Speicherzuweisungen

Dieser Abschnitt enthält die empfohlene CPU und die Zuweisungen für die einzelnen Komponenten, die in Logging und Monitoring verwendet werden. Jede der folgenden Tabellen enthält die CPU- und Speicheranforderungen für einen Cluster mit einer Reihe von Knotengrößen. Ressourcenanfragen für eine Komponente werden in der Datei in der Tabelle festgelegt.

Weitere Informationen finden Sie unter Best Practices für Kubernetes: Ressourcenanforderungen und -limits und Ressourcen für Container verwalten.

1-10-Knoten

Datei	Ressource	CPU-Anforderungen	CPU-Beschränkungen	Speicheranforderungen	Beschränkungen des Arbeitsspeichers
`monitoring/gke-metrics-agent.yaml`	gke-metrics-agent	30 m	100 m	50 Mi	500 Mi
`logging/forwarder.yaml`	stackdriver-log-forwarder	50 m	100 m	100 Mi	600 Mi

10 bis 100 Knoten

Datei	Ressource	CPU-Anforderungen	CPU-Beschränkungen	Speicheranforderungen	Beschränkungen des Arbeitsspeichers
`monitoring/gke-metrics-agent.yaml`	gke-metrics-agent	50 m	100 m	50 Mi	500 Mi
`logging/forwarder.yaml`	stackdriver-log-forwarder	60m	100 m	100 Mi	600 Mi

Mehr als 100 Knoten

Datei	Ressource	CPU-Anforderungen	CPU-Beschränkungen	Speicheranforderungen	Beschränkungen des Arbeitsspeichers
`monitoring/gke-metrics-agent.yaml`	gke-metrics-agent	50 m	100 m	100 Mi	–
`logging/forwarder.yaml`	stackdriver-log-forwarder	60m	100 m	100 Mi	600 Mi