Se usó la API de Cloud Translation para traducir esta página.

Soluciona problemas de registro en GKE

Autopilot Estándar

En esta página, se muestra cómo investigar y resolver problemas relacionados con el registro en GKE.

Si necesitas asistencia adicional, comunícate con Atención al cliente de Cloud.

Faltan registros de clústeres en Cloud Logging

Verifica que el registro esté habilitado en el proyecto

Enumera los servicios habilitados:

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

En el siguiente resultado, se indica que el registro está habilitado para el proyecto:

NAME                    TITLE
logging.googleapis.com  Cloud Logging API

Opcional: Revisa los registros en el visor de registros para determinar quién inhabilitó la API y cuándo la inhabilitó:

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

Si el registro está inhabilitado, habilítalo:

gcloud services enable logging.googleapis.com

Verifica que el registro esté habilitado en el clúster

Enumera los clústeres:

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

Reemplaza lo siguiente:

PROJECT_ID: El Google Cloud ID de tu proyecto.

El resultado es similar a este:

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

Si el valor de tu clúster está vacío, el registro se inhabilita. Por ejemplo, cluster-3 en esta salida tiene el registro inhabilitado.

Habilita el registro del clúster si está configurado como NONE:
```
gcloud container clusters update CLUSTER_NAME  \
    --logging=SYSTEM,WORKLOAD \
    --location=COMPUTE_LOCATION
```
Reemplaza lo siguiente:
- CLUSTER_NAME: es el nombre de tu clúster.
- COMPUTE_LOCATION: la ubicación de Compute Engine del clúster.

Verifica que los nodos de los grupos de nodos tengan permiso de acceso a Cloud Logging

Se requiere uno de los siguientes permisos para que los nodos escriban registros en Cloud Logging:

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

Verifica los permisos configurados en cada grupo de nodos en el clúster:
```
gcloud container node-pools list --cluster=CLUSTER_NAME \
    --format="table(name,config.oauthScopes)" \
    --location COMPUTE_LOCATION
```
Reemplaza lo siguiente:
- CLUSTER_NAME: es el nombre de tu clúster.
- COMPUTE_LOCATION: la ubicación de Compute Engine del clúster.
Migra tus cargas de trabajo del grupo de nodos anterior al grupo de nodos recién creado y supervisa el progreso.
Crea grupos de nodos nuevos con el permiso de registro correcto:
```
gcloud container node-pools create NODE_POOL_NAME \
    --cluster=CLUSTER_NAME \
    --location=COMPUTE_LOCATION \
    --scopes="gke-default"
```
Reemplaza lo siguiente:
- CLUSTER_NAME: es el nombre de tu clúster.
- COMPUTE_LOCATION: la ubicación de Compute Engine del clúster.

Identifica los clústeres con cuentas de servicio de nodos a las que les faltan permisos esenciales

Para identificar los clústeres con cuentas de servicio de nodos a las que les faltan permisos esenciales, usa las recomendaciones de GKE del subtipo de recomendador NODE_SA_MISSING_PERMISSIONS:

Uso de consola de Google Cloud. Ve a la página Clústeres de Kubernetes y busca la recomendación Otorgar permisos críticos en la columna Notificaciones para clústeres específicos.

Usa la CLI de gcloud o la API de Recommender y especifica el subtipo de recommender NODE_SA_MISSING_PERMISSIONS.

Para consultar las recomendaciones, ejecuta el siguiente comando:

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

Ten en cuenta que la recomendación puede tardar hasta 24 horas en aparecer. Para obtener instrucciones detalladas, consulta cómo ver estadísticas y recomendaciones.

Para implementar esta recomendación, otorga el rol roles/container.defaultNodeServiceAccount a la cuenta de servicio del nodo.

