Configuração do pipeline do Azure Monitor no edge

2025-05-21

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 de ponta permite coleta em larga 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 ativar e configurar o pipeline na periferia do seu ambiente.

Visão geral

O pipeline do Azure Monitor na periferia é uma solução contentorizada que é implantada em um cluster Kubernetes habilitado para Arc e utiliza o OpenTelemetry Collector como base. O diagrama a seguir mostra os componentes do pipeline na extremidade. 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 ficheiro de configuração do pipeline define os fluxos de dados e as propriedades de cache para o pipeline na periferia. 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.

Observação

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 ativar o pipeline do Azure Monitor na Edge. Se utilizar o portal do Azure para configurar o pipeline na periferia, então cada um desses componentes será criado para si. Com outros métodos, você precisa configurar cada um.

Componente	Descrição
Extensão do controlador de pipeline de borda	Extensão adicionada ao cluster Kubernetes com Arc para suportar a funcionalidade de pipeline - `microsoft.monitor.pipelinecontroller`.
Instância do controlador de pipeline de borda	Instância do pipeline edge em execução no cluster Kubernetes com Arc habilitado.
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 recolha de dados (DCE)	Endpoint 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	Descrição
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
Motor Kubernetes Rancher
VMware Tanzu Kubernetes Grid

Localizações suportadas

O pipeline do Azure Monitor no edge é suportado nas seguintes regiões do Azure:

Canadá Central
Leste dos EUA2
Itália Norte
Oeste dos EUA2
Europa Ocidental

Para obter mais informações, consulte Disponibilidade do produto por região

Pré-requisitos

Cluster Kubernetes habilitado para Arc no 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 gerir locais personalizados no Kubernetes habilitado no Azure Arc.
O espaço de trabalho do Log Analytics no Azure Monitor para receber os dados do pipeline na extremidade. 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 recolha de dados através do pipeline na extremidade e a sua transferência 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 da canalização 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.
3ª.	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 vindos do pipeline na extremidade.
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 fluxo de dados na nuvem envia os dados ao 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. A canalização na borda da rede pode ser usada para coletar dados desses segmentos de rede e enviá-los para a canalização de nuvem computacional.

Para utilizar o pipeline do Azure Monitor numa configuração de rede em camadas, precisa de adicionar as seguintes entradas à lista de autorização para o cluster Kubernetes com Arc ativado. 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 recolha de dados para o pipeline na periferia, precisa de 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 pode ser necessário 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 a implantação da extensão e da instância de pipeline no cluster.

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

Propriedade	Descrição
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 uma instância de pipeline.
Nome do cluster	Selecione o seu cluster Kubernetes, habilitado para Arc, em que o pipeline será instalado.
Localização personalizada	Local personalizado para o seu cluster Kubernetes ativado pelo 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 Dataflow permite criar e editar fluxos de dados para a instância da pipeline. Cada fluxo de dados inclui os seguintes detalhes:

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

Propriedade	Descrição
Nome	Nome para o fluxo de dados. Deve ser exclusivo para este pipeline.
Tipo de fonte	O tipo de dados que estão a ser recolhidos. Os seguintes tipos de fonte são suportados atualmente: - Syslog - OTLP
Porto	Porta em que o pipeline escuta por onde recebe dados. Se dois fluxos de dados usarem a mesma porta, ambos receberão e processarão os dados.
Espaço 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 no edge usando Azure CLI.

Extensão do pipeline de periferia

O comando a seguir adiciona a extensão de edge pipeline ao cluster Kubernetes com suporte 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 seguinte modelo ARM cria a localização personalizada para o 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/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourceGroups/my-resource-group/providers/Microsoft.Kubernetes/connectedClusters/my-cluster --cluster-extension-ids /subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/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 assim que forem recebidos do pipeline no edge. O pipeline na configuração de periferia especifica o immutable ID do DCR e o stream no DCR que irá 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	Descrição
`name`	Nome do DCR. Deve ser exclusivo para a assinatura.
`location`	Localização do DCR. Deve coincidir com a 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 para o destino a ser referenciado na seção `dataFlows`. 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, as tabelas internas não são suportadas com pipeline na borda.

{
    "properties": {
        "dataCollectionEndpointId": "/subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/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/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourceGroups/my-resource-group/providers/Microsoft.OperationalInsights/workspaces/my-workspace",
                }
            ]
        },
        "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 a DCR

O cluster Kubernetes habilitado pela Arc deve ter acesso ao DCR para enviar dados para o pipeline na 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/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/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.

Propriedade	Descrição
Geral
`name`	Nome da instância do pipeline. Deve ser único 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 em que o recetor está a escutar. Use `0.0.0.0` para todos os endereços.
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 no edge enviará os dados. Você pode localizá-lo no portal do Azure navegando até o DCE e copiando 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. Recomenda-se apenas uma instância para cada extensão de pipeline.
Tubulações	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 receber dados.
`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/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/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 no limite usando o modelo ARM único 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	Descrição
Á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 recolha 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 periferia	`Microsoft.KubernetesConfiguration/extensions`	O único parâmetro necessário é o nome da extensão do pipeline.
Localização personalizada	`Microsoft.ExtendedLocation/customLocations`	Localização personalizada do cluster Kubernetes habilitado para Arc para criar o cluster customizado.
Instância do pipeline de borda	`Microsoft.monitor/pipelineGroups`	Instância de pipeline local que inclui a configuração do listener, 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/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourceGroups/my-resource-group/providers/Microsoft.Kubernetes/connectedClusters/my-arc-cluster"
        },
        "clusterExtensionIds": {
            "value": ["/subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/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 configuração

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 fluxo>-serviço externo
<nome do serviço>-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. Verifique Recuperar endpoint de ingresso 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 OSMajorVersion deve corresponder ao nome da sua instância de 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 a aplicação estiver num pod dentro do cluster, copie o valor cluster-ip.