Configuration du pipeline de périphérie Azure Monitor

Article
05/02/2024

Le pipeline Azure Monitor est un pipeline d’ingestion de données qui fournit une collecte de données constante et centralisée pour Azure Monitor. Le pipeline de périphérie active la collecte à grande échelle et le routage des données de télémétrie avant qu’elles ne soient envoyées vers le cloud. Il peut mettre en cache les données localement et se synchroniser avec le cloud lorsque la connectivité est restaurée, et acheminer les données de télémétrie vers Azure Monitor dans les cas où le réseau est segmenté et que les données ne peuvent pas être envoyées directement au cloud. Cet article explique comment activer et configurer le pipeline de périphérie dans votre environnement.

Vue d’ensemble

Le pipeline de périphérie Azure Monitor est une solution conteneurisée déployée sur un cluster Kubernetes avec Arc et tire profit d’OpenTelemetry Collector comme base. Le diagramme ci-après montre les composants du pipeline de périphérie. Un ou plusieurs flux de données écoutent les données entrantes des clients, et l’extension de pipeline transfère les données vers le cloud, en utilisant le cache local si nécessaire.

Le fichier de configuration du pipeline définit les flux de données et les propriétés du cache pour le pipeline de périphérie. La DCR définit le schéma des données envoyées au pipeline cloud, une transformation pour filtrer ou modifier les données et la destination où les données doivent être envoyées. Chaque définition de flux de données pour la configuration du pipeline spécifie la DCR et le flux au sein de cette DCR qui traitera ces données dans le pipeline cloud.

Remarque

La liaison privée est prise en charge par le pipeline de périphérie pour la connexion au pipeline cloud.

Les composants et configurations suivants sont nécessaires pour activer le pipeline de périphérie Azure Monitor. Si vous utilisez le Portail Azure pour configurer le pipeline de périphérie, alors chacun de ces composants est créé pour vous. Avec d’autres méthodes, vous devez tous les configurer.

Composant	Description
Extension du contrôleur de pipeline de périphérie	Extension ajoutée à votre cluster Kubernetes avec Arc pour prendre en charge les fonctionnalités de pipeline - `microsoft.monitor.pipelinecontroller`.
Instance du contrôleur de pipeline de périphérie	Instance du pipeline de périphérie s’exécutant sur votre cluster Kubernetes avec Arc.
Flux de données	Combinaison des récepteurs et des exportateurs qui s’exécutent sur l’instance de contrôleur de pipeline. Les récepteurs acceptent les données des clients et les exportateurs fournissent ces données à Azure Monitor.
Configuration du pipeline	Fichier de configuration qui définit les flux de données pour l’instance de pipeline. Chaque flux de données inclut un récepteur et un exportateur. Le récepteur écoute les données entrantes et l’exportateur envoie les données vers la destination.
Point de terminaison de collecte de données (DCE)	Point de terminaison où les données sont envoyées au pipeline Azure Monitor. La configuration du pipeline inclut une propriété pour l’URL du DCE afin que l’instance de pipeline sache où envoyer les données.

Configuration	Description
Règle de collecte de données (DCR)	Fichier de configuration qui définit la façon dont les données sont reçues dans le pipeline cloud et où elles sont envoyées. La DCR peut également inclure une transformation pour filtrer ou modifier les données avant qu’elles ne soient envoyées à la destination.
Configuration du pipeline	Configuration qui définit les flux de données pour l’instance de pipeline, incluant les flux de données et le cache.

Configurations prises en charge

Distributions prises en charge
Le pipeline de périphérie est pris en charge sur les distributions Kubernetes suivantes :

Canonical
Cluster API Provider for Azure
K3
Rancher Kubernetes Engine
VMware Tanzu Kubernetes Grid

Emplacements pris en charge
Le pipeline de périphérie est pris en charge dans les régions Azure suivantes :

USA Est 2
USA Ouest 2
Europe Ouest

Prérequis

Cluster Kubernetes avec Arc dans votre propre environnement avec une adresse IP externe. Consultez Connecter un cluster Kubernetes existant à Azure Arc pour plus d’informations sur l’activation d’Arc pour un cluster.
Le cluster Kubernetes avec Arc doit avoir les fonctionnalités d’emplacements personnalisés activées. Consultez Créer et gérer des emplacements personnalisés sur Kubernetes avec Azure Arc.
Espace de travail Log Analytics dans Azure Monitor pour recevoir les données du pipeline de périphérie. Pour plus d’informations sur la création d’un espace de travail, consultez Créer un espace de travail Log Analytics dans le Portail Azure.
Les fournisseurs de ressources suivants doivent être inscrits dans votre abonnement Azure. Voir Fournisseurs et types de ressources Azure.
- Microsoft.Insights
- Microsoft.Monitor

Workflow

Vous n’avez pas besoin d’une compréhension détaillée des différentes étapes effectuées par le pipeline Azure Monitor pour le configurer en utilisant le Portail Azure. Vous aurez peut-être besoin d’une compréhension plus détaillée de celles-ci si vous utilisez une autre méthode d’installation, ou si vous devez effectuer une configuration plus avancée comme la transformation des données avant stockage dans leur destination.

