Diese Seite wurde von der Cloud Translation API übersetzt.

Fehlerbehebung beim Logging in GKE

Autopilot Standard

Probleme mit der Logging-Pipeline in Google Kubernetes Engine (GKE) können verhindern, dass Ihre Clusterlogs in Cloud Logging angezeigt werden. Dies kann Ihre Bemühungen zur Überwachung und Fehlerbehebung behindern.

In diesem Dokument wird beschrieben, wie Sie häufige Probleme mit der GKE-Logging-Pipeline diagnostizieren und beheben. Hier finden Sie Informationen zur Fehlerbehebung bei der Logging-Pipeline. Dazu werden wichtige Bereiche wie die Aktivierung von APIs und Funktionen, Cluster- und Knotenkonfigurationen, Berechtigungen und Ressourcenkontingente untersucht.

Diese Informationen sind wichtig für Plattformadministratoren und ‑operatoren, die für die Aufrechterhaltung der Cluster-Beobachtbarkeit verantwortlich sind, sowie für alle, die Cloud Logging zur Fehlerbehebung bei GKE-Vorgängen verwenden. Weitere Informationen zu den gängigen Rollen und Beispielaufgaben, auf die wir in Google Cloud -Inhalten verweisen, finden Sie unter Häufig verwendete GKE-Nutzerrollen und ‑Aufgaben.

Weitere Informationen zur Verwendung von Logs zur Fehlerbehebung bei Arbeitslasten und Clustern finden Sie unter Verlaufsanalyse mit Cloud Logging durchführen.

Fehlende Cluster-Logs in Cloud Logging

Prüfen, ob das Logging im Projekt aktiviert ist

Aktivierte Dienste auflisten:

gcloud services list --enabled --filter="NAME=logging.googleapis.com"

Die folgende Ausgabe zeigt an, dass das Logging für das Projekt aktiviert ist:

NAME                    TITLE
logging.googleapis.com  Cloud Logging API

Optional: Prüfen Sie die Logs in der Loganzeige, um festzustellen, wer die API deaktiviert hat und wann sie deaktiviert wurde:

protoPayload.methodName="google.api.serviceusage.v1.ServiceUsage.DisableService"
protoPayload.response.services="logging.googleapis.com"

Wenn das Logging deaktiviert ist, aktivieren Sie das Logging:
```
gcloud services enable logging.googleapis.com
```

Prüfen, ob das Logging für den Cluster aktiviert ist

Listen Sie die Cluster auf:

gcloud container clusters list \
    --project=PROJECT_ID \
    '--format=value(name,loggingConfig.componentConfig.enableComponents)' \
    --sort-by=name | column -t

Ersetzen Sie Folgendes:

PROJECT_ID: Projekt-ID in Google Cloud .

Die Ausgabe sieht etwa so aus:

cluster-1              SYSTEM_COMPONENTS
cluster-2              SYSTEM_COMPONENTS;WORKLOADS
cluster-3

Wenn der Wert für Ihren Cluster leer ist, ist das Logging deaktiviert. Beispiel: In dieser Ausgabe ist fürcluster-3 das Logging deaktiviert.

Aktivieren Sie das Cluster-Logging, wenn Sie auf NONE gesetzt sind:
```
gcloud container clusters update CLUSTER_NAME  \
    --logging=SYSTEM,WORKLOAD \
    --location=COMPUTE_LOCATION
```
Dabei gilt:
- CLUSTER_NAME: Der Name Ihres Clusters.
- COMPUTE_LOCATION: der Compute Engine-Standort für Ihren Cluster.

Nachdem Sie überprüft haben, dass das Logging in Ihrem Projekt und im Cluster aktiviert ist, können Sie Gemini Cloud Assist-Prüfungen verwenden, um zusätzliche Informationen aus Ihren Logs zu erhalten und Probleme zu beheben. Weitere Informationen zu den verschiedenen Möglichkeiten, eine Untersuchung mit dem Log-Explorer zu starten, finden Sie in der Gemini-Dokumentation unter Probleme mit Gemini Cloud Assist-Prüfungen beheben.

