Esta página foi traduzida pela API Cloud Translation.

Solução de problemas na geração de registros no GKE

Autopilot Standard

Problemas com o pipeline de geração de registros no Google Kubernetes Engine (GKE) podem impedir que os registros do cluster apareçam no Cloud Logging, dificultando seus esforços de monitoramento e depuração.

Use este documento para diagnosticar e resolver problemas comuns que afetam o pipeline de geração de registros do GKE. Encontre orientações sobre como resolver problemas no pipeline de geração de registros examinando áreas importantes, como ativação de API e recursos, configurações de cluster e nós, permissões e cotas de recursos.

Essas informações são importantes para administradores e operadores da plataforma responsáveis por manter a capacidade de observação do cluster e para qualquer pessoa que use o Cloud Logging para resolver problemas de operações do GKE. Para mais informações sobre as funções comuns e exemplos de tarefas que mencionamos no conteúdo do Google Cloud , consulte Funções e tarefas comuns do usuário do GKE.

Para mais informações sobre como usar registros para resolver problemas nas cargas de trabalho e nos clusters, consulte Fazer análises históricas com o Cloud Logging.

Registros de cluster ausentes no Cloud Logging

Verificar se a geração de registros está ativada no projeto

Listar serviços ativados:

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

A saída a seguir indica que a geração de registros está ativada para o projeto:

NAME                    TITLE
logging.googleapis.com  Cloud Logging API

Opcional: verifique os registros no Visualizador de registros para determinar quem desativou a API e quando ela foi desativada:

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

Se a geração de registros estiver desativada, ative-a:
```
gcloud services enable logging.googleapis.com
```

Verifique se a geração de registros está ativada no cluster

Liste os clusters:

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

Substitua:

PROJECT_ID: o ID do projeto Google Cloud .

O resultado será assim:

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

Se o valor do cluster estiver vazio, a geração de registros será desativada. Por exemplo, a geração de registros fica desativada para cluster-3 nesta saída.

Ative a geração de registros de cluster se definida como NONE:
```
gcloud container clusters update CLUSTER_NAME  \
    --logging=SYSTEM,WORKLOAD \
    --location=COMPUTE_LOCATION
```
Substitua:
- CLUSTER_NAME: o nome do cluster.
- COMPUTE_LOCATION: a região do Compute Engine para o cluster.

Depois de verificar se você ativou o registro em seu projeto e no cluster, use as Investigações do Gemini Cloud Assist para ter mais insights sobre seus registros e resolver problemas. Para mais informações sobre diferentes maneiras de iniciar uma investigação usando o Explorador de registros, consulte Resolver problemas com o Gemini Cloud Assist Investigations na documentação do Gemini.

Verificar se os nós nos pools de nós têm o escopo de acesso do Cloud Logging

Um dos escopos a seguir é necessário para que os nós gravem registros no Cloud Logging:

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

Verifique os escopos configurados em cada pool de nós no cluster:
```
gcloud container node-pools list --cluster=CLUSTER_NAME \
    --format="table(name,config.oauthScopes)" \
    --location COMPUTE_LOCATION
```
Substitua:
- CLUSTER_NAME: o nome do cluster.
- COMPUTE_LOCATION: a região do Compute Engine para o cluster.
Migre suas cargas de trabalho do pool de nós antigo para o pool de nós recém-criado e monitore o progresso.
Crie novos pools de nós com o escopo de geração de registros correto:
```
gcloud container node-pools create NODE_POOL_NAME \
    --cluster=CLUSTER_NAME \
    --location=COMPUTE_LOCATION \
    --scopes="gke-default"
```
Substitua:
- CLUSTER_NAME: o nome do cluster.
- COMPUTE_LOCATION: a região do Compute Engine para o cluster.

Verifique se os agentes de serviço de nó padrão do GKE têm as permissões necessárias

