El producto descrito en esta documentación, clústeres de Anthos en AWS (generación anterior), ahora está en modo de mantenimiento. Todas las instalaciones nuevas deben usar el producto de generación actual, clústeres de Anthos en AWS.

Registro y supervisión para GKE en AWS

En este tema, se muestra cómo exportar registros y métricas de un clúster de usuario de GKE en AWS a Cloud Logging y Cloud Monitoring.

Descripción general

Existen varias opciones para registrar y supervisar con GKE en AWS. GKE Enterprise se puede integrar a Cloud Logging y Cloud Monitoring. Debido a que GKE Enterprise está basado en Kubernetes de código abierto, muchas herramientas de código abierto y de terceros son compatibles.

Opciones de registro y supervisión

Tienes varias opciones de registro y supervisión para tu clúster de GKE Enterprise:

Implementa los agentes de Cloud Logging y Cloud Monitoring para supervisar y ver los registros de tus cargas de trabajo en la consola de Google Cloud. En este tema, se explica esta solución.
Usa herramientas de código abierto, como Prometheus, Grafana y Elasticsearch. En este tema, no se describe esta solución.
Usa soluciones de terceros como Datadog. En este tema, no se describe esta solución.

Cloud Logging y Cloud Monitoring

Con GKE Enterprise, Cloud Logging y Cloud Monitoring, puedes crear paneles, enviar alertas, supervisar y revisar registros de las cargas de trabajo que se ejecutan en tu clúster. Debes configurar los agentes de Cloud Logging y Cloud Monitoring para recopilar los registros y las métricas en tu proyecto de Google Cloud. Si no configuras estos agentes, GKE en AWS no recopila datos de registro ni supervisión.

Qué datos se recopilan

Cuando se configuran, los agentes recopilan registros y datos de métricas de tu clúster y las cargas de trabajo que se ejecutan en él. Estos datos se almacenan en tu proyecto de Google Cloud. El ID del proyecto se configura en el campo project_id en un archivo de configuración cuando instalas el servidor de reenvío.

Entre los datos recopilados, se incluyen los siguientes:

Registros de los servicios del sistema en cada uno de los nodos trabajadores.
Registros de aplicaciones para todas las cargas de trabajo que se ejecutan en el clúster.
Métricas para los servicios del clúster y del sistema. Para obtener más información sobre métricas específicas, consulta Métricas de GKE Enterprise.
Métricas de la aplicación para los pods, si tus aplicaciones están configuradas con los objetivos de recopilación de Prometheus y se anotan con la configuración, incluidos prometheus.io/scrape, prometheus.io/path y prometheus.io/port.

Los agentes pueden inhabilitarse en cualquier momento. Para obtener más información, consulta cómo hacer una limpieza. Los datos que recopilan los agentes se pueden administrar y borrar como cualquier otro dato de métrica y registro, como se describe en la documentación de Cloud Monitoring y Cloud Logging.

Los datos de registro se almacenan de acuerdo con las reglas de retención configuradas. La retención de datos de las métricas varía según el tipo.

Registra y supervisa componentes

Para exportar la telemetría a nivel de clúster desde GKE en AWS a Google Cloud, debes implementar los siguientes componentes en tu clúster:

Stackdriver Log Forwarder (stackdriver-log-forwarder-*). Un DaemonSet de Fluentbit que reenvía los registros de cada nodo de Kubernetes a Cloud Logging.
Agente de métricas de GKE (gke-metrics-agent-*). Un DaemonSet basado en OpenTelemetry Collector que recopila datos de métricas y los reenvía a Cloud Monitoring.

Los manifiestos para estos componentes se encuentran en el repositorio anthos-samples en GitHub.

Requisitos previos

Un proyecto de Google Cloud con facturación habilitada. Para obtener más información sobre los costos, consulta Precios de Google Cloud Observability.

El proyecto también debe tener habilitadas las API de Cloud Logging y Cloud Monitoring. Para habilitar estas API, ejecuta los siguientes comandos:
```
gcloud services enable logging.googleapis.com
gcloud services enable monitoring.googleapis.com
```
Un entorno de GKE en AWS, incluido el clúster de usuario registrado con Connect. Ejecuta el siguiente comando para verificar que tu clúster esté registrado.
```
gcloud container fleet memberships list
```
Si tu clúster está registrado, Google Cloud CLI imprime el nombre y el ID del clúster.
```
NAME       EXTERNAL_ID
cluster-0  1abcdef-1234-4266-90ab-123456abcdef
```
Si no ves tu clúster en la lista, consulta Conéctate a un clúster con Connect
Instala la herramienta de línea de comandos de git en tu máquina.

