Abilita Application Signals su Amazon ECS utilizzando AWS CDK

Per abilitare l'utilizzo di Application Signals on Amazon ECS AWS CDK, procedi come segue.

Abilitazione di Application Signals per le applicazioni: se non hai ancora abilitato Application Signals in questo account, devi concedere ad Application Signals le autorizzazioni necessarie per scoprire i tuoi servizi.
```
import { aws_applicationsignals as applicationsignals } from 'aws-cdk-lib';

const cfnDiscovery = new applicationsignals.CfnDiscovery(this,
  'ApplicationSignalsServiceRole', { }
);
```
La CloudFormation risorsa Discovery concede ad Application Signals le seguenti autorizzazioni:
- xray:GetServiceGraph
- logs:StartQuery
- logs:GetQueryResults
- cloudwatch:GetMetricData
- cloudwatch:ListMetrics
- tag:GetResources
Per ulteriori informazioni su questo ruolo, consulta Autorizzazioni di ruolo collegate al servizio per Application Signals CloudWatch.

Strumenta la tua applicazione con la AWS::ApplicationSignals Construct Library nel CDK. AWS I frammenti di codice contenuti in questo documento sono forniti in. TypeScript Per altre alternative specifiche del linguaggio, consultate Linguaggi di programmazione supportati per il CDK. AWS

Abilitazione di Application Signals su Amazon ECS con modalità sidecar

Configurate l'applicazione instrumentation per strumentalizzare l'applicazione con l'agente SDK AWS Distro for OpenTelemetry (ADOT). Di seguito è riportato un esempio di instrumentazione di un'applicazione Java. Vedi tutte InstrumentationVersionle versioni linguistiche supportate.

cloudWatchAgentSidecarSpecificare di configurare l' CloudWatch agente come contenitore collaterale.


import { Construct } from 'constructs';
import * as appsignals from '@aws-cdk/aws-applicationsignals-alpha';
import * as cdk from 'aws-cdk-lib';
import * as ec2 from 'aws-cdk-lib/aws-ec2';
import * as ecs from 'aws-cdk-lib/aws-ecs';

class MyStack extends cdk.Stack {
  public constructor(scope?: Construct, id?: string, props: cdk.StackProps = {}) {
    super();
    const vpc = new ec2.Vpc(this, 'TestVpc', {});
    const cluster = new ecs.Cluster(this, 'TestCluster', { vpc });

    const fargateTaskDefinition = new ecs.FargateTaskDefinition(this, 'SampleAppTaskDefinition', {
      cpu: 2048,
      memoryLimitMiB: 4096,
    });

    fargateTaskDefinition.addContainer('app', {
      image: ecs.ContainerImage.fromRegistry('test/sample-app'),
    });

    new appsignals.ApplicationSignalsIntegration(this, 'ApplicationSignalsIntegration', {
      taskDefinition: fargateTaskDefinition,
      instrumentation: {
        sdkVersion: appsignals.JavaInstrumentationVersion.V2_10_0,
      },
      serviceName: 'sample-app',
      cloudWatchAgentSidecar: {
        containerName: 'ecs-cwagent',
        enableLogging: true,
        cpu: 256,
        memoryLimitMiB: 512,
      }
    });

    new ecs.FargateService(this, 'MySampleApp', {
      cluster: cluster,
      taskDefinition: fargateTaskDefinition,
      desiredCount: 1,
    });
  }
}

Abilitazione di Application Signals su Amazon ECS con modalità daemon

Nota

La strategia di distribuzione dei daemon non è supportata su Amazon ECS Fargate ed è supportata solo su Amazon ECS su Amazon. EC2

Esegui CloudWatch Agent come servizio daemon con modalità di rete. HOST

Configura instrumentation per instrumentare l'applicazione con l'agente Python di ADOT.


import { Construct } from 'constructs';
import * as appsignals from '@aws-cdk/aws-applicationsignals-alpha';
import * as cdk from 'aws-cdk-lib';
import * as ec2 from 'aws-cdk-lib/aws-ec2';
import * as ecs from 'aws-cdk-lib/aws-ecs';