Puedes seguir esta secuencia de comandos para encontrar todas las cuentas de servicio de nodos que no tienen permisos fundamentales para los clústeres del modo estándar en un proyecto.

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


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}')

  while read nodepool; do
    nodepool_name=$(echo "$nodepool" | awk '{print $1}')

    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
        all_service_accounts+=( ${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)")"
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")
  monitoring_permission=$(service_account_has_permission "$project_id" "$sa" "monitoring.timeSeries.create")
  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

Identifica las cuentas de servicio de nodos a las que les faltan permisos esenciales en un clúster

GKE usa cuentas de servicio de IAM adjuntas a tus nodos para ejecutar tareas del sistema, como el registro y la supervisión. Como mínimo, estas cuentas de servicio de nodo deben tener el rol de cuenta de servicio de nodo predeterminado de Kubernetes Engine (roles/container.defaultNodeServiceAccount) en tu proyecto. De forma predeterminada, GKE usa la cuenta de servicio predeterminada de Compute Engine, que se crea automáticamente en tu proyecto, como la cuenta de servicio del nodo.

Si tu organización aplica de forma forzosa la restricción de la política de la organización iam.automaticIamGrantsForDefaultServiceAccounts, es posible que la cuenta de servicio predeterminada de Compute Engine en tu proyecto no obtenga automáticamente los permisos necesarios para GKE.

Para identificar el problema, busca errores 401 en la carga de trabajo de registro del sistema en tu clúster:
```
[[ $(kubectl logs -l k8s-app=fluentbit-gke -n kube-system -c fluentbit-gke | grep -cw "Received 401") -gt 0 ]] && echo "true" || echo "false"
```
Si el resultado es true, la carga de trabajo del sistema tiene errores 401, lo que indica que no hay permisos. Si el resultado es false,omite el resto de estos pasos y prueba otro procedimiento de solución de problemas.

Busca el nombre de la cuenta de servicio que usan tus nodos:
Console
1. Ve a la página Clústeres de Kubernetes:
  Ir a clústeres de Kubernetes
2. En la lista de clústeres, haz clic en el nombre del clúster que quieres inspeccionar.
3. Según el modo de operación del clúster, realiza una de las siguientes acciones:
  
  En el caso de los clústeres en modo Autopilot, en la sección Seguridad, busca el campo Cuenta de servicio.
  
  Para los clústeres en modo Standard, haz lo siguiente:
  
  Haz clic en la pestaña Nodos.
  
  En la tabla Grupos de nodos, haz clic en el nombre de un grupo de nodos. Se abrirá la página Detalles del grupo de nodos.
  
  En la sección Seguridad, busca el campo Cuenta de servicio.
Si el valor del campo Cuenta de servicio es default, tus nodos usan la cuenta de servicio predeterminada de Compute Engine. Si el valor de este campo no es default, tus nodos usan una cuenta de servicio personalizada. Para otorgar el rol requerido a una cuenta de servicio personalizada, consulta Usa cuentas de servicio de IAM con privilegios mínimos.
gcloud

Para los clústeres del modo Autopilot, ejecuta el siguiente comando:
gcloud container clusters describe CLUSTER_NAME \ --location=LOCATION \ --flatten=autoscaling.autoprovisioningNodePoolDefaults.serviceAccount
Para los clústeres del modo estándar, ejecuta el siguiente comando:
gcloud container clusters describe CLUSTER_NAME \ --location=LOCATION \ --format="table(nodePools.name,nodePools.config.serviceAccount)"
Si el resultado es default, tus nodos usan la cuenta de servicio predeterminada de Compute Engine. Si el resultado no es default, tus nodos usan una cuenta de servicio personalizada. Para otorgar el rol requerido a una cuenta de servicio personalizada, consulta Usa cuentas de servicio de IAM con privilegios mínimos.
Para otorgar el rol roles/container.defaultNodeServiceAccount a la cuenta de servicio predeterminada de Compute Engine, completa los siguientes pasos:
Console
1. Ve a la página Bienvenida:
  Ir a Bienvenida
2. En el campo Número del proyecto, haz clic en Copiar en el portapapeles.
3. Ve a la página IAM:
  Ir a IAM
4. Haz clic en Grant access.
5. En el campo Principales nuevas, especifica el siguiente valor:
  PROJECT_NUMBER-compute@developer.gserviceaccount.com
  Reemplaza PROJECT_NUMBER por el número de proyecto que copiaste.
6. En el menú Selecciona un rol, selecciona el rol de Cuenta de servicio de nodo predeterminado de Kubernetes Engine.
7. Haz clic en Guardar.
gcloud
1. Busca el Google Cloud número de proyecto:
  gcloud projects describe PROJECT_ID \ --format="value(projectNumber)"
  
  Reemplaza PROJECT_ID con el ID del proyecto.
  
  El resultado es similar a este:
  
  12345678901
2. Otorga el rol roles/container.defaultNodeServiceAccount a la cuenta de servicio predeterminada de Compute Engine:
  gcloud projects add-iam-policy-binding PROJECT_ID \ --member="serviceAccount:PROJECT_NUMBER-compute@developer.gserviceaccount.com" \ --role="roles/container.defaultNodeServiceAccount"
  
  Reemplaza PROJECT_NUMBER por el número de proyecto del paso anterior.

Verifica que no se hayan alcanzado las cuotas de la API de Write de Cloud Logging

Confirma que no alcanzaste las cuotas de escritura de API para Cloud Logging.

Dirígete a la página Cuotas en la consola de Google Cloud.

Ir a Cuotas
Filtra la tabla por “API de Cloud Logging”.
Confirma que no alcanzaste ninguna de las cuotas.

Cómo depurar problemas de registro de GKE con gcpdiag

Si faltan registros o los registros de tu clúster de GKE están incompletos, usa la herramienta gcpdiag para solucionar el problema.

gcpdiag es una herramienta de código abierto. No es un producto Google Cloud compatible oficialmente. Puedes usar la herramienta gcpdiag para identificar y corregir problemas del proyecto de Google Cloud. Para obtener más información, consulta el proyecto gcpdiag en GitHub.

Cuando falten registros del clúster de GKE o estén incompletos, investiga las posibles causas enfocándote en la siguiente configuración principal que es esencial para las funciones de registro adecuadas:

Registro a nivel del proyecto: Garantiza que el Google Cloud proyecto que aloja el clúster de GKE tenga habilitada la API de Cloud Logging.
Registro a nivel del clúster: Verifica que el registro esté habilitado de forma explícita en la configuración del clúster de GKE.
Permisos del grupo de nodos: Confirma que los nodos de los grupos de nodos del clúster tengan habilitado el permiso de escritura de Cloud Logging, lo que les permite enviar datos de registro.
Permisos de la cuenta de servicio: Valida que la cuenta de servicio que usan los grupos de nodos tenga los permisos de IAM necesarios para interactuar con Cloud Logging. Específicamente, por lo general, se requiere el rol “roles/logging.logWriter”.
Cuotas de escritura de la API de Cloud Logging: Verifica que no se hayan excedido las cuotas de escritura de la API de Cloud Logging en el período especificado.

Consola de Google Cloud

Completa y, luego, copia el siguiente comando.

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

Abre la consola de Google Cloud y activa Cloud Shell.

Abre la consola de Cloud

Pega el comando copiado.
Ejecuta el comando gcpdiag, que descarga la imagen de Docker gcpdiag y, luego, realiza verificaciones de diagnóstico. Si corresponde, sigue las instrucciones de salida para corregir las verificaciones que fallaron.

Docker

Puedes ejecutar gcpdiag con un wrapper que inicie gcpdiag en un contenedor de Docker. Se debe instalar Docker o Podman.

Copia y ejecuta el siguiente comando en tu estación de trabajo local.
```
curl https://gcpdiag.dev/gcpdiag.sh >gcpdiag && chmod +x gcpdiag
```

Ejecuta el comando gcpdiag.

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

Consulta los parámetros disponibles para este runbook.