Configuração do pipeline do Azure Monitor no edge

Artigo
11/05/2024

O pipeline do Azure Monitor é um pipeline de ingestão de dados que fornece coleta de dados consistente e centralizada para o Azure Monitor. O pipeline na borda permite a coleta em escala e o roteamento de dados de telemetria antes de serem enviados para a nuvem. Ele pode armazenar dados em cache localmente e sincronizar com a nuvem quando a conectividade é restaurada e rotear a telemetria para o Azure Monitor nos casos em que a rede é segmentada e os dados não podem ser enviados diretamente para a nuvem. Este artigo descreve como habilitar e configurar o pipeline na borda em seu ambiente.

Descrição geral

O pipeline do Azure Monitor na borda é uma solução conteinerizada que é implantada em um cluster Kubernetes habilitado para Arc e aproveita o OpenTelemetry Collector como base. O diagrama a seguir mostra os componentes do pipeline na borda. Um ou mais fluxos de dados escutam os dados recebidos dos clientes, e a extensão do pipeline encaminha os dados para a nuvem, usando o cache local, se necessário.

O arquivo de configuração do pipeline define os fluxos de dados e as propriedades de cache para o pipeline na borda. O DCR define o esquema dos dados que estão sendo enviados para o pipeline de nuvem, uma transformação para filtrar ou modificar os dados e o destino para onde os dados devem ser enviados. Cada definição de fluxo de dados para a configuração do pipeline especifica o DCR e o fluxo dentro desse DCR que processará esses dados no pipeline de nuvem.

Nota

A ligação privada é suportada pelo pipeline no edge para a ligação ao pipeline da cloud.

Os seguintes componentes e configurações são necessários para habilitar o pipeline do Azure Monitor na borda. Se você usar o portal do Azure para configurar o pipeline na borda, cada um desses componentes será criado para você. Com outros métodos, você precisa configurar cada um.

Componente	Description
Extensão do controlador de pipeline de borda	Extensão adicionada ao cluster Kubernetes habilitado para Arc para suportar a funcionalidade de pipeline - `microsoft.monitor.pipelinecontroller`.
Instância do controlador de pipeline de borda	Instância do pipeline de borda em execução no cluster Kubernetes habilitado para Arc.
Fluxo de dados	Combinação de recetores e exportadores que são executados na instância do controlador de pipeline. Os destinatários aceitam dados de clientes e exportadores para entregar esses dados ao Azure Monitor.
Configuração do pipeline	Arquivo de configuração que define os fluxos de dados para a instância do pipeline. Cada fluxo de dados inclui um recetor e um exportador. O recetor escuta os dados recebidos e o exportador envia os dados para o destino.
Ponto de extremidade de coleta de dados (DCE)	Ponto de extremidade onde os dados são enviados para o pipeline do Azure Monitor. A configuração do pipeline inclui uma propriedade para a URL do DCE para que a instância do pipeline saiba para onde enviar os dados.

Configuração	Description
Regra de recolha de dados (DCR)	Arquivo de configuração que define como os dados são recebidos no pipeline de nuvem e para onde são enviados. O DCR também pode incluir uma transformação para filtrar ou modificar os dados antes de serem enviados para o destino.
Configuração do pipeline	Configuração que define os fluxos de dados para a instância do pipeline, incluindo os fluxos de dados e o cache.

Configurações suportadas

Distribuições suportadas
O pipeline do Azure Monitor no edge é suportado nas seguintes distribuições do Kubernetes:

Canónico
Fornecedor da API do Cluster para o Azure
K3
Rancher Kubernetes Engine
VMware Tanzu Kubernetes Grid

Localizações suportadas
O pipeline do Azure Monitor na borda é suportado nas seguintes regiões do Azure:

E.U.A. Leste 2
E.U.A. Oeste 2
Europa Ocidental

Pré-requisitos

