Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Solution pour surveiller les applications Kafka avec Amazon Managed Grafana
Les applications basées sur [Apache Kafka](https://kafka.apache.org) ont des besoins de surveillance spécialisés. Cette page décrit un modèle qui fournit une solution pour surveiller les applications Kafka exécutées sur des machines virtuelles Java sur votre cluster Amazon EKS. La solution peut être installée à l'aide de [AWS Cloud Development Kit (AWS CDK)](https://docs.aws.amazon.com/cdk/v2/guide/home.html).
**Note**
Cette solution ne prend pas en charge la surveillance des applications Amazon Managed Streaming for Apache Kafka. Pour plus d'informations sur la surveillance des applications Amazon MSK, consultez la section [Surveiller un cluster Amazon MSK](https://docs.aws.amazon.com/msk/latest/developerguide/monitoring.html) dans le manuel *Amazon Managed Streaming for Apache Kafka* Developer Guide.
Cette solution permet de configurer :
+ Votre espace de travail Amazon Managed Service for Prometheus pour stocker les métriques de Kafka et de machine virtuelle Java (JVM) à partir de votre cluster Amazon EKS.
+ Collecte de métriques Kafka et JVM spécifiques à l'aide de l' CloudWatch agent, ainsi que d'un module complémentaire d' CloudWatch agent. Les métriques sont configurées pour être envoyées à l'espace de travail Amazon Managed Service for Prometheus.
+ Votre espace de travail Amazon Managed Grafana pour extraire ces statistiques et créer des tableaux de bord pour vous aider à surveiller votre cluster.
**Note**
Cette solution fournit des métriques JVM et Kafka pour votre application exécutée sur Amazon EKS, mais n'inclut pas les métriques Amazon EKS. Vous pouvez utiliser la [solution Observability pour surveiller Amazon EKS](solution-eks.md) afin de consulter les métriques et les alertes relatives à votre cluster Amazon EKS.
## À propos de cette solution
Cette solution configure un espace de travail Grafana géré par Amazon afin de fournir des métriques pour votre application Apache Kafka. Les métriques sont utilisées pour générer des tableaux de bord qui vous aident à exploiter votre application plus efficacement en fournissant des informations sur les performances et la charge de travail de l'application Kafka.
L'image suivante montre un exemple de l'un des tableaux de bord créés par cette solution.
![\[Image illustrant un exemple de dossier de tableau de bord Grafana créé à l'aide de cette solution.\]](http://docs.aws.amazon.com/fr_fr/grafana/latest/userguide/images/kafka-solution-cluster-overview.png)
Les métriques sont scrutées avec un intervalle d'une minute. Les tableaux de bord affichent des statistiques agrégées à 1 minute, 5 minutes ou plus, en fonction de la métrique spécifique.
Pour obtenir la liste des mesures suivies par cette solution, consultez[Liste des indicateurs suivis](#solution-kafka-metrics).
## Coûts
Cette solution crée et utilise des ressources dans votre espace de travail. L'utilisation standard des ressources créées vous sera facturée, notamment :
+ Accès des utilisateurs à l'espace de travail de Grafana géré par Amazon. Pour plus d'informations sur les tarifs, consultez les tarifs [d'Amazon Managed Grafana](https://aws.amazon.com/grafana/pricing/).
+ Amazon Managed Service pour l'ingestion et le stockage des métriques Prometheus, ainsi que pour l'analyse des métriques (traitement des échantillons de requêtes). Le nombre de métriques utilisées par cette solution dépend de la configuration et de l'utilisation de votre application.
Vous pouvez consulter les statistiques d'ingestion et de stockage dans Amazon Managed Service for Prometheus à CloudWatch l'aide de Pour plus d'informations, [CloudWatchconsultez](https://docs.aws.amazon.com/prometheus/latest/userguide/AMP-CW-usage-metrics.html) le guide de l'utilisateur d'*Amazon Managed Service for Prometheus*.
Vous pouvez estimer le coût à l'aide du calculateur de prix sur la page de tarification d'[Amazon Managed Service for Prometheus](https://aws.amazon.com/prometheus/pricing/). Le nombre de métriques dépendra du nombre de nœuds de votre cluster et des métriques produites par vos applications.
+ Coûts de mise en réseau. Des frais AWS réseau standard peuvent vous être facturés pour le trafic entre zones de disponibilité, régions ou autres.
Les calculateurs de prix, disponibles sur la page de tarification de chaque produit, peuvent vous aider à comprendre les coûts potentiels de votre solution. Les informations suivantes peuvent vous aider à obtenir un coût de base pour la solution exécutée dans la même zone de disponibilité que le cluster Amazon EKS.
| Produit (langue française non garantie) | Métrique du calculateur | Value |
| --- | --- | --- |
| Amazon Managed Service for Prometheus | Série Active | 95 (par capsule Kafka) |
| | Intervalle de collecte moyen | 60 (secondes) |
| Amazon Managed Grafana | Nombre de rédacteurs/administrateurs actifs | 1 (ou plus, en fonction de vos utilisateurs) |
Ces numéros sont les numéros de base d'une solution exécutant Kafka sur Amazon EKS. Cela vous donnera une estimation des coûts de base. Au fur et à mesure que vous ajouterez des modules Kafka à votre application, les coûts augmenteront, comme indiqué. Ces coûts ne tiennent pas compte des coûts d'utilisation du réseau, qui varieront selon que l'espace de travail Amazon Managed Grafana, l'espace de travail Amazon Managed Service for Prometheus et le cluster Amazon EKS se trouvent dans la même zone de disponibilité et que le VPN sont situés dans la même zone de disponibilité. Région AWS
## Conditions préalables
Cette solution nécessite que vous ayez effectué les opérations suivantes avant de l'utiliser.
1. Vous devez avoir ou **créer un cluster Amazon Elastic Kubernetes Service** que vous souhaitez surveiller, et le cluster doit comporter au moins un nœud. L'accès au point de terminaison du serveur API doit être configuré pour inclure l'accès privé (il peut également autoriser l'accès public).
Le [mode d'authentification](https://docs.aws.amazon.com/eks/latest/userguide/grant-k8s-access.html#set-cam) doit inclure l'accès à l'API (il peut être défini sur l'un `API` ou l'autre`API_AND_CONFIG_MAP`). Cela permet au déploiement de la solution d'utiliser des entrées d'accès.
Les éléments suivants doivent être installés dans le cluster (vrai par défaut lors de la création du cluster via la console, mais doivent être ajoutés si vous créez le cluster à l'aide de l' AWS API ou AWS CLI) : Amazon EKS Pod Identity Agent, AWS CNI, CoreDNS, Kube-proxy et pilote Amazon EBS CSI AddOns (le pilote Amazon EBS CSI n'est pas techniquement requis pour la solution, mais est requis pour la plupart des applications Kafka). AddOn
*Enregistrez le nom du cluster pour le spécifier ultérieurement*. Cela se trouve dans les détails du cluster dans la console Amazon EKS.
**Note**
Pour en savoir plus sur la création d'un cluster Amazon EKS, consultez [Getting started with Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/getting-started.html).
1. Vous devez exécuter une application Apache Kafka sur des machines virtuelles Java de votre cluster Amazon EKS.
1. Vous devez **créer un espace de travail Amazon Managed Service for Prometheus identique** à celui de votre cluster Compte AWS Amazon EKS. Pour plus de détails, consultez la section [Créer un espace de travail](https://docs.aws.amazon.com/prometheus/latest/userguide/AMP-create-workspace.html) dans le guide de l'utilisateur d'*Amazon Managed Service for Prometheus*.
*Enregistrez l'ARN de l'espace de travail Amazon Managed Service for Prometheus pour le spécifier ultérieurement.*
1. Vous devez **créer un espace de travail Amazon Managed Grafana** avec la version 9 ou une version ultérieure de Grafana, au même titre que Région AWS votre cluster Amazon EKS. Pour plus de détails sur la création d'un nouvel espace de travail, consultez[Création d'un espace de travail Grafana géré par Amazon](AMG-create-workspace.md).
Le rôle de l'espace de travail doit être autorisé à accéder à Amazon Managed Service pour Prometheus et Amazon. CloudWatch APIs Le moyen le plus simple de le faire est d'utiliser les [autorisations gérées par le service](AMG-manage-permissions.md) et de sélectionner Amazon Managed Service pour Prometheus et. CloudWatch Vous pouvez également ajouter manuellement les [AmazonGrafanaCloudWatchAccess](security-iam-awsmanpol.md#security-iam-awsmanpol-AmazonGrafanaCloudWatchAccess)politiques [AmazonPrometheusQueryAccess](https://docs.aws.amazon.com/prometheus/latest/userguide/security-iam-awsmanpol.html#AmazonPrometheusQueryAccess)et au rôle IAM de votre espace de travail.
*Enregistrez l'identifiant et le point de terminaison de l'espace de travail Amazon Managed Grafana pour les spécifier ultérieurement.* L'identifiant se trouve dans le formulaire`g-123example`. L'ID et le point de terminaison se trouvent dans la console Amazon Managed Grafana. Le point de terminaison est l'URL de l'espace de travail et inclut l'ID. Par exemple, `https://g-123example.grafana-workspace..amazonaws.com/`.
**Note**
Bien que cela ne soit pas strictement obligatoire pour configurer la solution, vous devez configurer l'authentification des utilisateurs dans votre espace de travail Amazon Managed Grafana avant que les utilisateurs puissent accéder aux tableaux de bord créés. Pour de plus amples informations, veuillez consulter [Authentifier les utilisateurs dans les espaces de travail Amazon Managed Grafana](authentication-in-AMG.md).
## Utilisation de cette solution
Cette solution configure AWS l'infrastructure pour prendre en charge les métriques de reporting et de surveillance à partir d'une application Kafka exécutée dans un cluster Amazon EKS. Vous pouvez l'installer en utilisant [AWS Cloud Development Kit (AWS CDK)](https://docs.aws.amazon.com/cdk/v2/guide/home.html).
**Note**
Les étapes décrites ici supposent que vous disposez d'un environnement dans AWS CLI lequel [Node.js](https://nodejs.org/) et [NPM](https://docs.npmjs.com/) sont installés. AWS CDK Vous utiliserez `make` et `brew` simplifierez la construction et d'autres actions courantes.
**Pour utiliser cette solution pour surveiller un cluster Amazon EKS avec AWS CDK**
1. Assurez-vous d'avoir effectué toutes les étapes [préalables](#solution-kafka-prerequisites).
1. Téléchargez tous les fichiers de la solution depuis Amazon S3. Les fichiers se trouvent à l'adresse `s3://aws-observability-solutions/Kafka_EKS/OSS/CDK/v1.0.0/iac` suivante et vous pouvez les télécharger à l'aide de la commande Amazon S3 suivante. Exécutez cette commande à partir d'un dossier de votre environnement de ligne de commande.
```
aws s3 sync s3://aws-observability-solutions/Kafka_EKS/OSS/CDK/v1.0.0/iac/ .
```
Il n'est pas nécessaire de modifier ces fichiers.
1. Dans votre environnement de ligne de commande (depuis le dossier dans lequel vous avez téléchargé les fichiers de solution), exécutez les commandes suivantes.
Configurez les variables d'environnement nécessaires. Remplacez*REGION*, *AMG\$1ENDPOINT**EKS\$1CLUSTER*, et *AMP\$1ARN* par votre Région AWS point de terminaison d'espace de travail Amazon Managed Grafana (dans le formulaire`http://g-123example.grafana-workspace.us-east-1.amazonaws.com`), le nom du cluster Amazon EKS et l'ARN de votre espace de travail Amazon Managed Service for Prometheus.
```
export AWS_REGION=REGION
export AMG_ENDPOINT=AMG_ENDPOINT
export EKS_CLUSTER_NAME=EKS_CLUSTER
export AMP_WS_ARN=AMP_ARN
```
1. Vous devez créer des annotations utilisables par le déploiement. Vous pouvez choisir d'annoter un espace de noms, un déploiement, un statefulset, un daemonset ou vos pods directement. La solution Kafka nécessite cinq annotations. Vous allez les utiliser `kubectl` pour annoter vos ressources à l'aide des commandes suivantes :
```
kubectl annotate instrumentation.opentelemetry.io/inject-java=true
kubectl annotate cloudwatch.aws.amazon.com/inject-jmx-jvm=true
kubectl annotate cloudwatch.aws.amazon.com/inject-jmx-kafka=true
kubectl annotate cloudwatch.aws.amazon.com/inject-jmx-kafka-producer=true
kubectl annotate cloudwatch.aws.amazon.com/inject-jmx-kafka-consumer=true
```
Remplacez ** et ** par les valeurs correctes pour votre système. Par exemple, pour annoter votre `foo` déploiement, votre première commande serait :
```
kubectl annotate deployment foo instrumentation.opentelemetry.io/inject-java=true
```
1. Créez un jeton de compte de service avec un accès ADMIN pour appeler Grafana HTTP. APIs Pour en savoir plus, consultez [Utilisez des comptes de service pour vous authentifier avec le protocole HTTP Grafana APIs](service-accounts.md). Vous pouvez utiliser AWS CLI les commandes suivantes pour créer le jeton. Vous devrez remplacer le par l'*GRAFANA\$1ID*identifiant de votre espace de travail Grafana (il figurera dans le formulaire`g-123example`). Cette clé expirera au bout de 7 200 secondes, soit 2 heures. Vous pouvez modifier l'heure (`seconds-to-live`), si nécessaire. Le déploiement prend moins d'une heure.
```
# creates a new service account (optional: you can use an existing account)
GRAFANA_SA_ID=$(aws grafana create-workspace-service-account \
--workspace-id GRAFANA_ID \
--grafana-role ADMIN \
--name grafana-operator-key \
--query 'id' \
--output text)
# creates a new token for calling APIs
export AMG_API_KEY=$(aws grafana create-workspace-service-account-token \
--workspace-id $managed_grafana_workspace_id \
--name "grafana-operator-key-$(date +%s)" \
--seconds-to-live 7200 \
--service-account-id $GRAFANA_SA_ID \
--query 'serviceAccountToken.key' \
--output text)
```
Mettez la clé d'API à la disposition du AWS CDK en l'ajoutant à l' AWS Systems Manager aide de la commande suivante. Remplacez *AWS\$1REGION* par la région dans laquelle votre solution sera exécutée (dans le formulaire`us-east-1`).
```
aws ssm put-parameter --name "/observability-aws-solution-kafka-eks/grafana-api-key" \
--type "SecureString" \
--value $AMG_API_KEY \
--region AWS_REGION \
--overwrite
```
1. Exécutez la `make` commande suivante, qui installera toutes les autres dépendances du projet.
```
make deps
```
1. Enfin, lancez le AWS CDK projet :
```
make build && make pattern aws-observability-solution-kafka-eks-$EKS_CLUSTER_NAME deploy
```
1. [Facultatif] Une fois la création de la pile terminée, vous pouvez utiliser le même environnement pour créer d'autres instances de la pile pour d'autres applications Kafka exécutées sur des clusters Amazon EKS de la même région, à condition de remplir les autres conditions requises pour chacune d'entre elles (y compris les espaces de travail Amazon Managed Grafana et Amazon Managed Service for Prometheus distincts). Vous devrez redéfinir les `export` commandes avec les nouveaux paramètres.
Une fois la création de la pile terminée, votre espace de travail Amazon Managed Grafana sera renseigné avec un tableau de bord présentant les mesures relatives à votre application et à votre cluster Amazon EKS. L'affichage des métriques prendra quelques minutes, au fur et à mesure de leur collecte.
## Liste des indicateurs suivis
Cette solution collecte des métriques à partir de votre application Kafka basée sur JVM. Ces statistiques sont stockées dans Amazon Managed Service for Prometheus, puis affichées dans les tableaux de bord Amazon Managed Grafana.
Les mesures suivantes sont suivies avec cette solution.
+ jvm.classes.loaded
+ jvm.gc.collections.count
+ jvm.gc.collections.elapsed
+ jvm.memory.heap.init
+ jvm.memory.heap.max
+ jvm.memory.heap.used
+ jvm.memory.heap.committed
+ jvm.memory.nonheap.init
+ jvm.memory.nonheap.max
+ jvm.memory.nonheap.used
+ jvm.memory.nonheap.committed
+ jvm.memory.pool.init
+ jvm.memory.pool.max
+ jvm.memory.pool.used
+ jvm.memory.pool.committed
+ jvm.threads.count
+ kafka.message.count
+ kafka.request.count
+ kafka.request.failed
+ kafka.request.time.total
+ kafka.request.time.50 p
+ kafka.request.time.99p
+ kafka.request.time.avg
+ kafka.network.io
+ kafka.purgatory.size
+ kafka.partition.count
+ kafka.partition.offline
+ kafka.partition.under\$1replicated
+ kafka.isr.operation.count
+ kafka.max.lag
+ kafka.controller.active.count
+ kafka.leader.election.rate
+ kafka.unclean.election.rate
+ kafka.request.queue
+ kafka.logs.flush.time.count
+ kafka.logs.flush.time.median
+ kafka.logs.flush.time.99p
+ kafka.consumer.fetch-rate
+ kafka.consumer. records-lag-max
+ kafka.consumer.total. bytes-consumed-rate
+ kafka.consumer.total. fetch-size-avg
+ kafka.consumer.total. records-consumed-rate
+ kafka.consumer. bytes-consumed-rate
+ kafka.consumer. fetch-size-avg
+ kafka.consumer. records-consumed-rate
+ Kafka. Producteur. io-wait-time-ns-moyenne
+ Kafka. Producteur. outgoing-byte-rate
+ Kafka. Producteur. request-latency-avg
+ kafka.producer.request-rate
+ kafka.producer.response-rate
+ kafka.producer.byte-rate
+ kafka.producer.taux de compression
+ Kafka. Producteur. record-error-rate
+ Kafka. Producteur. record-retry-rate
+ Kafka. Producteur. record-send-rate
## Résolution des problèmes
Plusieurs facteurs peuvent entraîner l'échec de la configuration du projet. Assurez-vous de vérifier les points suivants.
+ Vous devez remplir tous les [prérequis](#solution-kafka-prerequisites) avant d'installer la solution.
+ Le cluster doit contenir au moins un nœud avant de tenter de créer la solution ou d'accéder aux métriques.
+ Les modules complémentaires `CoreDNS` et les `kube-proxy` modules complémentaires doivent être installés sur `AWS CNI` votre cluster Amazon EKS. S'ils ne sont pas installés, la solution ne fonctionnera pas correctement. Ils sont installés par défaut, lors de la création du cluster via la console. Vous devrez peut-être les installer si le cluster a été créé via un AWS SDK.
+ Le délai d'installation des modules Amazon EKS a expiré. Cela peut se produire si la capacité des nœuds n'est pas suffisante. Les causes de ces problèmes sont multiples, notamment :
+ Le cluster Amazon EKS a été initialisé avec Fargate au lieu d'Amazon EC2. Ce projet nécessite Amazon EC2.
+ Les nœuds sont endommagés et [ne sont](https://docs.aws.amazon.com/eks/latest/userguide/node-taints-managed-node-groups.html) donc pas disponibles.
Vous pouvez l'utiliser `kubectl describe node NODENAME | grep Taints` pour vérifier les taches. Ensuite, `kubectl taint node NODENAME TAINT_NAME-` pour enlever les souillures. Assurez-vous d'inclure le nom `-` après le nom de la tache.
+ Les nœuds ont atteint la limite de capacité. Dans ce cas, vous pouvez créer un nouveau nœud ou augmenter la capacité.
+ Vous ne voyez aucun tableau de bord dans Grafana : l'identifiant de l'espace de travail Grafana est incorrect.
Exécutez la commande suivante pour obtenir des informations sur Grafana :
```
kubectl describe grafanas external-grafana -n grafana-operator
```
Vous pouvez vérifier les résultats pour trouver l'URL de l'espace de travail correcte. Si ce n'est pas celui que vous attendez, redéployez-le avec le bon identifiant d'espace de travail.
```
Spec:
External:
API Key:
Key: GF_SECURITY_ADMIN_APIKEY
Name: grafana-admin-credentials
URL: https://g-123example.grafana-workspace.aws-region.amazonaws.com
Status:
Admin URL: https://g-123example.grafana-workspace.aws-region.amazonaws.com
Dashboards:
...
```
+ Vous ne voyez aucun tableau de bord dans Grafana : vous utilisez une clé d'API expirée.
Pour rechercher ce cas, vous devez obtenir l'opérateur grafana et vérifier la présence d'erreurs dans les journaux. Obtenez le nom de l'opérateur Grafana avec cette commande :
```
kubectl get pods -n grafana-operator
```
Cela renverra le nom de l'opérateur, par exemple :
```
NAME READY STATUS RESTARTS AGE
grafana-operator-1234abcd5678ef90 1/1 Running 0 1h2m
```
Utilisez le nom de l'opérateur dans la commande suivante :
```
kubectl logs grafana-operator-1234abcd5678ef90 -n grafana-operator
```
Les messages d'erreur tels que les suivants indiquent une clé d'API expirée :
```
ERROR error reconciling datasource {"controller": "grafanadatasource", "controllerGroup": "grafana.integreatly.org", "controllerKind": "GrafanaDatasource", "GrafanaDatasource": {"name":"grafanadatasource-sample-amp","namespace":"grafana-operator"}, "namespace": "grafana-operator", "name": "grafanadatasource-sample-amp", "reconcileID": "72cfd60c-a255-44a1-bfbd-88b0cbc4f90c", "datasource": "grafanadatasource-sample-amp", "grafana": "external-grafana", "error": "status: 401, body: {\"message\":\"Expired API key\"}\n"}
github.com/grafana-operator/grafana-operator/controllers.(*GrafanaDatasourceReconciler).Reconcile
```
Dans ce cas, créez une nouvelle clé d'API et déployez à nouveau la solution. Si le problème persiste, vous pouvez forcer la synchronisation à l'aide de la commande suivante avant le redéploiement :
```
kubectl delete externalsecret/external-secrets-sm -n grafana-operator
```
+ Paramètre SSM manquant. Si le message d'erreur suivant s'affiche, exécutez `cdk bootstrap` et réessayez.
```
Deployment failed: Error: aws-observability-solution-kafka-eks-$EKS_CLUSTER_NAME: SSM
parameter /cdk-bootstrap/xxxxxxx/version not found. Has the environment been
bootstrapped? Please run 'cdk bootstrap' (see https://docs.aws.amazon.com/cdk/latest/
guide/bootstrapping.html)
```