Prüfen, ob Knoten in den Knotenpools den Cloud Logging-Zugriffsbereich haben

Einer der folgenden Bereiche ist erforderlich, damit Knoten Logs in Cloud Logging schreiben können:

https://www.googleapis.com/auth/logging.write
https://www.googleapis.com/auth/cloud-platform
https://www.googleapis.com/auth/logging.admin

Prüfen Sie die Bereiche, die in jedem Knotenpool im Cluster konfiguriert sind:
```
gcloud container node-pools list --cluster=CLUSTER_NAME \
    --format="table(name,config.oauthScopes)" \
    --location COMPUTE_LOCATION
```
Dabei gilt:
- CLUSTER_NAME: Der Name Ihres Clusters.
- COMPUTE_LOCATION: der Compute Engine-Standort für Ihren Cluster.
Migrieren Sie Ihre Arbeitslasten vom alten Knotenpool zum neu erstellten Knotenpool und überwachen Sie den Fortschritt.
Erstellen Sie neue Knotenpools mit dem richtigen Logging-Bereich:
```
gcloud container node-pools create NODE_POOL_NAME \
    --cluster=CLUSTER_NAME \
    --location=COMPUTE_LOCATION \
    --scopes="gke-default"
```
Dabei gilt:
- CLUSTER_NAME: Der Name Ihres Clusters.
- COMPUTE_LOCATION: der Compute Engine-Standort für Ihren Cluster.

Sicherstellen, dass die standardmäßigen GKE-Knotendienstkonten die erforderlichen Berechtigungen haben

Für GKE-Cluster mit Kubernetes-Version 1.33 oder höher muss dem GKE-Standardknoten-Dienst-Agent im Format service-PROJECT_NUMBER@gcp-sa-gkenode.iam.gserviceaccount.com die Rolle „Kubernetes Default Node Service Agent“ in Ihrem Projekt zugewiesen werden. Dieser Dienst-Agent wird von allen Google Kubernetes Engine-Knotensystemarbeitslasten verwendet, um Logs in Cloud Logging zu exportieren. Folgen Sie der Anleitung unter Fehler 400/403: Dem Konto fehlen Bearbeitungsberechtigungen, um sicherzustellen, dass der Dienst-Agent seine Standardberechtigungen hat.

Cluster mit Knotendienstkonten identifizieren, denen wichtige Berechtigungen fehlen

Wenn Sie Cluster mit Knotendienstkonten identifizieren möchten, denen wichtige Berechtigungen fehlen, verwenden Sie GKE-Empfehlungen des NODE_SA_MISSING_PERMISSIONS-Empfehlungssubtyps:

Verwenden Sie die Google Cloud Console. Rufen Sie die Seite Kubernetes-Cluster auf. Suchen Sie in der Spalte Benachrichtigungen für bestimmte Cluster nach der Empfehlung Wichtige Berechtigungen erteilen.

Verwenden Sie die gcloud CLI oder die Recommender API und geben Sie den Recommender-Untertyp NODE_SA_MISSING_PERMISSIONS an.

Führen Sie den folgenden Befehl aus, um diese Empfehlung abzufragen:

gcloud recommender recommendations list \
    --recommender=google.container.DiagnosisRecommender \
    --location LOCATION \
    --project PROJECT_ID \
    --format yaml \
    --filter="recommenderSubtype:NODE_SA_MISSING_PERMISSIONS"

Weisen Sie dem Dienstkonto des Knotens die Rolle roles/container.defaultNodeServiceAccount zu, um diese Empfehlung umzusetzen.

