Registros y supervisión de clústeres conectados de Anthos

En esta página, se muestra cómo exportar registros y métricas a partir de un clúster conectado a Anthos a Cloud Logging y Cloud Monitoring.

Cómo funciona

Google Cloud's operations suite es la solución de observabilidad integrada para Google Cloud. Para exportar la telemetría a nivel de clúster de un clúster conectado a Google Cloud, debes implementar los siguientes agentes de exportación de código abierto en tu clúster:

Agregador de registros de Stackdriver (stackdriver-log-aggregator-*). Un StatefulSet de Fluentd que envía registros a la API de Cloud Logging (antes llamada Stackdriver Logging).
Servidor de reenvío 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 sidecar de exportación de Stackdriver, para enviar métricas de Prometheus a la API de Cloud Monitoring (antes llamado Stackdriver Monitoring). El sidecar es otro contenedor dentro del mismo pod que lee las métricas y que el servidor de Prometheus almacena en el disco y reenvía a la API de Cloud Monitoring.

Requisitos previos

Un proyecto de Google Cloud con facturación habilitada. Consulta nuestra guía de precios para obtener información sobre los costos de las operaciones de Cloud.
Un clúster conectado de Anthos, registrado con esta guía. Ejecuta el siguiente comando para verificar que tu clúster esté registrado.
```
gcloud container fleet memberships list
```
Resultado de ejemplo:
```
NAME  EXTERNAL_ID
eks   ae7b76b8-7922-42e9-89cd-e46bb8c4ffe4
```
Un entorno local desde el que puedes acceder a tu clúster y ejecutar comandos kubectl. Consulta la guía de inicio rápido de GKE para obtener instrucciones sobre cómo instalar kubectl mediante gcloud. Ejecuta el siguiente comando para verificar que puedes acceder al clúster conectado con kubectl.
```
kubectl cluster-info
```
Salida de ejemplo:
```
Kubernetes master is running at https://[redacted].gr7.us-east-2.eks.amazonaws.com
```

Crear

Clona el repositorio de muestra y navega hasta el directorio de esta guía.

git clone https://github.com/GoogleCloudPlatform/anthos-samples
cd anthos-samples/attached-logging-monitoring

Configura la variable de ID del proyecto en el proyecto en el que registraste tu clúster.
```
PROJECT_ID="your-project-id"
```

Crea una cuenta de servicio de Google Cloud con permisos para escribir métricas y registros en las API de Cloud Monitoring y Cloud Logging. Agrega la clave de esta cuenta de servicio a las cargas de trabajo implementadas en la siguiente sección.

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

Crea y descarga una clave JSON para la cuenta de servicio que acabas de crear y, luego, crea un secreto de Kubernetes en tu clúster con esa clave.

gcloud iam service-accounts keys create credentials.json \
--iam-account anthos-lm-forwarder@${PROJECT_ID}.iam.gserviceaccount.com

kubectl create secret generic google-cloud-credentials -n kube-system --from-file credentials.json

Instala el agente de Logging

Cambia al directorio logging/ con el siguiente comando:
```
cd logging/
```
Abre aggregator.yaml. En la parte inferior del archivo, configura las siguientes variables como el valor correspondiente para tu proyecto y clúster:
```
project_id [PROJECT_ID]
k8s_cluster_name [CLUSTER_NAME]
k8s_cluster_location [CLUSTER_LOCATION]
```
Para encontrar la ubicación de tu clúster, ejecuta el siguiente comando con el nombre de membresía del clúster conectado y obtén la ubicación que aparece en /locations/<location>.
```
gcloud container fleet memberships describe eks | grep name
```
Resultado:
```
name: projects/my-project/locations/global/memberships/eks
```
En aggregator.yaml, bajo volumeClaimTemplates/spec, especifica el storageClassName de PersistentVolumeClaim para tu clúster: proporcionamos valores predeterminados para EKS y AKS para que quites los comentarios según corresponda. Si usas EKS, es gp2. Para AKS, es default.

Si configuraste una clase de almacenamiento de Kubernetes personalizada en AWS o Azure, quieres usar una clase de almacenamiento no predeterminada o usas otro tipo de clúster compatible, puedes agregar tu propio storageClassName. El storageClassName adecuado se basa en el tipo de PersistentVolume (PV) que aprovisionó un administrador para el clúster mediante StorageClass. Puedes obtener más información sobre las clases de almacenamiento y las clases de almacenamiento predeterminadas para otros proveedores principales de Kubernetes en la documentación de Kubernetes.
```
# storageClassName: standard #Google Cloud
# storageClassName: gp2 #AWS EKS
# storageClassName: default #Azure AKS
```

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

kubectl apply -f aggregator.yaml
kubectl apply -f forwarder.yaml