Cluster Kubernetes habilitado para Arc em seu próprio ambiente com um endereço IP externo. Consulte Conectar um cluster Kubernetes existente ao Azure Arc para obter detalhes sobre como habilitar o Arc para um cluster.
O cluster Kubernetes habilitado para Arc deve ter os recursos de locais personalizados habilitados. Consulte Criar e gerenciar locais personalizados no Kubernetes habilitado para Azure Arc.
Espaço de trabalho do Log Analytics no Azure Monitor para receber os dados do pipeline na borda. Consulte Criar um espaço de trabalho do Log Analytics no portal do Azure para obter detalhes sobre como criar um espaço de trabalho.
Os seguintes provedores de recursos devem ser registrados em sua assinatura do Azure. Veja Fornecedores e tipos de recursos do Azure.
- Microsoft.Insights
- Microsoft.Monitor

Fluxo de Trabalho

Você não precisa de uma compreensão detalhada das diferentes etapas executadas pelo pipeline do Azure Monitor para configurá-lo usando o portal do Azure. Você pode precisar de uma compreensão mais detalhada se você usar outro método de instalação ou se precisar executar uma configuração mais avançada, como transformar os dados antes que eles sejam armazenados em seu destino.

As tabelas e diagramas a seguir descrevem as etapas e os componentes detalhados no processo de coleta de dados usando o pipeline na borda e passando-os para o pipeline de nuvem para armazenamento no Azure Monitor. Também está incluída nas tabelas a configuração necessária para cada um desses componentes.

Passo	Ação	Configuração de suporte
1.	O cliente envia dados para o recetor de pipeline de borda.	O cliente é configurado com IP e porta do recetor de pipeline de borda e envia dados no formato esperado para o tipo de recetor.
2.	O recetor encaminha os dados para o exportador.	Recetor e exportador são configurados no mesmo pipeline.
3.	O exportador tenta enviar os dados para o pipeline de nuvem.	O exportador na configuração do pipeline inclui a URL do DCE, um identificador exclusivo para o DCR e o fluxo no DCR que define como os dados serão processados.
3a.	O exportador armazena dados no cache local se não puder se conectar ao DCE.	O volume persistente para o cache e a configuração do cache local está habilitado na configuração do pipeline.

Passo	Ação	Configuração de suporte
4.	O pipeline de nuvem aceita os dados recebidos.	O DCR inclui uma definição de esquema para o fluxo de entrada que deve corresponder ao esquema dos dados provenientes do pipeline na borda.
5.	O pipeline de nuvem aplica uma transformação aos dados.	O DCR inclui uma transformação que filtra ou modifica os dados antes de serem enviados para o destino. A transformação pode filtrar dados, remover ou adicionar colunas ou alterar completamente seu esquema. A saída da transformação deve corresponder ao esquema da tabela de destino.
6.	O pipeline de nuvem envia os dados para o destino.	O DCR inclui um destino que especifica o espaço de trabalho do Log Analytics e a tabela onde os dados serão armazenados.

Rede segmentada

A segmentação de rede é um modelo em que você usa perímetros definidos por software para criar uma postura de segurança diferente para diferentes partes da sua rede. Neste modelo, você pode ter um segmento de rede que não pode se conectar à internet ou a outros segmentos de rede. O pipeline na borda pode ser usado para coletar dados desses segmentos de rede e enviá-los para o pipeline de nuvem.

Para usar o pipeline do Azure Monitor em uma configuração de rede em camadas, você deve adicionar as seguintes entradas à lista de permissões para o cluster Kubernetes habilitado para Arc. Consulte Configurar o Azure IoT Layered Network Management Preview no cluster de nível 4.

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

Criar tabela no espaço de trabalho do Log Analytics

Antes de configurar o processo de coleta de dados para o pipeline na borda, você precisa criar uma tabela no espaço de trabalho do Log Analytics para receber os dados. Esta deve ser uma tabela personalizada, uma vez que as tabelas internas não são suportadas no momento. O esquema da tabela deve corresponder aos dados que recebe, mas há várias etapas no processo de coleta em que você pode modificar os dados de entrada, para que o esquema da tabela não precise corresponder aos dados de origem que você está coletando. O único requisito para a tabela no espaço de trabalho do Log Analytics é que ela tenha uma TimeGenerated coluna.