Sie können ein Skript ausführen, das in den Standard- und Autopilot-Clustern Ihres Projekts nach Knotendienstkonten sucht, die nicht die erforderlichen Berechtigungen für GKE haben. In diesem Skript werden die gcloud CLI und das jq-Dienstprogramm verwendet. Wenn Sie das Skript aufrufen möchten, maximieren Sie den folgenden Abschnitt:

Skript ansehen

#!/bin/bash

# Set your project ID
project_id=PROJECT_ID
project_number=$(gcloud projects describe "$project_id" --format="value(projectNumber)")
declare -a all_service_accounts
declare -a sa_missing_permissions

# Function to check if a service account has a specific permission
# $1: project_id
# $2: service_account
# $3: permission
service_account_has_permission() {
  local project_id="$1"
  local service_account="$2"
  local permission="$3"

  local roles=$(gcloud projects get-iam-policy "$project_id" \
          --flatten="bindings[].members" \
          --format="table[no-heading](bindings.role)" \
          --filter="bindings.members:\"$service_account\"")

  for role in $roles; do
    if role_has_permission "$role" "$permission"; then
      echo "Yes" # Has permission
      return
    fi
  done

  echo "No" # Does not have permission
}

# Function to check if a role has the specific permission
# $1: role
# $2: permission
role_has_permission() {
  local role="$1"
  local permission="$2"
  gcloud iam roles describe "$role" --format="json" | \
  jq -r ".includedPermissions" | \
  grep -q "$permission"
}

# Function to add $1 into the service account array all_service_accounts
# $1: service account
add_service_account() {
  local service_account="$1"
  all_service_accounts+=( ${service_account} )
}

# Function to add service accounts into the global array all_service_accounts for a Standard GKE cluster
# $1: project_id
# $2: location
# $3: cluster_name
add_service_accounts_for_standard() {
  local project_id="$1"
  local cluster_location="$2"
  local cluster_name="$3"

  while read nodepool; do
    nodepool_name=$(echo "$nodepool" | awk '{print $1}')
    if [[ "$nodepool_name" == "" ]]; then
      # skip the empty line which is from running `gcloud container node-pools list` in GCP console
      continue
    fi
    while read nodepool_details; do
      service_account=$(echo "$nodepool_details" | awk '{print $1}')

      if [[ "$service_account" == "default" ]]; then
        service_account="${project_number}-compute@developer.gserviceaccount.com"
      fi
      if [[ -n "$service_account" ]]; then
        printf "%-60s| %-40s| %-40s| %-10s| %-20s\n" $service_account $project_id  $cluster_name $cluster_location $nodepool_name
        add_service_account "${service_account}"
      else
        echo "cannot find service account for node pool $project_id\t$cluster_name\t$cluster_location\t$nodepool_details"
      fi
    done <<< "$(gcloud container node-pools describe "$nodepool_name" --cluster "$cluster_name" --zone "$cluster_location" --project "$project_id" --format="table[no-heading](config.serviceAccount)")"
  done <<< "$(gcloud container node-pools list --cluster "$cluster_name" --zone "$cluster_location" --project "$project_id" --format="table[no-heading](name)")"

}

# Function to add service accounts into the global array all_service_accounts for an Autopilot GKE cluster
# Autopilot cluster only has one node service account.
# $1: project_id
# $2: location
# $3: cluster_name
add_service_account_for_autopilot(){
  local project_id="$1"
  local cluster_location="$2"
  local cluster_name="$3"

  while read service_account; do
      if [[ "$service_account" == "default" ]]; then
        service_account="${project_number}-compute@developer.gserviceaccount.com"
      fi
      if [[ -n "$service_account" ]]; then
        printf "%-60s| %-40s| %-40s| %-10s| %-20s\n" $service_account $project_id  $cluster_name $cluster_location $nodepool_name
        add_service_account "${service_account}"
      else
        echo "cannot find service account" for cluster  "$project_id\t$cluster_name\t$cluster_location\t"
      fi
  done <<< "$(gcloud container clusters describe "$cluster_name" --location "$cluster_location" --project "$project_id" --format="table[no-heading](autoscaling.autoprovisioningNodePoolDefaults.serviceAccount)")"
}


