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 de contenedores de la definición de tarea con el endpoint de metadatos de tareas ECS. De acuerdo con la documentación de ECS sobre ese endpoint:

• Este endpoint devuelve JSON de estadísticas Docker de contenedores asociados a la tarea. Para obtener más información sobre cada una de las estadísticas devueltas, consulta Estadísticas de contenedores en la documentación de la API 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.

Configuración

Los siguientes pasos cubren la configuración del Datadog Container Agent dentro de Amazon ECS Fargate. **Nota: Se necesita la versión 6.1.1 o posterior del Datadog Agent para aprovechar al máximo la integración de 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 muestran cómo configurar la tarea utilizando la consola de Amazon Web, 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

const ecsDatadog = new DatadogECSFargate({
  apiKey: <DATADOG_API_KEY>
  site: <DATADOG_SITE>
});

const fargateTaskDefinition = ecsDatadog.fargateTaskDefinition(
  this,
  <TASK_ID>,
  <FARGATE_TASK_DEFINITION_PROPS>
);

fargateTaskDefinition.addContainer(<CONTAINER_ID>, <CONTAINER_DEFINITION_OPTIONS>);

module "ecs_fargate_task" {
  source  = "DataDog/ecs-datadog/aws//modules/ecs_fargate"
  version = "1.0.0"

  # Configure Datadog
  dd_api_key = <DATADOG_API_KEY>
  dd_site    = <DATADOG_SITE>
  dd_dogstatsd = {
    enabled = true,
  }
  dd_apm = {
    enabled = true,
  }

  # Configure Task Definition
  family                   = <TASK_FAMILY>
  container_definitions    = <CONTAINER_DEFINITIONS>
  cpu                      = 256
  memory                   = 512
  network_mode             = "awsvpc"
  requires_compatibilities = ["FARGATE"]
}

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 tus contenedores de aplicaciones e integraciones.

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
      #(...)

const service = new ecs.FargateService(this, <SERVICE_ID>, {
  <CLUSTER>,
  fargateTaskDefinition,
  desiredCount: 1
});

resource "aws_ecs_service" <SERVICE_ID> {
  name            = <SERVICE_NAME>
  cluster         = <CLUSTER_ID>
  task_definition = module.ecs_fargate_task.arn
  desired_count   = 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 obligatorios a tu política IAM de Datadog para poder recopilar métricas de ECS Fargate. Para obtener más información, consulta las políticas de EC2 en el sitio web de AWS.

Uso de los secretos

En lugar de rellenar la variable de entorno DD_API_KEY con tu clave de API en texto plano, puedes hacer referencia al ARN de un secreto en texto plano 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 la tarea o trabajo. Asegúrate de que el rol de ejecución de la tarea/trabajo tiene el permiso necesario para recuperar secretos de AWS Secrets Manager.

Recopilación de métricas

Después de configurar el Datadog Agent como se ha descrito anteriormente, ecs_fargate check recopila métricas con la detección automática activada. Añade etiquetas (labels) Docker a tus otros 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.

Para obtener más información sobre la recopilación de métricas de integraciones, consulta Configuración de una 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 utilizar DD_DOCKER_LABELS_AS_TAGS. Con este método, el Agent extrae etiquetas (tags) a partir de las etiquetas (labels) de tu contenedor. Esto requiere que añadas las etiquetas (labels) apropiadas a tus otros contenedores. Las etiquetas (labels) pueden añadirse 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 (tag) 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 recopiladas por el Datadog Agent, Datadog tiene una integración ECS basada en CloudWatch. Esta integración recopila las métricas de Amazon ECS CloudWatch .

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 utiliza el Datadog Agent, debes configurar la integración AWS marcando ECS en el cuadro de la 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 CloudWatch por defecto 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 ver la disponibilidad. Nota: Hay aumentos de costes del 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 utilizar AWS FireLens por las siguientes razones:

• Puedes configurar Fluent Bit directamente en tus tareas de Fargate.
• El complemento de salida Fluent Bit de Datadog proporciona un etiquetado adicional de los logs. El ECS Explorer utiliza las etiquetas (tags) para correlacionar logs con recursos ECS.

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 tus datos de logs monitorizados por FireLens log a Datadog Logs. Puedes encontrar un ejemplo de definición de tarea para esta configuración aquí.

1. Añade el contenedor del enrutador de logs Fluent Bit FireLens en tu tarea de Fargate existente. Para obtener más información sobre cómo activar FireLens, consulta los documentos específicos de AWS Firelens. Para obtener más información sobre definiciones de contenedores de Fargate, consulta los documentos de AWS sobre definiciones de contenedores. AWS recomienda utilizar la imagen regional de Docker. A continuación se muestra un fragmento de ejemplo de una definición de tarea en la que se configura 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 utilizar 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 Análisis de logs stdout de contenedor que son JSON serializados para obtener más información.

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.ap1.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.ddog-gov.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",
      "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"
    },
    "secretOptions": [
    {
      "name": "apikey",
      "valueFrom": "<API_SECRET_ARN>"
    }
  ]
 }
}

