Activez vos applications sur les clusters Amazon EKS

Pour activer Application Signals pour vos applications sur un cluster Amazon EKS existant

1. Ouvrez la CloudWatch console à l'adresse https://console.aws.amazon.com/cloudwatch/.

2. Choisissez Application Signals.

3. Pour Spécifier la plateforme, choisissez EKS.

4. Pour Sélectionner un cluster EKS, sélectionnez le cluster dans lequel vous souhaitez activer Application Signals.

5. Si le module complémentaire Amazon CloudWatch Observability EKS n'est pas encore activé sur ce cluster, vous êtes invité à l'activer. Dans ce cas, vous pouvez procéder de l’une des façons suivantes :

   1. Choisissez Ajouter le module complémentaire CloudWatch Observability EKS. La console Amazon EKS apparaît.

   2. Cochez la case Amazon CloudWatch Observability et choisissez Next.

      Le module complémentaire CloudWatch Observability EKS active à la fois les signaux d'application et les informations sur les CloudWatch conteneurs avec une observabilité améliorée pour Amazon EKS. Pour plus d'informations sur Container Insights, consultez Container Insights.

   3. Sélectionnez la version la plus récente du module complémentaire à installer.

   4. Sélectionnez un rôle IAM à utiliser pour le module complémentaire. Si vous choisissez Hériter du nœud, attachez les autorisations appropriées au rôle IAM utilisé par vos composants master. my-worker-node-roleRemplacez-le par le rôle IAM utilisé par vos nœuds de travail Kubernetes.

      aws iam attach-role-policy \
      --role-name my-worker-node-role \
      --policy-arn arn:aws:iam::aws:policy/CloudWatchAgentServerPolicy \
      --policy-arn arn:aws:iam::aws:policy/AWSXRayWriteOnlyAccess

   5. Si vous souhaitez créer une fonction du service pour utiliser le module complémentaire, veuillez consulter Installez l' CloudWatch agent avec le module complémentaire Amazon CloudWatch Observability EKS ou le graphique Helm.

   6. Choisissez Suivant, confirmez les informations affichées à l’écran, puis choisissez Créer.

   7. Dans l'écran suivant, choisissez Enable CloudWatch Application Signals pour revenir à la CloudWatch console et terminer le processus.

