Amazon ECS en AWS Fargate
En esta página se describe la integración de ECS Fargate. Para ECS Fargate, consulta la documentación sobre la
integración de EKS Fargate de Datadog.
Obtén métricas de todos tus contenedores que se ejecutan en ECS Fargate:
- Métricas de límite y uso de CPU/memoria
- Monitoriza tus aplicaciones que se ejecutan en Fargate con las métricas personalizadas o integraciones de Datadog.
El Datadog Agent recupera métricas para los contenedores de la definición de tarea con el endpoint de metadatos de la tarea de ECS. Según la Documentación de ECS sobre ese endpoint:
- Este endpoint devuelve estadísticas de Docker en formato JSON para todos los contenedores asociados con la tarea. Para obtener más información sobre cada una de las estadísticas devueltas, consulta ContainerStats en la documentación de la API de Docker.
El endpoint de metadatos de la tarea solo se encuentra disponible desde la propia definición de tarea, por lo que se debe ejecutar el Datadog Agent como un contenedor adicional dentro de cada definición de tarea que se vaya a monitorizar.
La única configuración necesaria para habilitar esta recopilación de métricas es establecer una variable de entorno ECS_FARGATE
en "true"
en la definición de tarea.
Nota: Network Performance Monitoring (NPM) no es compatible con ECS Fargate.
Configuración
En los siguientes pasos se cubre la configuración del contenedor del Datadog Agent dentro de AWS ECS Fargate. Nota: Se necesita la versión 6.1.1, o una posterior, del Datadog Agent para aprovechar al máximo la integración con Fargate.
Las tareas que no tienen el Datadog Agent aún informan métricas con Cloudwatch, sin embargo, se necesita el Agent para Autodiscovery, las métricas detalladas de los contenedores, el rastreo y más. Asimismo, las métricas de Cloudwatch son menos detalladas y tienen más latencia en los informes que las métricas que se envían directamente a través del Datadog Agent.
Instalación
Para monitorizar las tareas de ECS Fargate con Datadog, ejecuta el Agent como un contenedor en la misma definición de tarea que el contenedor de tu aplicación. Para recopilar métricas con Datadog, cada definición de tarea debe incluir un contenedor del Datadog Agent además de los contenedores de la aplicación. Sigue estos pasos de configuración:
- Crear una tarea de ECS Fargate
- Crear o modificar la política de IAM
- Ejecutar la tarea como un servicio de réplica
Crear una tarea de ECS Fargate
La unidad de trabajo principal en Fargate es la tarea, que se configura en la definición de tarea. Una definición de tarea es comparable a un pod en Kubernetes. Una definición de tarea debe contener uno o más contenedores. Para ejecutar el Datadog Agent, crea tu definición de tarea a fin de ejecutar los contenedores de tu aplicación, así como el contenedor del Datadog Agent.
Las siguientes instrucciones te muestran cómo configurar la tarea mediante la consola web de Amazon , herramientas de la AWS CLI o AWS CloudFormation.
Definición de tarea de la IU web
- Inicia sesión en tu consola web de AWS y dirígete a la sección de ECS.
- Haz clic en Task Definitions (Definiciones de tarea) en el menú de la izquierda, luego haz clic en el botón Create new Task Definition (Crear definición de tarea nueva) o elige una definición de tarea de Fargate existente.
- Para definiciones de tarea nuevas:
- Selecciona Fargate como tipo de inicio y, a continuación, haz clic en el botón Next step (Siguiente paso).
- Ingresa un Task Definition Name (Nombre de definición de tarea), como
my-app-and-datadog
. - Selecciona un rol de IAM para la ejecución de tareas. A continuación, consulta los requisitos de permisos en la sección Crear o modificar la política de IAM.
- Elige Task memory (Memoria de tarea) y Task CPU (CPU de tarea) en función de tus necesidades.
- Haz clic en el botón Add container (Añadir contenedor) para comenzar a añadir el contenedor del Datadog Agent.
- En Container name (Nombre del contenedor), ingresa
datadog-agent
. - En Image (Imagen), ingresa
public.ecr.aws/datadog/agent:latest
. - En Env Variables (Variables de entorno), añade la Key (Clave)
DD_API_KEY
e ingresa tu clave de API de Datadog como valor. - Añade otra variable de entorno con la clave
ECS_FARGATE
y el valor true
. Haz clic en Add (Añadir) para añadir el contenedor. - Añade otra variable de entorno con la clave
DD_SITE
y el valor
. El valor predeterminado es datadoghq.com
si no lo estableces. - (Solo Windows) Selecciona
C:\
como directorio de trabajo.
- Añade otros contenedores de aplicaciones a la definición de tarea. A fin de obtener detalles sobre cómo recopilar métricas de integración, consulta la Configuración de la integración para ECS Fargate.
- Haz clic en Create (Crear) para crear la definición de tarea.
Definición de tarea de la AWS CLI
- Descarga datadog-agent-ecs-fargate.json. Nota: Si usas Internet Explorer, es posible que se descargue como un archivo gzip, que contiene el archivo JSON que se menciona a continuación.
- Actualiza el JSON con un
TASK_NAME
, tu clave de API de Datadog y el DD_SITE
(
) adecuado. Nota: La variable de entorno ECS_FARGATE
ya se encuentra establecida en "true"
.
Añade otros contenedores de aplicaciones a la definición de tarea. A fin de obtener detalles sobre cómo recopilar métricas de integración, consulta la Configuración de la integración para ECS Fargate.
De manera opcional, añade un check de estado del Agent.
Añade lo siguiente a tu definición de tarea de ECS para crear un check de estado del Agent:
"healthCheck": {
"retries": 3,
"command": ["CMD-SHELL","agent health"],
"timeout": 5,
"interval": 30,
"startPeriod": 15
}
Ejecuta el siguiente comando para registrar la definición de tarea de ECS:
aws ecs register-task-definition --cli-input-json file://<PATH_TO_FILE>/datadog-agent-ecs-fargate.json
Puedes usar la plantilla de AWS CloudFormation para configurar tus contenedores de Fargate. Usa el recurso AWS::ECS::TaskDefinition
en tu plantilla de CloudFormation a fin de configurar la tarea de Amazon ECS y especifica FARGATE
como el tipo de inicio requerido para esa tarea.
A continuación, actualiza esta plantilla de CloudFormation con tu clave de API de Datadog. Además, incluye la variable de entorno DD_SITE
(
) adecuada si es necesario, ya que su valor predeterminado es datadoghq.com
si no lo estableces.
Resources:
ECSTaskDefinition:
Type: 'AWS::ECS::TaskDefinition'
Properties:
NetworkMode: awsvpc
RequiresCompatibilities:
- FARGATE
Cpu: 256
Memory: 512
ContainerDefinitions:
- Name: datadog-agent
Image: 'public.ecr.aws/datadog/agent:latest'
Environment:
- Name: DD_API_KEY
Value: <DATADOG_API_KEY>
- Name: ECS_FARGATE
Value: true
Por último, incluye otros contenedores de aplicaciones dentro de ContainerDefinitions
y despliégalos a través de CloudFormation.
Para obtener más información sobre las plantillas y la sintaxis de CloudFormation, consulta la Documentación de la definición de tarea de AWS CloudFormation.
Ejecutar la tarea como un servicio de réplica
La única opción en ECS Fargate es ejecutar la tarea como un servicio de réplica. El Datadog Agent se ejecuta en la misma definición de tarea que tu aplicación y los contenedores de integración.
Servicio de réplica de la IU web
- Inicia sesión en tu consola web de AWS y dirígete a la sección de ECS. Si es necesario, crea un clúster con la plantilla de clúster Networking only (Solo redes).
- Elige el clúster para ejecutar el Datadog Agent.
- En la pestaña Services (Servicios), haz clic en el botón Create (Crear).
- En Launch type (Tipo de inicio), elige FARGATE.
- En Task Definition (Definición de tarea), selecciona la tarea que se creó en los pasos anteriores.
- Ingresa un Service name (Nombre de servicio).
- En Number of tasks (Número de tareas) ingresa
1
y, a continuación, haz clic en el botón Next step (Siguiente paso). - Selecciona la Cluster VPC (VPC del clúster), Subnets (Subredes), and Security Groups (Grupos de seguridad).
- El Load balancing (Equilibrio de carga) y Service discovery (Descubrimiento de servicios) son opcionales en función de tus preferencias.
- Haz clic en el botón Next step (Siguiente paso).
- El Auto Scaling (Escalado automático) es opcional en función de tus preferencias.
- Haz clic en el botón Next step (Siguiente paso) y, a continuación, en el botón Create service (Crear servicio).
Servicio de réplica de la AWS CLI
Ejecuta los siguientes comandos con las herramientas de la AWS CLI.
Nota: Se requiere la versión 1.1.0, o una posterior, de Fargate, por lo que el siguiente comando especifica la versión de la plataforma.
Si es necesario, crea un clúster:
aws ecs create-cluster --cluster-name "<CLUSTER_NAME>"
Ejecuta la tarea como un servicio para tu clúster:
aws ecs run-task --cluster <CLUSTER_NAME> \
--network-configuration "awsvpcConfiguration={subnets=["<PRIVATE_SUBNET>"],securityGroups=["<SECURITY_GROUP>"]}" \
--task-definition arn:aws:ecs:us-east-1:<AWS_ACCOUNT_NUMBER>:task-definition/<TASK_NAME>:1 \
--region <AWS_REGION> --launch-type FARGATE --platform-version 1.4.0
En la plantilla de CloudFormation, puedes hacer referencia al recurso ECSTaskDefinition
que se creó en el ejemplo anterior en el recurso AWS::ECS::Service
que se está creando. Después de esto, especifica tu Cluster
, DesiredCount
y cualquier otro parámetro necesario para la aplicación en tu servicio de réplica.
Resources:
ECSTaskDefinition:
#(...)
ECSService:
Type: 'AWS::ECS::Service'
Properties:
Cluster: <CLUSTER_NAME>
TaskDefinition:
Ref: "ECSTaskDefinition"
DesiredCount: 1
#(...)
Para obtener más información sobre las plantillas y la sintaxis de CloudFormation, consulta la Documentación del servicio de AWS CloudFormation ECS.
Para proporcionar tu clave de API de Datadog como un secreto, consulta Uso de secretos.
Instalación para AWS Batch
Para monitorizar tus trabajos de AWS Batch con Datadog, consulta AWS Batch con ECS Fargate y el Datadog Agent
Crear o modificar la política de IAM
Añade los siguientes permisos a tu política de IAM de Datadog para recopilar métricas de ECS Fargate. Para obtener más información, consulta las políticas de ECS en el sitio web de AWS.
Permiso de AWS | Descripción |
---|
ecs:ListClusters | Enumera los clústeres disponibles. |
ecs:ListContainerInstances | Enumera las instancias de un clúster. |
ecs:DescribeContainerInstances | Describe instancias para añadir métricas sobre recursos y tareas en ejecución. |
Uso de los secretos
Como alternativa a completar la variable de entorno DD_API_KEY
con tu clave de API en texto sin formato, puedes hacer referencia al ARN de un secreto de texto sin formato almacenado en AWS Secrets Manager. Coloca la variable de entorno DD_API_KEY
en la sección containerDefinitions.secrets
del archivo de definición de tarea o trabajo. Asegúrate de que el rol de ejecución de tarea o trabajo tenga el permiso necesario para obtener secretos de AWS Secrets Manager.
Recopilación de métricas
Una vez que el Datadog Agent se configure como se describe anteriormente, el check ecs_fargate recopila métricas con Autodiscovery habilitado. Añade etiquetas (labels) de Docker a tus demás contenedores en la misma tarea para recopilar métricas adicionales.
Si bien la integración funciona en Linux y Windows, algunas métricas dependen del sistema operativo. Todas las métricas expuestas cuando se ejecuta en Windows también se exponen en Linux, pero hay algunas métricas que solo se encuentran disponibles en Linux. Consulta Datos recopilados para ver la lista de métricas que proporciona esta integración. En la lista también se especifica qué métricas solo son para Linux.
A fin de obtener detalles sobre la recopilación de métricas de integración, consulta la Configuración de la integración para ECS Fargate.
DogStatsD
Las métricas se recopilan con DogStatsD a través del puerto UDP 8125.
Otras variables de entorno
Para conocer las variables de entorno disponibles con el contenedor del Docker Agent, consulta la página Docker Agent. Nota: Algunas variables no se encuentran disponibles para Fargate.
Variable de entorno | Descripción |
---|
DD_DOCKER_LABELS_AS_TAGS | Extrae etiquetas (labels) de contenedores de Docker |
DD_CHECKS_TAG_CARDINALITY | Añade etiquetas a las métricas de los checks |
DD_DOGSTATSD_TAG_CARDINALITY | Añade etiquetas a las métricas personalizadas |
Para el etiquetado global, se recomienda usar DD_DOCKER_LABELS_AS_TAGS
. Con este método, el Agent obtiene las etiquetas (tags) de las etiquetas (labels) de tu contenedor. Para ello, debes añadir las etiquetas (labels) adecuadas a tus demás contenedores. Las etiquetas (labels) se pueden añadir directamente en la definición de tarea.
Formato para el contenedor del Agent:
{
"name": "DD_DOCKER_LABELS_AS_TAGS",
"value": "{\"<LABEL_NAME_TO_COLLECT>\":\"<TAG_KEY_FOR_DATADOG>\"}"
}
Ejemplo para el contenedor del Agent:
{
"name": "DD_DOCKER_LABELS_AS_TAGS",
"value": "{\"com.docker.compose.service\":\"service_name\"}"
}
Ejemplo de CloudFormation (YAML):
ContainerDefinitions:
- #(...)
Environment:
- Name: DD_DOCKER_LABELS_AS_TAGS
Value: "{\"com.docker.compose.service\":\"service_name\"}"
Nota: No debes usar DD_HOSTNAME
, ya que no existe el concepto de host para el usuario en Fargate. El uso de esta etiqueta puede hacer que tus tareas aparezcan como hosts de APM en la lista de infraestructura, lo que podría afectar tu facturación. En su lugar, tradicionalmente se usa DD_TAGS
para asignar etiquetas de host. A partir de la versión 6.13.0 del Datadog Agent, también puedes usar la variable de entorno DD_TAGS
para establecer etiquetas globales en tus métricas de integración.
Métricas basadas en rastreadores
Además de las métricas que recopila el Datadog Agent, Datadog tiene una integración de ECS basada en CloudWatch. Esta integración recopila las métricas de CloudWatch de Amazon ECS.
Como se indica allí, las tareas de Fargate también informan métricas de esta manera:
Las métricas disponibles dependerán del tipo de inicio de las tareas y los servicios en tus clústeres o trabajos por lotes. Si usas el tipo de inicio de Fargate para tus servicios, se proporcionarán métricas de uso de CPU y memoria a fin de ayudar en la monitorización de tus servicios.
Debido a que este método no usa el Datadog Agent, debes configurar la integración de AWS al marcar ECS en el cuadro de integración. Luego, Datadog extrae estas métricas de CloudWatch (con el espacio de nombres aws.ecs.*
en Datadog) en tu nombre. Consulta la sección Datos recopilados de la documentación.
Si estas son las únicas métricas que necesitas, puedes confiar en esta integración para la recopilación mediante métricas de CloudWatch. Nota: Los datos de CloudWatch son menos detallados (entre 1 y 5 minutos, en función del tipo de monitorización que hayas habilitado) y se demoran en enviarse a Datadog. Esto se debe a que la recopilación de datos de CloudWatch debe cumplir con los límites de la API de AWS, en lugar de enviarlos a Datadog con el Agent.
El rastreador de CloudWatch predeterminado de Datadog sondea las métricas una vez cada 10 minutos. Si necesitas un cronograma de rastreo más rápido, ponte en contacto con el servicio de asistencia de Datadog para consultar la disponibilidad. Nota: Hay aumentos de costes involucrados en el lado de AWS, ya que CloudWatch factura las llamadas a la API.
Recopilación de logs
Puedes monitorizar los logs de Fargate mediante:
- La integración de AWS FireLens basada en el complemento de salida Fluent Bit de Datadog para enviar logs directamente a Datadog
- El uso del controlador de logs
awslogs
para almacenar los logs en un grupo de logs de CloudWatch y luego una función de Lambda a fin de enrutar los logs a Datadog
Datadog recomienda usar AWS FireLens porque puedes configurar Fluent Bit directamente en tus tareas de Fargate.
Nota: La recopilación de logs con Fluent Bit y FireLens no es compatible con AWS Batch en ECS Fargate.
Fluent Bit y FireLens
Configura la integración de AWS FireLens basada en el complemento de salida Fluent Bit de Datadog para conectar los datos de logs monitorizados de FireLens a los logs de Datadog. Puedes encontrar una definición de tarea de muestra completa para esta configuración aquí.
Añade el contenedor de enrutador de logs de FireLens y Fluent Bit en tu tarea de Fargate existente. Para obtener más información sobre cómo habilitar FireLens, consulta la Documentación de AWS Firelens dedicada. Para obtener más información sobre las definiciones de contenedor de Fargate, consulta la Documentación de AWS sobre definiciones de contenedor. AWS recomienda que uses la imagen regional de Docker. A continuación, se incluye un fragmento de ejemplo de una definición de tarea donde se ha configurado la imagen de Fluent Bit:
{
"essential": true,
"image": "amazon/aws-for-fluent-bit:stable",
"name": "log_router",
"firelensConfiguration": {
"type": "fluentbit",
"options": { "enable-ecs-log-metadata": "true" }
}
}
Si tus contenedores publican logs JSON serializados a través de stdout, debes usar esta configuración adicional de FireLens para analizarlos correctamente en Datadog:
{
"essential": true,
"image": "amazon/aws-for-fluent-bit:stable",
"name": "log_router",
"firelensConfiguration": {
"type": "fluentbit",
"options": {
"enable-ecs-log-metadata": "true",
"config-file-type": "file",
"config-file-value": "/fluent-bit/configs/parse-json.conf"
}
}
}
Esto convierte el JSON serializado del campo log:
en campos de nivel superior. Consulta el ejemplo de AWS en Parseo de logs de stdout de contenedor que son JSON serializados para obtener más detalles.
Luego, en la misma tarea de Fargate, define una configuración de log para los contenedores deseados a los que se enviarán logs. Esta configuración de log debe tener AWS FireLens como controlador de logs y contar con datos que se envíen a Fluent Bit. A continuación, se incluye un fragmento de ejemplo de una definición de tarea en la que FireLens es el controlador de logs y envía datos a Fluent Bit:
{
"logConfiguration": {
"logDriver": "awsfirelens",
"options": {
"Name": "datadog",
"apikey": "<DATADOG_API_KEY>",
"Host": "http-intake.logs.datadoghq.com",
"dd_service": "firelens-test",
"dd_source": "redis",
"dd_message_key": "log",
"dd_tags": "project:fluentbit",
"TLS": "on",
"provider": "ecs"
}
}
}
{
"logConfiguration": {
"logDriver": "awsfirelens",
"options": {
"Name": "datadog",
"apikey": "<DATADOG_API_KEY>",
"Host": "http-intake.logs.us3.datadoghq.com",
"dd_service": "firelens-test",
"dd_source": "redis",
"dd_message_key": "log",
"dd_tags": "project:fluentbit",
"TLS": "on",
"provider": "ecs"
}
}
}
{
"logConfiguration": {
"logDriver": "awsfirelens",
"options": {
"Name": "datadog",
"apikey": "<DATADOG_API_KEY>",
"Host": "http-intake.logs.us5.datadoghq.com",
"dd_service": "firelens-test",
"dd_source": "redis",
"dd_message_key": "log",
"dd_tags": "project:fluentbit",
"TLS": "on",
"provider": "ecs"
}
}
}
{
"logConfiguration": {
"logDriver": "awsfirelens",
"options": {
"Name": "datadog",
"apikey": "<DATADOG_API_KEY>",
"Host": "http-intake.logs.datadoghq.eu",
"dd_service": "firelens-test",
"dd_source": "redis",
"dd_message_key": "log",
"dd_tags": "project:fluentbit",
"TLS": "on",
"provider": "ecs"
}
}
}
{
"logConfiguration": {
"logDriver": "awsfirelens",
"options": {
"Name": "datadog",
"apikey": "<DATADOG_API_KEY>",
"Host": "http-intake.logs.ddog-gov.datadoghq.com",
"dd_service": "firelens-test",
"dd_source": "redis",
"dd_message_key": "log",
"dd_tags": "project:fluentbit",
"TLS": "on",
"provider": "ecs"
}
}
}
Se pueden ajustar el dd_service
, dd_source
y dd_tags
en función de las etiquetas deseadas.
- Cada vez que se ejecuta una tarea de Fargate, Fluent Bit envía los logs de contenedores a Datadog con información sobre todos los contenedores gestionados por las tareas de Fargate. Puedes ver los logs sin procesar en la página del Log Explorer, crear monitores para los logs y usar la vista de Live Container.
IU web
Para añadir el contenedor de Fluent Bit a tu definición de tarea existente, marca la casilla de verificación Enable FireLens integration (Habilitar integración de FireLens) en Log router integration (Integración de enrutador de logs) a fin de crear el contenedor log_router
de manera automática. Esto extrae la imagen regional; sin embargo, recomendamos usar la etiqueta de imagen stable
en lugar de latest
. Una vez que hagas clic en Apply (Aplicar), se creará el contenedor base. Para personalizar aún más la firelensConfiguration
, haz clic en el botón Configure via JSON (Configurar mediante JSON) en la parte inferior a fin de editarlo de forma manual.
Una vez que esto se haya añadido, edita el contenedor de la aplicación en tu definición de tarea desde donde quieres enviar logs y cambia el Log driver (Controlador de logs) a awsfirelens
al completar las Log options (Opciones de log) con las claves que se muestran en el ejemplo anterior.
AWS CLI
Edita el archivo de la definición de tarea JSON existente a fin de incluir el contenedor log_router
y la logConfiguration
actualizada para el contenedor de tu aplicación, como se describe en la sección anterior. Una vez hecho esto, crea una revisión nueva de la definición de tarea con el siguiente comando:
aws ecs register-task-definition --cli-input-json file://<PATH_TO_FILE>/datadog-agent-ecs-fargate.json
Para usar la plantilla de AWS CloudFormation, usa el recurso AWS::ECS::TaskDefinition
y establece la opción Datadog
a fin de configurar la gestión de logs.
Por ejemplo, para configurar Fluent Bit con el fin de enviar logs a Datadog:
Resources:
ECSTaskDefinition:
Type: 'AWS::ECS::TaskDefinition'
Properties:
NetworkMode: awsvpc
RequiresCompatibilities:
- FARGATE
Cpu: 256
Memory: 1GB
ContainerDefinitions:
- Name: tomcat-test
Image: 'tomcat:jdk8-adoptopenjdk-openj9'
LogConfiguration:
LogDriver: awsfirelens
Options:
Name: datadog
apikey: <DATADOG_API_KEY>
Host: http-intake.logs.datadoghq.com
dd_service: test-service
dd_source: test-source
TLS: 'on'
provider: ecs
MemoryReservation: 500
- Name: log_router
Image: 'amazon/aws-for-fluent-bit:stable'
Essential: true
FirelensConfiguration:
Type: fluentbit
Options:
enable-ecs-log-metadata: true
MemoryReservation: 50
Resources:
ECSTaskDefinition:
Type: 'AWS::ECS::TaskDefinition'
Properties:
NetworkMode: awsvpc
RequiresCompatibilities:
- FARGATE
Cpu: 256
Memory: 1GB
ContainerDefinitions:
- Name: tomcat-test
Image: 'tomcat:jdk8-adoptopenjdk-openj9'
LogConfiguration:
LogDriver: awsfirelens
Options:
Name: datadog
apikey: <DATADOG_API_KEY>
Host: http-intake.logs.us3.datadoghq.com
dd_service: test-service
dd_source: test-source
TLS: 'on'
provider: ecs
MemoryReservation: 500
- Name: log_router
Image: 'amazon/aws-for-fluent-bit:stable'
Essential: true
FirelensConfiguration:
Type: fluentbit
Options:
enable-ecs-log-metadata: true
MemoryReservation: 50
Resources:
ECSTaskDefinition:
Type: 'AWS::ECS::TaskDefinition'
Properties:
NetworkMode: awsvpc
RequiresCompatibilities:
- FARGATE
Cpu: 256
Memory: 1GB
ContainerDefinitions:
- Name: tomcat-test
Image: 'tomcat:jdk8-adoptopenjdk-openj9'
LogConfiguration:
LogDriver: awsfirelens
Options:
Name: datadog
apikey: <DATADOG_API_KEY>
Host: http-intake.logs.us5.datadoghq.com
dd_service: test-service
dd_source: test-source
TLS: 'on'
provider: ecs
MemoryReservation: 500
- Name: log_router
Image: 'amazon/aws-for-fluent-bit:stable'
Essential: true
FirelensConfiguration:
Type: fluentbit
Options:
enable-ecs-log-metadata: true
MemoryReservation: 50
Resources:
ECSTaskDefinition:
Type: 'AWS::ECS::TaskDefinition'
Properties:
NetworkMode: awsvpc
RequiresCompatibilities:
- FARGATE
Cpu: 256
Memory: 1GB
ContainerDefinitions:
- Name: tomcat-test
Image: 'tomcat:jdk8-adoptopenjdk-openj9'
LogConfiguration:
LogDriver: awsfirelens
Options:
Name: datadog
apikey: <DATADOG_API_KEY>
Host: http-intake.logs.datadoghq.eu
dd_service: test-service
dd_source: test-source
TLS: 'on'
provider: ecs
MemoryReservation: 500
- Name: log_router
Image: 'amazon/aws-for-fluent-bit:stable'
Essential: true
FirelensConfiguration:
Type: fluentbit
Options:
enable-ecs-log-metadata: true
MemoryReservation: 50
Resources:
ECSTaskDefinition:
Type: 'AWS::ECS::TaskDefinition'
Properties:
NetworkMode: awsvpc
RequiresCompatibilities:
- FARGATE
Cpu: 256
Memory: 1GB
ContainerDefinitions:
- Name: tomcat-test
Image: 'tomcat:jdk8-adoptopenjdk-openj9'
LogConfiguration:
LogDriver: awsfirelens
Options:
Name: datadog
apikey: <DATADOG_API_KEY>
Host: http-intake.logs.ddog-gov.datadoghq.com
dd_service: test-service
dd_source: test-source
TLS: 'on'
provider: ecs
MemoryReservation: 500
- Name: log_router
Image: 'amazon/aws-for-fluent-bit:stable'
Essential: true
FirelensConfiguration:
Type: fluentbit
Options:
enable-ecs-log-metadata: true
MemoryReservation: 50
Para obtener más información sobre las plantillas y la sintaxis de CloudFormation, consulta la Documentación de AWS CloudFormation.
Nota: Usa un secreto TaskDefinition para evitar exponer la apikey
en texto sin formato.
Controlador de logs de AWS
Monitoriza los logs de Fargate mediante el controlador de logs awslogs
y una función de Lambda para enrutar los logs a Datadog.
Define el controlador de logs como awslogs
en el contenedor de la aplicación en la tarea o el trabajo del que quieras recopilar logs. Consulta la guía para desarrolladores de AWS Fargate a fin de obtener instrucciones.
Esto configura las tareas o trabajos de Fargate para enviar información de logs a Amazon CloudWatch Logs. A continuación, se muestra un fragmento de una definición de tarea o trabajo donde se ha configurado el controlador de logs awslogs:
{
"logConfiguration": {
"logDriver": "awslogs",
"options": {
"awslogs-group": "/ecs/fargate-task|job-definition",
"awslogs-region": "us-east-1",
"awslogs-stream-prefix": "ecs"
}
}
}
Para obtener más información sobre cómo usar el controlador de logs awslogs
en las definiciones de tarea o trabajo a fin de enviar logs de contenedores a CloudWatch Logs, consulta Uso del controlador de logs awslogs. Este controlador recopila los logs que genera el contenedor y los envía directamente a CloudWatch Logs.
Por último, usa la función de Lambda del Datadog Forwarder de logs para recopilar logs de CloudWatch y enviarlos a Datadog.
Recopilación de trazas
- Sigue las instrucciones anteriores para añadir el contenedor del Datadog Agent a tu definición de trabajo o tarea con la variable de entorno adicional
DD_APM_ENABLED
establecida en true
. Establece la variable DD_SITE
en
. El valor predeterminado es datadoghq.com
si no lo estableces.
Instrumenta la aplicación en función de tu configuración:
Nota: Con las aplicaciones de APM y Fargate, no establezcas DD_AGENT_HOST
; el valor predeterminado localhost
funciona.
Consulta información más general sobre el Envío de trazas a Datadog.
Asegúrate de que tu aplicación se ejecute en la misma definición de trabajo o tarea que el contenedor del Datadog Agent.
Recopilación de procesos
Puedes ver tus procesos de ECS Fargate en Datadog. Para ver su relación con los contenedores de ECS Fargate, utiliza la versión del Datadog Agent 7.50.0 o una posterior.
Puedes monitorizar los procesos en ECS Fargate en Datadog mediante la página de Live Processes. Para habilitar la recopilación de procesos, añade el [parámetro PidMode
] 42 en la definición de tarea y establécelo en task
de la siguiente manera:
Para filtrar procesos por ECS, usa la faceta de contenedores de AWS Fargate
o ingresa fargate:ecs
en la consulta de búsqueda de la página de Live Processes.
Etiquetas predefinidas
El Agent puede detectar de manera automática y adjuntar etiquetas a todos los datos emitidos por la tarea completa o un contenedor individual en esta tarea o trabajo. La lista de etiquetas adjuntadas de manera automática depende de la configuración de cardinalidad del Agent.
Etiqueta | Cardinalidad | Fuente |
---|
container_name | Alto | API de ECS |
container_id | Alto | API de ECS |
docker_image | Bajo | API de ECS |
image_name | Bajo | API de ECS |
short_image | Bajo | API de ECS |
image_tag | Bajo | API de ECS |
ecs_cluster_name | Bajo | API de ECS |
ecs_container_name | Bajo | API de ECS |
task_arn | Orquestador | API de ECS |
task_family | Bajo | API de ECS |
task_name | Bajo | API de ECS |
task_version | Bajo | API de ECS |
availability-zone | Bajo | API de ECS |
region | Bajo | API de ECS |
Datos recopilados
Métricas
ecs.fargate.cpu.limit (gauge) | Soft limit (CPU Shares) in CPU Units. |
ecs.fargate.cpu.percent (gauge) | Percentage of CPU used per container (Linux only). Shown as percent |
ecs.fargate.cpu.system (gauge) | System CPU time. Shown as nanocore |
ecs.fargate.cpu.task.limit (gauge) | Task CPU Limit (shared by all containers). Shown as nanocore |
ecs.fargate.cpu.usage (gauge) | Total CPU Usage. Shown as nanocore |
ecs.fargate.cpu.user (gauge) | User CPU time. Shown as nanocore |
ecs.fargate.ephemeral_storage.reserved (gauge) | The reserved ephemeral storage of this task. (Fargate 1.4.0+ required). Shown as mebibyte |
ecs.fargate.ephemeral_storage.utilized (gauge) | The current ephemeral storage usage of this task. (Fargate 1.4.0+ required). Shown as mebibyte |
ecs.fargate.io.bytes.read (gauge) | Number of bytes read on the disk. Shown as byte |
ecs.fargate.io.bytes.write (gauge) | Number of bytes written to the disk. Shown as byte |
ecs.fargate.io.ops.read (gauge) | Number of read operation on the disk. |
ecs.fargate.io.ops.write (gauge) | Number of write operations to the disk. |
ecs.fargate.mem.active_anon (gauge) | Number of bytes of anonymous and swap cache memory on active LRU list (Linux only). Shown as byte |
ecs.fargate.mem.active_file (gauge) | Number of bytes of file-backed memory on active LRU list (Linux only). Shown as byte |
ecs.fargate.mem.cache (gauge) | Number of bytes of page cache memory (Linux only). Shown as byte |
ecs.fargate.mem.hierarchical_memory_limit (gauge) | Number of bytes of memory limit with regard to hierarchy under which the memory cgroup is (Linux only). Shown as byte |
ecs.fargate.mem.hierarchical_memsw_limit (gauge) | Number of bytes of memory+swap limit with regard to hierarchy under which memory cgroup is (Linux only). Shown as byte |
ecs.fargate.mem.inactive_file (gauge) | Number of bytes of file-backed memory on inactive LRU list (Linux only). Shown as byte |
ecs.fargate.mem.limit (gauge) | Number of bytes memory limit (Linux only). Shown as byte |
ecs.fargate.mem.mapped_file (gauge) | Number of bytes of mapped file (includes tmpfs/shmem) (Linux only). Shown as byte |
ecs.fargate.mem.max_usage (gauge) | Show max memory usage recorded. Shown as byte |
ecs.fargate.mem.pgfault (gauge) | Number of page faults per second (Linux only). |
ecs.fargate.mem.pgmajfault (gauge) | Number of major page faults per second (Linux only). |
ecs.fargate.mem.pgpgin (gauge) | Number of charging events to the memory cgroup. The charging event happens each time a page is accounted as either mapped anon page(RSS) or cache page(Page Cache) to the cgroup (Linux only). |
ecs.fargate.mem.pgpgout (gauge) | Number of uncharging events to the memory cgroup. The uncharging event happens each time a page is unaccounted from the cgroup (Linux only). |
ecs.fargate.mem.rss (gauge) | Number of bytes of anonymous and swap cache memory (includes transparent hugepages) (Linux only). Shown as byte |
ecs.fargate.mem.task.limit (gauge) | Task Memory Limit (shared by all containers). Shown as byte |
ecs.fargate.mem.usage (gauge) | Number of bytes of memory used. Shown as byte |
ecs.fargate.net.bytes_rcvd (gauge) | Number of bytes received (Fargate 1.4.0+ required). Shown as byte |
ecs.fargate.net.bytes_sent (gauge) | Number of bytes sent (Fargate 1.4.0+ required). Shown as byte |
ecs.fargate.net.packet.in_dropped (gauge) | Number of ingoing packets dropped (Fargate 1.4.0+ required). Shown as packet |
ecs.fargate.net.packet.out_dropped (gauge) | Number of outgoing packets dropped (Fargate 1.4.0+ required). Shown as packet |
ecs.fargate.net.rcvd_errors (gauge) | Number of received errors (Fargate 1.4.0+ required). Shown as error |
ecs.fargate.net.sent_errors (gauge) | Number of sent errors (Fargate 1.4.0+ required). Shown as error |
Eventos
El check de ECS Fargate no incluye eventos.
Checks de servicio
fargate_check
Returns CRITICAL
if the Agent is unable to connect to Fargate, otherwise returns OK
.
Statuses: ok, critical
Solucionar problemas
¿Necesitas ayuda? Ponte en contacto con el servicio de asistencia de Datadog.
Referencias adicionales