Amazon ECS en AWS Fargate

Supported OS Linux Windows Mac OS

Integration version4.3.1

Información general

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

También puedes monitorizar trabajos de AWS Batch en ECS Fargate. Consulta la Instalación de AWS Batch.

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.

Definición de tarea de la IU web

  1. Inicia sesión en tu consola web de AWS y dirígete a la sección de ECS.
  2. 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.
  3. Para definiciones de tarea nuevas:
    1. Selecciona Fargate como tipo de inicio y, a continuación, haz clic en el botón Next step (Siguiente paso).
    2. Ingresa un Task Definition Name (Nombre de definición de tarea), como my-app-and-datadog.
    3. 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.
    4. Elige Task memory (Memoria de tarea) y Task CPU (CPU de tarea) en función de tus necesidades.
  4. Haz clic en el botón Add container (Añadir contenedor) para comenzar a añadir el contenedor del Datadog Agent.
    1. En Container name (Nombre del contenedor), ingresa datadog-agent.
    2. En Image (Imagen), ingresa public.ecr.aws/datadog/agent:latest.
    3. En Env Variables (Variables de entorno), añade la Key (Clave) DD_API_KEY e ingresa tu clave de API de Datadog como valor.
    4. 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.
    5. Añade otra variable de entorno con la clave DD_SITE y el valor . El valor predeterminado es datadoghq.com si no lo estableces.
    6. (Solo Windows) Selecciona C:\ como directorio de trabajo.
  5. 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.
  6. Haz clic en Create (Crear) para crear la definición de tarea.

Definición de tarea de la AWS CLI
  1. 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.

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

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

  2. 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
    }
    
  3. 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
Definición de tarea de AWS CloudFormation

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
  1. 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).
  2. Elige el clúster para ejecutar el Datadog Agent.
  3. En la pestaña Services (Servicios), haz clic en el botón Create (Crear).
  4. En Launch type (Tipo de inicio), elige FARGATE.
  5. En Task Definition (Definición de tarea), selecciona la tarea que se creó en los pasos anteriores.
  6. Ingresa un Service name (Nombre de servicio).
  7. En Number of tasks (Número de tareas) ingresa 1 y, a continuación, haz clic en el botón Next step (Siguiente paso).
  8. Selecciona la Cluster VPC (VPC del clúster), Subnets (Subredes), and Security Groups (Grupos de seguridad).
  9. El Load balancing (Equilibrio de carga) y Service discovery (Descubrimiento de servicios) son opcionales en función de tus preferencias.
  10. Haz clic en el botón Next step (Siguiente paso).
  11. El Auto Scaling (Escalado automático) es opcional en función de tus preferencias.
  12. 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
Servicio de réplica de AWS CloudFormation

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 AWSDescripción
ecs:ListClustersEnumera los clústeres disponibles.
ecs:ListContainerInstancesEnumera las instancias de un clúster.
ecs:DescribeContainerInstancesDescribe 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 entornoDescripción
DD_DOCKER_LABELS_AS_TAGSExtrae etiquetas (labels) de contenedores de Docker
DD_CHECKS_TAG_CARDINALITYAñade etiquetas a las métricas de los checks
DD_DOGSTATSD_TAG_CARDINALITYAñ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í.

  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"
    }
  }
}

Nota: Establece tu apikey así como el Host en relación con tu respectivo sitio http-intake.logs.. La lista completa de parámetros disponibles se describe en la Documentación sobre Fluent Bit de Datadog.

Se pueden ajustar el dd_service, dd_source y dd_tags en función de las etiquetas deseadas.

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

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.

  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

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

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

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

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

EtiquetaCardinalidadFuente
container_nameAltoAPI de ECS
container_idAltoAPI de ECS
docker_imageBajoAPI de ECS
image_nameBajoAPI de ECS
short_imageBajoAPI de ECS
image_tagBajoAPI de ECS
ecs_cluster_nameBajoAPI de ECS
ecs_container_nameBajoAPI de ECS
task_arnOrquestadorAPI de ECS
task_familyBajoAPI de ECS
task_nameBajoAPI de ECS
task_versionBajoAPI de ECS
availability-zoneBajoAPI de ECS
regionBajoAPI 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