Les tableaux et diagrammes suivants décrivent les étapes détaillées et les composants du processus de collecte des données à l’aide du pipeline de périphérie, et leur passage au pipeline cloud pour stockage dans Azure Monitor. La configuration requise pour chacun de ces composants est également incluse dans les tableaux.

Étape	Action	Configuration de prise en charge
1.	Le client envoie des données au récepteur du pipeline de périphérie.	Le client est configuré avec l’adresse IP et le port du récepteur du pipeline de périphérie et envoie les données au format attendu pour le type de récepteur.
2.	Le récepteur transfère les données à l’exportateur.	Le récepteur et l’exportateur sont configurés dans le même pipeline.
3.	L’exportateur tente d’envoyer les données au pipeline cloud.	L’exportateur dans la configuration du pipeline inclut l’URL du DCE, un identificateur unique pour la DCR et le flux dans la DCR qui définit comment les données seront traitées.
3a.	L’exportateur stocke les données dans le cache local s’il ne peut pas se connecter au DCE.	Le volume persistant pour le cache et la configuration du cache local sont activés dans la configuration du pipeline.

Étape	Action	Configuration de prise en charge
4.	Le pipeline cloud accepte les données entrantes.	La DCR inclut une définition de schéma pour le flux entrant qui doit correspondre au schéma des données provenant du pipeline de périphérie.
5.	Le pipeline cloud applique une transformation aux données.	La DCR inclut une transformation qui filtre ou modifie les données avant qu’elles ne soient envoyées à la destination. La transformation peut filtrer les données, supprimer ou ajouter des colonnes ou modifier complètement leur schéma. La sortie de la transformation doit correspondre au schéma de la table de destination.
6.	Le pipeline cloud envoie les données à la destination.	La DCR inclut une destination qui spécifie l’espace de travail Log Analytics et la table où les données seront stockées.

Réseau segmenté

La segmentation de réseau est un modèle dans lequel vous utilisez des périmètres définis par logiciel pour créer une posture de sécurité différente pour les différentes parties de votre réseau. Dans ce modèle, il peut exister un segment réseau qui ne peut pas se connecter à Internet ou à d’autres segments réseau. Le pipeline de périphérie peut être utilisé pour collecter des données depuis ces segments réseau et les envoyer au pipeline cloud.

Pour utiliser le pipeline Azure Monitor dans une configuration de réseau en couches, vous devez ajouter les entrées suivantes à la liste d’autorisation du cluster Kubernetes avec Arc. Consultez Configurer la gestion de réseau en couches Azure IoT (préversion) sur un cluster de niveau 4.

- destinationUrl: "*.ingest.monitor.azure.com"
  destinationType: external
- destinationUrl: "login.windows.net"
  destinationType: external

Créer une table dans un espace de travail Log Analytics

Avant de configurer le processus de collecte de données pour le pipeline de périphérie, vous devez créer une table dans l’espace de travail Log Analytics pour recevoir les données. Il doit s’agir d’une table personnalisée, car les tables intégrées ne sont actuellement pas prises en charge. Le schéma de la table doit correspondre aux données qu’elle reçoit, mais il existe plusieurs étapes dans le processus de collecte où vous pouvez modifier les données entrantes. Par conséquent, le schéma de la table n’a pas besoin de correspondre aux données sources que vous collectez. La seule condition requise pour la table dans l’espace de travail Log Analytics est qu’elle ait une colonne TimeGenerated.

Pour plus d’informations sur les différentes méthodes de création d’une table, consultez Ajouter ou supprimer des tables et des colonnes dans les journaux Azure Monitor. Par exemple, utilisez la commande CLI ci-dessous pour créer une table avec les trois colonnes appelées Body, TimeGenerated et SeverityText.

az monitor log-analytics workspace table create --workspace-name my-workspace --resource-group my-resource-group  --name my-table_CL --columns TimeGenerated=datetime Body=string SeverityText=string

Activer le cache

Les appareils de périphérie dans certains environnements peuvent rencontrer une connectivité intermittente en raison de divers facteurs comme une congestion du réseau, des interférences du signal, une panne de courant ou la mobilité. Dans ces environnements, vous pouvez configurer le pipeline de périphérie pour mettre en cache les données en créant un volume persistant dans votre cluster. Le processus pour le faire varie en fonction de votre environnement spécifique, mais la configuration doit répondre aux exigences suivantes :

L’espace de noms de métadonnées doit être identique à l’instance spécifiée du pipeline Azure Monitor.
Le mode d’accès doit prendre en charge ReadWriteMany.

Une fois le volume créé dans l’espace de noms approprié, configurez-le en utilisant les paramètres du fichier de configuration du pipeline ci-dessous.

Attention

Chaque réplica du pipeline de périphérie stocke les données dans un emplacement du volume persistant spécifique à ce réplica. La diminution du nombre de réplicas pendant que le cluster est déconnecté du cloud empêche que les données ne soient renvoyées lors de la restauration de la connectivité.

Activer et configurer un pipeline

Les options actuelles pour l’activation et la configuration sont détaillées dans les onglets ci-dessous.

Configurer le pipeline en utilisant le Portail Azure

Lorsque vous utilisez le Portail Azure pour activer et configurer le pipeline, tous les composants requis sont créés en fonction de vos sélections. Cela vous permet de réduire la complexité de créer chaque composant individuellement, mais vous pourriez avoir besoin d’utiliser d’autres méthodes.

