El 30 de abril, se lanzó una nueva versión de los clústeres de Anthos en AWS (GKE en AWS). Consulta las notas de la versión para obtener más información.

Configura el registro y la supervisión de los clústeres de Anthos en AWS

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

Descripción general

Existen varias opciones para registrar y supervisar con clústeres de Anthos en AWS. Anthos se puede integrar a Cloud Logging y Cloud Monitoring. Debido a que Anthos 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 Anthos:

  1. Implementa los agentes de Cloud Logging y Cloud Monitoring para supervisar y ver los registros de tus cargas de trabajo en Google Cloud Console. En este tema, se explica esta solución.

  2. Usa herramientas de código abierto, como Prometheus, Grafana y Elasticsearch. En este tema, no se describe esta solución.

  3. Usa soluciones de terceros, como Datadog. En este tema, no se describe esta solución.

Cloud Logging y Cloud Monitoring

Con Anthos, 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, los clústeres de Anthos en AWS no recopilan 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 agregador de registros y 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 Anthos.
  • 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 los clústeres de Anthos en AWS a Google Cloud, debes implementar los siguientes componentes en tu clúster:

  • Agregador de registros de Stackdriver (stackdriver-log-aggregator-*). Un StatefulSet de Fluentd que envía registros a Cloud Logging.
  • Reenviador de registros de Stackdriver (stackdriver-log-forwarder-*). Un daemonset de Fluentbit que reenvía los registros de cada nodo de Kubernetes al agregador de registros de Stackdriver.
  • Recopilador de métricas de Stackdriver (stackdriver-prometheus-k8s-*). Un StatefulSet de Prometheus, configurado con un contenedor de archivo adicional para enviar métricas de Prometheus a Cloud Monitoring. El archivo adicional es otro contenedor dentro del mismo Pod, que lee las métricas que el servidor de Prometheus almacena en el disco. El colector usa la API de Cloud Monitoring para escribir datos de métricas en tu proyecto de Cloud.

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

Requisitos previos

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

    El proyecto también debe tener habilitadas las API de Cloud Logging y Cloud Monitoring.

  2. Un entorno de clústeres de Anthos 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 hub memberships list
    

    Si tu clúster está registrado, el SDK de Cloud muestra el nombre y el ID.

    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

  3. Instala la herramienta de línea de comandos de git en tu máquina.

Conéctate al host de bastión

Para conectarte a tus clústeres de Anthos en recursos de AWS, sigue estos pasos. 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, clústeres de Anthos alojados en AWS incluye un host de bastión en una subred pública.

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

  1. Cambia al directorio con tu configuración de clústeres de Anthos alojados en AWS. Creaste este directorio cuando instalaste el servicio de administración.

    cd anthos-aws

  2. 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.

  3. Abre una terminal nueva y cambia a tu directorio de anthos-aws.

    cd anthos-aws
  4. 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.

Configura Google Cloud's operations suite

Antes de configurar tu clúster, realiza los siguientes pasos.

  1. Crea un lugar de trabajo de Cloud Monitoring para tu proyecto de Google Cloud.

  2. Clona el repositorio de muestra y cambia al directorio anthos-samples/aws-logging-monitoring.

    git clone https://github.com/GoogleCloudPlatform/anthos-samples
    cd anthos-samples/aws-logging-monitoring
    
  3. Establece una variable de entorno para el proyecto de Google Cloud en el que registraste tu clúster.

    PROJECT_ID="PROJECT_ID"
    

    Reemplaza PROJECT_ID con el ID del proyecto.

  4. Usa la herramienta de línea de comandos de gcloud a fin de crear una cuenta de servicio de Google Cloud con permisos para escribir métricas y registros en las API de Cloud Monitoring y Cloud Logging.

    gcloud iam service-accounts create anthos-lm-forwarder
    
    gcloud projects add-iam-policy-binding $PROJECT_ID \
      --member="serviceAccount:anthos-lm-forwarder@${PROJECT_ID}.iam.gserviceaccount.com" \
      --role=roles/logging.logWriter
    
    gcloud projects add-iam-policy-binding $PROJECT_ID \
      --member="serviceAccount:anthos-lm-forwarder@${PROJECT_ID}.iam.gserviceaccount.com" \
      --role=roles/monitoring.metricWriter
    
  5. Crea y descarga una clave para la cuenta de servicio que acabas de crear.

    gcloud iam service-accounts keys create credentials.json \
      --iam-account anthos-lm-forwarder@${PROJECT_ID}.iam.gserviceaccount.com
    
  6. 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.

  7. Usa la herramienta de línea de comandos de kubectl para crear un secreto en el clúster con el contenido de la clave.

    env HTTPS_PROXY=http://localhost:8118 \
      kubectl create secret generic google-cloud-credentials \
      -n kube-system --from-file credentials.json
    

Instala el agregador y el reenviador de registros