Configura los permisos para Google Cloud Observability

Los agentes de registro y supervisión usan Workload Identity de la flota para comunicarse con Cloud Logging y Cloud Monitoring. La identidad necesita permisos para escribir registros y métricas en tu proyecto. Para agregar los permisos, ejecuta los siguientes comandos:

gcloud projects add-iam-policy-binding PROJECT_ID \
  --member="serviceAccount:PROJECT_ID.svc.id.goog[kube-system/stackdriver]" \
  --role=roles/logging.logWriter
gcloud projects add-iam-policy-binding PROJECT_ID \
  --member="serviceAccount:PROJECT_ID.svc.id.goog[kube-system/stackdriver]" \
  --role=roles/monitoring.metricWriter

Reemplaza PROJECT_ID con el proyecto de Google Cloud.

Conéctate al host de bastión

Para conectarte a tus recursos de GKE en AWS, realiza las siguientes instrucciones. Selecciona si tienes una VPC de AWS existente (o conexión directa a tu VPC) o si creaste una VPC dedicada cuando creaste tu servicio de administración.

VPC existente

Si tienes una conexión directa o de VPN con una VPC existente, omite la línea env HTTP_PROXY=http://localhost:8118 de los comandos en este tema.

VPC dedicada

Cuando creas un servicio de administración en una VPC dedicada, GKE on AWS incluye un host de bastión en una subred pública.

Para conectarte al servicio de administración, realiza los siguientes pasos:

Cambia al directorio con la configuración de GKE en AWS. Creaste este directorio cuando instalaste el servicio de administración.
```
cd anthos-aws
```
Para abrir el túnel, ejecuta la secuencia de comandos bastion-tunnel.sh. El túnel reenvía a localhost:8118.

Para abrir un túnel al host de bastión, ejecuta el siguiente comando:
```
./bastion-tunnel.sh -N
```
Los mensajes del túnel SSH aparecen en esta ventana. Cuando estés listo para cerrar la conexión, detén el proceso mediante Control+C o cierra la ventana.
Abre una terminal nueva y cambia a tu directorio de anthos-aws.
```
cd anthos-aws
```
Verifica que puedas conectarte al clúster con kubectl.
```
env HTTPS_PROXY=http://localhost:8118 \
kubectl cluster-info
```
El resultado incluye la URL para el servidor de API del servicio de administración.

Cloud Logging y Cloud Monitoring en nodos del plano de control

Con la versión 1.8.0 de GKE en AWS y las versiones posteriores, Cloud Logging y Cloud Monitoring para los nodos del plano de control se pueden configurar de forma automática cuando se crean clústeres de usuario nuevos. Para habilitar Cloud Logging o Cloud Monitoring, propaga la sección controlPlane.cloudOperations de la configuración de AWSCluster.

cloudOperations:
  projectID: PROJECT_ID
  location: GC_REGION
  enableLogging: ENABLE_LOGGING
  enableMonitoring: ENABLE_MONITORING

Reemplaza lo siguiente:

PROJECT_ID: el ID de tu proyecto
GC_REGION: es la región de Google Cloud en la que deseas almacenar los registros. Elige una región ubicada cerca de la región de AWS. Para obtener más información, consulta Ubicaciones globales: Regiones y zonas, por ejemplo, us-central1.
ENABLE_LOGGING: true o false, si Cloud Logging está habilitado en nodos del plano de control.
ENABLE_MONITORING: true o false, si Cloud Monitoring está habilitado en nodos del plano de control.

A continuación, sigue los pasos en Crea un clúster de usuario personalizado.

Cloud Logging y Cloud Monitoring en nodos trabajadores

Quita la versión anterior

Si configuraste una versión anterior de los agentes de Logging y Monitoring que incluyestackdriver-log-aggregator (Fluentd) ystackdriver-prometheus-k8s (Prometheus), es posible que quieras desinstalarlas antes de continuar.