Effectuez l’une des opérations suivantes dans le Portail Azure pour lancer le processus d’installation du pipeline Azure Monitor :

Dans le menu Pipelines Azure Monitor (préversion), cliquez sur Créer.
Dans le menu de votre cluster Kubernetes avec Arc, sélectionnez Extensions, puis ajoutez l’Extension de pipeline Azure Monitor (préversion).

L’onglet Essentiel vous invite à entrer les informations suivantes pour déployer l’extension et l’instance de pipeline sur votre cluster.

Les paramètres de cet onglet sont décrits dans le tableau suivant.

Propriété	Description
Nom de l’instance	Nom de l’instance de pipeline Azure Monitor. Doit être unique pour l’abonnement.
Abonnement	Abonnement Azure dans lequel créer l’instance de pipeline.
Resource group	Groupe de ressources pour créer l’instance de pipeline.
Nom du cluster	Sélectionnez votre cluster Kubernetes avec Arc sur lequel le pipeline sera installé.
Emplacement personnalisé	Emplacement personnalisé de votre cluster Kubernetes avec Arc. Ceci sera rempli automatiquement avec le nom d’un emplacement personnalisé qui sera créé pour votre cluster, ou vous pouvez sélectionner un autre emplacement personnalisé dans le cluster.

L’onglet Flux de données vous permet de créer et de modifier des flux de données pour l’instance de pipeline. Chaque flux de données inclut les informations suivantes :

Les paramètres de cet onglet sont décrits dans le tableau suivant.

Propriété	Description
Nom	Nom du flux de données. Doit être unique pour ce pipeline.
Type de source	Type de données collectées. Les types de ressource suivants sont pris en charge : - Syslog - OTLP
Port	Port sur lequel le pipeline écoute les données entrantes. Si deux flux de données utilisent le même port, ils reçoivent et traitent tous deux les données.
Espace de travail Log Analytics	Espace de travail Log Analytics vers lequel envoyer les données.
Nom de table	Nom de la table dans l’espace de travail Log Analytics vers laquelle envoyer les données.

Configurer le pipeline en utilisant Azure CLI

Voici les étapes requises pour créer et configurer les composants requis pour le pipeline de périphérie Azure Monitor en utilisant Azure CLI.

Extension de pipeline de périphérie

La commande suivante ajoute l’extension de pipeline de périphérie à votre cluster Kubernetes avec Arc.

az k8s-extension create --name <pipeline-extension-name> --extension-type microsoft.monitor.pipelinecontroller --scope cluster --cluster-name <cluster-name> --resource-group <resource-group> --cluster-type connectedClusters --release-train Preview

## Example
az k8s-extension create --name my-pipe --extension-type microsoft.monitor.pipelinecontroller --scope cluster --cluster-name my-cluster --resource-group my-resource-group --cluster-type connectedClusters --release-train Preview

Emplacement personnalisé

Le modèle ARM suivant crée l’emplacement personnalisé de votre cluster Kubernetes avec Arc.

az customlocation create --name <custom-location-name>  --resource-group <resource-group-name> --namespace <name of namespace> --host-resource-id <connectedClusterId> --cluster-extension-ids <extensionId>

## Example
az customlocation create --name my-cluster-custom-location --resource-group my-resource-group --namespace my-cluster-custom-location --host-resource-id /subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/my-resource-group/providers/Microsoft.Kubernetes/connectedClusters/my-cluster --cluster-extension-ids /subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/my-resource-group/providers/Microsoft.Kubernetes/connectedClusters/my-cluster/providers/Microsoft.KubernetesConfiguration/extensions/my-cluster

DCE

Le modèle ARM suivant crée le point de terminaison de collecte de données (Data Collection Endpoint/DCE) requis pour que le pipeline de périphérie se connecte au pipeline cloud. Vous pouvez utiliser un DCE existante si vous en avez déjà un dans la même région. Remplacez les propriétés dans la table suivante avant de déployer le modèle.

az monitor data-collection endpoint create -g "myResourceGroup" -l "eastus2euap" --name "myCollectionEndpoint" --public-network-access "Enabled"

## Example
 az monitor data-collection endpoint create --name strato-06-dce --resource-group strato --public-network-access "Enabled"

DCR

La DCR est stockée dans Azure Monitor et définit la façon dont les données seront traitées lorsqu’elles sont reçues du pipeline de périphérie. La configuration du pipeline de périphérie spécifie l’immutable ID de la DCR et le stream dans la DCR qui traitera les données. L’immutable ID est généré automatiquement lors de la création de la DCR.

Remplacez les propriétés dans le modèle suivant et enregistrez-les dans un fichier json avant d’exécuter la commande CLI pour créer la DCR. Consultez Structure d’une règle de collecte de données dans Azure Monitor pour plus d’informations sur la structure d’une DCR.