# Function to check whether the cluster is an Autopilot cluster or not
# $1: project_id
# $2: location
# $3: cluster_name
is_autopilot_cluster() {
  local project_id="$1"
  local cluster_location="$2"
  local cluster_name="$3"
  autopilot=$(gcloud container clusters describe "$cluster_name" --location "$cluster_location" --format="table[no-heading](autopilot.enabled)")
  echo "$autopilot"
}


echo "--- 1. List all service accounts in all GKE node pools"
printf "%-60s| %-40s| %-40s| %-10s| %-20s\n" "service_account" "project_id" "cluster_name" "cluster_location" "nodepool_name"
while read cluster; do
  cluster_name=$(echo "$cluster" | awk '{print $1}')
  cluster_location=$(echo "$cluster" | awk '{print $2}')
  # how to find a cluster is a Standard cluster or an Autopilot cluster
  autopilot=$(is_autopilot_cluster "$project_id" "$cluster_location" "$cluster_name")
  if [[ "$autopilot" == "True" ]]; then
    add_service_account_for_autopilot "$project_id" "$cluster_location"  "$cluster_name"
  else
    add_service_accounts_for_standard "$project_id" "$cluster_location"  "$cluster_name"
  fi
done <<< "$(gcloud container clusters list --project "$project_id" --format="value(name,location)")"

echo "--- 2. Check if service accounts have permissions"
unique_service_accounts=($(echo "${all_service_accounts[@]}" | tr ' ' '\n' | sort -u | tr '\n' ' '))

echo "Service accounts: ${unique_service_accounts[@]}"
printf "%-60s| %-40s| %-40s| %-20s\n" "service_account" "has_logging_permission" "has_monitoring_permission" "has_performance_hpa_metric_write_permission"
for sa in "${unique_service_accounts[@]}"; do
  logging_permission=$(service_account_has_permission "$project_id" "$sa" "logging.logEntries.create")
  time_series_create_permission=$(service_account_has_permission "$project_id" "$sa" "monitoring.timeSeries.create")
  metric_descriptors_create_permission=$(service_account_has_permission "$project_id" "$sa" "monitoring.metricDescriptors.create")
  if [[ "$time_series_create_permission" == "No" || "$metric_descriptors_create_permission" == "No" ]]; then
    monitoring_permission="No"
  else
    monitoring_permission="Yes"
  fi
  performance_hpa_metric_write_permission=$(service_account_has_permission "$project_id" "$sa" "autoscaling.sites.writeMetrics")
  printf "%-60s| %-40s| %-40s| %-20s\n" $sa $logging_permission $monitoring_permission $performance_hpa_metric_write_permission

  if [[ "$logging_permission" == "No" || "$monitoring_permission" == "No" || "$performance_hpa_metric_write_permission" == "No" ]]; then
    sa_missing_permissions+=( ${sa} )
  fi
done

echo "--- 3. List all service accounts that don't have the above permissions"
if [[ "${#sa_missing_permissions[@]}" -gt 0 ]]; then
  printf "Grant roles/container.defaultNodeServiceAccount to the following service accounts: %s\n" "${sa_missing_permissions[@]}"
else
  echo "All service accounts have the above permissions"
fi

Knotendienstkonten identifizieren, denen wichtige Berechtigungen in einem Cluster fehlen

GKE verwendet IAM-Dienstkonten, die an Ihre Knoten angehängt sind, um Systemaufgaben wie Logging und Monitoring auszuführen. Diese Knoten-Dienstkonten müssen in Ihrem Projekt mindestens die Rolle Kubernetes Engine Default Node Service Account (roles/container.defaultNodeServiceAccount) haben. Standardmäßig verwendet GKE das Compute Engine-Standarddienstkonto, das automatisch in Ihrem Projekt erstellt wird, als Knotendienstkonto.

