Prérequis Activation de la collecte de métriques Prometheus Configuration avancée

Configurer l'ingestion de métriques à l'aide de AWS Distro pour un OpenTelemetry cluster Amazon Elastic Kubernetes Service

Vous pouvez utiliser le collecteur AWS Distor for OpenTelemetry (ADOT) pour extraire les métriques d'une application instrumentée par Prometheus et les envoyer à Amazon Managed Service for Prometheus.

Note

Pour plus d'informations sur le collecteur ADOT, consultez AWS Distro for. OpenTelemetry

Pour plus d'informations sur les applications instrumentées par Prometheus, consultez. Quelles sont les métriques compatibles avec Prometheus ?

La collecte des métriques Prometheus avec ADOT implique trois OpenTelemetry composants : le récepteur Prometheus, l'exportateur d'écriture à distance Prometheus et l'extension d'authentification Sigv4.

Vous pouvez configurer Prometheus Receiver à l’aide de votre configuration Prometheus existante pour effectuer la découverte de service et la collecte des métriques. Prometheus Receiver collecte des métriques dans le format d’exposition Prometheus. Toutes les applications ou points de terminaison que vous souhaitez collecter doivent être configurés avec la bibliothèque client Prometheus. Prometheus Receiver prend en charge l’ensemble complet des configurations de collecte et de réétiquetage de Prometheus décrites dans la section Configuration de la documentation Prometheus. Vous pouvez coller ces configurations directement dans les configurations de votre collecteur ADOT.

Prometheus Remote Write Exporter utilise le point de terminaison remote_write pour envoyer les métriques collectées à l’espace de travail de votre portail de gestion. Les demandes HTTP pour exporter des données seront signées avec AWS Sigv4, le AWS protocole d'authentification sécurisée, avec l'extension d'authentification Sigv4. Pour plus d'informations, consultez Processus de signature Signature Version 4.

Le collecteur reconnaît automatiquement les points de terminaison des métriques Prometheus sur Amazon EKS et utilise la configuration trouvée dans <kubernetes_sd_config>.

La démonstration suivante est un exemple de cette configuration sur un cluster exécutant Amazon Elastic Kubernetes Service ou Kubernetes autogéré. Pour effectuer ces étapes, vous devez disposer AWS d'informations d'identification provenant de l'une des options potentielles de la chaîne AWS d'informations d'identification par défaut. Pour plus d'informations, consultez Configuration du AWS SDK for Go. Cette démonstration utilise un exemple d’application qui est utilisé pour les tests d’intégration du processus. L’exemple d’application expose les métriques au niveau du point de terminaison /metrics, comme la bibliothèque client Prometheus.

Prérequis

Avant de commencer les étapes de configuration d’ingestion suivantes, vous devez configurer votre rôle IAM pour le compte de service et la politique d’approbation.

Pour configurer le rôle IAM pour le compte de service et la politique d’approbation

Créez le rôle IAM pour le compte de service en suivant les étapes décrites dans Configuration de rôles de service pour l'ingestion de métriques à partir de clusters Amazon EKS.

Le collecteur ADOT utilisera ce rôle lorsqu’il collectera et exportera des métriques.
Modifiez ensuite la politique d’approbation. Ouvrez la console IAM à l’adresse https://console.aws.amazon.com/iam/.
Dans le volet de navigation de gauche, choisissez Rôles et recherchez ceux amp-iamproxy-ingest-roleque vous avez créés à l'étape 1.
Choisissez l’onglet Relations d’approbation, puis Modifier la relation d’approbation.

Dans le JSON de la politique de relation d’approbation, remplacez aws-amp par adot-col, puis choisissez Update Trust Policy. La politique d’approbation obtenue doit être similaire à ce qui suit :


{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Principal": {
        "Federated": "arn:aws:iam::account-id:oidc-provider/oidc.eks.region.amazonaws.com/id/openid"
      },
      "Action": "sts:AssumeRoleWithWebIdentity",
      "Condition": {
        "StringEquals": {
          "oidc.eks.region.amazonaws.com/id/openid:sub": "system:serviceaccount:adot-col:amp-iamproxy-ingest-service-account"
        }
      }
    }
  ]
}

Choisissez l’onglet Autorisations et assurez-vous que la politique d’autorisations suivante est associée au rôle.


{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "aps:RemoteWrite",
                "aps:GetSeries",
                "aps:GetLabels",
                "aps:GetMetricMetadata"
            ],
            "Resource": "*"
        }
    ]
}