Verifica que los pods se hayan iniciado. Deberías ver 2 pods de agregador y un pod de reenvío por cada nodo de trabajador de Kubernetes. Por ejemplo, en un clúster de 4 nodos, deberías ver 4 pods de reenvío.

kubectl get pods -n kube-system | grep stackdriver-log

Resultado:

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

Obtén registros de agregador y verifica que se envíen a Google Cloud.

kubectl logs stackdriver-log-aggregator-0 -n kube-system

Salida:

2020-10-12 14:35:40 +0000 [info]: #3 [google_cloud] Successfully sent gRPC to Stackdriver Logging API.

Implementa una aplicación de prueba en tu clúster. Este es un servidor web HTTP básico con un generador de cargas.

kubectl apply -f  https://raw.githubusercontent.com/GoogleCloudPlatform/istio-samples/master/sample-apps/helloserver/server/server.yaml

kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/istio-samples/master/sample-apps/helloserver/loadgen/loadgen.yaml

Verifica que puedas ver los registros de tu clúster adjunto en el panel de Cloud Logging. Ve al Explorador de registros en Google Cloud Console.

Ir al Explorador de registros
En el Explorador de registros, copia la consulta de muestra que aparece a continuación en el campo Compilador de consultas y reemplaza ${your-cluster-name} por el nombre de tu clúster. Haz clic en Ejecutar consulta. Los registros de clústeres recientes deberían aparecer en Resultados de consultas.
```
resource.type="k8s_container" resource.labels.cluster_name="${your-cluster-name}"
```

Registros del clúster adjunto

Instalar el agente de Cloud Monitoring

Sal del directorio logging/ y entra en el directorio monitoring/.
```
cd ../monitoring
```

Abre prometheus.yaml. En stackdriver-prometheus-sidecar/args, configura las siguientes variables para que coincidan con tu entorno.

"--stackdriver.project-id=[PROJECT_ID]"
"--stackdriver.kubernetes.location=[CLUSTER_LOCATION]"
"--stackdriver.generic.location=[CLUSTER_LOCATION]"
"--stackdriver.kubernetes.cluster-name=[CLUSTER_NAME]"

En prometheus.yaml, en volumeClaimTemplates/spec, quita el comentario de storageClassName que coincida con tu proveedor de servicios en la nube, como se describe en Instala el agente de Logging.
```
# storageClassName: standard #Google Cloud
# storageClassName: gp2 #AWS EKS
# storageClassName: default #Azure AKS
```

Implementa el StatefulSet de stackdriver-prometheus, configurado con el sidecar del exportador, en tu clúster.

kubectl apply -f server-configmap.yaml
kubectl apply -f sidecar-configmap.yaml
kubectl apply -f prometheus.yaml

Verifica que el Pod stackdriver-prometheus se esté ejecutando.

watch kubectl get pods -n kube-system | grep stackdriver-prometheus

Salida:

stackdriver-prometheus-k8s-0         2/2     Running   0          5h24m

Obtén los registros del contenedor del sidecar de Stackdriver Prometheus para verificar que se haya iniciado el pod.

kubectl logs stackdriver-prometheus-k8s-0 -n kube-system stackdriver-prometheus-sidecar

Resultado:

level=info ts=2020-11-18T21:37:24.819Z caller=main.go:598 msg="Web server started"
level=info ts=2020-11-18T21:37:24.819Z caller=main.go:579 msg="Stackdriver client started"

Verifica que las métricas del clúster se exporten correctamente a Cloud Monitoring. Ve al Explorador de métricas en Google Cloud Console:

Ir al Explorador de métricas
Haz clic en Editor de consultas y, luego, copia el siguiente comando y reemplaza ${your-project-id} y ${your-cluster-name} por la información de tu proyecto y de tu clúster. A continuación, haz clic en Ejecutar consulta. Deberías ver 1.0.
```
fetch k8s_container
| metric 'kubernetes.io/anthos/up'
| filter
    resource.project_id == '${your-project-id}'
    && (resource.cluster_name =='${your-cluster-name}')
| group_by 1m, [value_up_mean: mean(value.up)]
| every 1m
```

Supervisión del clúster adjunto

Realiza una limpieza

Para quitar todos los recursos creados en esta guía, haz lo siguiente:

kubectl delete -f logging
kubectl delete -f monitoring
kubectl delete secret google-cloud-credentials -n kube-system
kubectl delete -f https://raw.githubusercontent.com/GoogleCloudPlatform/istio-samples/master/sample-apps/helloserver/loadgen/loadgen.yaml
kubectl delete -f https://raw.githubusercontent.com/GoogleCloudPlatform/istio-samples/master/sample-apps/helloserver/server/server.yaml
rm -r credentials.json
gcloud compute service-accounts delete anthos-lm-forwarder