Paramètre	Description
`name`	Nom de la DCR. Doit être unique pour l’abonnement.
`location`	Emplacement de la DCR. Doit correspondre à l’emplacement du DCE.
`dataCollectionEndpointId`	ID de ressource du DCE.
`streamDeclarations`	Schéma des données reçues. Un flux est requis pour chaque flux de données dans la configuration du pipeline. Le nom doit être unique dans la DCR et doit commencer par Custom-. Les sections `column` des exemples ci-dessous doivent être utilisées pour les flux de données OLTP et Syslog. Si le schéma de votre table de destination est différent, alors vous pouvez le modifier en utilisant une transformation définie dans le paramètre `transformKql`.
`destinations`	Ajoutez une section supplémentaire pour envoyer des données à plusieurs espaces de travail.
- `name`	Nom de la destination à référencer dans la section `dataFlows`. Doit être unique pour la DCR.
- `workspaceResourceId`	ID de ressource de l’espace de travail Log Analytics.
- `workspaceId`	ID d’espace de travail de l’espace de travail Log Analytics.
`dataFlows`	Correspond aux flux et aux destinations. Une entrée pour chaque combinaison flux/destination.
- `streams`	Un ou plusieurs flux (défini dans `streamDeclarations`). Vous pouvez inclure plusieurs flux s’ils sont envoyés à la même destination.
- `destinations`	Une ou plusieurs destinations (défini dans `destinations`). Vous pouvez inclure plusieurs destinations si elles sont envoyées à la même destination.
- `transformKql`	Transformation à appliquer aux données avant de les envoyer à la destination. Utilisez `source` pour envoyer les données sans aucune modification. La sortie de la transformation doit correspondre au schéma de la table de destination. Pour plus d’informations sur les transformation, consultez Transformations de la collecte de données dans Azure Monitor.
- `outputStream`	Spécifie la table de destination dans l’espace de travail Log Analytics. La table doit déjà exister dans l’espace de travail. Pour des tables personnalisées, préfixez le nom de la table avec Custom-. Les tables intégrées ne sont actuellement pas prises en charge avec le pipeline de périphérie.

{
    "properties": {
        "dataCollectionEndpointId": "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/my-resource-group/providers/Microsoft.Insights/dataCollectionEndpoints/my-dce",
        "streamDeclarations": {
            "Custom-OTLP": {
                "columns": [
                    {
                        "name": "Body",
                        "type": "string"
                    },
                    {
                        "name": "TimeGenerated",
                        "type": "datetime"
                    },
                    {
                        "name": "SeverityText",
                        "type": "string"
                    }
                ]
            },
            "Custom-Syslog": {
                "columns": [
                    {
                        "name": "Body",
                        "type": "string"
                    },
                    {
                        "name": "TimeGenerated",
                        "type": "datetime"
                    },
                    {
                        "name": "SeverityText",
                        "type": "string"
                    }
                ]
            }
        },
        "dataSources": {},
        "destinations": {
            "logAnalytics": [
                {
                    "name": "LogAnayticsWorkspace01",
                    "workspaceResourceId": "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/my-resource-group/providers/Microsoft.OperationalInsights/workspaces/my-workspace",
                    "workspaceId": "00000000-0000-0000-0000-000000000000"
                }
            ]
        },
        "dataFlows": [
            {
                "streams": [
                    "Custom-OTLP"
                ],
                "destinations": [
                    "LogAnayticsWorkspace01"
                ],
                "transformKql": "source",
                "outputStream": "Custom-OTelLogs_CL"
            },
            {
                "streams": [
                    "Custom-Syslog"
                ],
                "destinations": [
                    "LogAnayticsWorkspace01"
                ],
                "transformKql": "source",
                "outputStream": "Custom-Syslog_CL"
            }
        ]
    }
}

Installez la DCR à l’aide de la commande suivante :

az monitor data-collection rule create --name 'myDCRName' --location <location> --resource-group <resource-group>  --rule-file '<dcr-file-path.json>' 

## Example
az monitor data-collection rule create --name my-pipeline-dcr  --location westus2 --resource-group 'my-resource-group' --rule-file 'C:\MyDCR.json'

Accès DCR

Le cluster Kubernetes avec Arc doit avoir accès à la DCR pour envoyer des données au pipeline cloud. Utilisez la commande suivante pour récupérer l’ID d’objet de l’identité affectée par le système de votre cluster.

az k8s-extension show --name <extension-name> --cluster-name <cluster-name> --resource-group <resource-group> --cluster-type connectedClusters --query "identity.principalId" -o tsv 

## Example:
az k8s-extension show --name my-pipeline-extension --cluster-name my-cluster --resource-group my-resource-group --cluster-type connectedClusters --query "identity.principalId" -o tsv

Utilisez la sortie de cette commande comme entrée dans la commande suivante pour permettre au pipeline Azure Monitor d’envoyer ses données de télémétrie à la DCR.

az role assignment create --assignee "<extension principal ID>" --role "Monitoring Metrics Publisher" --scope "/subscriptions/<subscription-id>/resourceGroups/<resource-group>/providers/Microsoft.Insights/dataCollectionRules/<dcr-name>" 

## Example:
az role assignment create --assignee "00000000-0000-0000-0000-000000000000" --role "Monitoring Metrics Publisher" --scope "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/my-resource-group/providers/Microsoft.Insights/dataCollectionRules/my-dcr"

Configuration du pipeline de périphérie

La configuration du pipeline de périphérie définit les informations de l’instance de pipeline de périphérie et déploie les flux de données nécessaires pour recevoir et envoyer des données de télémétrie au cloud.

Remplacez les propriétés dans la table suivante avant de déployer le modèle.

