Engineering

Cómo monitorear Amazon ECS con Elastic Observability

Con cada vez más organizaciones que migran sus aplicaciones y cargas de trabajo a contenedores, la capacidad de monitorear y rastrear el estado y uso de los contenedores es más importante que nunca. Muchos equipos ya usan el módulo docker de Metricbeat para recopilar datos de monitoreo de contenedores de Docker con el objetivo de almacenarlos y analizarlos en Elasticsearch para más detalles. Pero ¿qué sucede cuando los usuarios usan Amazon Elastic Container Service (Amazon ECS)? ¿Aún puede usarse Metricbeat para monitorear Amazon ECS? Sí.

En este blog, te guiaremos paso a paso por cómo monitorear Amazon ECS con Elastic Observability.

¿Qué es Amazon ECS?

Amazon ECS es un servicio completamente gestionado y sumamente escalable que facilita orquestar y provisionar los contenedores Docker. Está respaldado por dos servicios en el cloud subyacentes diferentes denominados “tipos de inicio” que determinan cómo se gestionarán los recursos informáticos: EC2 y Fargate.

Cuando se usa el tipo de inicio EC2, los contenedores se ejecutan en instancias EC2 que los usuarios deben gestionar ellos mismos. Cuando, en cambio, se usa el tipo de inicio Fargate alternativo, los usuarios solo necesitan especificar contenedores y tareas. Fargate se ocupará del provisionamiento, la configuración y la gestión de la infraestructura de backend.

Veamos cómo monitorear cada tipo de inicio con Metricbeat

Cómo monitorear contenedores de Amazon ECS EC2 con Elastic

Cuando despliegan contenedores en EC2, los usuarios son responsables de desplegar y gestionar su propio cluster de Amazon ECS. Desde una perspectiva de monitoreo, estas instancias de EC2 son como cualquier otra VM normal, lo que significa que los usuarios pueden conectarse con ellas y recopilar estadísticas de Docker desde el daemon de Docker directamente. Veamos cómo podemos monitorear nuestros contenedores de Amazon ECS que se ejecutan en EC2 con algunos pasos simples:

Requisito previo: Clave SSL

Cuando creas tu cluster de Amazon ECS, asegúrate de adjuntar una clave SSL válida para que las instancias sean accesibles mediante SSH:

Paso 1: Grupo de seguridad

En la sección de redes, asegúrate de seleccionar un Security group (Grupo de seguridad) que te permitirá habilitar el acceso SSH (puerto 22):

Paso 2: Verificar la instancia de EC2

Una vez que hayas iniciado correctamente el cluster de Amazon ECS, deberías poder enumerar tus instancias de EC2:

Paso 3: Conexión SSL

Puedes conectarte a cada una de ellas a través de SSH con el par de claves que adjuntaste en el paso 1, por ejemplo:

ssh -i "ec2-ecs-test.pem" ec2-user@3.125.104.129

Paso 4: Instalar Metricbeat

Como tienes acceso a todas las instancias del cluster, puedes instalar Metricbeat en cada instancia y comenzar a recopilar métricas desde el daemon de Docker:

curl -L -O <a href="https://artifacts.elastic.co/downloads/beats/metricbeat/metricbeat-7.11.1-x86_64.rpm">https://artifacts.elastic.co/downloads/beats/metricbeat/metricbeat-7.11.1-x86_64.rpm</a> 
sudo rpm -vi metricbeat-7.10.1-x86_64.rpm 
sudo metricbeat modules disable system 
sudo metricbeat modules enable docker

Ahora podemos definir el endpoint de Elasticsearch al cual enviar las métricas; en este caso, una instancia que se ejecuta en Elastic Cloud. Puedes activar una prueba gratuita si deseas seguir los pasos.

Edita metricbeat.yml y agrega opciones de Elastic Cloud:

Generalmente encontrarás este archivo en /etc/metricbeat/metricbeat.yml y puedes editarlo de la siguiente manera:

sudo vi /etc/metricbeat/metricbeat.yml
cloud.id: "elastic-observability-deployment:ZXV…….k3MTI1ZTA1Ng==" 
cloud.auth: "elastic:2vXXXXXXXXXXXxxxxxxxxxxxV"

Si estás ejecutando un cluster de Elasticsearch autogestionado, necesitarás configurar la salida de Elasticsearch:

