Déployer des ressources d’observabilité et configurer des journaux

Article
11/05/2024

Important

Opérations Azure IoT Préversion avec Azure Arc est actuellement en préversion. Vous ne devez pas utiliser ce logiciel en préversion dans des environnements de production.

Lorsqu’une version en disponibilité générale sera publiée, vous devrez déployer une nouvelle installation d’Opérations Azure IoT. Vous ne pourrez pas mettre à niveau une installation en préversion.

Pour connaître les conditions juridiques qui s’appliquent aux fonctionnalités Azure en version bêta, en préversion ou plus généralement non encore en disponibilité générale, consultez l’Avenant aux conditions d’utilisation des préversions de Microsoft Azure.

L’observabilité offre une visibilité sur chaque couche de votre configuration Opérations Azure IoT. Elle vous donne un aperçu du comportement réel des problèmes, ce qui augmente l’efficacité de l’ingénierie de fiabilité du site. Opérations Azure IoT offre une observabilité via des tableaux de bord Grafana organisés personnalisés hébergés dans Azure. Ces tableaux de bord sont alimentés par le service géré Azure Monitor pour Prometheus et par Container Insights. Ce guide vous montre comment configurer Azure Managed Prometheus et Azure Managed Grafana et activer la surveillance de votre cluster Azure Arc.

Suivez les étapes décrites dans cet article avant de déployer Opérations Azure IoT sur votre cluster.

Prérequis

Un cluster Kubernetes avec Arc.
Azure CLI installé sur votre ordinateur de développement. Pour obtenir des instructions, consultez Installation de l’interface de ligne de commande Azure.
Helm doit être installé sur votre ordinateur de développement. Pour obtenir plus d’instructions, consultez Installer Helm.
Kubectl doit être installé sur votre ordinateur de développement. Pour obtenir plus d’instructions, consultez Installer les outils Kubernetes.

Créer des ressources dans Azure

Inscrivez les fournisseurs dans l’abonnement où se trouve votre cluster.

Remarque

Cette étape doit être exécutée une seule fois par abonnement. Pour inscrire des fournisseurs de ressources, vous devez disposer de l’autorisation d’effectuer l’opération /register/action qui est incluse dans les rôles Contributeur et Propriétaire de l’abonnement. Pour plus d’informations, consultez Fournisseurs et types de ressources Azure.
```
az account set -s <SUBSCRIPTION_ID>
az provider register --namespace Microsoft.AlertsManagement
az provider register --namespace Microsoft.Monitor
az provider register --namespace Microsoft.Dashboard
az provider register --namespace Microsoft.Insights
az provider register --namespace Microsoft.OperationalInsights
```
Installez les extensions Azure CLI pour la collecte de métriques pour les clusters avec Azure Arc et Azure Managed Grafana.
```
az extension add --name k8s-extension
az extension add --name amg
```
Créez un espace de travail Azure Monitor pour activer la collecte de métriques pour votre cluster Kubernetes avec Azure Arc.
```
az monitor account create --name <WORKSPACE_NAME> --resource-group <RESOURCE_GROUP> --location <LOCATION> --query id -o tsv
```
Enregistrez l’ID d’espace de travail Azure Monitor à partir de la sortie de cette commande. Vous utiliserez l’ID lorsque vous activerez la collecte de métriques dans la section suivante.
Créez une instance Azure Managed Grafana pour visualiser vos métriques Prometheus.
```
az grafana create --name <GRAFANA_NAME> --resource-group <RESOURCE_GROUP> --query id -o tsv
```
Enregistrez l’ID Grafana de la sortie de cette commande. Vous utiliserez l’ID lorsque vous activerez la collecte de métriques dans la section suivante.
Créez un espace de travail Log Analytics pour Container Insights.
```
az monitor log-analytics workspace create -g <RESOURCE_GROUP> -n <LOGS_WORKSPACE_NAME> --query id -o tsv
```
Enregistrez l’ID d’espace de travail Log Analytics de la sortie de cette commande. Vous utiliserez l’ID lorsque vous activerez la collecte de métriques dans la section suivante.

Activer la collecte de métriques pour le cluster

Mettez à jour le cluster Azure Arc pour qu’il collecte des métriques et les envoie à l’espace de travail Azure Monitor créé précédemment. Vous liez également cet espace de travail à l’instance Grafana.

az k8s-extension create --name azuremonitor-metrics --cluster-name <CLUSTER_NAME> --resource-group <RESOURCE_GROUP> --cluster-type connectedClusters --extension-type Microsoft.AzureMonitor.Containers.Metrics --configuration-settings azure-monitor-workspace-resource-id=<AZURE_MONITOR_WORKSPACE_ID> grafana-resource-id=<GRAFANA_ID>

Activez les journaux Container Insights pour la collecte des journaux d’activité.

az k8s-extension create --name azuremonitor-containers --cluster-name <CLUSTER_NAME> --resource-group <RESOURCE_GROUP> --cluster-type connectedClusters --extension-type Microsoft.AzureMonitor.Containers --configuration-settings logAnalyticsWorkspaceResourceID=<LOG_ANALYTICS_WORKSPACE_ID>