Propriété	Description
Général
`name`	Nom de l’instance de pipeline. Doit être unique dans l’abonnement.
`location`	Emplacement de l’instance de pipeline.
`extendedLocation`
Récepteurs	Une entrée pour chaque récepteur. Chaque entrée spécifie le type de données reçues, le port sur lequel il écoutera et un nom unique qui sera utilisé dans la section `pipelines` de la configuration.
`type`	Type des données reçues. Les options actuelles sont `OTLP` et `Syslog`.
`name`	Nom du récepteur référencé dans la section `service`. Doit être unique pour l’instance de pipeline.
`endpoint`	Adresse et port sur lequel le récepteur écoute. Utiliser `0.0.0.0` pour toutes les adresses.
Processeurs	Réservé pour un usage futur.
Exportateurs	Une entrée pour chaque destination.
`type`	Le seul type actuellement pris en charge est `AzureMonitorWorkspaceLogs`.
`name`	Doit être unique pour l’instance de pipeline. Le nom est utilisé dans la section `pipelines` de la configuration.
`dataCollectionEndpointUrl`	URL du DCE où le pipeline de périphérie enverra les données. Vous pouvez le localiser dans le Portail Azure en accédant au DCE et en copiant la valeur Ingestion des journaux.
`dataCollectionRule`	ID immuable de la DCR qui définit la collecte de données dans le pipeline cloud. Dans la vue JSON de votre DCR dans le Portail Azure, copiez la valeur de l’ID immuable dans la section Général.
- `stream`	Nom du flux dans votre DCR qui acceptera les données.
- `maxStorageUsage`	Capacité du cache. Lorsque 80 % de cette capacité sont atteints, les données les plus anciennes sont élaguées pour libérer de l’espace pour plus de données.
- `retentionPeriod`	Période de conservation en minutes. Les données sont élaguées après ce délai.
- `schema`	Schéma des données envoyées au pipeline cloud. Cela doit correspondre au schéma défini dans le flux dans la DCR. Le schéma utilisé dans l’exemple est valide pour Syslog et OTLP.
service	Une entrée pour chaque instance de pipeline. Une seule instance pour chaque extension de pipeline est recommandé.
Pipelines	Une entrée pour chaque flux de données. Chaque entrée associe un `receiver` à un `exporter`.
`name`	Nom unique du pipeline.
`receivers`	Un ou plusieurs récepteurs pour écouter les données à recevoir.
`processors`	Réservé pour un usage futur.
`exporters`	Un ou plusieurs exportateurs pour envoyer les données au pipeline cloud.
`persistence`	Nom du volume persistant utilisé pour le cache. Supprimez ce paramètre si vous ne souhaitez pas activer le cache.

{
    "type": "Microsoft.monitor/pipelineGroups",
    "location": "eastus",
    "apiVersion": "2023-10-01-preview",
     "name": "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/my-resource-group/providers/Microsoft.ExtendedLocation/customLocations/my-custom-location",

    "extendedLocation": {
        "name": "my-custom-location",
        "type": "CustomLocation"
    },
    "properties": {
        "receivers": [
            {
                "type": "OTLP",
                "name": "receiver-OTLP",
                "otlp": {
                    "endpoint": "0.0.0.0:4317"
                }
            },
            {
                "type": "Syslog",
                "name": "receiver-Syslog",
                "syslog": {
                    "endpoint": "0.0.0.0:514"
                }
            }
        ],
        "processors": [],
        "exporters": [
            {
                "type": "AzureMonitorWorkspaceLogs",
                "name": "exporter-log-analytics-workspace",
                "azureMonitorWorkspaceLogs": {
                    "api": {
                        "dataCollectionEndpointUrl": "https://my-dce-4agr.eastus-1.ingest.monitor.azure.com",
                        "dataCollectionRule": "dcr-00000000000000000000000000000000",
                        "stream": "Custom-OTLP",
                        "cache": {
                            "maxStorageUsage": "10000",
                            "retentionPeriod": "60"
                        },
                        "schema": {
                            "recordMap": [
                                {
                                    "from": "body",
                                    "to": "Body"
                                },
                                {
                                    "from": "severity_text",
                                    "to": "SeverityText"
                                },
                                {
                                    "from": "time_unix_nano",
                                    "to": "TimeGenerated"
                                }
                            ]
                        }
                    }
                }
            }
        ],
        "service": {
            "pipelines": [
                {
                    "name": "DefaultOTLPLogs",
                    "receivers": [
                        "receiver-OTLP"
                    ],
                    "processors": [],
                    "exporters": [
                        "exporter-log-analytics-workspace"
                    ],
                    "type": "logs"
                },
                {
                    "name": "DefaultSyslogs",
                    "receivers": [
                        "receiver-Syslog"
                    ],
                    "processors": [],
                    "exporters": [
                        "exporter-log-analytics-workspace"
                    ],
                    "type": "logs"
                }
            ],
            "persistence": {
                "persistentVolume": "my-persistent-volume"
            }
        },
        "networkingConfigurations": [
            {
                "externalNetworkingMode": "LoadBalancerOnly",
                "routes": [
                    {
                        "receiver": "receiver-OTLP"
                    },
                    {
                        "receiver": "receiver-Syslog"
                    }
                ]
            }
         ]
    }
}

Installez le modèle à l’aide de la commande suivante :

az deployment group create --resource-group <resource-group-name> --template-file <path-to-template>