Wenn Ihre Organisation die Einschränkung der Organisationsrichtlinie iam.automaticIamGrantsForDefaultServiceAccounts erzwingt, erhält das Compute Engine-Standarddienstkonto in Ihrem Projekt möglicherweise nicht automatisch die erforderlichen Berechtigungen für GKE.

So prüfen Sie, ob Berechtigungen für die Protokollierung fehlen: Suchen Sie in der Protokollierung Ihres Clusters nach 401-Fehlern:
```
[[ $(kubectl logs -l k8s-app=fluentbit-gke -n kube-system -c fluentbit-gke | grep -cw "Received 401") -gt 0 ]] && echo "true" || echo "false"
```
Wenn die Ausgabe true ist, treten bei der Systemarbeitslast 401-Fehler auf, die auf fehlende Berechtigungen hinweisen. Wenn die Ausgabe false ist, überspringen Sie die restlichen Schritte und versuchen Sie es mit einer anderen Vorgehensweise zur Fehlerbehebung.Um alle fehlenden kritischen Berechtigungen zu ermitteln, sehen Sie sich das Script an.

So finden Sie den Namen des Dienstkontos, das von Ihren Knoten verwendet wird:
Console
1. Zur Seite Kubernetes-Cluster
  Zur Seite "Kubernetes-Cluster"
2. Klicken Sie in der Clusterliste auf den Namen des Clusters, den Sie prüfen möchten.
3. Führen Sie je nach Clustermodus einen der folgenden Schritte aus:
  
  Suchen Sie bei Clustern im Autopilot-Modus im Abschnitt Sicherheit nach dem Feld Dienstkonto.
  
  Gehen Sie für Cluster im Standardmodus so vor:
  
  Klicken Sie auf den Tab Knoten.
  
  Klicken Sie in der Tabelle Knotenpools auf einen Knotenpoolnamen. Die Seite Knotenpooldetails wird geöffnet.
  
  Suchen Sie im Abschnitt Sicherheit nach dem Feld Dienstkonto.
Wenn der Wert im Feld Dienstkonto default ist, verwenden Ihre Knoten das Compute Engine-Standarddienstkonto. Wenn der Wert in diesem Feld nicht default ist, verwenden Ihre Knoten ein benutzerdefiniertes Dienstkonto. Informationen zum Zuweisen der erforderlichen Rolle zu einem benutzerdefinierten Dienstkonto finden Sie unter IAM-Dienstkonten mit geringsten Berechtigungen verwenden.
gcloud

Führen Sie für Cluster im Autopilot-Modus den folgenden Befehl aus:
gcloud container clusters describe CLUSTER_NAME \ --location=LOCATION \ --flatten=autoscaling.autoprovisioningNodePoolDefaults.serviceAccount
Führen Sie für Cluster im Standardmodus den folgenden Befehl aus:
gcloud container clusters describe CLUSTER_NAME \ --location=LOCATION \ --format="table(nodePools.name,nodePools.config.serviceAccount)"
Wenn die Ausgabe default ist, verwenden Ihre Knoten das Compute Engine-Standarddienstkonto. Wenn die Ausgabe nicht default ist, verwenden Ihre Knoten ein benutzerdefiniertes Dienstkonto. Informationen zum Zuweisen der erforderlichen Rolle zu einem benutzerdefinierten Dienstkonto finden Sie unter IAM-Dienstkonten mit geringsten Berechtigungen verwenden.
So weisen Sie dem Compute Engine-Standarddienstkonto die Rolle roles/container.defaultNodeServiceAccount zu:
Console
1. Rufen Sie die Seite Willkommen auf:
  Zur Begrüßungsseite