Para clusters do GKE que usam o Kubernetes versão 1.33 ou mais recente, o agente de serviço de nó padrão do GKE, que tem o formato service-PROJECT_NUMBER@gcp-sa-gkenode.iam.gserviceaccount.com, precisa receber o papel de agente de serviço de nó padrão do Kubernetes no seu projeto. Esse agente de serviço é usado por todas as cargas de trabalho do sistema de nós do Google Kubernetes Engine para exportar registros para o Cloud Logging. Siga as instruções em Erro 400/403: permissões de edição ausentes na conta para garantir que o agente de serviço tenha as permissões padrão.

Identificar clusters com contas de serviço de nó que não têm permissões essenciais

Para identificar clusters com contas de serviço de nó sem permissões críticas, use as recomendações do GKE do NODE_SA_MISSING_PERMISSIONS subtipo de recomendador:

Use o console do Google Cloud . Acesse a página Clusters do Kubernetes. Na coluna Notificações de clusters específicos, verifique a recomendação Conceder permissões essenciais.

Use a CLI gcloud ou a API Recommender especificando o subtipo NODE_SA_MISSING_PERMISSIONS do recomendador.

Para consultar essa recomendação, execute o seguinte comando:

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

Para implementar essa recomendação, conceda o papel roles/container.defaultNodeServiceAccount à conta de serviço do nó.

É possível executar um script que pesquisa pools de nós nos clusters Standard e Autopilot do projeto para encontrar contas de serviço de nós que não têm as permissões necessárias para o GKE. Esse script usa a CLI gcloud e o utilitário jq. Para ver o script, expanda a seção a seguir:

Ver o script

#!/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

Identificar contas de serviço de nós que não têm permissões essenciais em um cluster

O GKE usa contas de serviço do IAM anexadas aos nós para executar tarefas do sistema, como geração de registros e monitoramento. No mínimo, essas contas de serviço de nó precisam ter o papel Conta de serviço de nó padrão do Kubernetes Engine (roles/container.defaultNodeServiceAccount) no seu projeto. Por padrão, o GKE usa a conta de serviço padrão do Compute Engine, que é criada automaticamente no seu projeto, como a conta de serviço do nó.

Se a organização aplicar a restrição da política da organização iam.automaticIamGrantsForDefaultServiceAccounts, a conta de serviço padrão do Compute Engine no projeto talvez não receba automaticamente as permissões necessárias para o GKE.

Para verificar se as permissões de geração de registros estão faltando, procure erros 401 no registro do seu cluster:
```
[[ $(kubectl logs -l k8s-app=fluentbit-gke -n kube-system -c fluentbit-gke | grep -cw "Received 401") -gt 0 ]] && echo "true" || echo "false"
```
Se a saída for true, a carga de trabalho do sistema estará apresentando erros de 401, o que indica falta de permissões. Se a saída for false, pule o restante das etapas e tente outro procedimento de solução de problemas.Para identificar todas as permissões críticas ausentes, verifique o script.

Encontre o nome da conta de serviço usada pelos seus nós:
Console
1. Acesse a página Clusters do Kubernetes:
  Acessar os clusters do Kubernetes
2. Na lista de clusters, clique no nome do cluster que você quer inspecionar.
3. Dependendo do modo de operação do cluster, faça o seguinte:
  
  Para clusters no modo Autopilot, na seção Segurança, encontre o campo Conta de serviço.
  
  Para clusters no modo padrão, faça o seguinte:
  
  Clique na guia Nós.
  
  Na tabela Pools de nós, clique no nome de um pool de nós. A página Detalhes do pool de nós é aberta.
  
  Na seção Segurança, encontre o campo Conta de serviço.
Se o valor no campo Conta de serviço for default, os nós usarão a conta de serviço padrão do Compute Engine. Se o valor nesse campo não for default, seus nós usarão uma conta de serviço personalizada. Para conceder o papel necessário a uma conta de serviço personalizada, consulte Usar contas de serviço do IAM privilégio mínimo mínimos.
gcloud