## Example
az deployment group create --resource-group my-resource-group --template-file C:\MyPipelineConfig.json

Exemple de modèle ARM pour configurer tous les composants

Vous pouvez déployer tous les composants requis pour le pipeline de périphérie Azure Monitor en utilisant le modèle ARM unique ci-dessous. Modifiez le fichier de paramètres avec les valeurs spécifiques pour votre environnement. Chaque section du modèle est décrite ci-dessous, y compris les sections que vous devez modifier avant de l’utiliser.

Composant	Type	Description
Espace de travail Log Analytics	`Microsoft.OperationalInsights/workspaces`	Supprimez cette section si vous utilisez un espace de travail Log Analytics existant. Le seul paramètre requis est le nom de l’espace de travail. L’ID immuable de l’espace de travail, nécessaire pour d’autres composants, sera créé automatiquement.
Point de terminaison de collecte de données (DCE)	`Microsoft.Insights/dataCollectionEndpoints`	Supprimez cette section si vous utilisez un DCE existante. Le seul paramètre requis est le nom du DCE. L’URL d’ingestion des journaux pour le DCE, qui est nécessaire pour d’autres composants, sera créée automatiquement.
Extension de pipeline de périphérie	`Microsoft.KubernetesConfiguration/extensions`	Le seul paramètre requis est le nom de l’extension de pipeline.
Emplacement personnalisé	`Microsoft.ExtendedLocation/customLocations`	Emplacement personnalisé du cluster Kubernetes avec Arc pour créer le cluster Kubernetes personnalisé
Instance de pipeline de périphérie	`Microsoft.monitor/pipelineGroups`	Instance de pipeline de périphérie qui inclut la configuration de l’écouteur, des exportateurs et des flux de données. Vous devez modifier les propriétés de l’instance de pipeline avant de déployer le modèle.
Règle de collecte de données (DCR)	`Microsoft.Insights/dataCollectionRules`	Le seul paramètre requis est le nom de la DCR, mais vous devez modifier les propriétés de la DCR avant de déployer le modèle.

Fichier de modèle