Consulte Adicionar ou excluir tabelas e colunas nos Logs do Azure Monitor para obter detalhes sobre diferentes métodos para criar uma tabela. Por exemplo, use o comando CLI abaixo para criar uma tabela com as três colunas chamadas Body, TimeGeneratede 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

Ativar cache

Dispositivos de borda em alguns ambientes podem experimentar conectividade intermitente devido a vários fatores, como congestionamento de rede, interferência de sinal, falta de energia ou mobilidade. Nesses ambientes, você pode configurar o pipeline na borda para armazenar dados em cache criando um volume persistente no cluster. O processo para isso variará com base em seu ambiente específico, mas a configuração deve atender aos seguintes requisitos:

O namespace de metadados deve ser o mesmo que a instância especificada do pipeline do Azure Monitor.
O modo de acesso deve suportar ReadWriteMany.

Depois que o volume for criado no namespace apropriado, configure-o usando parâmetros no arquivo de configuração de pipeline abaixo.

Atenção

Cada réplica do pipeline de borda armazena dados em um local no volume persistente específico dessa réplica. Diminuir o número de réplicas enquanto o cluster está desconectado da nuvem impedirá que os dados sejam preenchidos quando a conectividade for restaurada.

Os dados são recuperados do cache usando FIFO (first-in-first-out). Quaisquer dados com mais de 48 horas serão descartados.

Habilitar e configurar pipeline

As opções atuais para ativação e configuração são detalhadas nas guias abaixo.

Configurar pipeline usando o portal do Azure

Quando você usa o portal do Azure para habilitar e configurar o pipeline, todos os componentes necessários são criados com base em suas seleções. Isso evita a complexidade de criar cada componente individualmente, mas você fez a necessidade de usar outros métodos para

Execute um dos seguintes procedimentos no portal do Azure para iniciar o processo de instalação do pipeline do Azure Monitor:

No menu Pipelines do Azure Monitor (visualização), clique em Criar.
No menu do cluster Kubernetes habilitado para Arc, selecione Extensões e adicione a extensão de pipeline (visualização) do Azure Monitor.

A guia Básico solicita as seguintes informações para implantar a extensão e a instância de pipeline em seu cluster.

As configurações nesta guia são descritas na tabela a seguir.

Property	Description
Nome da instância	Nome para a instância de pipeline do Azure Monitor. Deve ser exclusivo para a assinatura.
Subscrição	Assinatura do Azure para criar a instância de pipeline.
Grupo de recursos	Grupo de recursos para criar a instância de pipeline.
Nome do cluster	Selecione seu cluster Kubernetes habilitado para Arc no qual o pipeline será instalado.
Localização personalizada	Local personalizado para seu cluster Kubernetes habilitado para Arc. Isso será preenchido automaticamente com o nome de um local personalizado que será criado para seu cluster ou você pode selecionar outro local personalizado no cluster.

A guia Fluxo de dados permite criar e editar fluxos de dados para a instância do pipeline. Cada fluxo de dados inclui os seguintes detalhes:

As configurações nesta guia são descritas na tabela a seguir.

Property	Descrição
Name	Nome para o fluxo de dados. Deve ser exclusivo para este pipeline.
Source type	O tipo de dados que estão a ser recolhidos. Os seguintes tipos de fonte são suportados atualmente: - Syslog - OTLP
Porta	Porta que o pipeline escuta para obter dados de entrada. Se dois fluxos de dados usarem a mesma porta, ambos receberão e processarão os dados.
Área de trabalho do Log Analytics	Espaço de trabalho do Log Analytics para o qual enviar os dados.
Nome da Tabela	O nome da tabela no espaço de trabalho do Log Analytics para o qual enviar os dados.

