Abilita Application Signals su Amazon ECS utilizzando AWS CDK

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

Abilita Application Signals per le tue 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

Abilita Application Signals su Amazon ECS con la modalità sidecar

Configura l'applicazione instrumentation per strumentalizzare l'applicazione con l'agente AWS SDK Distro for OpenTelemetry (ADOT). Di seguito è riportato un esempio di strumentazione 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,
    });
  }
}

Abilita 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 strumentare 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,
    });
  }
}

Abilita Application Signals su Amazon ECS con modalità 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: Port 2000 (HTTP) e Port 4316 (HTTP). Questa configurazione garantisce una connettività adeguata tra l' CloudWatch agente e i servizi dipendenti.

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

Sostituisci le variabili di ambiente configurando l'utilizzo degli endpoint Service Connect overrideEnvironments 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 Limitazioni note su Node.js con ESM.

Per il formato del modulo ESM, l'abilitazione di Application Signals utilizzando il init contenitore per iniettare l'SDK di strumentazione 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 la strumentazione automatica.


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

Aggiorna. TaskDefinition

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

(Facoltativo) Aggiungi CloudWatch Agent 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,
    });
}

Distribuisci lo stack aggiornato: esegui il cdk synth comando 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 contenitori seguenti:
  - init— Un contenitore necessario per l'inizializzazione dei segnali di applicazione.
  - ecs-cwagent— Un contenitore su cui è in esecuzione l'agente CloudWatch
  - my-app— Questo è il contenitore di applicazioni di esempio nella nostra documentazione. Nei carichi di lavoro effettivi, questo contenitore specifico potrebbe non esistere o potrebbe essere sostituito con contenitori di servizi personalizzati.
Se hai utilizzato la strategia daemon, vedrai la creazione di due servizi:
- CloudWatchAgentDaemon è il servizio daemon CloudWatch dell'agente.
- APPLICATION_SERVICEè il servizio dell'applicazione. Include i due contenitori seguenti:
  - init— Un contenitore necessario per l'inizializzazione dei segnali di applicazione.
  - my-app— Questo è il contenitore di applicazioni di esempio nella nostra documentazione. Nei carichi di lavoro effettivi, questo contenitore specifico potrebbe non esistere o potrebbe essere sostituito con contenitori di servizi personalizzati.
Se hai utilizzato la strategia di replica, vedrai la creazione di due servizi:
- CloudWatchAgentServiceè il servizio di replica CloudWatch dell'agente.
- APPLICATION_SERVICEè il servizio dell'applicazione. Include i due contenitori seguenti:
  - init— Un contenitore necessario per l'inizializzazione dei segnali di applicazione.
  - my-app— Questo è il contenitore di applicazioni di esempio nella nostra documentazione. Nei carichi di lavoro effettivi, questo contenitore specifico potrebbe non esistere o potrebbe essere sostituito con contenitori 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

Esegui la distribuzione utilizzando la strategia daemon

Abilita le tue applicazioni su Kubernetes