6. Il existe deux options pour activer vos applications pour les signaux d'application. Pour des raisons de cohérence, nous vous recommandons de choisir une option par cluster.

   • L'option Console est plus simple. L'utilisation de cette méthode entraîne le redémarrage immédiat de vos pods.

   • La méthode Annotate Manifest File vous permet de mieux contrôler le moment où vos pods redémarrent et peut également vous aider à gérer votre surveillance de manière plus décentralisée si vous ne souhaitez pas la centraliser.

   Note

   Si vous activez les signaux d'application pour une application Node.js avec ESM, passez Configuration d'une application Node.js au format du module ESM plutôt à.

   Console

   L'option Console utilise la configuration avancée du module complémentaire Amazon CloudWatch Observability EKS pour configurer les signaux d'application pour vos services. Pour plus d'informations sur le module complémentaire, consultez(Facultatif) Configuration supplémentaire.

   Si la liste des charges de travail et des espaces de noms ne s'affiche pas, assurez-vous de disposer des autorisations appropriées pour les consulter pour ce cluster. Pour plus d'informations, consultez la section Autorisations requises.

   Vous pouvez soit surveiller toutes les charges de travail des services en cochant la case Surveillance automatique, soit choisir de manière sélective les charges de travail et les espaces de noms spécifiques à surveiller.

   Pour surveiller toutes les charges de service à l'aide de la surveillance automatique, procédez comme suit :

   1. Cochez la case Surveillance automatique pour sélectionner automatiquement toutes les charges de travail de service d'un cluster.

   2. Choisissez Auto restart pour redémarrer tous les pods de charge de travail afin d'activer immédiatement les signaux d'application grâce à l' SDKs injection de AWS Distro for OpenTelemetry Auto-Instrumentation (ADOT) dans vos pods.

   3. Sélectionnez Exécuté. Lorsque le redémarrage automatique est sélectionné, le module complémentaire CloudWatch Observability EKS active immédiatement les signaux d'application. Dans le cas contraire, les signaux d'application seront activés lors du prochain déploiement de chaque charge de travail.

   Vous pouvez surveiller des charges de travail uniques ou des espaces de noms entiers.

   Pour surveiller une seule charge de travail, procédez comme suit :

   1. Cochez la case correspondant à la charge de travail que vous souhaitez surveiller.

   2. Utilisez la liste déroulante Sélectionner une ou plusieurs langues pour sélectionner la langue de la charge de travail. Sélectionnez les langues pour lesquelles vous souhaitez activer les signaux d'application, puis cliquez sur l'icône en forme de coche (✓) pour enregistrer cette sélection.

      Pour les applications Python, assurez-vous que votre application respecte les prérequis requis avant de continuer. Pour de plus amples informations, veuillez consulter L'application Python ne démarre pas une fois les signaux d'application activés.

   3. Sélectionnez Exécuté. Le module complémentaire Amazon CloudWatch Observability EKS injectera immédiatement AWS Distro for OpenTelemetry autoinstrumentation (ADOT) SDKs dans vos pods et déclenchera le redémarrage des pods pour permettre la collecte de métriques et de traces d'applications.

   Pour surveiller l'intégralité d'un espace de noms :

   1. Cochez la case correspondant à l'espace de noms que vous souhaitez surveiller.

   2. Utilisez la liste déroulante Sélectionner une ou plusieurs langues pour sélectionner la langue de l'espace de noms. Sélectionnez les langues pour lesquelles vous souhaitez activer les signaux d'application, puis cliquez sur l'icône en forme de coche (✓) pour enregistrer cette sélection. Cela s'applique à toutes les charges de travail de cet espace de noms, qu'elles soient actuellement déployées ou qu'elles le soient dans le futur.

      Pour les applications Python, assurez-vous que votre application respecte les prérequis requis avant de continuer. Pour de plus amples informations, veuillez consulter L'application Python ne démarre pas une fois les signaux d'application activés.

   3. Sélectionnez Exécuté. Le module complémentaire Amazon CloudWatch Observability EKS injectera immédiatement AWS Distro for OpenTelemetry autoinstrumentation (ADOT) SDKs dans vos pods et déclenchera le redémarrage des pods pour permettre la collecte de métriques et de traces d'applications.

   Pour activer Application Signals dans un autre cluster Amazon EKS, choisissez Activer Application Signals dans l’écran Services.

   Annotate manifest file

   Dans la CloudWatch console, la section Monitor Services explique que vous devez ajouter une annotation à un manifeste YAML dans le cluster. L’ajout de cette annotation permet à l’application d’envoyer automatiquement des métriques, des suivis et des journaux à Application Signals.

   Vous avez deux options pour l’annotation :

   • Annoter une charge de travail instrumente automatiquement une seule charge de travail dans le cluster.

   • Annoter l’espace de noms permet d’instrumenter automatiquement toutes les charges de travail déployées dans l’espace de noms sélectionné.

   Choisissez l’une de ces options, puis suivez les étapes appropriées :

   • Pour annoter une seule charge de travail :

     1. Choisissez Annoter la charge de travail.

     2. Collez l'une des lignes suivantes dans la PodTemplate section du fichier manifeste de charge de travail.

        • Pour les charges de travail Java : annotations: instrumentation.opentelemetry.io/inject-java: "true"

        • Pour les charges de travail en Python : annotations: instrumentation.opentelemetry.io/inject-python: "true"

          Pour les applications Python, des configurations supplémentaires sont requises. Pour de plus amples informations, veuillez consulter L'application Python ne démarre pas une fois les signaux d'application activés.

        • Pour les charges de travail .NET annotations: instrumentation.opentelemetry.io/inject-dotnet: "true"

          Note

          Pour activer les signaux d'application pour une charge de travail .NET sur des images basées sur Alpine Linux (linux-musl-x64), ajoutez l'annotation suivante.

          instrumentation.opentelemetry.io/otel-dotnet-auto-runtime: "linux-musl-x64"

        • Pour les charges de travail Node.js : annotations: instrumentation.opentelemetry.io/inject-nodejs: "true"

     3. Dans votre terminal, saisissez kubectl apply -f your_deployment_yaml pour appliquer la modification.

   • Pour annoter toutes les charges de travail dans un espace de noms :

     1. Choisissez Annoter l’espace de noms.

     2. Collez l'une des lignes suivantes dans la section des métadonnées du fichier manifeste de l'espace de noms. Si l'espace de noms inclut des charges de travail Java, Python et .NET, collez toutes les lignes suivantes dans le fichier manifeste de l'espace de noms.

        • S'il existe des charges de travail Java dans l'espace de noms : annotations: instrumentation.opentelemetry.io/inject-java: "true"

        • S'il existe des charges de travail Python dans l'espace de noms : annotations: instrumentation.opentelemetry.io/inject-python: "true"

          Pour les applications Python, des configurations supplémentaires sont requises. Pour de plus amples informations, veuillez consulter L'application Python ne démarre pas une fois les signaux d'application activés.

        • S'il existe des charges de travail .NET dans l'espace de noms : annotations: instrumentation.opentelemetry.io/inject-dotnet: "true"

        • S'il existe des charges de travail Node.JS dans l'espace de noms : annotations: instrumentation.opentelemetry.io/inject-nodejs: "true"

     3. Dans votre terminal, saisissez kubectl apply -f your_namespace_yaml pour appliquer la modification.

     4. Dans votre terminal, saisissez une commande pour redémarrer tous les pods de l’espace de noms. Voici un exemple de commande pour redémarrer les charges de travail de déploiement : kubectl rollout restart deployment -n namespace_name