Configurar pipeline usando a CLI do Azure

A seguir estão as etapas necessárias para criar e configurar os componentes necessários para o pipeline do Azure Monitor na borda usando a CLI do Azure.

Extensão do pipeline de borda

O comando a seguir adiciona a extensão de pipeline de borda ao cluster Kubernetes habilitado para 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

Localização personalizada

O modelo ARM a seguir cria o local personalizado para seu cluster Kubernetes habilitado para 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

O modelo ARM a seguir cria o ponto de extremidade de coleta de dados (DCE) necessário para que o pipeline na borda se conecte ao pipeline de nuvem. Você pode usar um DCE existente se já tiver um na mesma região. Substitua as propriedades na tabela a seguir antes de implantar o modelo.

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

O DCR é armazenado no Azure Monitor e define como os dados serão processados quando forem recebidos do pipeline na borda. O pipeline na configuração de borda especifica o immutable ID do DCR e o stream no DCR que processará os dados. O immutable ID é gerado automaticamente quando o DCR é criado.

Substitua as propriedades no modelo a seguir e salve-as em um arquivo json antes de executar o comando CLI para criar o DCR. Consulte Estrutura de uma regra de coleta de dados no Azure Monitor para obter detalhes sobre a estrutura de um DCR.

Parâmetro	Description
`name`	Nome do DCR. Deve ser exclusivo para a assinatura.
`location`	Localização do DCR. Deve corresponder à localização do DCE.
`dataCollectionEndpointId`	ID do recurso do DCE.
`streamDeclarations`	Esquema dos dados que estão sendo recebidos. É necessário um fluxo para cada fluxo de dados na configuração do pipeline. O nome deve ser exclusivo no DCR e deve começar com Custom-. As `column` seções nos exemplos abaixo devem ser usadas para os fluxos de dados OLTP e Syslog. Se o esquema da tabela de destino for diferente, você poderá modificá-lo usando uma transformação definida no `transformKql` parâmetro.
`destinations`	Adicione uma seção adicional para enviar dados para vários espaços de trabalho.
- `name`	Nome do destino a ser referenciado `dataFlows` na seção. Deve ser exclusivo para o DCR.
- `workspaceResourceId`	ID do recurso do espaço de trabalho do Log Analytics.
- `workspaceId`	ID do espaço de trabalho do Log Analytics.
`dataFlows`	Corresponde a fluxos e destinos. Uma entrada para cada combinação fluxo/destino.
- `streams`	Um ou mais fluxos (definidos em `streamDeclarations`). Você pode incluir vários fluxos se eles estiverem sendo enviados para o mesmo destino.
- `destinations`	Um ou mais destinos (definidos em `destinations`). Você pode incluir vários destinos se eles estiverem sendo enviados para o mesmo destino.
- `transformKql`	Transformação para aplicar aos dados antes de enviá-los para o destino. Use `source` para enviar os dados sem alterações. A saída da transformação deve corresponder ao esquema da tabela de destino. Consulte Transformações de coleta de dados no Azure Monitor para obter detalhes sobre transformações.
- `outputStream`	Especifica a tabela de destino no espaço de trabalho do Log Analytics. A tabela já deve existir no espaço de trabalho. Para tabelas personalizadas, prefixe o nome da tabela com Custom-. Atualmente, não há suporte para tabelas internas com pipeline na borda.

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

Instale o DCR usando o seguinte comando:

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'

Acesso DCR

O cluster Kubernetes habilitado para Arc deve ter acesso ao DCR para enviar dados para o pipeline de nuvem. Use o comando a seguir para recuperar a ID do objeto da Identidade Atribuída ao Sistema para seu 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

Use a saída desse comando como entrada para o comando a seguir para dar ao pipeline do Azure Monitor a autoridade para enviar sua telemetria para o 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"

Configuração do pipeline de borda