output.elasticsearch: 
  hosts: ["https://myEShost:9200"] 
  username: "elastic" 
  password: "changeme"

A continuación, puedes configurar dashboards, índices y mapeos predefinidos:

sudo metricbeat setup -e

Inicia Metricbeat:

./metricbeat -e -d & 
sudo service metricbeat start

También puedes configurar el servicio de Metricbeat para que se inicie automáticamente cuando se inicie el sistema:

systemctl enable metricbeat
Nota: Este proceso debe realizarse en todas las instancias de EC2 del cluster.

Paso 5: Verificar recopilación de métricas

Ahora que Metricbeat se está ejecutando, podemos verificar que los eventos se almacenen en nuestro cluster de Elasticsearch observando las métricas relacionadas con Docker en la vista Discover (Descubrir) de Kibana:

Ahora podemos continuar y desplegar tareas en nuestro cluster de Amazon ECS, y Metricbeat recopilará las métricas de estas. Podemos usar estas métricas para crear visualizaciones y dashboard, y aprovechar metadatos adicionales, como cloud_metadata y host_metadata, que se agregan de forma predeterminada para correlacionar las métricas por cuentas de AWS, regiones, identificadores de host, tipos, etc. Por ejemplo, si combinamos la métrica docker.info.containers.running con host.name, podemos proporcionar una visión general de la cantidad de contenedores en ejecución por host en el tiempo:

Paso 6: Ver métricas en dashboards de Kibana prediseñados

Además, tenemos una buena visión general de nuestras cargas de trabajo de contenedores en el dashboard de Docker predeterminado incluido con Metricbeat:

Monitorear las tareas de Amazon ECS solo requiere algunos pasos, y a partir de allí puedes seguir agregando visibilidad al cluster de EC2 con Metricbeat. Ahora continuemos y veamos cómo podemos monitorear nuestras tareas de Amazon ECS cuando usamos Fargate.

Cómo monitorear contenedores de Fargate con Elastic

Amazon ECS en Fargate expone varios metadatos, métricas de red y estadísticas de Docker sobre ejecutar tareas y contenedores mediante el endpoint de metadatos de tareas. Metricbeat usa la versión 4 del endpoint de metadatos de tareas, disponible por contenedor y habilitado de forma predeterminada en la plataforma AWS Fargate versión 1.4.0 o posterior.

Para monitorear una tarea que se ejecuta en Fargate, debes desplegar un contenedor de Metricbeat en la tarea en sí agregando manualmente una definición de contenedor nueva. En la sección Standard (Estándar), puedes asignar un Container name (Nombre de contenedor) como metricbeat-container y usar la imagen de Docker de Metricbeat del registro de Docker de Elastic docker.elastic.co/beats/metricbeat:7.11.0 para una versión específica para la imagen de Metricbeat.

También debemos agregar un comando para este contenedor para configurar e iniciar Metricbeat con el envío de datos a Elastic Cloud:

./metricbeat setup -E cloud.id=$ELASTIC_CLOUD_ID -E cloud.auth=$ELASTIC_CLOUD_AUTH && ./metricbeat modules disable system && ./metricbeat modules enable awsfargate && ./metricbeat -e -E cloud.id=$ELASTIC_CLOUD_ID -E cloud.auth=$ELASTIC_CLOUD_AUTH

Debes agregar valores para $ELASTIC_CLOUD_ID y $ELASTIC_CLOUD_AUTH en la sección Environment variables (Variables de entorno) con las credenciales reales, posiblemente usando AWS Secrets Manager para evitar almacenar estos valores en texto sin formato:

Una vez creada la nueva revisión de definición de tarea, haz clic en run task (ejecutar tarea) debajo del menú desplegable Actions (Acciones) y Metricbeat se agregará a la tarea cuando se reinicie.

Si tienes más que algunas pocas tareas para monitorear, agregar manualmente contenedores de Metricbeat puede ser tedioso y requerir mucho tiempo. En este caso, recomendamos usar AWS CloudFormation, una forma nativa de AWS para gestionar recursos provisionando y actualizándolos durante todo su ciclo de vida sin acciones manuales. AWS CloudFormation te permite tratar la infraestructura como código y gestionarla a través de un archivo de plantilla que define todos los recursos requeridos y sus dependencias.