{
    "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
    "contentVersion": "1.0.0.0",
    "parameters": {
        "location": {
            "type": "string"
        },
        "clusterId": {
            "type": "string"
        },
        "clusterExtensionIds": {
            "type": "array"
        },
        "customLocationName": {
            "type": "string"
        },
        "cachePersistentVolume": {
            "type": "string"
        },
        "cacheMaxStorageUsage": {
            "type": "int"
        },
        "cacheRetentionPeriod": {
            "type": "int"
        },
        "dceName": {
            "type": "string"
        },
        "dcrName": {
            "type": "string"
        },
        "logAnalyticsWorkspaceName": {
            "type": "string"
        },
        "pipelineExtensionName": {
            "type": "string"
        },
        "pipelineGroupName": {
            "type": "string"
        },
        "tagsByResource": {
            "type": "object",
            "defaultValue": {}
        }
    },
    "resources": [
        {
            "type": "Microsoft.OperationalInsights/workspaces",            
            "name": "[parameters('logAnalyticsWorkspaceName')]",
            "location": "[parameters('location')]",
            "apiVersion": "2017-03-15-preview",
            "tags": "[ if(contains(parameters('tagsByResource'), 'Microsoft.OperationalInsights/workspaces'), parameters('tagsByResource')['Microsoft.OperationalInsights/workspaces'], json('{}')) ]",
            "properties": {
                "sku": {
                    "name": "pergb2018"
                }
            }
        },
        {
            "type": "Microsoft.Insights/dataCollectionEndpoints",            
            "name": "[parameters('dceName')]",
            "location": "[parameters('location')]",
            "apiVersion": "2021-04-01",
            "tags": "[ if(contains(parameters('tagsByResource'), 'Microsoft.Insights/dataCollectionEndpoints'), parameters('tagsByResource')['Microsoft.Insights/dataCollectionEndpoints'], json('{}')) ]",
            "properties": {
                "configurationAccess": {},
                "logsIngestion": {},
                "networkAcls": {
                    "publicNetworkAccess": "Enabled"
                }
            }
        },
        {
            "type": "Microsoft.Insights/dataCollectionRules",
            "name": "[parameters('dcrName')]",
            "location": "[parameters('location')]",
            "apiVersion": "2021-09-01-preview",
            "dependsOn": [
                "[resourceId('Microsoft.OperationalInsights/workspaces', 'DefaultWorkspace-westus2')]",
                "[resourceId('Microsoft.Insights/dataCollectionEndpoints', 'Aep-mytestpl-ZZPXiU05tJ')]"
            ],
            "tags": "[ if(contains(parameters('tagsByResource'), 'Microsoft.Insights/dataCollectionRules'), parameters('tagsByResource')['Microsoft.Insights/dataCollectionRules'], json('{}')) ]",
            "properties": {
                "dataCollectionEndpointId": "[resourceId('Microsoft.Insights/dataCollectionEndpoints', 'Aep-mytestpl-ZZPXiU05tJ')]",
                "streamDeclarations": {
                    "Custom-OTLP": {
                        "columns": [
                            {
                                "name": "Body",
                                "type": "string"
                            },
                            {
                                "name": "TimeGenerated",
                                "type": "datetime"
                            },
                            {
                                "name": "SeverityText",
                                "type": "string"
                            }
                        ]
                    },
                    "Custom-Syslog": {
                        "columns": [
                            {
                                "name": "Body",
                                "type": "string"
                            },
                            {
                                "name": "TimeGenerated",
                                "type": "datetime"
                            },
                            {
                                "name": "SeverityText",
                                "type": "string"
                            }
                        ]
                    }
                },
                "dataSources": {},
                "destinations": {
                    "logAnalytics": [
                        {
                            "name": "DefaultWorkspace-westus2",
                            "workspaceResourceId": "[resourceId('Microsoft.OperationalInsights/workspaces', 'DefaultWorkspace-westus2')]",
                            "workspaceId": "[reference(resourceId('Microsoft.OperationalInsights/workspaces', 'DefaultWorkspace-westus2'))].customerId"
                        }
                    ]
                },
                "dataFlows": [
                    {
                        "streams": [
                            "Custom-OTLP"
                        ],
                        "destinations": [
                            "localDest-DefaultWorkspace-westus2"
                        ],
                        "transformKql": "source",
                        "outputStream": "Custom-OTelLogs_CL"
                    },
                    {
                        "streams": [
                            "Custom-Syslog"
                        ],
                        "destinations": [
                            "DefaultWorkspace-westus2"
                        ],
                        "transformKql": "source",
                        "outputStream": "Custom-Syslog_CL"
                    }
                ]
            }
        },
        {
            "type": "Microsoft.KubernetesConfiguration/extensions",
            "apiVersion": "2022-11-01",
            "name": "[parameters('pipelineExtensionName')]",
            "scope": "[parameters('clusterId')]",
            "tags": "[ if(contains(parameters('tagsByResource'), 'Microsoft.KubernetesConfiguration/extensions'), parameters('tagsByResource')['Microsoft.KubernetesConfiguration/extensions'], json('{}')) ]",
            "identity": {
                "type": "SystemAssigned"
            },
            "properties": {
                "aksAssignedIdentity": {
                    "type": "SystemAssigned"
                },
                "autoUpgradeMinorVersion": false,
                "extensionType": "microsoft.monitor.pipelinecontroller",
                "releaseTrain": "preview",
                "scope": {
                    "cluster": {
                        "releaseNamespace": "my-strato-ns"
                    }
                },
                "version": "0.37.3-privatepreview"
            }
        },
        {
            "type": "Microsoft.ExtendedLocation/customLocations",
            "apiVersion": "2021-08-15",
            "name": "[parameters('customLocationName')]",
            "location": "[parameters('location')]",
            "tags": "[ if(contains(parameters('tagsByResource'), 'Microsoft.ExtendedLocation/customLocations'), parameters('tagsByResource')['Microsoft.ExtendedLocation/customLocations'], json('{}')) ]",
            "dependsOn": [
                "[parameters('pipelineExtensionName')]"
            ],
            "properties": {
                "hostResourceId": "[parameters('clusterId')]",
                "namespace": "[toLower(parameters('customLocationName'))]",
                "clusterExtensionIds": "[parameters('clusterExtensionIds')]",
                "hostType": "Kubernetes"
            }
        },
        {
            "type": "Microsoft.monitor/pipelineGroups",
            "location": "[parameters('location')]",
            "apiVersion": "2023-10-01-preview",
            "name": "[parameters('pipelineGroupName')]",
            "tags": "[ if(contains(parameters('tagsByResource'), 'Microsoft.monitor/pipelineGroups'), parameters('tagsByResource')['Microsoft.monitor/pipelineGroups'], json('{}')) ]",
            "dependsOn": [
                "[parameters('customLocationName')]",
                "[resourceId('Microsoft.Insights/dataCollectionRules','Aep-mytestpl-ZZPXiU05tJ')]"
            ],
            "extendedLocation": {
                "name": "[resourceId('Microsoft.ExtendedLocation/customLocations', parameters('customLocationName'))]",
                "type": "CustomLocation"
            },
            "properties": {
                "receivers": [
                    {
                        "type": "OTLP",
                        "name": "receiver-OTLP-4317",
                        "otlp": {
                            "endpoint": "0.0.0.0:4317"
                        }
                    },
                    {
                        "type": "Syslog",
                        "name": "receiver-Syslog-514",
                        "syslog": {
                            "endpoint": "0.0.0.0:514"
                        }
                    }
                ],
                "processors": [],
                "exporters": [
                    {
                        "type": "AzureMonitorWorkspaceLogs",
                        "name": "exporter-lu7mbr90",
                        "azureMonitorWorkspaceLogs": {
                            "api": {
                                "dataCollectionEndpointUrl": "[reference(resourceId('Microsoft.Insights/dataCollectionEndpoints','Aep-mytestpl-ZZPXiU05tJ')).logsIngestion.endpoint]",
                                "stream": "Custom-DefaultAEPOTelLogs_CL-FqXSu6GfRF",
                                "dataCollectionRule": "[reference(resourceId('Microsoft.Insights/dataCollectionRules', 'Aep-mytestpl-ZZPXiU05tJ')).immutableId]",
                                "cache": {
                                    "maxStorageUsage": "[parameters('cacheMaxStorageUsage')]",
                                    "retentionPeriod": "[parameters('cacheRetentionPeriod')]"
                                },
                                "schema": {
                                    "recordMap": [
                                        {
                                            "from": "body",
                                            "to": "Body"
                                        },
                                        {
                                            "from": "severity_text",
                                            "to": "SeverityText"
                                        },
                                        {
                                            "from": "time_unix_nano",
                                            "to": "TimeGenerated"
                                        }
                                    ]
                                }
                            }
                        }
                    }
                ],
                "service": {
                    "pipelines": [
                        {
                            "name": "DefaultOTLPLogs",
                            "receivers": [
                                "receiver-OTLP"
                            ],
                            "processors": [],
                            "exporters": [
                                "exporter-lu7mbr90"
                            ]
                        }
                    ],
                    "persistence": {
                        "persistentVolume": "[parameters('cachePersistentVolume')]"
                    }
                }
            }
        }
    ],
    "outputs": {}
}