A configuração do pipeline de borda define os detalhes do pipeline na instância de borda e implanta os fluxos de dados necessários para receber e enviar telemetria para a nuvem.

Substitua as propriedades na tabela a seguir antes de implantar o modelo.

Property	Descrição
General (Geral)
`name`	Nome da instância do pipeline. Deve ser exclusivo na assinatura.
`location`	Localização da instância do pipeline.
`extendedLocation`
Recetores	Uma entrada para cada recetor. Cada entrada especifica o tipo de dados que estão sendo recebidos, a porta em que ele escutará e um nome exclusivo que será usado na `pipelines` seção da configuração.
`type`	Tipo de dados recebidos. As opções atuais são `OTLP` e `Syslog`.
`name`	Nome do recetor mencionado na `service` secção. Deve ser exclusivo para a instância do pipeline.
`endpoint`	Endereço e porta que o recetor escuta. Use `0.0.0.0` para endereços al.
Processadores	Reservado para uso futuro.
Exportadores	Uma entrada para cada destino.
`type`	Apenas o tipo suportado atualmente é `AzureMonitorWorkspaceLogs`.
`name`	Deve ser exclusivo para a instância do pipeline. O nome é usado na `pipelines` seção da configuração.
`dataCollectionEndpointUrl`	URL do DCE para onde o pipeline na borda enviará os dados. Você pode localizá-lo no portal do Azure navegando até o DCE e copiando o valor de Ingestão de Logs.
`dataCollectionRule`	ID imutável do DCR que define a coleta de dados no pipeline de nuvem. Na vista JSON do seu DCR no portal do Azure, copie o valor do ID imutável na secção Geral .
- `stream`	Nome do fluxo em seu DCR que aceitará os dados.
- `maxStorageUsage`	Capacidade do cache. Quando 80% dessa capacidade é atingida, os dados mais antigos são removidos para abrir espaço para mais dados.
- `retentionPeriod`	Período de retenção em minutos. Os dados são removidos após esse período de tempo.
- `schema`	Esquema dos dados que estão sendo enviados para o pipeline de nuvem. Isso deve corresponder ao esquema definido no fluxo no DCR. O esquema usado no exemplo é válido para Syslog e OTLP.
Serviço	Uma entrada para cada instância de pipeline. Apenas uma instância para cada extensão de pipeline é recomendada.
Pipelines	Uma entrada para cada fluxo de dados. Cada entrada corresponde a um `receiver` com um `exporter`.
`name`	Nome exclusivo do pipeline.
`receivers`	Um ou mais recetores para ouvir os dados para receber.
`processors`	Reservado para uso futuro.
`exporters`	Um ou mais exportadores para enviar os dados para o pipeline de nuvem.
`persistence`	Nome do volume persistente usado para o cache. Remova esse parâmetro se não quiser habilitar o cache.

{
    "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
    "contentVersion": "1.0.0.0",
    "metadata": {
        "description": "This template deploys an edge pipeline for azure monitor."
    },
    "resources": [
        {
            "type": "Microsoft.monitor/pipelineGroups",
            "location": "eastus",
            "apiVersion": "2023-10-01-preview",
            "name": "my-pipeline-group-name",
            "extendedLocation": {
                "name": "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/my-resource-group/providers/Microsoft.ExtendedLocation/customLocations/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",
                                "schema": {
                                    "recordMap": [
                                        {
                                            "from": "body",
                                            "to": "Body"
                                        },
                                        {
                                            "from": "severity_text",
                                            "to": "SeverityText"
                                        },
                                        {
                                            "from": "time_unix_nano",
                                            "to": "TimeGenerated"
                                        }
                                    ]
                                }
                            },
                            "cache": {
                                "maxStorageUsage": 10000,
                                "retentionPeriod": 60
                            }
                        }
                    }
                ],
                "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": {
                        "persistentVolumeName": "my-persistent-volume"
                    }
                },
                "networkingConfigurations": [
                    {
                        "externalNetworkingMode": "LoadBalancerOnly",
                        "routes": [
                            {
                                "receiver": "receiver-OTLP"
                            },
                            {
                                "receiver": "receiver-Syslog"
                            }
                        ]
                    }
                ]
            }
        }
    ]
}