Haz clic para ver los comandos a fin de desinstalar la versión anterior.

    kubectl delete -n kube-system statefulset stackdriver-log-aggregator
    kubectl delete -n kube-system configmap stackdriver-log-aggregator-input-config
    kubectl delete -n kube-system configmap stackdriver-log-aggregator-output-config
    kubectl delete -n kube-system networkpolicy stackdriver-log-aggregator-in-forward
    kubectl delete -n kube-system networkpolicy stackdriver-log-aggregator-prometheus-scrape
    kubectl delete -n kube-system serviceaccount stackdriver-log-aggregator
    kubectl delete -n kube-system service stackdriver-log-aggregator-in-forward
    kubectl delete -n kube-system statefulset stackdriver-prometheus-k8s
    kubectl delete -n kube-system service stackdriver-prometheus-k8s
    kubectl delete -n kube-system secret stackdriver-prometheus-scrape
    kubectl delete -n kube-system clusterrolebinding stackdriver-prometheus-scrape
    kubectl delete -n kube-system clusterrole stackdriver-prometheus-scrape
    kubectl delete -n kube-system serviceaccount stackdriver-prometheus-scrape
    kubectl delete -n kube-system clusterrolebinding stackdriver-user:prometheus
    kubectl delete -n kube-system clusterrole stackdriver-user:prometheus
    kubectl delete -n kube-system serviceaccount stackdriver-prometheus
    kubectl delete -n kube-system configmap stackdriver-prometheus-k8s
    kubectl delete -n kube-system configmap stackdriver-prometheus-sidecar-config
    kubectl delete -n kube-system pvc/stackdriver-log-aggregator-persistent-volume-claim-stackdriver-log-aggregator-0
    kubectl delete -n kube-system pvc/stackdriver-log-aggregator-persistent-volume-claim-stackdriver-log-aggregator-1
    kubectl delete -n kube-system pvc/stackdriver-prometheus-data-stackdriver-prometheus-k8s-0
    kubectl delete secret google-cloud-credentials -n kube-system

Instala el servidor de reenvío de registros

En esta sección, instalarás Stackdriver Log Forwarder en tu clúster.

Desde el directorio anthos-samples/aws-logging-monitoring/, cambia al directorio logging/.
```
cd logging/
```
Modifica el archivo forwarder.yaml para que coincida con la configuración de tu proyecto:
```
sed -i "s/PROJECT_ID/PROJECT_ID/g" forwarder.yaml
sed -i "s/CLUSTER_NAME/CLUSTER_NAME/g" forwarder.yaml
sed -i "s/CLUSTER_LOCATION/GC_REGION/g" forwarder.yaml
```
Reemplaza lo siguiente:
- PROJECT_ID: el ID de tu proyecto
- CLUSTER_NAME: El nombre de tu clúster, por ejemplo, cluster-0
- GC_REGION: es la región de Google Cloud en la que deseas almacenar los registros. Elige una región ubicada cerca de la región de AWS. Para obtener más información, consulta Ubicaciones globales: Regiones y zonas, por ejemplo, us-central1.
En función de tus cargas de trabajo, la cantidad de nodos en tu clúster y la cantidad de Pods por nodo, es posible que debas configurar las solicitudes de memoria y recursos de CPU (opcional). Para obtener más información, consulta las asignaciones de CPU y memoria recomendadas.
Desde tu directorio de anthos-aws, usa anthos-gke para cambiar el contexto a tu clúster de usuario.
```
cd anthos-aws
env HTTPS_PROXY=http://localhost:8118 \
  anthos-gke aws clusters get-credentials CLUSTER_NAME
```
Reemplaza CLUSTER_NAME por el nombre de tu clúster de usuario.

Crea la cuenta de servicio stackdriver si no existe y, luego, implementa el servidor de reenvío de registros en el clúster.

env HTTPS_PROXY=http://localhost:8118 \
  kubectl create serviceaccount stackdriver -n kube-system
env HTTPS_PROXY=http://localhost:8118 \
  kubectl apply -f forwarder.yaml

Usa kubectl para verificar que los Pods se hayan iniciado.

env HTTPS_PROXY=http://localhost:8118 \
  kubectl get pods -n kube-system | grep stackdriver-log

Deberías ver un Pod de reenvío por nodo en un grupo de nodos. Por ejemplo, en un clúster de 6 nodos, deberías ver seis Pods de reenvío.

stackdriver-log-forwarder-2vlxb              2/2     Running   0          21s
stackdriver-log-forwarder-dwgb7              2/2     Running   0          21s
stackdriver-log-forwarder-rfrdk              2/2     Running   0          21s
stackdriver-log-forwarder-sqz7b              2/2     Running   0          21s
stackdriver-log-forwarder-w4dhn              2/2     Running   0          21s
stackdriver-log-forwarder-wrfg4              2/2     Running   0          21s

Prueba el reenvío de registros

En esta sección, implementarás una carga de trabajo que contiene un servidor web HTTP básico con un generador de cargas en tu clúster. Luego, probarás que los registros estén presentes en Cloud Logging.