Exemple de fichier de paramètres

{
    "$schema": "https://schema.management.azure.com/schemas/2015-01-01/deploymentParameters.json#",
    "contentVersion": "1.0.0.0",
    "parameters": {
        "location": {
        "value": "eastus"
        },
        "clusterId": {
            "value": "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/my-resource-group/providers/Microsoft.Kubernetes/connectedClusters/my-arc-cluster"
        },
        "clusterExtensionIds": {
            "value": ["/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/my-resource-group/providers/Microsoft.KubernetesConfiguration/extensions/my-pipeline-extension"]
        },
        "customLocationName": {
            "value": "my-custom-location"
        },
        "dceName": {
            "value": "my-dce"
        },
        "dcrName": {
            "value": "my-dcr"
        },
        "logAnalyticsWorkspaceName": {
            "value": "my-workspace"
        },
        "pipelineExtensionName": {
            "value": "my-pipeline-extension"
        },
        "pipelineGroupName": {
            "value": "my-pipeline-group"
        },
        "tagsByResource": {
            "value": {}
        }   
    }
}

Vérifier la configuration

Vérifier les composants du pipeline en cours d’exécution dans le cluster

Dans le Portail Azure, accédez au menu Services Kubernetes et sélectionnez votre cluster Kubernetes avec Arc. Sélectionnez Services et entrées et vérifiez que vous voyez les services suivants :

<nom du pipeline>-external-service
<nom du pipeline>-service

Cliquez sur l’entrée pour <nom du pipeline>-external-service et notez l’adresse IP et le port dans la colonne Points de terminaison. Il s’agit de l’adresse IP externe et du port auxquels vos clients enverront des données.

Vérifier la pulsation

Chaque pipeline configuré dans votre instance de pipeline enverra un enregistrement de pulsation à la table Heartbeat dans votre espace de travail Log Analytics toutes les minutes. Le contenu de la colonne OSMajorVersion doit correspondre au nom de votre instance de pipeline. S’il existe plusieurs espaces de travail dans l’instance de pipeline, alors le premier configuré sera utilisé.

Récupérez les enregistrements de pulsation à l’aide d’une requête de journal comme dans l’exemple suivant :

Configuration de client

Une fois l’extension et l’instance de pipeline de périphérie installées, vous devez configurer vos clients pour qu’ils envoient des données au pipeline.

Récupérer le point de terminaison d’entrée

Chaque client a besoin de l’adresse IP externe du pipeline. Utilisez la commande suivante pour récupérer cette adresse :

kubectl get services -n <namespace where azure monitor pipeline was installed>

Si l’application produisant des journaux est externe au cluster, copiez la valeur external-ip du service nginx-controller-service avec le type d’équilibreur de charge. Si l’application se trouve sur un pod au sein du cluster, copiez la valeur cluster-ip. Si le champ external-ip est défini sur en attente, vous devrez configurer une adresse IP externe pour cette entrée manuellement, en fonction de la configuration de votre cluster.

Client	Description
syslog	Mettre à jour les clients Syslog pour qu’ils envoient des données au point de terminaison du pipeline et au port de votre flux de données Syslog.
OTLP	Le pipeline de périphérie Azure Monitor expose un point de terminaison OTLP basé sur gRPC sur le port 4317. La configuration de votre instrumentation pour envoyer vers ce point de terminaison OTLP dépendra de la bibliothèque d’instrumentation elle-même. Consultez Point de terminaison OTLP ou Collecteur pour la documentation OpenTelemetry. La méthode de variable d’environnement est documentée à l’adresse Configuration de l’exportateur OTLP.

Client

Description

syslog

Mettre à jour les clients Syslog pour qu’ils envoient des données au point de terminaison du pipeline et au port de votre flux de données Syslog.

OTLP

Le pipeline de périphérie Azure Monitor expose un point de terminaison OTLP basé sur gRPC sur le port 4317. La configuration de votre instrumentation pour envoyer vers ce point de terminaison OTLP dépendra de la bibliothèque d’instrumentation elle-même. Consultez Point de terminaison OTLP ou Collecteur pour la documentation OpenTelemetry. La méthode de variable d’environnement est documentée à l’adresse Configuration de l’exportateur OTLP.

Vérifier les données

La dernière étape consiste à vérifier que les données sont reçues dans l’espace de travail Log Analytics. Vous pouvez effectuer cette vérification en exécutant une requête dans l’espace de travail Log Analytics pour récupérer des données de la table.

Étapes suivantes

En savoir plus sur les pipelines Azure Monitor.

Partage via