Monitorear ECS en EC2 con OpenTelemetry

Monitoree las tareas de Amazon ECS que se ejecutan en instancias EC2 al desplegar OpenTelemetry Collector Contrib como un contenedor sidecar. Esta guía completa lo guía a través de la creación de definiciones de tareas, la configuración del recolector y la configuración del monitoreo para sus workloads de ECS en EC2.

Pasos de instalación

Siga estos pasos para configurar el monitoreo de sus tareas de ECS en EC2.

Antes de que empieces

Asegúrese de que su entorno cumpla con estos requisitos:

Guarde su clave de licencia de New Relic

Guarde su clave de licencia como un parámetro de Systems Manager (SSM) para almacenar de forma segura las credenciales para el OpenTelemetry Collector:

bash

$aws ssm put-parameter \
>  --name "/newrelic-infra/ecs/license-key" \
>  --type SecureString \
>  --description 'New Relic license key for ECS monitoring' \
>  --value "YOUR_NEW_RELIC_LICENSE_KEY"

Crear una política de IAM y un rol de ejecución

Crea una política de IAM para que tus contenedores de ECS puedan recuperar de forma segura la clave de licencia de New Relic:

bash

$aws iam create-policy \
>  --policy-name "NewRelicSSMLicenseKeyReadAccess" \
>  --policy-document '{"Version":"2012-10-17","Statement":[{"Effect":"Allow","Action":["ssm:GetParameters"],"Resource":["arn:aws:ssm:*:*:parameter/newrelic-infra/ecs/license-key"]}]}' \
>  --description "Provides read access to the New Relic SSM license key parameter"

Cree una función de IAM para utilizarla como función de ejecución de tareas:

bash

$aws iam create-role \
>  --role-name "NewRelicECSTaskExecutionRole" \
>  --assume-role-policy-document '{"Version":"2012-10-17","Statement":[{"Effect":"Allow","Principal":{"Service":"ecs-tasks.amazonaws.com"},"Action":"sts:AssumeRole"}]}' \
>  --description "ECS task execution role for New Relic infrastructure"

Adjunte las políticas administradas requeridas al rol:

bash

$# Attach the standard ECS task execution policy
$aws iam attach-role-policy \
>  --role-name "NewRelicECSTaskExecutionRole" \
>  --policy-arn "arn:aws:iam::aws:policy/service-role/AmazonECSTaskExecutionRolePolicy"
$
$# Attach the New Relic SSM license key read access policy
$aws iam attach-role-policy \
>  --role-name "NewRelicECSTaskExecutionRole" \
>  --policy-arn "arn:aws:iam::$(aws sts get-caller-identity --query Account --output text):policy/NewRelicSSMLicenseKeyReadAccess"

Almacenar configuración del recolector

Almacene la configuración del Collector de OpenTelemetry en el almacén de parámetros de AWS Systems Manager para que pueda administrar y actualizar los ajustes sin reconstruir las imágenes de contenedor:

bash