Activation de la collecte de métriques Prometheus

Note

Lorsque vous créez un espace de noms dans Amazon EKS, alertmanager l’exportateur de nœuds sont désactivés par défaut.

Pour activer la collecte Prometheus sur un cluster Amazon EKS ou Kubernetes

Forkez et clonez l'exemple d'application depuis le référentiel à l'adresse aws-otel-community.

Exécutez ensuite les commandes suivantes.
```
cd ./sample-apps/prometheus-sample-app
docker build . -t prometheus-sample-app:latest
```
Transférez cette image vers un registre tel qu'Amazon ECR ou DockerHub.
Déployez l’exemple d’application dans le cluster en copiant cette configuration Kubernetes et en l’appliquant. Remplacez l’image par celle que vous venez d’envoyer en remplaçant {{PUBLIC_SAMPLE_APP_IMAGE}} dans le fichier prometheus-sample-app.yaml.
```
curl https://raw.githubusercontent.com/aws-observability/aws-otel-collector/main/examples/eks/aws-prometheus/prometheus-sample-app.yaml -o prometheus-sample-app.yaml
kubectl apply -f prometheus-sample-app.yaml
```
Exécutez la commande suivante pour vérifier que l’exemple d’application a démarré. Dans la sortie de la commande, prometheus-sample-app apparaît dans la colonne NAME.
```
kubectl get all -n aoc-prometheus-pipeline-demo
```
Démarrez une instance par défaut du collecteur ADOT. Pour ce faire, commencez par entrer la commande suivante pour extraire la configuration Kubernetes du collecteur ADOT.
```
curl https://raw.githubusercontent.com/aws-observability/aws-otel-collector/main/examples/eks/aws-prometheus/prometheus-daemonset.yaml -o prometheus-daemonset.yaml
```
Modifiez ensuite le fichier modèle en remplaçant le point de terminaison remote_write de votre espace de travail Amazon Managed Service for Prometheus par YOUR_ENDPOINT et votre région par YOUR_REGION. Utilisez le point de terminaison remote_write affiché dans la console Amazon Managed Service for Prometheus lorsque vous consultez les détails de votre espace de travail.

YOUR_ACCOUNT_IDDans la section du compte de service de la configuration de Kubernetes, vous devrez également remplacer votre AWS identifiant de compte.

Dans cet exemple, la configuration du collecteur ADOT utilise une annotation (scrape=true) pour indiquer les points de terminaison cible à collecter. Cela permet au collecteur ADOT de distinguer le point de terminaison de l’exemple d’application des points de terminaison kube-system dans votre cluster. Vous pouvez le supprimer des configurations de réétiquetage si vous souhaitez récupérer un autre exemple d’application.
Entrez la commande suivante pour déployer le collecteur ADOT.
```
kubectl apply -f prometheus-daemonset.yaml
```
Exécutez la commande suivante pour vérifier que le collecteur ADOT a démarré. Recherchez adot-col dans la colonne NAMESPACE.
```
kubectl get pods -n adot-col
```

Vérifiez que le pipeline fonctionne à l’aide de l’exportateur de journalisation. Notre exemple de modèle est déjà intégré à l’exportateur de journalisation. Entrez les commandes suivantes :


kubectl get pods -A
kubectl logs -n adot-col name_of_your_adot_collector_pod

Certaines des métriques collectées de l’exemple d’application ressembleront à celles de l’exemple suivant.


Resource labels:
     -> service.name: STRING(kubernetes-service-endpoints)
     -> host.name: STRING(192.168.16.238)
     -> port: STRING(8080)
     -> scheme: STRING(http)
InstrumentationLibraryMetrics #0
Metric #0
Descriptor:
     -> Name: test_gauge0
     -> Description: This is my gauge
     -> Unit: 
     -> DataType: DoubleGauge
DoubleDataPoints #0
StartTime: 0
Timestamp: 1606511460471000000
Value: 0.000000

Pour vérifier si Amazon Managed Service for Prometheus a reçu les statistiques, utilisez awscurl. Cet outil vous permet d'envoyer des requêtes HTTP via la ligne de commande avec l'authentification AWS Sigv4. Vous devez donc disposer d'informations d' AWS identification configurées localement avec les autorisations appropriées pour effectuer des requêtes auprès d'Amazon Managed Service for Prometheus. Pour obtenir des instructions sur awscurl l'installation, consultez awscurl.

