Información general

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:

1. Crear una tarea de ECS Fargate
2. Crear o modificar la política de IAM
3. 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.

aws ecs register-task-definition --cli-input-json file://<PATH_TO_FILE>/datadog-agent-ecs-fargate.json

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

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.

aws ecs create-cluster --cluster-name "<CLUSTER_NAME>"

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

Resources:
  ECSTaskDefinition:
    #(...)
  ECSService:
    Type: 'AWS::ECS::Service'
    Properties:
      Cluster: <CLUSTER_NAME>
      TaskDefinition:
        Ref: "ECSTaskDefinition"
      DesiredCount: 1
      #(...)

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.

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.

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

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

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

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

aws ecs register-task-definition --cli-input-json file://<PATH_TO_FILE>/datadog-agent-ecs-fargate.json

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

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.

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

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

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

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

   Lenguaje
   Java
   Python
   Ruby
   Go
   Node.js
   PHP
   C++
   .NET Core
   .NET Framework

   Consulta información más general sobre el Envío de trazas a Datadog.

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

"pidMode": "task"

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.

Datos recopilados

Métricas

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

• Entrada de blog: Monitorizar las aplicaciones de AWS Fargate con Datadog
• FAQ: Configuración de la integración de ECS Fargate
• Entrada de blog: Monitorizar los logs de contenedores de Fargate con FireLens y Datadog
• Entrada de blog: Métricas clave para la monitorización de AWS Fargate
• Entrada de blog: Cómo recopilar métricas y logs de las cargas de trabajo de AWS Fargate
• Entrada de blog: Monitorización de AWS Fargate con Datadog
• Entrada de blog: Despliegues de AWS Fargate impulsados por Graviton2
• Entrada de blog: Monitorizar AWS Fargate para aplicaciones en contenedores de Windows
• Entrada de blog: Monitorizar los procesos que se ejecutan en AWS Fargate con Datadog
• Entrada de blog: Monitorizar AWS Batch en Fargate con Datadog