7. Choisissez Afficher les services lorsque vous avez terminé. Cela vous amène à la vue Services d’Application Signals, où vous pouvez voir les données collectées par Application Signals. Les données peuvent prendre quelques minutes pour s’afficher.

   Pour activer Application Signals dans un autre cluster Amazon EKS, choisissez Activer Application Signals dans l’écran Services.

   Pour plus d’informations sur la vue Services, veuillez consulter Surveillez l’état de fonctionnement de vos applications avec Application Signals.

Pour activer les signaux d'application pour une application Node.js avec ESM

1. Installez les dépendances pertinentes dans votre application Node.js pour l'autoinstrumentation :

   npm install @aws/aws-distro-opentelemetry-node-autoinstrumentation
   npm install @opentelemetry/instrumentation@0.54.0

2. Ajoutez les variables environnementales suivantes au Dockerfile de votre application et créez l'image.

   ...
   ENV OTEL_AWS_APPLICATION_SIGNALS_ENABLED=true
   ENV OTEL_TRACES_SAMPLER_ARG='endpoint=http://cloudwatch-agent.amazon-cloudwatch:2000'
   ENV OTEL_TRACES_SAMPLER='xray'
   ENV OTEL_EXPORTER_OTLP_PROTOCOL='http/protobuf'
   ENV OTEL_EXPORTER_OTLP_TRACES_ENDPOINT='http://cloudwatch-agent.amazon-cloudwatch:4316/v1/traces'
   ENV OTEL_AWS_APPLICATION_SIGNALS_EXPORTER_ENDPOINT='http://cloudwatch-agent.amazon-cloudwatch:4316/v1/metrics'
   ENV OTEL_METRICS_EXPORTER='none'
   ENV OTEL_LOGS_EXPORTER='none'
   ENV NODE_OPTIONS='--import @aws/aws-distro-opentelemetry-node-autoinstrumentation/register --experimental-loader=@opentelemetry/instrumentation/hook.mjs'
   ENV OTEL_SERVICE_NAME='YOUR_SERVICE_NAME' #replace with a proper service name
   ENV OTEL_PROPAGATORS='tracecontext,baggage,b3,xray'
   ...
   
   # command to start the application
   # for example
   # CMD ["node", "index.mjs"]