{
  "logConfiguration": {
    "logDriver": "awsfirelens",
    "options": {
      "Name": "datadog",
      "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"
    },
    "secretOptions": [
    {
      "name": "apikey",
      "valueFrom": "<API_SECRET_ARN>"
    }
  ]
  }
}

{
  "logConfiguration": {
    "logDriver": "awsfirelens",
    "options": {
      "Name": "datadog",
      "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"
    },
    "secretOptions": [
    {
      "name": "apikey",
      "valueFrom": "<API_SECRET_ARN>"
    }
  ]
  }
}

{
  "logConfiguration": {
    "logDriver": "awsfirelens",
    "options": {
      "Name": "datadog",
      "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"
    },
    "secretOptions": [
    {
      "name": "apikey",
      "valueFrom": "<API_SECRET_ARN>"
    }
  ]
  }
}

{
  "logConfiguration": {
    "logDriver": "awsfirelens",
    "options": {
      "Name": "datadog",
      "Host": "http-intake.logs.ap1.datadoghq.com",
      "dd_service": "firelens-test",
      "dd_source": "redis",
      "dd_message_key": "log",
      "dd_tags": "project:fluentbit",
      "TLS": "on",
      "provider": "ecs"
    },
    "secretOptions": [
    {
      "name": "apikey",
      "valueFrom": "<API_SECRET_ARN>"
    }
  ]
  }
}

{
  "logConfiguration": {
    "logDriver": "awsfirelens",
    "options": {
      "Name": "datadog",
      "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"
    },
    "secretOptions": [
    {
      "name": "apikey",
      "valueFrom": "<API_SECRET_ARN>"
    }
  ]
  }
}

Los campos dd_service, dd_source y dd_tags pueden ajustarse para las etiquetas (tags) 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 logs y utilizar 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

const ecsDatadog = new DatadogECSFargate({
  apiKey: <DATADOG_API_KEY>,
  site: <DATADOG_SITE>,
  logCollection: {
    isEnabled: true,
  }
});

module "ecs_fargate_task" {
  source  = "DataDog/ecs-datadog/aws//modules/ecs_fargate"
  version = "1.0.0"

  # Configure Datadog
  dd_api_key = <DATADOG_API_KEY>
  dd_site    = <DATADOG_SITE>
  dd_log_collection = {
    enabled = true,
  }

  # Configure Task Definition
  family                   = <TASK_FAMILY>
  container_definitions    = <CONTAINER_DEFINITIONS>
  cpu                      = 256
  memory                   = 512
  network_mode             = "awsvpc"
  requires_compatibilities = ["FARGATE"]
}

Nota: Utiliza un secreto de TaskDefinition para evitar exponer la apikey en texto plano.

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 para 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 utilizarar el controlador de logs awslogs en las definiciones de tareas o trabajos para enviar logs de contenedor 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, utiliza la función Lambda del Log Forwarder de Datadog para recopilar logs de CloudWatch y enviarlos a Datadog.

Recopilación de trazas

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

   Consulte más información general sobre Envío de trazas (traces) 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 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 en la definición de tarea y defínelo como 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 (tags) predefinidas

El Agent puede detectar de manera automática y adjuntar etiquetas (tags) a todos los datos emitidos por la tarea completa o un contenedor individual de esta tarea o trabajo. La lista de etiquetas adjuntadas de manera automática depende de la configuración de cardinalidad del Agent.

Nota: Configura las etiquetas (tags) env y service en tu definición de tarea para obtener todas las ventajas del etiquetado unificado de servicios de Datadog. Para obtener instrucciones, consulta la sección de configuración completa de la documentación del etiquetado unificado de servicios.

Datos recopilados

Métricas

Eventos

El check de ECS Fargate no incluye eventos.

Checks de servicio

fargate_check

Devuelve CRITICAL si el Agent no puede conectarse a Fargate, en caso contrario devuelve OK.

Estados: ok, crítico

Solucionar problemas

¿Necesitas ayuda? Ponte en contacto con el servicio de asistencia de Datadog.

Referencias adicionales

• Entrada en el blog: Monitorización de aplicaciones AWS Fargate con Datadog
• FAQ: Configuración de integraciones para ECS Fargate
• Entrada en el blog: Monitorización de tus logs de contenedor Fargate con FireLens y Datadog
• Entrada en el blog: Métricas claves para la monitorización de AWS Fargate
• Entrada en el blog: Recopilación de métricas y logs de las cargas de trabajo de AWS Fargate
• Entrada en el blog: Monitorización de AWS Fargate con Datadog
• Entrada en el blog: Despliegues de AWS Fargate con tecnología Graviton2
• Entrada en el blog: Monitorización de AWS Fargate para aplicaciones en contenedores en Windows
• Entrada en el blog: Monitorización de procesos que se ejecutan en AWS Fargate con Datadog
• Entrada en el blog: Monitorización de AWS Batch en Fargate con Datadog
• Documentación: Rastreo de API Gateway al enviar solicitudes proxy a ECS Fargate