En esta página se explica cómo solucionar problemas con la propia canalización de registros de Google Kubernetes Engine (GKE), como que los registros no aparezcan en Cloud Logging. Para obtener más información sobre cómo usar los registros para solucionar problemas de tus cargas de trabajo y clústeres, consulta Realizar análisis históricos con Cloud Logging.
Faltan registros de clústeres en Cloud Logging
Verificar que el registro esté habilitado en el proyecto
Mostrar servicios habilitados:
gcloud services list --enabled --filter="NAME=logging.googleapis.com"El siguiente resultado indica que el registro está habilitado en el proyecto:
NAME TITLE logging.googleapis.com Cloud Logging APIOpcional: Consulta los registros en el Visor de registros para determinar quién inhabilitó la API y cuándo lo hizo:
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
Verificar que el registro esté habilitado en el clúster
Lista los clústeres:
gcloud container clusters list \ --project=PROJECT_ID \ '--format=value(name,loggingConfig.componentConfig.enableComponents)' \ --sort-by=name | column -tHaz los cambios siguientes:
PROJECT_ID: tu ID de proyecto Google Cloud .
El resultado debería ser similar al siguiente:
cluster-1 SYSTEM_COMPONENTS cluster-2 SYSTEM_COMPONENTS;WORKLOADS cluster-3Si el valor de tu clúster está vacío, el registro se inhabilita. Por ejemplo, en este resultado,
cluster-3tiene 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_LOCATIONHaz los cambios siguientes:
CLUSTER_NAME: el nombre de tu clúster.COMPUTE_LOCATION: la ubicación de Compute Engine de tu clúster.
Después de verificar que has habilitado el registro en tu proyecto y en el clúster, te recomendamos que uses Investigaciones de Gemini Cloud Assist para obtener más información sobre tus registros y resolver problemas. Para obtener más información sobre las diferentes formas de iniciar una investigación con el Explorador de registros, consulta el artículo Solucionar problemas con las investigaciones de Gemini Cloud Assist en la documentación de Gemini.
Verificar que los nodos de los grupos de nodos tienen el ámbito de acceso de Cloud Logging
Los nodos deben tener uno de los siguientes permisos para escribir registros en Cloud Logging:
https://www.googleapis.com/auth/logging.writehttps://www.googleapis.com/auth/cloud-platformhttps://www.googleapis.com/auth/logging.admin
Comprueba los ámbitos configurados en cada grupo de nodos del clúster:
gcloud container node-pools list --cluster=CLUSTER_NAME \ --format="table(name,config.oauthScopes)" \ --location COMPUTE_LOCATIONHaz los cambios siguientes:
CLUSTER_NAME: el nombre de tu clúster.COMPUTE_LOCATION: la ubicación de Compute Engine de tu clúster.
Migra tus cargas de trabajo del grupo de nodos antiguo al que acabas de crear y monitoriza el progreso.
Crea grupos de nodos con el ámbito de registro correcto:
gcloud container node-pools create NODE_POOL_NAME \ --cluster=CLUSTER_NAME \ --location=COMPUTE_LOCATION \ --scopes="gke-default"Haz los cambios siguientes:
CLUSTER_NAME: el nombre de tu clúster.COMPUTE_LOCATION: la ubicación de Compute Engine de tu clúster.
Identificar clústeres con cuentas de servicio de nodos a las que les faltan permisos críticos
Para identificar los clústeres a los que les faltan permisos críticos de cuentas de servicio de nodos, usa las recomendaciones de GKE del NODE_SA_MISSING_PERMISSIONS subtipo de recomendador:
- Usa la consola Google Cloud . Ve a la página Clústeres de Kubernetes. En la columna Notificaciones de clústeres específicos, busca la recomendación Conceder permisos críticos.
Usa la CLI de gcloud o la API Recommender especificando el subtipo
NODE_SA_MISSING_PERMISSIONSrecommender.Para consultar esta recomendación, 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"
Para implementar esta recomendación, concede el rol roles/container.defaultNodeServiceAccount a la cuenta de servicio del nodo.
Puedes ejecutar una secuencia de comandos que busque en los grupos de nodos de los clústeres Estándar y Autopilot de tu proyecto las cuentas de servicio de nodos que no tengan los permisos necesarios para GKE. Esta secuencia de comandos usa la CLI de gcloud y la utilidad jq. Para ver la secuencia de comandos, despliega la siguiente sección:
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"
fiIdentificar cuentas de servicio de nodos a las que les faltan permisos críticos en un clúster
GKE usa cuentas de servicio de gestión de identidades y accesos que están asociadas a tus nodos para ejecutar tareas del sistema, como el registro y la monitorización. Como mínimo, estas cuentas de servicio de nodo deben tener el rol Cuenta de servicio de nodo predeterminada 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 cuenta de servicio del nodo.
Si tu organización aplica la
restricción de política de organización iam.automaticIamGrantsForDefaultServiceAccounts, es posible que la cuenta de servicio predeterminada de Compute Engine de tu proyecto no obtenga automáticamente los permisos necesarios para GKE.
Para comprobar si faltan permisos de registro, busca errores de
401en el registro de 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, significa que la carga de trabajo del sistema está experimentando401errores, lo que indica que faltan permisos. Si el resultado esfalse, salta el resto de estos pasos y prueba con otro procedimiento para solucionar el problema.Para identificar todos los permisos críticos que faltan, consulta la secuencia de comandos.
-
Busca el nombre de la cuenta de servicio que usan tus nodos:
Consola
- Ve a la página Clústeres de Kubernetes:
- En la lista de clústeres, haga clic en el nombre del clúster que quiera inspeccionar.
- En función del modo de funcionamiento del clúster, haz una de las siguientes acciones:
- En el caso de los clústeres en modo Autopilot, ve a la sección Seguridad y busca el campo Cuenta de servicio.
- En los clústeres del modo Estándar, haga 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 usarán la cuenta de servicio predeterminada de Compute Engine. Si el valor de este campo no esdefault, tus nodos usan una cuenta de servicio personalizada. Para asignar el rol necesario a una cuenta de servicio personalizada, consulta Usar cuentas de servicio de IAM con el mínimo de privilegios.gcloud
En los clústeres del modo Autopilot, ejecuta el siguiente comando:
gcloud container clusters describe
CLUSTER_NAME\ --location=LOCATION\ --flatten=autoscaling.autoprovisioningNodePoolDefaults.serviceAccountEn 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 esdefault, tus nodos usan una cuenta de servicio personalizada. Para conceder el rol necesario a una cuenta de servicio personalizada, consulta Usar cuentas de servicio de IAM con el mínimo de privilegios. -
Para asignar el rol
roles/container.defaultNodeServiceAccounta la cuenta de servicio predeterminada de Compute Engine, sigue estos pasos:consola
- Ve a la página Bienvenida:
- En el campo Número de proyecto, haz clic en Copiar en el portapapeles.
- Ve a la página Gestión de identidades y accesos:
- Haz clic en Conceder acceso.
- En el campo Nuevos principales, especifique el siguiente valor:
PROJECT_NUMBER-compute@developer.gserviceaccount.comPROJECT_NUMBERpor el número de proyecto que has copiado. - En el menú Seleccionar un rol, elige el rol Cuenta de servicio de nodo predeterminada de Kubernetes Engine.
- Haz clic en Guardar.
gcloud
- Busca tu Google Cloud número de proyecto:
gcloud projects describe PROJECT_ID \ --format="value(projectNumber)"
Sustituye
PROJECT_IDpor el ID del proyecto.El resultado debería ser similar al siguiente:
12345678901
- Asigna el rol
roles/container.defaultNodeServiceAccounta 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"
Sustituye
PROJECT_NUMBERpor el número de proyecto del paso anterior.
- Verifica que las cuentas de servicio de los nodos tengan los permisos necesarios. Consulta la secuencia de comandos para verificarlo.
Una secuencia de comandos para identificar los permisos que faltan en la cuenta de servicio de nodo de GKE
Puedes ejecutar una secuencia de comandos que busque en los grupos de nodos de los clústeres Estándar y Autopilot de tu proyecto las cuentas de servicio de nodos que no tengan los permisos necesarios para GKE. Esta secuencia de comandos usa la CLI de gcloud y la utilidad jq. Para ver la secuencia de comandos, despliega la siguiente sección:
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"
fiVerificar que no se hayan alcanzado las cuotas de la API de escritura de Cloud Logging
Confirma que no has alcanzado las cuotas de escritura de la API de Cloud Logging.
Ve a la página Cuotas de la Google Cloud consola.
Filtra la tabla por "API de Cloud Logging".
Confirma que no has alcanzado ninguna de las cuotas.
Depurar problemas de registro de GKE con gcpdiag
Si faltan registros o están incompletos en tu clúster de GKE, usa la herramienta gcpdiag para solucionar los problemas.
gcpdiag
es una herramienta de código abierto. No es un producto Google Cloud oficialmente compatible.
Puedes usar la gcpdiag herramienta para identificar y solucionar Google Cloudproblemas de proyectos. Para obtener más información, consulta el proyecto gcpdiag en GitHub.
- Registro a nivel de proyecto: asegura que el proyecto que aloja el clúster de GKE tenga habilitada la API Cloud Logging. Google Cloud
- Registro a nivel de clúster: verifica que el registro esté habilitado explícitamente 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 tienen habilitado el ámbito "Escribir en Cloud Logging", lo que les permite enviar datos de registro.
- Permisos de la cuenta de servicio: valida que la cuenta de servicio utilizada por los grupos de nodos tenga los permisos de gestión de identidades y accesos necesarios para interactuar con Cloud Logging. En concreto, suele ser necesario el rol "roles/logging.logWriter".
- Cuotas de escritura de la API Cloud Logging: comprueba que no se hayan superado las cuotas de escritura de la API Cloud Logging en el periodo especificado.
Docker
Puedes
ejecutar gcpdiag mediante un envoltorio que inicie gcpdiag en un
contenedor Docker. Debes tener instalado 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 de este runbook.
Haz los cambios siguientes:
- PROJECT_ID: el ID del proyecto que contiene el recurso.
- GKE_NAME: el nombre del clúster de GKE.
- LOCATION: La zona o región del clúster de GKE.
Marcas útiles:
--universe-domain: Si procede, el dominio Trusted Partner Sovereign Cloud que aloja el recurso--parametero-p: parámetros de runbook
Para ver una lista y una descripción de todas las marcas de la herramienta gcpdiag, consulta las gcpdiaginstrucciones de uso.
Siguientes pasos
Si no encuentras una solución a tu problema en la documentación, consulta la sección Obtener asistencia para obtener más ayuda, incluidos consejos sobre los siguientes temas:
- Abrir un caso de asistencia poniéndose en contacto con el equipo de Atención al Cliente de Cloud.
- Obtener asistencia de la comunidad haciendo preguntas en Stack Overflow
y usando la etiqueta
google-kubernetes-enginepara buscar problemas similares. También puedes unirte al#kubernetes-enginecanal de Slack para obtener más ayuda de la comunidad. - Abrir errores o solicitudes de funciones mediante el seguimiento de problemas público.