3. Ajoutez les variables environnementalesOTEL_RESOURCE_ATTRIBUTES_POD_NAME, OTEL_RESOURCE_ATTRIBUTES_NODE_NAMEOTEL_RESOURCE_ATTRIBUTES_DEPLOYMENT_NAME, POD_NAMESPACE et OTEL_RESOURCE_ATTRIBUTES au fichier yaml de déploiement de l'application. Par exemple :

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: nodejs-app
     labels:
       app: nodejs-app
   spec:
     replicas: 2
     selector:
       matchLabels:
         app: nodejs-app
     template:
       metadata:
         labels:
           app: nodejs-app
         # annotations:
         # make sure this annotation doesn't exit
         #   instrumentation.opentelemetry.io/inject-nodejs: 'true'
       spec:
         containers:
         - name: nodejs-app
           image:your-nodejs-application-image #replace with a proper image uri
           imagePullPolicy: Always
           ports:
           - containerPort: 8000
           env:
             - name: OTEL_RESOURCE_ATTRIBUTES_POD_NAME
               valueFrom:
                 fieldRef:
                   fieldPath: metadata.name
             - name: OTEL_RESOURCE_ATTRIBUTES_NODE_NAME
               valueFrom:
                 fieldRef:
                   fieldPath: spec.nodeName
             - name: OTEL_RESOURCE_ATTRIBUTES_DEPLOYMENT_NAME
               valueFrom:
                 fieldRef:
                   fieldPath: metadata.labels['app'] # Assuming 'app' label is set to the deployment name
             - name: POD_NAMESPACE
               valueFrom:
                 fieldRef:
                   fieldPath: metadata.namespace
             - name: OTEL_RESOURCE_ATTRIBUTES
               value: "k8s.deployment.name=$(OTEL_RESOURCE_ATTRIBUTES_DEPLOYMENT_NAME),k8s.namespace.name=$(POD_NAMESPACE),k8s.node.name=$(OTEL_RESOURCE_ATTRIBUTES_NODE_NAME),k8s.pod.name=$(OTEL_RESOURCE_ATTRIBUTES_POD_NAME)"

4. Déployez l'application Node.js sur le cluster.

1. Activez les signaux d'application pour vos applications.

   import { aws_applicationsignals as applicationsignals } from 'aws-cdk-lib';
   
   const cfnDiscovery = new applicationsignals.CfnDiscovery(this,
     'ApplicationSignalsServiceRole', { }
   );

   La CloudFormation ressource Discovery accorde à Application Signals les autorisations suivantes :

   • xray:GetServiceGraph

   • logs:StartQuery

   • logs:GetQueryResults

   • cloudwatch:GetMetricData

   • cloudwatch:ListMetrics

   • tag:GetResources

   Pour plus d’informations sur ce rôle, consultez Autorisations de rôle liées au service pour les signaux d'application CloudWatch .

2. Installez le amazon-cloudwatch-observability module complémentaire.

   1. Créez un rôle IAM avec le CloudWatchAgentServerPolicy et l'OIDC associés au cluster.

      const cloudwatchRole = new Role(this, 'CloudWatchAgentAddOnRole', {
          assumedBy: new OpenIdConnectPrincipal(cluster.openIdConnectProvider),
          managedPolicies: [ManagedPolicy.fromAwsManagedPolicyName('CloudWatchAgentServerPolicy')],
      });

3. Installez le module complémentaire avec le rôle IAM créé ci-dessus.

   new CfnAddon(this, 'CloudWatchAddon', {
       addonName: 'amazon-cloudwatch-observability',
       clusterName: cluster.clusterName,
       serviceAccountRoleArn: cloudwatchRole.roleArn
   });

4. Ajoutez l'un des éléments suivants dans la PodTemplate section de votre fichier manifeste de charge de travail.

   Langue	Fichier
   Java	instrumentation.opentelemetry.io/inject-java : « vrai »
   Python	instrumentation.opentelemetry.io/inject-python : « vrai »
   .Net	instrumentation.opentelemetry.io/inject-dotnet : « vrai »
   Node.js	instrumentation.opentelemetry.io/inject-nodejs : « vrai »

   const deployment = {
     apiVersion: "apps/v1",
     kind: "Deployment",
     metadata: { name: "sample-app" },
     spec: {
       replicas: 3,
       selector: {
         matchLabels: {
           "app": "sample-app"
         }
       },
       template: {
         metadata: {
           labels: {
             "app": "sample-app"
           },
           annotations: {
             "instrumentation.opentelemetry.io/inject-$LANG": "true"
           }
         },
         spec: {...},
       },
     },
   };
   
   cluster.addManifest('sample-app', deployment)