class MyStack extends cdk.Stack {
  public constructor(scope?: Construct, id?: string, props: cdk.StackProps = {}) {
    super(scope, id, props);

    const vpc = new ec2.Vpc(this, 'TestVpc', {});
    const cluster = new ecs.Cluster(this, 'TestCluster', { vpc });

    // Define Task Definition for CloudWatch agent (Daemon)
    const cwAgentTaskDefinition = new ecs.Ec2TaskDefinition(this, 'CloudWatchAgentTaskDefinition', {
      networkMode: ecs.NetworkMode.HOST,
    });

    new appsignals.CloudWatchAgentIntegration(this, 'CloudWatchAgentIntegration', {
      taskDefinition: cwAgentTaskDefinition,
      containerName: 'ecs-cwagent',
      enableLogging: false,
      cpu: 128,
      memoryLimitMiB: 64,
      portMappings: [
        {
          containerPort: 4316,
          hostPort: 4316,
        },
        {
          containerPort: 2000,
          hostPort: 2000,
        },
      ],
    });

    // Create the CloudWatch Agent daemon service
    new ecs.Ec2Service(this, 'CloudWatchAgentDaemon', {
      cluster,
      taskDefinition: cwAgentTaskDefinition,
      daemon: true,  // Runs one container per EC2 instance
    });

    // Define Task Definition for user application
    const sampleAppTaskDefinition = new ecs.Ec2TaskDefinition(this, 'SampleAppTaskDefinition', {
      networkMode: ecs.NetworkMode.HOST,
    });

    sampleAppTaskDefinition.addContainer('app', {
      image: ecs.ContainerImage.fromRegistry('test/sample-app'),
      cpu: 0,
      memoryLimitMiB: 512,
    });

    // No CloudWatch Agent sidecar is needed as application container communicates to CloudWatch Agent daemon through host network
    new appsignals.ApplicationSignalsIntegration(this, 'ApplicationSignalsIntegration', {
      taskDefinition: sampleAppTaskDefinition,
      instrumentation: {
        sdkVersion: appsignals.PythonInstrumentationVersion.V0_8_0
      },
      serviceName: 'sample-app'
    });

    new ecs.Ec2Service(this, 'MySampleApp', {
      cluster,
      taskDefinition: sampleAppTaskDefinition,
      desiredCount: 1,
    });
  }
}

Abilitazione di Application Signals su Amazon ECS con modalità di replica

Nota

CloudWatch L'esecuzione del servizio Agent in modalità replica richiede configurazioni specifiche dei gruppi di sicurezza per consentire la comunicazione con altri servizi. Per la funzionalità Application Signals, configura il gruppo di sicurezza con le regole minime in entrata: Porta 2000 (HTTP) e Porta 4316 (HTTP). Questa configurazione garantisce la corretta connettività tra l' CloudWatch agente e i servizi dipendenti.

Esegui CloudWatch l'agente come servizio di replica con service connect.
Configura instrumentation per instrumentare l'applicazione con l'agente Python di ADOT.

Sostituisci le variabili di ambiente overrideEnvironments configurando l'utilizzo degli endpoint Service Connect per comunicare con il server dell'agente. CloudWatch


import { Construct } from 'constructs';
import * as appsignals from '@aws-cdk/aws-applicationsignals-alpha';
import * as cdk from 'aws-cdk-lib';
import * as ec2 from 'aws-cdk-lib/aws-ec2';
import * as ecs from 'aws-cdk-lib/aws-ecs';
import { PrivateDnsNamespace } from 'aws-cdk-lib/aws-servicediscovery';

