Activer les signaux d'application sur les plateformes Kubernetes

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

Dans le panneau de navigation, choisissez Services.

Choisissez Commencer à découvrir vos services.

Cochez la case et choisissez Commencer à découvrir vos services.

Lorsque vous effectuez cette étape pour la première fois dans votre compte, Application Signals crée le rôle AWSServiceRoleForCloudWatchApplicationSignalslié au service. Ce rôle accorde à Application Signals les autorisations suivantes :

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

Créez l'IAMutilisateur à utiliser pour fournir des autorisations à votre hôte local :

1. Ouvrez la IAM console à l'adresse https://console.aws.amazon.com/iam/.

2. Choisissez Utilisateurs, puis Créer un utilisateur.

3. Dans Détails de l'utilisateur, dans Nom d'utilisateur, entrez le nom du nouvel IAM utilisateur. Il s'agit du nom de connexion AWS qui sera utilisé pour authentifier votre hôte. Ensuite, sélectionnez Next

4. Sur la page Définir les autorisations, sous Options d'autorisations, sélectionnez Joindre directement les politiques.

5. Dans la liste des politiques d'autorisation, sélectionnez la CloudWatchAgentServerPolicypolitique à ajouter à votre utilisateur. Ensuite, sélectionnez Suivant.

6. Sur la page Réviser et créer, assurez-vous que vous êtes satisfait du nom d'utilisateur et que la CloudWatchAgentServerPolicypolitique figure dans le résumé des autorisations.

7. Choisissez Créer un utilisateur

Créez et récupérez votre clé AWS d'accès et votre clé secrète :

1. Dans le volet de navigation de la IAM console, choisissez Utilisateurs, puis sélectionnez le nom d'utilisateur de l'utilisateur que vous avez créé à l'étape précédente.

2. Sur la page de l'utilisateur, choisissez l'onglet Informations d'identification de sécurité. Ensuite, dans la section Clés d'accès, choisissez Créer une clé d'accès.

3. Pour l'étape 1 de création d'une clé d'accès, choisissez Command Line Interface (CLI).

4. Pour l'étape 2 de création d'une clé d'accès, entrez éventuellement une balise, puis choisissez Next.

5. Pour l'étape 3 de création d'une clé d'accès, sélectionnez Télécharger le fichier .csv pour enregistrer un fichier .csv avec la clé d'accès et la clé d'accès secrète de votre IAM utilisateur. Vous avez besoin de ces informations pour les prochaines étapes.

6. Sélectionnez Exécuté.

Configurez vos AWS informations d'identification sur votre hôte local en saisissant la commande suivante. Remplacez ACCESS_KEY_ID and SECRET_ACCESS_ID avec votre clé d'accès et votre clé d'accès secrète nouvellement générées à partir du fichier .csv que vous avez téléchargé à l'étape précédente. Par défaut, le fichier d'informations d'identification est enregistré dans /home/user/.aws/credentials.

$ aws configure --profile AmazonCloudWatchAgent
AWS Access Key ID [None]: ACCESS_KEY_ID
AWS Secret Access Key [None]: SECRET_ACCESS_ID
Default region name [None]: MY_REGION
Default output format [None]: json

Modifiez la ressource personnalisée installée par l' CloudWatch agent à l'aide du graphique Helm pour ajouter le secret AWS d'identification nouvellement créé.

kubectl edit amazoncloudwatchagent cloudwatch-agent -n amazon-cloudwatch

Lorsque votre éditeur de fichiers est ouvert, montez les AWS informations d'identification dans le conteneur de l' CloudWatch agent en ajoutant la configuration suivante en haut du déploiement. Remplacez le chemin /home/user/.aws/credentials par l'emplacement de votre fichier d' AWS informations d'identification local.

apiVersion: cloudwatch.aws.amazon.com/v1alpha1
kind: AmazonCloudWatchAgent
metadata:
  name: cloudwatch-agent
  namespace: amazon-cloudwatch
spec:
  volumeMounts:
  - mountPath: /rootfs
    volumeMounts:
    - name: aws-credentials
      mountPath: /root/.aws
      readOnly: true
    volumes:
    - hostPath:
      path: /home/user/.aws/credentials
    name: aws-credentials
---

Vous avez deux options pour l’annotation :

Choisissez l'une de ces options, puis suivez les étapes appropriées.

Pour annoter une seule charge de travail, entrez l'une des commandes suivantes. Remplacez $WORKLOAD_TYPE and $WORKLOAD_NAME avec les valeurs correspondant à votre charge de travail.

Pour annoter toutes les charges de travail dans un espace de noms, entrez l'une des commandes suivantes. Remplacez $NAMESPACE avec le nom de votre espace de noms.

Si l'espace de noms inclut Java, Python et. NETcharges de travail, ajoutez toutes les annotations à l'espace de noms.

Après avoir ajouté les annotations, redémarrez tous les pods de l'espace de noms en saisissant la commande suivante :

kubectl rollout restart

Lorsque les étapes précédentes sont terminées, dans la CloudWatch console, choisissez Application Signals, Services. Cela ouvre les tableaux de bord où vous pouvez voir les données collectées par Application Signals. Les données peuvent prendre quelques minutes pour s’afficher.

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

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

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"]

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 it 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)"

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