En esta sección, instalarás el Agregador de registros de Stackdriver y el reenviador de registros de Stackdriver en tu clúster.

  1. Desde el directorio anthos-samples/aws-logging-monitoring/, cambia al directorio logging/.

    cd logging/
    
  2. Edita el archivo aggregator.yaml. En la parte inferior del archivo, busca y edita las siguientes variables:

    project_id PROJECT_ID
    k8s_cluster_name CLUSTER_NAME
    k8s_cluster_location GC_REGION
    

    Reemplaza lo siguiente:

    • PROJECT_ID: el ID de tu proyecto
    • CLUSTER_NAME: Es el nombre del 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.
  3. 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.

  4. 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.

  5. Implementa el agregador de registros y el reenvío en el clúster.

    env HTTPS_PROXY=http://localhost:8118 \
      kubectl apply -f aggregator.yaml
    
    env HTTPS_PROXY=http://localhost:8118 \
      kubectl apply -f forwarder.yaml
    
  6. 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
    

    Debes ver dos pods de agregador y un pod de reenviador por nodo en un grupo de nodos. Por ejemplo, en un clúster de 6 nodos, deberías ver seis pods de reenviador y dos pods de agregador.

    stackdriver-log-aggregator-0                 1/1     Running   0          139m
    stackdriver-log-aggregator-1                 1/1     Running   0          139m
    stackdriver-log-forwarder-2vlxb              1/1     Running   0          139m
    stackdriver-log-forwarder-dwgb7              1/1     Running   0          139m
    stackdriver-log-forwarder-rfrdk              1/1     Running   0          139m
    stackdriver-log-forwarder-sqz7b              1/1     Running   0          139m
    stackdriver-log-forwarder-w4dhn              1/1     Running   0          139m
    stackdriver-log-forwarder-wrfg4              1/1     Running   0          139m
    
  7. Usa kubectl para verificar que los registros se envíen a Google Cloud.

    env HTTPS_PROXY=http://localhost:8118 \
      kubectl logs stackdriver-log-aggregator-0 -n kube-system
    

    El resultado incluye registros de información enviados a Google Cloud.

    2021-01-02 03:04:05 +0000 [info]: #3 [google_cloud] Successfully sent gRPC to Stackdriver Logging API.
    

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.

  1. Implementa el servidor web y el generador de cargas en tu 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
    
  2. Para verificar que puedas ver los registros de tu clúster en el panel de Cloud Logging, ve al Explorador de registros en Google Cloud Console:

    Ir al Explorador de registros

  3. 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.

  4. Haga clic en Run query. Los registros de clústeres recientes deberían aparecer en Resultados de consultas.

    Registros de clústeres en Google Cloud's operations suite

  5. 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.

  1. Desde el directorio anthos-samples/aws-logging-monitoring/logging/, cambia al directorio anthos-samples/aws-logging-monitoring/monitoring/.

    cd ../monitoring
    
  2. Abre prometheus.yaml en un editor de texto. Este archivo contiene un manifiesto con la configuración para el sidecar de Stackdriver-Prometheus.

    Busca el StatefulSet con el nombre stackdriver-prometheus-k8s. En spec.args, configura las siguientes variables para que coincidan con tu entorno.

    "--stackdriver.project-id=PROJECT_ID"
    "--stackdriver.kubernetes.location=GC_REGION"
    "--stackdriver.generic.location=GC_REGION"
    "--stackdriver.kubernetes.cluster-name=CLUSTER_NAME"
    

    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. Consulta Ubicaciones globales: regiones y zonas para obtener más información, por ejemplo, us-central1.
    • CLUSTER_NAME: Es el nombre del clúster.
  3. 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.

  4. Implementa el StatefulSet de stackdriver-prometheus y el sidecar del exportador en tu clúster.

    env HTTPS_PROXY=http://localhost:8118 \
      kubectl apply -f server-configmap.yaml
    
    env HTTPS_PROXY=http://localhost:8118 \
      kubectl apply -f sidecar-configmap.yaml
    
    env HTTPS_PROXY=http://localhost:8118 \
      kubectl apply -f prometheus.yaml
    
  5. Usa la herramienta de kubectl para verificar que el Pod stackdriver-prometheus esté en ejecución.

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

    La herramienta de kubectl genera el estado del pod stackdriver-prometheus.

    stackdriver-prometheus-k8s-0         2/2     Running   0          5h24m
    
  6. Usa la herramienta de kubectl para obtener los registros stackdriver-prometheus y verificar que el Pod se haya iniciado.

    env HTTPS_PROXY=http://localhost:8118 \
      kubectl logs stackdriver-prometheus-k8s-0 -n kube-system \
      stackdriver-prometheus-sidecar
    

    El resultado incluye mensajes de estado de la carga de trabajo.

    level=info ts=2021-01-02T03:04:05.678Z caller=main.go:598 msg="Web server started"
    level=info ts=2021-01-02T03:04:05.678Z caller=main.go:579 msg="Stackdriver client started"
    
  7. Para verificar que las métricas del clúster se exporten a Cloud Monitoring, ve al Explorador de métricas en Google Cloud Console:

    Ir al Explorador de métricas

  8. 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/up'
    | filter
        resource.project_id == 'PROJECT_ID'
        && (resource.cluster_name =='CLUSTER_NAME')
    | group_by 1m, [value_up_mean: mean(value.up)]
    | every 1m
    

    Reemplaza lo siguiente:

  9. Haz clic en Ejecutar consulta. Deberías ver 1.0. en el gráfico, que indica que el clúster está activo.

    Supervisión para el clúster

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.

  1. Desde el directorio anthos-samples/aws-logging-monitoring/monitoring/, cambia al directorio anthos-samples/aws-logging-monitoring/monitoring/dashboards.

    cd dashboards
    
  2. 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.

  3. 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
    
  4. Para verificar que se cree el panel, ve a los paneles de Cloud Monitoring en Google Cloud Console.

    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.

  1. Borra el panel de supervisión en la vista de lista de paneles en Google Cloud Console. Para ello, haz clic en el botón Borrar asociado con el nombre del panel.

  2. Cambia al directorio anthos-samples/aws-logging-monitoring/ con el siguiente comando:

    cd anthos-samples/aws-logging-monitoring
    
  3. 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/
    env HTTPS_PROXY=http://localhost:8118 \
      kubectl delete secret google-cloud-credentials -n kube-system
    env HTTPS_PROXY=http://localhost:8118 \
      kubectl delete -n kube-system \
        pvc/stackdriver-log-aggregator-persistent-volume-claim-stackdriver-log-aggregator-0
    env HTTPS_PROXY=http://localhost:8118 \
      kubectl delete -n kube-system \
        pvc/stackdriver-log-aggregator-persistent-volume-claim-stackdriver-log-aggregator-1
    env HTTPS_PROXY=http://localhost:8118 \
      kubectl delete -n kube-system \
        pvc/stackdriver-prometheus-data-stackdriver-prometheus-k8s-0
    
    rm -r credentials.json
    gcloud iam service-accounts delete anthos-lm-forwarder
    

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.