Para clusters no modo Autopilot, execute o seguinte comando:
gcloud container clusters describe CLUSTER_NAME \ --location=LOCATION \ --flatten=autoscaling.autoprovisioningNodePoolDefaults.serviceAccount
Para clusters no modo padrão, execute o seguinte comando:
gcloud container clusters describe CLUSTER_NAME \ --location=LOCATION \ --format="table(nodePools.name,nodePools.config.serviceAccount)"
Se a saída for default, os nós usarão a conta de serviço padrão do Compute Engine. Se a saída não for default, seus nós usarão uma conta de serviço personalizada. Para conceder o papel necessário a uma conta de serviço personalizada, consulte Usar contas de serviço do IAM privilégio mínimo mínimos.
Para conceder o papel roles/container.defaultNodeServiceAccount à conta de serviço padrão do Compute Engine, siga estas etapas:
Console
1. Acesse a página Boas-vindas:
  Acessar "Boas-vindas"
2. No campo Número do projeto, clique em Copiar para a área de transferência.
3. Acesse a página do IAM:
  Acessar IAM
4. Clique em CONCEDER ACESSO.
5. No campo Novos principais, especifique o seguinte valor:
  PROJECT_NUMBER-compute@developer.gserviceaccount.com
  Substitua PROJECT_NUMBER pelo número do projeto que você copiou.
6. No menu Selecionar um papel, escolha o papel Conta de serviço de nó padrão do Kubernetes Engine.
7. Clique em Salvar.
gcloud
1. Encontre o número do seu projeto Google Cloud :
  gcloud projects describe PROJECT_ID \ --format="value(projectNumber)"
  
  Substitua PROJECT_ID pela ID do seu projeto.
  
  O resultado será assim:
  
  12345678901
2. Conceda o papel roles/container.defaultNodeServiceAccount à conta de serviço padrão do Compute Engine:
  gcloud projects add-iam-policy-binding PROJECT_ID \ --member="serviceAccount:PROJECT_NUMBER-compute@developer.gserviceaccount.com" \ --role="roles/container.defaultNodeServiceAccount"
  
  Substitua PROJECT_NUMBER pelo número do projeto da etapa anterior.

Verifique se as contas de serviço do nó têm as permissões necessárias. Confira o script para verificar.

Um script para identificar permissões ausentes para a conta de serviço do nó do GKE

Ver o script

#!/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

Verifique se as cotas da API de gravação do Cloud Logging não foram alcançadas

Confirme se você não atingiu as cotas de gravação da API para o Cloud Logging.

Acesse a página Cotas no console do Google Cloud .

Acesse Cotas
Filtre a tabela por "API Cloud Logging".
Confirme que você não atingiu as cotas.

Como depurar problemas de geração de registros do GKE com o `gcpdiag`

Se você estiver recebendo registros incompletos ou ausentes do cluster do GKE, use a ferramenta gcpdiag para solução de problemas.

gcpdiag é uma ferramenta de código aberto. Não é um produto Google Cloud com suporte oficial. Use a ferramenta gcpdiag para identificar e corrigir problemas no projeto Google Cloud. Para mais informações, consulte o projeto gcpdiag no GitHub.

Quando os registros do cluster do GKE está ausente ou incompleto, investigue a causa potencial focando nas seguintes configurações básicas, que são essenciais para funções de registro adequadas:

Geração de registros no nível do projeto:garante que o projeto Google Cloud que hospeda o cluster do GKE tem a API Cloud Logging ativada.
Geração de registros no nível do cluster: verifica se a geração de registros está explicitamente ativada na configuração do cluster do GKE.
Permissões do pool de nós: confirma se os nós nos pools de nós do cluster têm o escopo "Cloud Logging Write" ativado, permitindo que enviem dados de registro.
Permissões da conta de serviço: valida se a conta de serviço usada pelos pools de nós tem as permissões de IAM necessárias para interagir com o Cloud Logging. Especificamente, o papel "roles/logging.logWriter" é normalmente necessário.
Cotas de gravação da API Cloud Logging: verifica se as cotas de gravação da API Cloud Logging não foram excedidas dentro do período especificado.

Docker

Você pode executar gcpdiag usando um wrapper que inicia gcpdiag em um contêiner do Docker. Docker ou Podman precisa ser instalado.

Copie e execute o seguinte comando na estação de trabalho local.
```
curl https://gcpdiag.dev/gcpdiag.sh >gcpdiag && chmod +x gcpdiag
```

Execute o comando gcpdiag.

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

Veja os parâmetros disponíveis para este runbook.