class MyStack extends cdk.Stack {
  public constructor(scope?: Construct, id?: string, props: cdk.StackProps = {}) {
    super(scope, id, props);

    const vpc = new ec2.Vpc(this, 'TestVpc', {});
    const cluster = new ecs.Cluster(this, 'TestCluster', { vpc });
    const dnsNamespace = new PrivateDnsNamespace(this, 'Namespace', {
      vpc,
      name: 'local',
    });
    const securityGroup = new ec2.SecurityGroup(this, 'ECSSG', { vpc });
    securityGroup.addIngressRule(securityGroup, ec2.Port.tcpRange(0, 65535));

    // Define Task Definition for CloudWatch agent (Replica)
    const cwAgentTaskDefinition = new ecs.FargateTaskDefinition(this, 'CloudWatchAgentTaskDefinition', {});

    new appsignals.CloudWatchAgentIntegration(this, 'CloudWatchAgentIntegration', {
      taskDefinition: cwAgentTaskDefinition,
      containerName: 'ecs-cwagent',
      enableLogging: false,
      cpu: 128,
      memoryLimitMiB: 64,
      portMappings: [
        {
          name: 'cwagent-4316',
          containerPort: 4316,
          hostPort: 4316,
        },
        {
          name: 'cwagent-2000',
          containerPort: 2000,
          hostPort: 2000,
        },
      ],
    });

    // Create the CloudWatch Agent replica service with service connect
    new ecs.FargateService(this, 'CloudWatchAgentService', {
      cluster: cluster,
      taskDefinition: cwAgentTaskDefinition,
      securityGroups: [securityGroup],
      serviceConnectConfiguration: {
        namespace: dnsNamespace.namespaceArn,
        services: [
          {
            portMappingName: 'cwagent-4316',
            dnsName: 'cwagent-4316-http',
            port: 4316,
          },
          {
            portMappingName: 'cwagent-2000',
            dnsName: 'cwagent-2000-http',
            port: 2000,
          },
        ],
      },
      desiredCount: 1,
    });

    // Define Task Definition for user application
    const sampleAppTaskDefinition = new ecs.FargateTaskDefinition(this, 'SampleAppTaskDefinition', {});

    sampleAppTaskDefinition.addContainer('app', {
      image: ecs.ContainerImage.fromRegistry('test/sample-app'),
      cpu: 0,
      memoryLimitMiB: 512,
    });

    // Overwrite environment variables to connect to the CloudWatch Agent service just created
    new appsignals.ApplicationSignalsIntegration(this, 'ApplicationSignalsIntegration', {
      taskDefinition: sampleAppTaskDefinition,
      instrumentation: {
        sdkVersion: appsignals.PythonInstrumentationVersion.V0_8_0,
      },
      serviceName: 'sample-app',
      overrideEnvironments: [
        {
          name: appsignals.CommonExporting.OTEL_AWS_APPLICATION_SIGNALS_EXPORTER_ENDPOINT,
          value: 'http://cwagent-4316-http:4316/v1/metrics',
        },
        {
          name: appsignals.TraceExporting.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT,
          value: 'http://cwagent-4316-http:4316/v1/traces',
        },
        {
          name: appsignals.TraceExporting.OTEL_TRACES_SAMPLER_ARG,
          value: 'endpoint=http://cwagent-2000-http:2000',
        },
      ],
    });

    // Create ECS Service with service connect configuration
    new ecs.FargateService(this, 'MySampleApp', {
      cluster: cluster,
      taskDefinition: sampleAppTaskDefinition,
      serviceConnectConfiguration: {
        namespace: dnsNamespace.namespaceArn,
      },
      desiredCount: 1,
    });
  }
}

Configurazione di un'applicazione Node.js con il formato del modulo ESM. Il supporto per le applicazioni Node.js con il formato del modulo ESM è limitato. Per ulteriori informazioni, consulta Known limitations about Node.js with ESM.

Per il formato del modulo ESM, l'abilitazione di Application Signals utilizzando il container init per iniettare l'SDK di instrumentazione Node.js non è applicabile. Salta il passaggio 2 di questa procedura ed esegui invece quanto segue.

Installa le dipendenze pertinenti nell'applicazione Node.js per l'instrumentazione automatica.


npm install @aws/aws-distro-opentelemetry-node-autoinstrumentation
npm install @opentelemetry/instrumentation@0.54.

Aggiorna. TaskDefinition

Aggiungi una configurazione aggiuntiva al container dell'applicazione.
Configurare NODE_OPTIONS.