Este es un ejemplo simplificado de cómo agregar contenedores de Metricbeat en una tarea usando CloudFormation:

 TaskDefinition: 
   Type: AWS::ECS::TaskDefinition 
   Properties: 
     Family: !Ref TaskName 
     Cpu: 256 
     Memory: 512 
     NetworkMode: awsvpc 
     ExecutionRoleArn: !Ref ExecutionRole 
     ContainerDefinitions: 
       - Name: metricbeat-container 
         Image: docker.elastic.co/beats/metricbeat:7.11.0 
         Secrets: 
           - Name: ELASTIC_CLOUD_ID 
             ValueFrom: !Ref CloudIDArn 
           - Name: ELASTIC_CLOUD_AUTH 
             ValueFrom: !Ref CloudAuthArn 
                 EntryPoint: 
           - sh 
           - -c 
         Command: 
           - ./metricbeat setup -E cloud.id=$ELASTIC_CLOUD_ID -E cloud.auth=$ELASTIC_CLOUD_AUTH && ./metricbeat modules disable system && ./metricbeat modules enable awsfargate && ./metricbeat -e -E cloud.id=$ELASTIC_CLOUD_ID -E cloud.auth=$ELASTIC_CLOUD_AUTH

También puedes encontrar una plantilla AWS CloudFormation completa con el módulo awsfargate, que crea un cluster nuevo, una tarea de definición con un contenedor de Metricbeat y un contenedor de prueba de estrés, e inicia el servicio. Siéntete libre de copiarla en un archivo cloudformation.yml de forma local para probarla.

Si usas Elastic Cloud, se recomienda almacenar la cloud id y cloud auth en AWS Secrets Manager; este es el ejemplo de AWS CLI:

Crea ELASTIC_CLOUD_AUTH secreto:

aws --region us-east-1 secretsmanager create-secret --name ELASTIC_CLOUD_AUTH --secret-string XXX

Crea ELASTIC_CLOUD_ID secreto:

aws --region us-east-1 secretsmanager create-secret --name ELASTIC_CLOUD_ID --secret-string YYY

Ahora que los secretos están listos, creemos un stack completo con una llamada de AWS CLI usando el archivo de plantilla de CloudFormation cloudformation.yml.

Crea el stack de CloudFormation:

aws --region us-east-1 cloudformation create-stack --stack-name test-metricbeat-deployment --template-body file://./cloudformation.yml --capabilities CAPABILITY_NAMED_IAM --parameters ParameterKey=SubnetID,ParameterValue=subnet-5d89de27 ParameterKey=CloudAuthArn,ParameterValue=arn:aws:secretsmanager:us-east-1:xxx:secret:ELASTIC_CLOUD_AUTH-abc ParameterKey=CloudIDArn,ParameterValue=arn:aws:secretsmanager:us-east-1:xxx:secret:ELASTIC_CLOUD_ID-abc ParameterKey=ClusterName,ParameterValue=metricbeat-fargate ParameterKey=RoleName,ParameterValue=ecsFargateTaskExecutionRole 
ParameterKey=TaskName,ParameterValue=task-metricbeat ParameterKey=ServiceName,ParameterValue=metricbeat-service ParameterKey=LogGroupName,ParameterValue=metricbeat-fargate-log-group

Una vez que CloudFormation muestre el estado CREATE_COMPLETE para tu stack, deberías poder ver que las métricas de monitoreo se enviaron a Elasticsearch cada 10 segundos. El módulo awsfargate recopila métricas de tiempo de ejecución de cada contenedor, incluida información sobre CPU, memoria, red y diskIO. También hay un dashboard listo para usar que puedes emplear para mostrar todos los datos de monitoreo de awsfargate en Kibana:

Una vez que hayas terminado de experimentar, puedes borrar fácilmente todo el stack con AWS CLI:

aws --region us-east-1 cloudformation delete-stack --stack-name test-metricbeat-deployment

¿Qué sigue?

¿Buscas una solución de monitoreo para tus despliegues de contenedores de Amazon ECS? Con los módulos docker y awsfargate de Metricbeat, los usuarios pueden monitorear con facilidad los contenedores de Amazon ECS y enviar las métricas a Elasticsearch Service en Elastic Cloud. Si tienes preguntas o comentarios, no dudes en publicarlos en el foro de debate de Beats.