2. Klicken Sie im Feld Projektnummer auf In die Zwischenablage kopieren.
3. Rufen Sie die IAM-Seite auf.
  IAM aufrufen
4. Klicken Sie auf Zugriffsrechte erteilen.
5. Geben Sie im Feld Neue Hauptkonten den folgenden Wert an:
  PROJECT_NUMBER-compute@developer.gserviceaccount.com
  Ersetzen Sie PROJECT_NUMBER durch die kopierte Projektnummer.
6. Wählen Sie im Menü Rolle auswählen die Rolle Kubernetes Engine Default Node Service Account aus.
7. Klicken Sie auf Speichern.
gcloud
1. So finden Sie Ihre Google Cloud Projektnummer:
  gcloud projects describe PROJECT_ID \ --format="value(projectNumber)"
  
  Ersetzen Sie PROJECT_ID durch Ihre Projekt-ID.
  
  Die Ausgabe sieht etwa so aus:
  
  12345678901
2. Weisen Sie dem Compute Engine-Standarddienstkonto die Rolle roles/container.defaultNodeServiceAccount zu:
  gcloud projects add-iam-policy-binding PROJECT_ID \ --member="serviceAccount:PROJECT_NUMBER-compute@developer.gserviceaccount.com" \ --role="roles/container.defaultNodeServiceAccount"
  
  Ersetzen Sie PROJECT_NUMBER durch die Projektnummer aus dem vorherigen Schritt.

Prüfen Sie, ob Knotendienstkonten die erforderlichen Berechtigungen haben. Prüfen Sie das Script , um dies zu bestätigen.

Ein Skript zum Ermitteln fehlender Berechtigungen für das GKE-Knotendienstkonto

Skript ansehen

#!/bin/bash

# Set your project ID
project_id=PROJECT_ID
project_number=$(gcloud projects describe "$project_id" --format="value(projectNumber)")
declare -a all_service_accounts
declare -a sa_missing_permissions

# Function to check if a service account has a specific permission
# $1: project_id
# $2: service_account
# $3: permission
service_account_has_permission() {
  local project_id="$1"
  local service_account="$2"
  local permission="$3"

  local roles=$(gcloud projects get-iam-policy "$project_id" \
          --flatten="bindings[].members" \
          --format="table[no-heading](bindings.role)" \
          --filter="bindings.members:\"$service_account\"")

  for role in $roles; do
    if role_has_permission "$role" "$permission"; then
      echo "Yes" # Has permission
      return
    fi
  done

  echo "No" # Does not have permission
}

# Function to check if a role has the specific permission
# $1: role
# $2: permission
role_has_permission() {
  local role="$1"
  local permission="$2"
  gcloud iam roles describe "$role" --format="json" | \
  jq -r ".includedPermissions" | \
  grep -q "$permission"
}

# Function to add $1 into the service account array all_service_accounts
# $1: service account
add_service_account() {
  local service_account="$1"
  all_service_accounts+=( ${service_account} )
}

# Function to add service accounts into the global array all_service_accounts for a Standard GKE cluster
# $1: project_id
# $2: location
# $3: cluster_name
add_service_accounts_for_standard() {
  local project_id="$1"
  local cluster_location="$2"
  local cluster_name="$3"

  while read nodepool; do
    nodepool_name=$(echo "$nodepool" | awk '{print $1}')
    if [[ "$nodepool_name" == "" ]]; then
      # skip the empty line which is from running `gcloud container node-pools list` in GCP console
      continue
    fi
    while read nodepool_details; do
      service_account=$(echo "$nodepool_details" | awk '{print $1}')

      if [[ "$service_account" == "default" ]]; then
        service_account="${project_number}-compute@developer.gserviceaccount.com"
      fi
      if [[ -n "$service_account" ]]; then
        printf "%-60s| %-40s| %-40s| %-10s| %-20s\n" $service_account $project_id  $cluster_name $cluster_location $nodepool_name
        add_service_account "${service_account}"
      else
        echo "cannot find service account for node pool $project_id\t$cluster_name\t$cluster_location\t$nodepool_details"
      fi
    done <<< "$(gcloud container node-pools describe "$nodepool_name" --cluster "$cluster_name" --zone "$cluster_location" --project "$project_id" --format="table[no-heading](config.serviceAccount)")"
  done <<< "$(gcloud container node-pools list --cluster "$cluster_name" --zone "$cluster_location" --project "$project_id" --format="table[no-heading](name)")"

}