(Facoltativo) Aggiungi CloudWatch agente se scegli la modalità sidecar.


import { Construct } from 'constructs';
import * as appsignals from '@aws-cdk/aws-applicationsignals-alpha';
import * as ecs from 'aws-cdk-lib/aws-ecs';

class MyStack extends cdk.Stack {
  public constructor(scope?: Construct, id?: string, props: cdk.StackProps = {}) {
    super(scope, id, props);
    const fargateTaskDefinition = new ecs.FargateTaskDefinition(stack, 'TestTaskDefinition', {
      cpu: 256,
      memoryLimitMiB: 512,
    });
    const appContainer = fargateTaskDefinition.addContainer('app', {
      image: ecs.ContainerImage.fromRegistry('docker/cdk-test'),
    });

    const volumeName = 'opentelemetry-auto-instrumentation'
    fargateTaskDefinition.addVolume({name: volumeName});

    // Inject additional configurations
    const injector = new appsignals.NodeInjector(volumeName, appsignals.NodeInstrumentationVersion.V0_5_0);
    injector.renderDefaultContainer(fargateTaskDefinition);
    // Configure NODE_OPTIONS
    appContainer.addEnvironment('NODE_OPTIONS', '--import @aws/aws-distro-opentelemetry-node-autoinstrumentation/register --experimental-loader=@opentelemetry/instrumentation/hook.mjs')

    // Optional: add CloudWatch agent
    const cwAgent = new appsignals.CloudWatchAgentIntegration(stack, 'AddCloudWatchAgent', {
      containerName: 'ecs-cwagent',
      taskDefinition: fargateTaskDefinition,
      memoryReservationMiB: 50,
    });
    appContainer.addContainerDependencies({
      container: cwAgent.agentContainer,
      condition: ecs.ContainerDependencyCondition.START,
    });
}

Implementa lo stack aggiornato: esegui il comando cdk synth nella directory principale dell'applicazione. Per distribuire il servizio nel tuo AWS account, esegui il cdk deploy comando nella directory principale dell'applicazione.

Se hai utilizzato la strategia sidecar, vedrai creato un servizio:
- APPLICATION_SERVICEè il servizio della tua applicazione. Include i tre container seguenti:
  - init: un container necessario per l'inizializzazione di Application Signals.
  - ecs-cwagent— Un contenitore su cui è in esecuzione l' CloudWatch agente
  - my-app: questo è il container dell'applicazione di esempio nella nostra documentazione. Nei carichi di lavoro effettivi, questo container specifico potrebbe non esistere o potrebbe essere sostituito con container di servizi personalizzati.
Se hai utilizzato la strategia daemon, vedrai che vengono creati due servizi:
- CloudWatchAgentDaemon è il servizio daemon dell' CloudWatch agente.
- APPLICATION_SERVICEè il servizio dell'applicazione. Include i due container seguenti:
  - init: un container necessario per l'inizializzazione di Application Signals.
  - my-app: questo è il container dell'applicazione di esempio nella nostra documentazione. Nei carichi di lavoro effettivi, questo container specifico potrebbe non esistere o potrebbe essere sostituito con container di servizi personalizzati.
Se hai utilizzato la strategia di replica, vedrai che vengono creati due servizi:
- CloudWatchAgentServiceè il servizio di replica CloudWatch dell'agente.
- APPLICATION_SERVICEè il servizio dell'applicazione. Include i due container seguenti:
  - init: un container necessario per l'inizializzazione di Application Signals.
  - my-app: questo è il container dell'applicazione di esempio nella nostra documentazione. Nei carichi di lavoro effettivi, questo container specifico potrebbe non esistere o potrebbe essere sostituito con container di servizi personalizzati.

Avvertimento JavaScript è disabilitato o non è disponibile nel tuo browser.

Per usare la documentazione AWS, JavaScript deve essere abilitato. Consulta le pagine della guida del browser per le istruzioni.

Convenzioni dei documenti

Implementazione utilizzando la strategia daemon

Abilitazione delle applicazioni su Kubernetes