1 a 3 nodos

Archivo Recurso Solicitudes de CPU Límites de CPU Solicitudes de memoria Límites de memoria
monitoring/prometheus.yaml prometheus-server 100m 390m 330Mi N/A
monitoring/prometheus.yaml stackdriver-prometheus-sidecar 25m 340m 370Mi N/A
logging/aggregator.yaml stackdriver-log-aggregator 70m 170m 1150Mi N/A
logging/forwarder.yaml stackdriver-log-forwarder 30m 100m 100Mi 600Mi

4 a 10 nodos

Archivo Recurso Solicitudes de CPU Límites de CPU Solicitudes de memoria Límites de memoria
monitoring/prometheus.yaml prometheus-server 120m 390m 420Mi N/A
monitoring/prometheus.yaml stackdriver-prometheus-sidecar 40 millones 340m 400 Mi N/A
logging/aggregator.yaml stackdriver-log-aggregator 70m 170m 1300Mi N/A
logging/forwarder.yaml stackdriver-log-forwarder 50m 100m 100Mi 600Mi

11 a 25 nodos

Archivo Recurso Solicitudes de CPU Límites de CPU Solicitudes de memoria Límites de memoria
monitoring/prometheus.yaml prometheus-server 150m 390m 500Mi N/A
monitoring/prometheus.yaml stackdriver-prometheus-sidecar 200m 340m 600Mi N/A
logging/aggregator.yaml stackdriver-log-aggregator 80m 300m 1500Mi N/A
logging/forwarder.yaml stackdriver-log-forwarder 60m 100m 100Mi 600Mi

25 a 50 nodos

Archivo Recurso Solicitudes de CPU Límites de CPU Solicitudes de memoria Límites de memoria
monitoring/prometheus.yaml prometheus-server 150m 390m 650Mi N/A
monitoring/prometheus.yaml stackdriver-prometheus-sidecar 200m 340m 1500Mi N/A
logging/aggregator.yaml stackdriver-log-aggregator 150m 170m 1600Mi N/A
logging/forwarder.yaml stackdriver-log-forwarder 60m 100m 100Mi 600Mi

51 a 100 nodos

Archivo Recurso Solicitudes de CPU Límites de CPU Solicitudes de memoria Límites de memoria
monitoring/prometheus.yaml prometheus-server 160m 500m 1800Mi N/A
monitoring/prometheus.yaml stackdriver-prometheus-sidecar 200m 500m 1900Mi N/A
logging/aggregator.yaml stackdriver-log-aggregator 220m 1100m 1600Mi N/A
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/prometheus.yaml prometheus-server 400m N/A 6500Mi N/A
monitoring/prometheus.yaml stackdriver-prometheus-sidecar 400m N/A 7500Mi N/A
logging/aggregator.yaml stackdriver-log-aggregator 450m N/A 1700Mi N/A
logging/forwarder.yaml stackdriver-log-forwarder 60m 100m 100Mi 600Mi

Próximos pasos

Obtén información sobre Cloud Logging:

Obtén información sobre Cloud Monitoring: