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

Soluciona problemas de errores 4xx

Autopilot estándar

En esta página, se muestra cómo resolver los errores 400, 401, 403 y 404 que podrías encontrar cuando uses Google Kubernetes Engine (GKE).

Problema: Errores de autenticación y autorización

Cuando te conectas a clústeres de GKE, puedes recibir un error de autenticación y autorización con el código de estado HTTP 401 (Unauthorized). Este problema puede ocurrir cuando intentas ejecutar un comando kubectl en tu clúster de GKE desde un entorno local.

La causa de este problema podría ser una de las siguientes:

El complemento de autenticación gke-gcloud-auth-plugin no está instalado ni configurado de forma correcta.
No tienes los permisos para conectarte al servidor de la API del clúster y ejecutar comandos de kubectl.

Para diagnosticar la causa, completa los pasos que se indican en las siguientes secciones:

Conéctate al clúster mediante curl.
Configura el complemento en kubeconfig

Conéctate al clúster mediante `curl`.

Para diagnosticar la causa del error de autenticación y autorización, conéctate al clúster con curl. El uso de curl omite la herramienta de línea de comandos de kubectl y el complemento de gke-gcloud-auth-plugin.

Establece las variables de entorno:

APISERVER=https://$(gcloud container clusters describe CLUSTER_NAME \
    --location=COMPUTE_LOCATION --format "value(endpoint)")
TOKEN=$(gcloud auth print-access-token)

Verifica que tu token de acceso sea válido:
```
curl https://oauth2.googleapis.com/tokeninfo?access_token=$TOKEN
```
Cuando tienes un token de acceso válido, este comando envía una solicitud al servidor de OAuth 2.0 de Google, y el servidor responde con información sobre el token.

Intenta conectarte al extremo principal de la API en el servidor de la API:

# Get cluster CA certificate
gcloud container clusters describe CLUSTER_NAME \
    --location=COMPUTE_LOCATION \
    --format "value(masterAuth.clusterCaCertificate)" | \
    base64 -d > /tmp/ca.crt

# Make API call with authentication and CA certificate
curl -s -X GET "${APISERVER}/api/v1/namespaces" \
    --header "Authorization: Bearer $TOKEN" \
    --cacert /tmp/ca.crt

Si el comando curl se ejecuta correctamente, verás una lista de espacios de nombres. Continúa para verificar si el complemento es la causa con los pasos de la sección Configura el complemento en kubeconfig.

Si el comando curl falla con un resultado similar al siguiente, significa que no tienes los permisos correctos para acceder al clúster:

{
"kind": "Status",
"apiVersion": "v1",
"metadata": {},
"status": "Failure",
"message": "Unauthorized",
"reason": "Unauthorized",
"code": 401
}

Para resolver este problema, consulta a tu administrador para obtener los permisos correctos para acceder al clúster.

Configura el uso del complemento en kubeconfig

Si recibes errores de autenticación y autorización cuando te conectas a tus clústeres, pero pudiste conectarte al clúster con curl, asegúrate de poder acceder a tu clúster sin necesidad del complemento gke-gcloud-auth-plugin.

Para resolver este problema, configura tu entorno local para ignorar el objeto binario gke-gcloud-auth-plugin cuando se autentique en el clúster. En los clientes de Kubernetes que ejecutan la versión 1.25 y posteriores, el objeto binario gke-gcloud-auth-plugin es obligatorio, por lo que debes usar una versión 1.24 o anterior para la herramienta de línea de comandos kubectl.

Sigue estos pasos para acceder a tu clúster sin necesidad del complemento:

Instala la herramienta de línea de comandos de kubectl con la versión 1.24 o una anterior usando curl. En el siguiente ejemplo, se instala la herramienta con la versión 1.24:
```
curl -LO https://dl.k8s.io/release/v1.24.0/bin/linux/amd64/kubectl
```
Abre el archivo de secuencia de comandos de inicio de la shell en un editor de texto. Por ejemplo, abre .bashrc para la shell de Bash:
```
vi ~/.bashrc
```
Si usas macOS, usa ~/.bash_profile en lugar de .bashrc en estas instrucciones.
Agrega la siguiente línea al archivo de secuencia de comandos de inicio y guárdala:
```
export USE_GKE_GCLOUD_AUTH_PLUGIN=False
```
Ejecuta la secuencia de comandos de inicio:
```
source ~/.bashrc
```
Obtén credenciales para el clúster, que configura el archivo .kube/config:
```
gcloud container clusters get-credentials CLUSTER_NAME \
    --location=COMPUTE_LOCATION
```
Reemplaza lo siguiente:
- CLUSTER_NAME: el nombre del clúster
- COMPUTE_LOCATION: la ubicación de Compute Engine.
Ejecuta un comando kubectl: Por ejemplo:
```
kubectl cluster-info
```
Si recibes un error 401 o un error de autorización similar después de ejecutar estos comandos, asegúrate de tener los permisos correctos y, luego, vuelve a ejecutar el paso que devolvió el error.