# Function to add service accounts into the global array all_service_accounts for an Autopilot GKE cluster
# Autopilot cluster only has one node service account.
# $1: project_id
# $2: location
# $3: cluster_name
add_service_account_for_autopilot(){
  local project_id="$1"
  local cluster_location="$2"
  local cluster_name="$3"

  while read service_account; do
      if [[ "$service_account" == "default" ]]; then
        service_account="${project_number}-compute@developer.gserviceaccount.com"
      fi
      if [[ -n "$service_account" ]]; then
        printf "%-60s| %-40s| %-40s| %-10s| %-20s\n" $service_account $project_id  $cluster_name $cluster_location $nodepool_name
        add_service_account "${service_account}"
      else
        echo "cannot find service account" for cluster  "$project_id\t$cluster_name\t$cluster_location\t"
      fi
  done <<< "$(gcloud container clusters describe "$cluster_name" --location "$cluster_location" --project "$project_id" --format="table[no-heading](autoscaling.autoprovisioningNodePoolDefaults.serviceAccount)")"
}


# Function to check whether the cluster is an Autopilot cluster or not
# $1: project_id
# $2: location
# $3: cluster_name
is_autopilot_cluster() {
  local project_id="$1"
  local cluster_location="$2"
  local cluster_name="$3"
  autopilot=$(gcloud container clusters describe "$cluster_name" --location "$cluster_location" --format="table[no-heading](autopilot.enabled)")
  echo "$autopilot"
}


echo "--- 1. List all service accounts in all GKE node pools"
printf "%-60s| %-40s| %-40s| %-10s| %-20s\n" "service_account" "project_id" "cluster_name" "cluster_location" "nodepool_name"
while read cluster; do
  cluster_name=$(echo "$cluster" | awk '{print $1}')
  cluster_location=$(echo "$cluster" | awk '{print $2}')
  # how to find a cluster is a Standard cluster or an Autopilot cluster
  autopilot=$(is_autopilot_cluster "$project_id" "$cluster_location" "$cluster_name")
  if [[ "$autopilot" == "True" ]]; then
    add_service_account_for_autopilot "$project_id" "$cluster_location"  "$cluster_name"
  else
    add_service_accounts_for_standard "$project_id" "$cluster_location"  "$cluster_name"
  fi
done <<< "$(gcloud container clusters list --project "$project_id" --format="value(name,location)")"

echo "--- 2. Check if service accounts have permissions"
unique_service_accounts=($(echo "${all_service_accounts[@]}" | tr ' ' '\n' | sort -u | tr '\n' ' '))

echo "Service accounts: ${unique_service_accounts[@]}"
printf "%-60s| %-40s| %-40s| %-20s\n" "service_account" "has_logging_permission" "has_monitoring_permission" "has_performance_hpa_metric_write_permission"
for sa in "${unique_service_accounts[@]}"; do
  logging_permission=$(service_account_has_permission "$project_id" "$sa" "logging.logEntries.create")
  time_series_create_permission=$(service_account_has_permission "$project_id" "$sa" "monitoring.timeSeries.create")
  metric_descriptors_create_permission=$(service_account_has_permission "$project_id" "$sa" "monitoring.metricDescriptors.create")
  if [[ "$time_series_create_permission" == "No" || "$metric_descriptors_create_permission" == "No" ]]; then
    monitoring_permission="No"
  else
    monitoring_permission="Yes"
  fi
  performance_hpa_metric_write_permission=$(service_account_has_permission "$project_id" "$sa" "autoscaling.sites.writeMetrics")
  printf "%-60s| %-40s| %-40s| %-20s\n" $sa $logging_permission $monitoring_permission $performance_hpa_metric_write_permission

  if [[ "$logging_permission" == "No" || "$monitoring_permission" == "No" || "$performance_hpa_metric_write_permission" == "No" ]]; then
    sa_missing_permissions+=( ${sa} )
  fi