Antes de instalar esta carga de trabajo, puedes verificar los manifiestos para el servidor web y el generador de cargas.

Implementa el servidor web y el generador de cargas en el clúster.

env HTTPS_PROXY=http://localhost:8118 \
  kubectl apply -f  https://raw.githubusercontent.com/GoogleCloudPlatform/istio-samples/master/sample-apps/helloserver/server/server.yaml
env HTTPS_PROXY=http://localhost:8118 \
  kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/istio-samples/master/sample-apps/helloserver/loadgen/loadgen.yaml

Para verificar que puedas ver los registros de tu clúster en el panel de Cloud Logging, ve al Explorador de registros en la consola de Google Cloud:

Ir al Explorador de registros
Copia la consulta de muestra que aparece a continuación en el campo Compilador de consultas.
```
resource.type="k8s_container" resource.labels.cluster_name="CLUSTER_NAME"
```
Reemplaza CLUSTER_NAME por el nombre del clúster.
Haga clic en Run query. Los registros de clústeres recientes deberían aparecer en Resultados de consultas.

Una vez que hayas confirmado los registros en los resultados de la consulta, quita el generador de cargas y el servidor web.

env HTTPS_PROXY=http://localhost:8118 \
  kubectl delete -f https://raw.githubusercontent.com/GoogleCloudPlatform/istio-samples/master/sample-apps/helloserver/loadgen/loadgen.yaml

env HTTPS_PROXY=http://localhost:8118 \
  kubectl delete -f https://raw.githubusercontent.com/GoogleCloudPlatform/istio-samples/master/sample-apps/helloserver/server/server.yaml

Instala el recopilador de métricas

En esta sección, instalarás un agente para enviar datos a Cloud Monitoring.

Desde el directorio anthos-samples/aws-logging-monitoring/logging/, cambia al directorio anthos-samples/aws-logging-monitoring/monitoring/.
```
cd ../monitoring
```
Modifica el archivo gke-metrics-agent.yaml para que coincida con la configuración de tu proyecto:
```
sed -i "s/PROJECT_ID/PROJECT_ID/g" gke-metrics-agent.yaml
sed -i "s/CLUSTER_NAME/CLUSTER_NAME/g" gke-metrics-agent.yaml
sed -i "s/CLUSTER_LOCATION/GC_REGION/g" gke-metrics-agent.yaml
```
Reemplaza lo siguiente:
- PROJECT_ID: el ID de tu proyecto
- CLUSTER_NAME: El nombre de tu clúster, por ejemplo, cluster-0
- GC_REGION: es la región de Google Cloud en la que deseas almacenar los registros. Elige una región ubicada cerca de la región de AWS. Para obtener más información, consulta Ubicaciones globales: Regiones y zonas, por ejemplo, us-central1.
En función de tus cargas de trabajo, la cantidad de nodos en tu clúster y la cantidad de Pods por nodo, es posible que debas configurar las solicitudes de memoria y recursos de CPU (opcional). Para obtener más información, consulta las asignaciones de CPU y memoria recomendadas.

Crea la cuenta de servicio stackdriver si no existe y, luego, implementa el agente de métricas en tu clúster.

env HTTPS_PROXY=http://localhost:8118 \
  kubectl create serviceaccount stackdriver -n kube-system
env HTTPS_PROXY=http://localhost:8118 \
  kubectl apply -f gke-metrics-agent.yaml

Usa la herramienta de kubectl para verificar que el Pod gke-metrics-agent esté en ejecución.

env HTTPS_PROXY=http://localhost:8118 \
  kubectl get pods -n kube-system | grep gke-metrics-agent

Deberías ver un Pod de agente por nodo en un grupo de nodos. Por ejemplo, en un clúster de 3 nodos, deberías ver tres Pods de agentes.

gke-metrics-agent-gjxdj                    2/2     Running   0          102s
gke-metrics-agent-lrnzl                    2/2     Running   0          102s
gke-metrics-agent-s6p47                    2/2     Running   0          102s

Para verificar que las métricas del clúster se exporten a Cloud Monitoring, ve al Explorador de métricas en la consola de Google Cloud:

Ir al Explorador de métricas
En el Explorador de métricas, haz clic en Editor de consultas y, luego, cópialo en el siguiente comando:
```
fetch k8s_container
| metric 'kubernetes.io/anthos/otelcol_exporter_sent_metric_points'
| filter
    resource.project_id == 'PROJECT_ID'
    && (resource.cluster_name =='CLUSTER_NAME')
| align rate(1m)
| every 1m
```
Reemplaza lo siguiente:
- PROJECT_ID: el ID de tu proyecto
- CLUSTER_NAME: el nombre del clúster que usaste cuando se creó un clúster de usuario, por ejemplo, cluster-0.
Haz clic en Ejecutar consulta. Aparecerá la tasa de puntos de métrica enviados a Cloud Monitoring desde cada pod de gke-metrics-agent en tu clúster.

Nota: Es posible que debas esperar varios minutos para poder ver las métricas en el Explorador de métricas.

Estas son otras métricas que vale la pena probar:
- kubernetes.io/anthos/container_memory_working_set_bytes: Uso de memoria del contenedor;
- kubernetes.io/anthos/container_cpu_usage_seconds_total: Uso de CPU de los contenedores;
- kubernetes.io/anthos/apiserver_aggregated_request_total: Recuento de solicitudes de kube-apiserver; solo está disponible si Cloud Monitoring está habilitado en el plano de control.
Para obtener una lista completa de las métricas disponibles, consulta Métricas de Anthos. Para obtener información sobre cómo usar la interfaz de usuario, consulta el Explorador de métricas.

Crea un panel en Cloud Monitoring

En esta sección, crearás un panel de Cloud Monitoring que supervisa el estado del contenedor en tu clúster.

Desde el directorio anthos-samples/aws-logging-monitoring/monitoring/, cambia al directorio anthos-samples/aws-logging-monitoring/monitoring/dashboards.
```
cd dashboards
```
Reemplaza las instancias de la string CLUSTER_NAME en pod-status.json por el nombre del clúster.
```
sed -i "s/CLUSTER_NAME/CLUSTER_NAME/g" pod-status.json
```
Reemplaza CLUSTER_NAME por el nombre del clúster.
Ejecuta el siguiente comando para crear un panel personalizado con el archivo de configuración:
```
gcloud monitoring dashboards create --config-from-file=pod-status.json
```
Para verificar que se haya creado tu panel de control, ve a Paneles de Cloud Monitoring en la consola de Google Cloud.

Ir a Paneles

Abre el panel recién creado con un nombre en el formato CLUSTER_NAME (Anthos cluster on AWS) pod status.

Realice una limpieza

En esta sección, quitarás los componentes de registro y supervisión de tu clúster.

Borra el panel de supervisión en la vista de lista de paneles en la consola de Google Cloud. Para ello, haz clic en el botón Borrar asociado con el nombre del panel.
Cambia al directorio anthos-samples/aws-logging-monitoring/ con el siguiente comando:
```
cd anthos-samples/aws-logging-monitoring
```

Para quitar todos los recursos creados en esta guía, ejecuta los siguientes comandos:

env HTTPS_PROXY=http://localhost:8118 \
  kubectl delete -f logging/
env HTTPS_PROXY=http://localhost:8118 \
  kubectl delete -f monitoring/

Asignaciones recomendadas de CPU y memoria

En esta sección, se incluyen la CPU recomendada y las asignaciones para los componentes individuales que se usan en los registros y la supervisión. En cada una de las siguientes tablas, se enumeran las solicitudes de CPU y memoria para un clúster con un rango de tamaños de nodos. Puedes configurar solicitudes de recursos para un componente en el archivo que aparece en la tabla.

Para obtener más información, consulta las prácticas recomendadas de Kubernetes sobre límites y solicitudes de recursos y la administración de recursos para contenedores.

De 1 a 10 nodos

Archivo	Recurso	Solicitudes de CPU	Límites de CPU	Solicitudes de memoria	Límites de memoria
`monitoring/gke-metrics-agent.yaml`	gke-metrics-agent	30m	100m	50Mi	500Mi
`logging/forwarder.yaml`	stackdriver-log-forwarder	50m	100m	100Mi	600Mi

De 10 a 100 nodos

Archivo	Recurso	Solicitudes de CPU	Límites de CPU	Solicitudes de memoria	Límites de memoria
`monitoring/gke-metrics-agent.yaml`	gke-metrics-agent	50m	100m	50Mi	500Mi
`logging/forwarder.yaml`	stackdriver-log-forwarder	60m	100m	100Mi	600Mi

Más de 100 nodos

Archivo	Recurso	Solicitudes de CPU	Límites de CPU	Solicitudes de memoria	Límites de memoria
`monitoring/gke-metrics-agent.yaml`	gke-metrics-agent	50m	100m	100Mi	N/A
`logging/forwarder.yaml`	stackdriver-log-forwarder	60m	100m	100Mi	600Mi