$aws ssm put-parameter \
>  --name "/ecs/otel-collector/ec2-config" \
>  --type "String" \
>  --value "$(cat <<EOF
$receivers:
$  awsecscontainermetrics:
$    collection_interval: <COLLECTION_INTERVAL>
$  hostmetrics:
$    collection_interval: <COLLECTION_INTERVAL>
$    scrapers:
$      cpu:
$        metrics:
$          system.cpu.time:
$            enabled: false
$          system.cpu.utilization:
$            enabled: true
$      load:
$      memory:
$        metrics:
$          system.memory.utilization:
$            enabled: true
$      paging:
$        metrics:
$          system.paging.utilization:
$            enabled: false
$          system.paging.faults:
$            enabled: false
$      filesystem:
$        metrics:
$          system.filesystem.utilization:
$            enabled: true
$      disk:
$        metrics:
$          system.disk.merged:
$            enabled: false
$          system.disk.pending_operations:
$            enabled: false
$          system.disk.weighted_io_time:
$            enabled: false
$      network:
$        metrics:
$          system.network.connections:
$            enabled: false
$
$processors:
$  metricstransform/containers:
$    transforms:
$      - include: container.cpu.utilized
$        action: insert
$        new_name: container.cpu.utilization
$      - include: container.memory.usage
$        action: insert
$        new_name: container.memory.usage.total
$      - include: container.storage.read_bytes
$        action: insert
$        new_name: container.blockio.io_service_bytes_recursive
$        operations:
$          - action: add_label
$            new_label: operation
$            new_value: read
$      - include: container.storage.write_bytes
$        action: insert
$        new_name: container.blockio.io_service_bytes_recursive
$        operations:
$          - action: add_label
$            new_label: operation
$            new_value: write
$  metricstransform:
$    transforms:
$      - include: system.cpu.utilization
$        action: update
$        operations:
$          - action: aggregate_labels
$            label_set: [ state ]
$            aggregation_type: mean
$      - include: system.paging.operations
$        action: update
$        operations:
$          - action: aggregate_labels
$            label_set: [ direction ]
$            aggregation_type: sum
$  filter/exclude_cpu_utilization:
$    metrics:
$      datapoint:
$        - 'metric.name == \"system.cpu.utilization\" and attributes[\"state\"] == \"interrupt\"'
$        - 'metric.name == \"system.cpu.utilization\" and attributes[\"state\"] == \"nice\"'
$        - 'metric.name == \"system.cpu.utilization\" and attributes[\"state\"] == \"softirq\"'
$  filter/exclude_memory_utilization:
$    metrics:
$      datapoint:
$        - 'metric.name == \"system.memory.utilization\" and attributes[\"state\"] == \"slab_unreclaimable\"'
$        - 'metric.name == \"system.memory.utilization\" and attributes[\"state\"] == \"inactive\"'
$        - 'metric.name == \"system.memory.utilization\" and attributes[\"state\"] == \"cached\"'
$        - 'metric.name == \"system.memory.utilization\" and attributes[\"state\"] == \"buffered\"'
$        - 'metric.name == \"system.memory.utilization\" and attributes[\"state\"] == \"slab_reclaimable\"'
$  filter/exclude_memory_usage:
$    metrics:
$      datapoint:
$        - 'metric.name == \"system.memory.usage\" and attributes[\"state\"] == \"slab_unreclaimable\"'
$        - 'metric.name == \"system.memory.usage\" and attributes[\"state\"] == \"inactive\"'
$  filter/exclude_filesystem_utilization:
$    metrics:
$      datapoint:
$        - 'metric.name == \"system.filesystem.utilization\" and attributes[\"type\"] == \"squashfs\"'
$  filter/exclude_filesystem_usage:
$    metrics:
$      datapoint:
$        - 'metric.name == \"system.filesystem.usage\" and attributes[\"type\"] == \"squashfs\"'
$        - 'metric.name == \"system.filesystem.usage\" and attributes[\"state\"] == \"reserved\"'
$  filter/exclude_filesystem_inodes_usage:
$    metrics:
$      datapoint:
$        - 'metric.name == \"system.filesystem.inodes.usage\" and attributes[\"type\"] == \"squashfs\"'
$        - 'metric.name == \"system.filesystem.inodes.usage\" and attributes[\"state\"] == \"reserved\"'
$  filter/exclude_system_disk:
$    metrics:
$      datapoint:
$        - 'metric.name == \"system.disk.operations\" and IsMatch(attributes[\"device\"], \"^loop.*\") == true'
$        - 'metric.name == \"system.disk.merged\" and IsMatch(attributes[\"device\"], \"^loop.*\") == true'
$        - 'metric.name == \"system.disk.io\" and IsMatch(attributes[\"device\"], \"^loop.*\") == true'
$        - 'metric.name == \"system.disk.io_time\" and IsMatch(attributes[\"device\"], \"^loop.*\") == true'
$        - 'metric.name == \"system.disk.operation_time\" and IsMatch(attributes[\"device\"], \"^loop.*\") == true'
$  filter/exclude_system_paging:
$    metrics:
$      datapoint:
$        - 'metric.name == \"system.paging.usage\" and attributes[\"state\"] == \"cached\"'
$        - 'metric.name == \"system.paging.operations\" and attributes[\"type\"] == \"cached\"'
$  filter/exclude_network:
$    metrics:
$      datapoint:
$        - 'IsMatch(metric.name, \"^system.network.*\") == true and attributes[\"device\"] == \"lo\"'
$
$  attributes/exclude_system_paging:
$    include:
$      match_type: strict
$      metric_names:
$        - system.paging.operations
$    actions:
$      - key: type
$        action: delete
$
$  cumulativetodelta:
$
$  transform/host:
$    metric_statements:
$      - context: metric
$        statements:
$          - set(metric.description, \"\")
$          - set(metric.unit, \"\")
$
$  transform:
$    trace_statements:
$      - context: span
$        statements:
$          - truncate_all(span.attributes, <ATTRIBUTE_TRUNCATION_LIMIT>)
$          - truncate_all(resource.attributes, <RESOURCE_ATTRIBUTE_TRUNCATION_LIMIT>)
$    log_statements:
$      - context: log
$        statements:
$          - truncate_all(log.attributes, <ATTRIBUTE_TRUNCATION_LIMIT>)
$          - truncate_all(resource.attributes, <RESOURCE_ATTRIBUTE_TRUNCATION_LIMIT>)
$
$  memory_limiter:
$    check_interval: <MEMORY_LIMITER_CHECK_INTERVAL>
$    limit_mib: \${env:NEW_RELIC_MEMORY_LIMIT_MIB:-<MEMORY_LIMIT_MIB>}
$  batch:
$    send_batch_size: <SEND_BATCH_SIZE>
$    timeout: <BATCH_TIMEOUT>
$  resource:
$    attributes:
$      - key: ClusterName
$        from_attribute: aws.ecs.cluster.name
$        action: insert
$      - key: ServiceName
$        from_attribute: aws.ecs.service.name
$        action: insert
$      - key: TaskId
$        from_attribute: aws.ecs.task.id
$        action: insert
$      - key: TaskDefinitionFamily
$        from_attribute: aws.ecs.task.family
$        action: insert
$      - key: LaunchType
$        from_attribute: aws.ecs.launch_type
$        action: insert
$
$  resourcedetection:
$    detectors:
$      - env
$      - ecs
$      - ec2
$      - system
$    timeout: <RESOURCE_DETECTION_TIMEOUT>
$    override: false
$
$exporters:
$  otlphttp:
$    endpoint: https://otlp.nr-data.net:443
$    headers:
$      api-key: \${NEW_RELIC_LICENSE_KEY}
$
$  debug:
$    verbosity: basic
$
$service:
$  pipelines:
$    metrics/containers:
$      receivers: [awsecscontainermetrics]
$      processors: [metricstransform/containers, resource, batch]
$      exporters: [otlphttp, debug]
$    metrics/host:
$      receivers: [hostmetrics]
$      processors:
$        - memory_limiter
$        - metricstransform
$        - filter/exclude_cpu_utilization
$        - filter/exclude_memory_utilization
$        - filter/exclude_memory_usage
$        - filter/exclude_filesystem_utilization
$        - filter/exclude_filesystem_usage
$        - filter/exclude_filesystem_inodes_usage
$        - filter/exclude_system_disk
$        - filter/exclude_network
$        - attributes/exclude_system_paging
$        - transform/host
$        - resourcedetection
$        - cumulativetodelta
$        - batch
$      exporters: [otlphttp, debug]
$EOF
$)"

Parámetro de configuración

Los siguientes parámetros se pueden personalizar en la configuración de OpenTelemetry Collector:

Parámetro	Descripción
`<COLLECTION_INTERVAL>`	Intervalo para recopilar métricas de los extremos de métricas del contenedor de ECS y del host.
`<MEMORY_LIMIT_MIB>`	Límite de memoria para el OpenTelemetry Collector en MiB
`<MEMORY_LIMITER_CHECK_INTERVAL>`	Intervalo para que el limitador de memoria verifique el uso actual de la memoria
`<SEND_BATCH_SIZE>`	Número de métricas a agrupar en lotes antes de enviarlas a New Relic
`<BATCH_TIMEOUT>`	Tiempo máximo de espera antes de enviar un lote
`<RESOURCE_DETECTION_TIMEOUT>`	Tiempo de espera para procesadores de detección de recursos
`<ATTRIBUTE_TRUNCATION_LIMIT>`	Longitud máxima para los valores de atributos de intervalo y log antes del truncamiento. Por defecto: 4095
`<RESOURCE_ATTRIBUTE_TRUNCATION_LIMIT>`	Longitud máxima para los valores de atributos de recurso antes del truncamiento. Por defecto: 4095

Crear definición de tarea

Cree una nueva definición de tarea de ECS que incluya el contenedor sidecar del OpenTelemetry Collector. Elija la definición de tarea adecuada para su plataforma de contenedores:

{
  "family": "otel-ecs-ec2-sidecar-metrics",
  "executionRoleArn": "arn:aws:iam::YOUR_ACCOUNT:role/NewRelicECSTaskExecutionRole",
  "networkMode": "host",
  "requiresCompatibilities": ["EC2"],
  "cpu": "<TASK_CPU>",
  "memory": "<TASK_MEMORY>",
  "containerDefinitions": [
    {
      "name": "your-application",
      "image": "your-app:latest",
      "cpu": <APP_CPU>,
      "memory": <APP_MEMORY>,
      "essential": true,
      "logConfiguration": {
        "logDriver": "awslogs",
        "options": {
          "awslogs-group": "<APP_LOG_GROUP>",
          "awslogs-create-group": "true",
          "awslogs-region": "<AWS_REGION>",
          "awslogs-stream-prefix": "<APP_LOG_STREAM_PREFIX>"
        }
      }
    },
    {
      "name": "otel-collector",
      "image": "otel/opentelemetry-collector-contrib:latest",
      "cpu": <COLLECTOR_CPU>,
      "memory": <COLLECTOR_MEMORY>,
      "essential": true,
      "command": ["--config=env:OTEL_CONFIG"],
      "mountPoints": [
        {
          "sourceVolume": "proc",
          "containerPath": "/proc",
          "readOnly": true
        },
        {
          "sourceVolume": "sys",
          "containerPath": "/sys",
          "readOnly": true
        }
      ],
      "secrets": [
        {
          "name": "OTEL_CONFIG",
          "valueFrom": "arn:aws:ssm:us-east-1:YOUR_ACCOUNT:parameter/ecs/otel-collector/ec2-config"
        },
        {
          "name": "NEW_RELIC_LICENSE_KEY",
          "valueFrom": "arn:aws:ssm:us-east-1:YOUR_ACCOUNT:parameter/newrelic-infra/ecs/license-key"
        }
      ],
      "logConfiguration": {
        "logDriver": "awslogs",
        "options": {
          "awslogs-group": "<COLLECTOR_LOG_GROUP>",
          "awslogs-create-group": "true",
          "awslogs-region": "<AWS_REGION>",
          "awslogs-stream-prefix": "<COLLECTOR_LOG_STREAM_PREFIX>"
        }
      }
    }
  ],
  "volumes": [
    {
      "name": "proc",
      "host": {
        "sourcePath": "/proc"
      }
    },
    {
      "name": "sys",
      "host": {
        "sourcePath": "/sys"
      }
    }
  ]
}

{
  "family": "otel-ecs-ec2-sidecar-metrics-windows",
  "executionRoleArn": "arn:aws:iam::YOUR_ACCOUNT:role/NewRelicECSTaskExecutionRole",
  "networkMode": "default",
  "requiresCompatibilities": ["EC2"],
  "cpu": "<TASK_CPU>",
  "memory": "<TASK_MEMORY>",
  "runtimePlatform": {
    "cpuArchitecture": "X86_64",
    "operatingSystemFamily": "WINDOWS_SERVER_2022_CORE"
  },
  "containerDefinitions": [
    {
      "name": "your-application",
      "image": "your-app:latest",
      "cpu": <APP_CPU>,
      "memory": <APP_MEMORY>,
      "essential": true,
      "logConfiguration": {
        "logDriver": "awslogs",
        "options": {
          "awslogs-group": "<APP_LOG_GROUP>",
          "awslogs-create-group": "true",
          "awslogs-region": "<AWS_REGION>",
          "awslogs-stream-prefix": "<APP_LOG_STREAM_PREFIX>"
        }
      }
    },
    {
      "name": "otel-collector",
      "image": "otel/opentelemetry-collector-contrib:latest-windows-2022-amd64",
      "cpu": <COLLECTOR_CPU>,
      "memory": <COLLECTOR_MEMORY>,
      "essential": true,
      "command": ["--config", "env:OTEL_CONFIG"],
      "secrets": [
        {
          "name": "OTEL_CONFIG",
          "valueFrom": "arn:aws:ssm:us-east-1:YOUR_ACCOUNT:parameter/ecs/otel-collector/ec2-config-windows"
        },
        {
          "name": "NEW_RELIC_LICENSE_KEY",
          "valueFrom": "arn:aws:ssm:us-east-1:YOUR_ACCOUNT:parameter/newrelic-infra/ecs/license-key"
        }
      ],
      "logConfiguration": {
        "logDriver": "awslogs",
        "options": {
          "awslogs-group": "<COLLECTOR_LOG_GROUP>",
          "awslogs-create-group": "true",
          "awslogs-region": "<AWS_REGION>",
          "awslogs-stream-prefix": "<COLLECTOR_LOG_STREAM_PREFIX>"
        }
      }
    }
  ],
  "volumes": []
}

Parámetros de definición de tarea

Los siguientes parámetros se pueden personalizar en la definición de su tarea de ECS:

Parámetro	Descripción
`<TASK_CPU>`	Unidades totales de CPU para la tarea de EC2
`<TASK_MEMORY>`	Memoria total para la tarea de EC2 en MiB
`<APP_CPU>`	Unidades de CPU asignadas a su contenedor de aplicación
`<APP_MEMORY>`	Memoria asignada a su contenedor de aplicación en MiB
`<COLLECTOR_CPU>`	Unidades de CPU asignadas al OpenTelemetry Collector
`<COLLECTOR_MEMORY>`	Memoria asignada al OpenTelemetry Collector en MiB
`<APP_LOG_GROUP>`	Nombre del grupo de logs de CloudWatch para su contenedor de aplicación
`<COLLECTOR_LOG_GROUP>`	Nombre del grupo de logs de CloudWatch para el OpenTelemetry Collector
`<AWS_REGION>`	Región de AWS para logs de CloudWatch
`<APP_LOG_STREAM_PREFIX>`	Prefijo del flujo de logs para su contenedor de aplicación
`<COLLECTOR_LOG_STREAM_PREFIX>`	Prefijo del flujo de logs para el OpenTelemetry Collector

Sugerencia

El networkMode está establecido en "host" para el contenedor de Linux y debería ser "default" para el contenedor de Windows. El modo host proporciona un mejor acceso a las métricas del sistema en instancias EC2.

Importante

Reemplace los valores de YOUR_ACCOUNT y de la región por el ID de su cuenta de AWS y la región de AWS reales.

Desplegar y ejecutar la tarea

Despliegue la definición de su tarea en su clúster de ECS:

Registre la definición de la tarea:

bash

$aws ecs register-task-definition --cli-input-json file://task-definition.json

Cree un servicio con la estrategia de programación daemon:
bash
```
$aws ecs create-service \
>  --cluster your-cluster-name \
>  --service-name otel-monitoring-service \
>  --task-definition otel-ecs-ec2-sidecar-metrics:1 \
>  --scheduling-strategy DAEMON \
>  --launch-type EC2
```
Sugerencia
La estrategia de programación DAEMON asegura que se ejecute una tarea de monitoreo en cada instancia EC2 de su clúster, proporcionando una cobertura integral de monitoreo de infraestructura.

Verificar la recopilación de datos

Verifique que sus datos estén fluyendo a New Relic:

Verifique el estado de OpenTelemetry Collector: revise los logs del contenedor para confirmar que el recolector se esté ejecutando sin errores y se conecte correctamente a New Relic:
bash
```
$aws logs get-log-events \
>  --log-group-name "/ecs/otel-collector-ec2" \
>  --log-stream-name "otel/otel-collector/TASK_ID"
```
Verifique los datos en la New Relic UI: navegue a one.newrelic.com > All Capabilities > Infrastructure para confirmar que sus hosts de ECS y contenedores aparecen con métricas. Para obtener orientación detallada sobre cómo explorar sus datos, consulte Buscar y consultar sus datos de monitoreo de ECS.

Próximos pasos

Después de configurar el monitoreo, puedes:

Crea dashboards personalizados para tus métricas de ECS
Configura alertas para problemas a nivel de contenedor y host
Correlacionar métricas de ECS con trazas y logs de la aplicación

Te ofrecemos esta traducción automática para facilitar la lectura.

Monitorear ECS en EC2 con OpenTelemetry

Pasos de instalación

Antes de que empieces

Requisitos de ECS

Requisitos de EC2

Permisos de AWS

Requisitos de New Relic

Guarde su clave de licencia de New Relic

Crear una política de IAM y un rol de ejecución

Almacenar configuración del recolector

Parámetro de configuración

Crear definición de tarea

Contenedores de Linux

Contenedores de Windows

Parámetros de definición de tarea

Sugerencia

Importante

Desplegar y ejecutar la tarea

Sugerencia

Verificar la recopilación de datos

Próximos pasos

Te ofrecemos esta traducción automática para facilitar la lectura.

Monitorear ECS en EC2 con OpenTelemetry

Pasos de instalación .css-21sua1{background:none;border:none;width:0;padding:0;}

Antes de que empieces

Requisitos de EC2

Permisos de AWS

Requisitos de New Relic

Guarde su clave de licencia de New Relic

Crear una política de IAM y un rol de ejecución

Almacenar configuración del recolector

Parámetro de configuración

Crear definición de tarea

Contenedores de Linux

Contenedores de Windows

Parámetros de definición de tarea

Sugerencia

Importante

Desplegar y ejecutar la tarea

Sugerencia

Verificar la recopilación de datos

Próximos pasos

Pasos de instalación