Instale o modelo usando o seguinte comando:

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

Exemplo de modelo ARM para configurar todos os componentes

Você pode implantar todos os componentes necessários para o pipeline do Azure Monitor na borda usando o único modelo ARM mostrado abaixo. Edite o arquivo de parâmetros com valores específicos para seu ambiente. Cada seção do modelo é descrita abaixo, incluindo seções que você deve modificar antes de usá-lo.

Componente	Tipo	Description
Área de trabalho do Log Analytics	`Microsoft.OperationalInsights/workspaces`	Remova esta seção se estiver usando um espaço de trabalho existente do Log Analytics. O único parâmetro necessário é o nome do espaço de trabalho. A ID imutável para o espaço de trabalho, que é necessária para outros componentes, será criada automaticamente.
Ponto de extremidade de coleta de dados (DCE)	`Microsoft.Insights/dataCollectionEndpoints`	Remova esta seção se estiver usando um DCE existente. O único parâmetro necessário é o nome DCE. O URL de ingestão de logs para o DCE, que é necessário para outros componentes, será criado automaticamente.
Extensão do pipeline de borda	`Microsoft.KubernetesConfiguration/extensions`	O único parâmetro necessário é o nome da extensão do pipeline.
Localização personalizada	`Microsoft.ExtendedLocation/customLocations`	Local personalizado do cluster Kubernetes habilitado para Arc para criar o cluster personalizado
Instância do pipeline de borda	`Microsoft.monitor/pipelineGroups`	Instância de pipeline de borda que inclui a configuração do ouvinte, exportadores e fluxos de dados. Você deve modificar as propriedades da instância de pipeline antes de implantar o modelo.
Regra de recolha de dados (DCR)	`Microsoft.Insights/dataCollectionRules`	O único parâmetro necessário é o nome DCR, mas você deve modificar as propriedades do DCR antes de implantar o modelo.

Arquivo de modelo

{
    "$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": {}
}

Arquivo de parâmetro de exemplo

{
    "$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": {}
        }   
    }
}

Verificar a configuração da regra

Verificar os componentes do pipeline em execução no cluster

No portal do Azure, navegue até o menu de serviços do Kubernetes e selecione seu cluster Kubernetes habilitado para Arc. Selecione Serviços e entradas e certifique-se de ver os seguintes serviços:

<nome> do pipeline-external-service
<serviço de nome> de pipeline

Clique na entrada para pipeline name-external-service> e anote o endereço IP e a porta na coluna Endpoints.< Este é o endereço IP externo e a porta para a qual seus clientes enviarão dados. Consulte Recuperar ponto de extremidade de entrada para recuperar esse endereço do cliente.

Verificar o batimento cardíaco

Cada pipeline configurado em sua instância de pipeline enviará um registro de pulsação para a Heartbeat tabela no espaço de trabalho do Log Analytics a cada minuto. O conteúdo da coluna deve corresponder ao nome da instância do OSMajorVersion pipeline. Se houver vários espaços de trabalho na instância do pipeline, o primeiro configurado será usado.

Recupere os registros de pulsação usando uma consulta de log como no exemplo a seguir:

Configuração do cliente

Depois que a extensão e a instância do pipeline de borda estiverem instaladas, você precisará configurar seus clientes para enviar dados para o pipeline.

Recuperar ponto de extremidade de entrada

Cada cliente requer o endereço IP externo do serviço de pipeline do Azure Monitor. Utilize o seguinte comando para obter este endereço:

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

Se o aplicativo que produz logs for externo ao cluster, copie o valor external-ip do pipeline ><name-service ou <pipeline name-external-service> com o tipo de balanceador de carga.
Se o aplicativo estiver em um pod dentro do cluster, copie o valor cluster-ip .