done

echo "--- 3. List all service accounts that don't have the above permissions"
if [[ "${#sa_missing_permissions[@]}" -gt 0 ]]; then
  printf "Grant roles/container.defaultNodeServiceAccount to the following service accounts: %s\n" "${sa_missing_permissions[@]}"
else
  echo "All service accounts have the above permissions"
fi

Prüfen, dass die Cloud Logging Write-API-Kontingente nicht erreicht wurden

Überzeugen Sie sich, dass Sie die API-Write-kontingente für Cloud Logging nicht erreicht haben.

Rufen Sie in der Google Cloud Console die Seite Kontingente auf.

Kontingente aufrufen
Filtern Sie die Tabelle nach "Cloud Logging API".
Schauen Sie nach, dass Sie keines der Kontingente erreicht haben.

GKE-Logging-Probleme mit `gcpdiag` beheben

Wenn Sie unvollständige Logs in Ihrem GKE-Cluster fehlen oder diese abrufen, verwenden Sie das gcpdiag-Tool zur Fehlerbehebung.

gcpdiag ist ein Open-Source-Tool. Es ist kein offiziell unterstütztes Google Cloud -Produkt. Mit dem Tool gcpdiag können Sie Probleme mit Google Cloud-Projekten identifizieren und beheben. Weitere Informationen finden Sie im gcpdiag-Projekt auf GitHub.

Wenn Logs aus dem GKE-Cluster fehlen oder unvollständig sind, untersuchen Sie mögliche Ursachen, indem Sie sich auf die folgenden zentralen Konfigurationseinstellungen konzentrieren, die für ordnungsgemäße Logging-Funktionen wichtig sind:

Logging auf Projektebene:Sorgt dafür, dass im Google Cloud-Projekt, in dem sich der GKE-Cluster befindet, die Cloud Logging API aktiviert ist.
Logging auf Clusterebene: Überprüft, ob das Logging explizit in der Konfiguration des GKE-Clusters aktiviert ist.
Knotenpoolberechtigungen: Bestätigt, dass für die Knoten in den Knotenpools des Clusters der Bereich "Cloud Logging-Schreibvorgänge" aktiviert ist, sodass sie Logdaten senden können.
Dienstkontoberechtigungen: Prüft, ob das von den Knotenpools verwendete Dienstkonto die erforderlichen IAM-Berechtigungen für die Interaktion mit Cloud Logging hat. Insbesondere ist die Rolle "roles/logging.logWriter" normalerweise erforderlich.
Schreibkontingente für die Cloud Logging API: Verifiziert, dass die Schreibkontingente für die Cloud Logging API im angegebenen Zeitraum nicht überschritten wurden.

Docker

Sie können gcpdiag mit einem Wrapper ausführen, der gcpdiag in einem Docker-Container startet. Docker oder Podman muss installiert sein.

Kopieren Sie den folgenden Befehl und führen Sie ihn auf Ihrer lokalen Workstation aus.
```
curl https://gcpdiag.dev/gcpdiag.sh >gcpdiag && chmod +x gcpdiag
```

Führen Sie den Befehl gcpdiag aus.

./gcpdiag runbook gke/logs \
    --parameter project_id=PROJECT_ID \
    --parameter name=GKE_NAME \
    --parameter location=LOCATION

Verfügbare Parameter für dieses Runbook ansehen