Error 400: El grupo de nodos requiere recreación

El siguiente error puede ocurrir cuando intentas realizar una acción que vuelve a crear el plano de control y los nodos:

ERROR: (gcloud.container.clusters.update) ResponseError: code=400, message=Node pool "test-pool-1" requires recreation.

Por ejemplo, este error puede ocurrir cuando completes una rotación de credenciales en curso.

En el backend, los grupos de nodos están marcados para su recreación, pero la operación de recreación real puede tomar un tiempo en comenzar. Por este motivo, la operación falla porque GKE aún no volvió a crear uno o más grupos de nodos en el clúster.

Para resolver este problema, selecciona una de las siguientes soluciones:

Espera a que se realice la recreación. Esto puede tardar horas, días o semanas, según factores como los períodos de mantenimiento y las exclusiones existentes.
Inicia de forma manual una recreación de los grupos de nodos afectados mediante el inicio de una actualización de la versión a la misma versión que el plano de control.

Para iniciar una recreación, ejecuta el siguiente comando:
```
gcloud container clusters upgrade CLUSTER_NAME \
    --node-pool=POOL_NAME
```
Una vez completada la actualización, vuelve a intentar la operación.

Error 401: Sin autorización

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

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

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

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

Para consultar 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 ejecutar una secuencia de comandos que busque grupos de nodos en los clústeres estándar y de Autopilot de tu proyecto para detectar cualquier cuenta de servicio de nodos que no tenga los permisos requeridos para GKE. Esta secuencia de comandos usa gcloud CLI y la utilidad jq. Para ver la secuencia de comandos, expande la siguiente sección:

Cómo ver la secuencia de comandos

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

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

GKE usa cuentas de servicio de IAM que se adjuntan 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 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 requeridos para GKE.

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 deseas inspeccionar.
3. Según el modo de operación del clúster, realiza una de las siguientes acciones:
  
  Para 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 en el 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 privilegio mínimo mínimos.
gcloud

Para los clústeres en modo Autopilot, ejecuta el siguiente comando:
gcloud container clusters describe CLUSTER_NAME \ --location=LOCATION \ --flatten=autoscaling.autoprovisioningNodePoolDefaults.serviceAccount
Para los clústeres en 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 privilegio mínimo 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 Bienvenido:
  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 tu 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.

Error 403: Permisos insuficientes

El siguiente error ocurre cuando intentas conectarte a un clúster de GKE mediante gcloud container clusters get-credentials, pero la cuenta no tiene permiso para acceder al servidor de la API de Kubernetes:

ERROR: (gcloud.container.clusters.get-credentials) ResponseError: code=403, message=Required "container.clusters.get" permission(s) for "projects/<your-project>/locations/<region>/clusters/<your-cluster>".

Para resolver este problema, realiza los siguientes pasos:

Identifica la cuenta que tiene el problema de acceso:
```
gcloud auth list
```
Otorga el acceso requerido a la cuenta mediante las instrucciones que aparecen en Autenticar en el servidor de la API de Kubernetes.

Error 403: Se agotó el presupuesto de reintentos

El siguiente error puede ocurrir cuando intentas crear un clúster de GKE:

Error: googleapi: Error 403: Retry budget exhausted: Google Compute Engine:
Required permission 'PERMISSION_NAME' for 'RESOURCE_NAME'.

En este mensaje de error, se aplican las siguientes variables:

PERMISSION_NAME: Es el nombre de un permiso, como compute.regions.get.
RESOURCE_NAME: Es la ruta de acceso al recurso Google Cloudal que intentabas acceder, como una región de Compute Engine.

Este error se produce si la cuenta de servicio de IAM adjunta al clúster no tiene los permisos mínimos necesarios para crear el clúster.

Para solucionar este problema, haz lo siguiente:

Crea o modifica una cuenta de servicio de IAM para que tenga todos los permisos necesarios para ejecutar un clúster de GKE. Para obtener instrucciones, consulta Usa cuentas de servicio de IAM con privilegios mínimos.
Especifica la cuenta de servicio de IAM actualizada en el comando de creación del clúster con la marca --service-account. Para obtener instrucciones, consulta Crea un clúster de Autopilot.

Como alternativa, omite la marca --service-account para permitir que GKE use la cuenta de servicio predeterminada de Compute Engine en el proyecto, que tiene los permisos requeridos de forma predeterminada.

Error 404: No se encontró el recurso

Si recibes un error 404, recurso no encontrado, cuando llames a los comandos gcloud container, resuelve el problema volviendo a autenticarte en Google Cloud CLI:

gcloud auth login

Error 400/403: Faltan permisos de edición en una cuenta

Si falta el permiso de edición en una cuenta (error 400 o 403), se indica que se borró o editó manualmente uno de los siguientes elementos:

Cuando habilitas la API de Compute Engine o de GKE, Google Cloudcrea las siguientes cuentas de servicio y agentes:

Cuenta de servicio predeterminada de Compute Engine en tu proyecto De forma predeterminada, GKE adjunta esta cuenta de servicio a los nodos para tareas del sistema, como el registro y la supervisión.
Agente de servicio de las APIs de Google en un proyecto administrado por Google, con permisos de edición en tu proyecto.
Agentes de servicio de Google Kubernetes Engine en un proyecto administrado por Google, con los roles de Agente de servicio de Kubernetes Engine y Agente de servicio de nodo predeterminado de Kubernetes Engine en tu proyecto.

La creación de clústeres y toda la administración fallan si, en algún momento, alguien edita esos permisos, quita las vinculaciones de roles del proyecto, quita la cuenta de servicio por completo o inhabilita la API.

Verifica los permisos de los agentes de servicio de GKE

Google Kubernetes Engine tiene los siguientes agentes de servicio:

Agente del servicio de Kubernetes Engine , que se usa para administrar recursos de procesamiento, como instancias, discos y balanceadores de cargas.
Kubernetes Engine Default Node Service Agent, que usan las cargas de trabajo del sistema de nodos de Google Kubernetes Engine para admitir capacidades estándar, como el registro y la supervisión.

Para verificar si los agentes de servicio de Google Kubernetes Engine tienen el rol de Agente de servicio de Kubernetes Engine asignado en el proyecto, completa los siguientes pasos:

Determina el nombre de tus agentes de servicio de Google Kubernetes Engine. Los agentes de servicio tienen el siguiente formato:
- Agente de servicio de Kubernetes Engine:
```
service-PROJECT_NUMBER@container-engine-robot.iam.gserviceaccount.com
```
- Agente de servicio de nodos predeterminado de Kubernetes Engine:
```
service-PROJECT_NUMBER@gcp-sa-gkenode.iam.gserviceaccount.com
```
Reemplaza PROJECT_NUMBER por el número del proyecto.
Verifica que tus agentes de servicio de Google Kubernetes Engine tengan los roles de Agente de servicio de Kubernetes Engine y Agente de servicio de nodo predeterminado de Kubernetes Engine asignados en el proyecto:
```
gcloud projects get-iam-policy PROJECT_ID
```
Reemplaza PROJECT_ID con el ID del proyecto.

Para solucionar el problema, si alguien quitó el rol de Agente de servicio de Kubernetes Engine o el de Agente de servicio de nodo predeterminado de Kubernetes Engine de tus agentes de servicio de Google Kubernetes Engine, sigue estas instrucciones para asegurarte de que la API de Kubernetes Engine esté habilitada y otorgar los roles necesarios a tus agentes de servicio:

Console

Ve a la página APIs y servicios en la consola de Google Cloud .

Ir a API y servicios.
Elige tu proyecto.
Haga clic en Habilitar API y servicios.
Busca Kubernetes y, luego, selecciona la API de los resultados de la búsqueda.
Haz clic en Habilitar. Si habilitaste la API antes, primero debes inhabilitarla y, luego, habilitarla de nuevo. La habilitación de la API y los servicios relacionados puede tomar varios minutos.

gcloud

Ejecuta los siguientes comandos en la gcloud CLI:

PROJECT_NUMBER=$(gcloud projects describe "PROJECT_ID"
    --format 'get(projectNumber)')
gcloud projects add-iam-policy-binding PROJECT_ID \
    --member "serviceAccount:service-${PROJECT_NUMBER?}@container-engine-robot.iam.gserviceaccount.com" \
    --role roles/container.serviceAgent
gcloud projects add-iam-policy-binding PROJECT_ID \
    --member "serviceAccount:service-${PROJECT_NUMBER?}@gcp-sa-gkenode.iam.gserviceaccount.com" \
    --role roles/container.defaultNodeServiceAgent

¿Qué sigue?

Si no encuentras una solución a tu problema en la documentación, consulta Obtener asistencia para obtener más ayuda, como asesoramiento en los siguientes temas:
- Comunicarse con Atención al cliente de Cloud para abrir un caso de asistencia.
- Hacer preguntas en StackOverflow para obtener asistencia de la comunidad y usar la etiqueta google-kubernetes-engine para buscar problemas similares. También puedes unirte al canal de Slack #kubernetes-engine para obtener más Asistencia de la comunidad.
- Abrir errores o solicitudes de funciones con la herramienta de seguimiento de errores pública.

Soluciona problemas de errores 4xx Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.

Problema: Errores de autenticación y autorización

Conéctate al clúster mediante curl.

Configura el uso del complemento en kubeconfig

Error 400: El grupo de nodos requiere recreación

Error 401: Sin autorización

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

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

Console

gcloud

Console

gcloud

Error 403: Permisos insuficientes

Error 403: Se agotó el presupuesto de reintentos

Error 404: No se encontró el recurso

Error 400/403: Faltan permisos de edición en una cuenta

Verifica los permisos de los agentes de servicio de GKE

Console

gcloud

¿Qué sigue?

Soluciona problemas de errores 4xx

Conéctate al clúster mediante `curl`.