Dans la commande suivante, remplacez AMP_REGION et AMP_ENDPOINT par les informations relatives à votre espace de travail Amazon Managed Service for Prometheus.
```
awscurl --service="aps" --region="AMP_REGION" "https://AMP_ENDPOINT/api/v1/query?query=adot_test_gauge0"
{"status":"success","data":{"resultType":"vector","result":[{"metric":{"__name__":"adot_test_gauge0"},"value":[1606512592.493,"16.87214000011479"]}]}}
```
Si vous recevez une métrique en réponse, cela signifie que la configuration de votre pipeline est réussie et que la métrique s’est propagée avec succès depuis l’exemple d’application dans Amazon Managed Service for Prometheus.

Nettoyage

Pour nettoyer cette démo, entrez les commandes suivantes.


kubectl delete namespace aoc-prometheus-pipeline-demo
kubectl delete namespace adot-col

Configuration avancée

Prometheus Receiver prend en charge l’ensemble complet des configurations de collecte et de réétiquetage de Prometheus décrites dans la section Configuration de la documentation Prometheus. Vous pouvez coller ces configurations directement dans les configurations de votre collecteur ADOT.

La configuration de Prometheus Receiver inclut vos configurations de découverte de service, de collecte et de réétiquetage. La configuration du récepteur ressemble à ce qui suit.


receivers:
  prometheus:
    config:
      [[Your Prometheus configuration]]

Voici un exemple de configuration.


receivers:
  prometheus:
    config:
      global:
        scrape_interval: 1m
        scrape_timeout: 10s
        
      scrape_configs:
      - job_name: kubernetes-service-endpoints
        sample_limit: 10000
        kubernetes_sd_configs:
        - role: endpoints
        tls_config:
          ca_file: /var/run/secrets/kubernetes.io/serviceaccount/ca.crt
          insecure_skip_verify: true
        bearer_token_file: /var/run/secrets/kubernetes.io/serviceaccount/token

Si vous disposez d’une configuration Prometheus existante, vous devez remplacer les caractères $ par les caractères $$ pour éviter que les valeurs soient remplacées par des variables d’environnement. *Ceci est particulièrement important pour la valeur de remplacement de relabel_configurations. Par exemple, si vous commencez par la configuration relabel_configuration suivante :


relabel_configs:
- source_labels: [__meta_kubernetes_ingress_scheme,__address__,__meta_kubernetes_ingress_path]
  regex: (.+);(.+);(.+)
  replacement: ${1}://${2}${3}
  target_label: __param_target

Elle deviendra :


relabel_configs:
- source_labels: [__meta_kubernetes_ingress_scheme,__address__,__meta_kubernetes_ingress_path]
  regex: (.+);(.+);(.+)
  replacement: $${1}://${2}${3}
  target_label: __param_target

Prometheus Remote Write Exporter et SigV4 Authentication Extension

Les configurations de Prometheus Remote Write Exporter et Sigv4 Authentication Extension sont plus simples que celle de Prometheus Receiver. À ce stade du pipeline, les métriques ont déjà été ingérées et nous sommes prêts à exporter ces données dans Amazon Managed Service for Prometheus. L’exemple suivant montre la configuration minimale requise pour communiquer avec Amazon Managed Service for Prometheus.


extensions:
  sigv4auth:
    service: "aps"
    region: "user-region"
exporters:
  prometheusremotewrite:
    endpoint: "https://aws-managed-prometheus-endpoint/api/v1/remote_write"
    auth:
      authenticator: "sigv4auth"

Cette configuration envoie une demande HTTPS signée par AWS SigV4 à l'aide des AWS informations d'identification de la chaîne d'informations AWS d'identification par défaut. Pour plus d’informations, consultez Configuration de l’ AWS SDK for Go. Vous devez spécifier le service aps.

Quelle que soit la méthode de déploiement, le collecteur ADOT doit avoir accès à l'une des options répertoriées dans la chaîne d' AWS informations d'identification par défaut. L'extension d'authentification Sigv4 dépend de AWS SDK for Go et l'utilise pour récupérer les informations d'identification et s'authentifier. Vous devez vous assurer que ces informations d’identification disposent d’autorisations d’écriture à distance pour Amazon Managed Service for Prometheus.

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Collecteurs ADOT

Ingérer depuis Amazon ECS