Une fois ces étapes terminées, Azure Monitor et Grafana sont configurés et liés à votre cluster pour l’observabilité et la collecte de métriques.

Déployer le collecteur OpenTelemetry

Définissez et déployez un collecteur OpenTelemetry (OTel) sur votre cluster Kubernetes avec Arc.

Créez un fichier appelé otel-collector-values.yaml et collez le code suivant pour définir un collecteur OpenTelemetry :

mode: deployment
fullnameOverride: aio-otel-collector
image:
  repository: otel/opentelemetry-collector
  tag: 0.107.0
config:
  processors:
    memory_limiter:
      limit_percentage: 80
      spike_limit_percentage: 10
      check_interval: '60s'
  receivers:
    jaeger: null
    prometheus: null
    zipkin: null
    otlp:
      protocols:
        grpc:
          endpoint: ':4317'
        http:
          endpoint: ':4318'
  exporters:
    prometheus:
      endpoint: ':8889'
      resource_to_telemetry_conversion:
        enabled: true
      add_metric_suffixes: false
  service:
    extensions:
      - health_check
    pipelines:
      metrics:
        receivers:
          - otlp
        exporters:
          - prometheus
      logs: null
      traces: null
    telemetry: null
  extensions:
    memory_ballast:
      size_mib: 0
resources:
  limits:
    cpu: '100m'
    memory: '512Mi'
ports:
  metrics:
    enabled: true
    containerPort: 8889
    servicePort: 8889
    protocol: 'TCP'
  jaeger-compact:
    enabled: false
  jaeger-grpc:
    enabled: false
  jaeger-thrift:
    enabled: false
  zipkin:
    enabled: false

Dans le fichier otel-collector-values.yaml, notez les valeurs suivantes que vous utilisez dans la commande az iot ops create lorsque vous déployez Opérations Azure IoT sur le cluster :
- fullnameOverride
- grpc.endpoint
- check_interval
Enregistrez et fermez le fichier.

Déployez le collecteur en exécutant les commandes suivantes :

kubectl get namespace azure-iot-operations || kubectl create namespace azure-iot-operations
helm repo add open-telemetry https://open-telemetry.github.io/opentelemetry-helm-charts

helm repo update
helm upgrade --install aio-observability open-telemetry/opentelemetry-collector -f otel-collector-values.yaml --namespace azure-iot-operations

Configurer la collection de métriques Prometheus

Configurez la collecte de métriques Prometheus sur votre cluster.

Créez un fichier nommé ama-metrics-prometheus-config.yaml et collez la configuration suivante :

apiVersion: v1
data:
  prometheus-config: |2-
    scrape_configs:
      - job_name: otel
        scrape_interval: 1m
        static_configs:
          - targets:
            - aio-otel-collector.azure-iot-operations.svc.cluster.local:8889
      - job_name: aio-annotated-pod-metrics
        kubernetes_sd_configs:
          - role: pod
        relabel_configs:
          - action: drop
            regex: true
            source_labels:
              - __meta_kubernetes_pod_container_init
          - action: keep
            regex: true
            source_labels:
              - __meta_kubernetes_pod_annotation_prometheus_io_scrape
          - action: replace
            regex: ([^:]+)(?::\\d+)?;(\\d+)
            replacement: $1:$2
            source_labels:
              - __address__
              - __meta_kubernetes_pod_annotation_prometheus_io_port
            target_label: __address__
          - action: replace
            source_labels:
              - __meta_kubernetes_namespace
            target_label: kubernetes_namespace
          - action: keep
            regex: 'azure-iot-operations'
            source_labels:
              - kubernetes_namespace
        scrape_interval: 1m
kind: ConfigMap
metadata:
  name: ama-metrics-prometheus-config
  namespace: kube-system

Appliquez le fichier de configuration en exécutant la commande suivante :
```
kubectl apply -f ama-metrics-prometheus-config.yaml
```

Déployer des tableaux de bord sur Grafana

Opérations Azure IoT fournit un exemple de tableau de bord conçu pour vous donner de nombreuses visualisations dont vous avez besoin pour comprendre l’intégrité et les performances de votre déploiement Opérations Azure IoT.

Effectuez les étapes suivantes pour installer les tableaux de bord Grafana organisés par Opérations Azure IoT.

Clonez ou téléchargez le référentiel azure-iot-operations pour obtenir l’exemple de fichier json du tableau de bord Grafana localement : https://github.com/Azure/azure-iot-operations.
Connectez-vous à la console Grafana. Vous pouvez accéder à la console via le portail Azure ou utiliser la commande az grafana show pour récupérer l’URL.
```
az grafana show --name <GRAFANA_NAME> --resource-group <RESOURCE_GROUP> --query url -o tsv
```
Dans l’application Grafana, sélectionnez l’icône +.
Sélectionnez Importer un tableau de bord.
Accédez à l’exemple de répertoire du tableau de bord dans votre copie locale du référentiel Opérations Azure IoT, azure-iot-operations>exemples>grafana-dashboard, puis sélectionnez le fichier de tableau de bord aio.sample.json.
Lorsque l’application vous y invite, sélectionnez votre source de données Prometheus gérée.
Cliquez sur Importer.

Partager via