Configuração do pipeline do Azure Monitor na borda

Artigo
11/05/2024

O pipeline do Azure Monitor é um pipeline de ingestão de dados que fornece uma coleta de dados consistente e centralizada para o Azure Monitor. O pipeline na borda habilita a coleta em escala e o roteamento dos dados telemétricos antes de serem enviados para a nuvem. Pode armazenar dados em cache localmente e sincronizar com a nuvem quando a conectividade for restaurada, além de 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 no seu ambiente.

Visão geral

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

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

Observação

O link privado é compatível com o pipeline na borda para a conexão com o pipeline de nuvem.

Os componentes e as configurações a seguir são necessários para habilitar o pipeline na borda do Azure Monitor. 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ê precisará configurar cada um deles.

Componente	Descrição
Extensão do controlador de pipeline de borda	Extensão adicionada ao cluster do Kubernetes habilitado para Arc para dar suporte à funcionalidade de pipeline – `microsoft.monitor.pipelinecontroller`.
Instância do controlador de pipeline de borda	Instância de pipeline de borda em execução no cluster do Kubernetes habilitado para Arc.
Fluxo de dados	Combinação de receptores e exportadores executados na instância do controlador de pipeline. Os receptores 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 de pipeline. Cada fluxo de dados inclui um receptor e um exportador. O receptor escuta os dados de entrada e o exportador envia os dados para o destino.
Ponto de extremidade de coleta de dados (DCE)	Ponto de extremidade em que 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 de pipeline saiba para onde enviar os dados.

Configuração	Descrição
DCR (regra de coleta de dados)	Arquivo de configuração que define como os dados serão recebidos no pipeline de nuvem e para onde serã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 de pipeline, incluindo os fluxos de dados e o cache.

Configurações com suporte

Distribuições com suporte
Há suporte para o pipeline na borda do Azure Monitor nas seguintes distribuições do Kubernetes:

Canônico
Provedor de API de Cluster do Azure
K3
Mecanismo Kubernetes do Rancher
Grade Kubernetes do VMware Tanzu

Locais com suporte
Há suporte para o pipeline na borda do Azure Monitor nas seguintes regiões do Azure:

Leste dos EUA 2
Oeste dos EUA 2
Europa Ocidental

Pré-requisitos

Cluster do Kubernetes habilitado para Arc no seu próprio ambiente com um endereço IP externo. Confira Conectar um cluster do Kubernetes existente ao Azure Arc para obter detalhes sobre como habilitar o Arc para um cluster.
O cluster do Kubernetes habilitado para Arc deve habilitar os recursos de locais personalizados. Confira Criar e gerenciar locais personalizados no Kubernetes habilitado para Azure Arc.
Workspace do Log Analytics no Azure Monitor para receber os dados do pipeline na borda. Confira Criar um workspace do Log Analytics no portal do Azure para obter detalhes sobre como criar um workspace.
Os seguintes provedores de recursos devem estar registrados na sua assinatura do Azure. Consulte Provedores e tipos de recursos do Azure.
- Microsoft.insights
- Microsoft.Monitor

Workflow

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. Talvez você precise de uma compreensão mais detalhada dele, se 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 no destino.

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

Etapa	Ação	Configuração de suporte
1.	O cliente envia os dados para o receptor de pipeline de borda.	O cliente é configurado com o IP e a porta do receptor de pipeline de borda e envia os dados no formato esperado para o tipo de receptor.
2.	O receptor encaminha os dados para o exportador.	O receptor e o exportador são configurados no mesmo pipeline.
3.	O exportador tenta enviar os dados para o pipeline de nuvem.	O exportador na configuração de 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 armazenará os dados no cache local, se não puder se conectar ao DCE.	Volume persistente para o cache e a configuração do cache local está habilitada na configuração do pipeline.

Etapa	Ação	Configuração de suporte
4.	O pipeline de nuvem aceita os dados de entrada.	A 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 o 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 workspace e a tabela do Log Analytics em que os dados serão armazenados.

Rede segmentada

A segmentação de rede é um modelo em que você usa os perímetros definidos pelo software para criar uma postura de segurança diferente para diferentes partes da rede. Nesse 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 do Kubernetes habilitado para Arc. Confira Configurar a Versão Prévia do Gerenciamento de Rede em Camadas de IoT do Azure no cluster de nível 4

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

Criar tabela no workspace do Log Analytics

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

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

Habilitar cache

Os dispositivos de borda em alguns ambientes podem experimentar conectividade intermitente devido a vários fatores, como congestionamento de rede, interferência de sinal, interrupção de energia ou mobilidade. Nesses ambientes, você pode configurar o pipeline na borda para armazenar dados em cache criando um volume persistente no seu cluster. Esse processo variará de acordo com o 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 dar suporte ao ReadWriteMany.

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

Cuidado

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

Os dados são recuperados do cache usando FIFO (primeiro a entrar, primeiro a sair). Todos os dados com mais de 48 horas serão descartados.

Habilitar e configurar o pipeline

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

Configurar o 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 de acordo com suas seleções. Isso elimina complexidade de criar cada componente individualmente, mas talvez você precise usar outros métodos

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 (versão prévia), clique em Criar.
No menu do cluster do Kubernetes habilitado para Arc, selecione Extensões e adicione a extensão de pipeline do Azure Monitor (versão prévia).

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

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

Propriedade	Descrição
Nome da instância	Nome da instância de pipeline do Azure Monitor. Deve ser exclusivo para a assinatura.
Assinatura	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 o cluster do Kubernetes habilitado para Arc no qual o pipeline será instalado.
Local Personalizado	Local personalizado para o cluster do Kubernetes habilitado para Arc. Será preenchido automaticamente com o nome de um local personalizado que será criado para o cluster ou você poderá selecionar outro local personalizado no cluster.

A guia Fluxo de Dados permite que você crie e edite fluxos de dados para a instância de 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 do fluxo de dados. Deve ser exclusivo para este pipeline.
Tipo de origem	O tipo de dados que está sendo coletado. No momento, há suporte para os seguintes tipos de recurso: - Syslog - OTLP
Porta	Porta que o pipeline escuta para os dados de entrada. Se dois fluxos de dados usarem a mesma porta, eles receberão e processarão os dados.
Workspace do Log Analytics	Workspace do Log Analytics para o qual os dados devem ser enviados.
Nome da Tabela	O nome da tabela no workspace do Log Analytics para o qual os dados devem ser enviados.

Configurar o pipeline usando a CLI do Azure

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

Extensão de pipeline de borda

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

Local personalizado

O modelo do ARM a seguir cria o local personalizado para o cluster do 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 do ARM a seguir cria o DCE (ponto de extremidade de coleta de dados) 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

A DCR é armazenada no Azure Monitor e define como os dados serão processados quando forem enviados pelo pipeline na borda. A configuração do pipeline na borda especifica o immutable ID da DCR e o stream na 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 da CLI para criar o DCR. Confira 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`	Local do DCR. Deve corresponder ao local do DCE.
`dataCollectionEndpointId`	ID do recurso do DCE.
`streamDeclarations`	Esquema dos dados recebidos. Um fluxo é necessário para cada fluxo de dados na configuração do pipeline. O nome deve ser exclusivo no DCR e deve começar com Custom-. As seções `column` 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 parâmetro `transformKql`.
`destinations`	Adicione outra seção para enviar dados a vários workspaces.
- `name`	Nome do destino a ser referenciado na seção `dataFlows`. Deve ser exclusivo para o DCR.
- `workspaceResourceId`	A ID do recurso do workspace do Log Analytics.
- `workspaceId`	A ID do workspace do Log Analytics.
`dataFlows`	Corresponde a fluxos e destinos. Uma entrada para cada combinação de 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 a ser aplicada 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. Confira Transformações de coleta de dados no Azure Monitor para obter detalhes sobre as transformações.
- `outputStream`	Especifica a tabela de destino no workspace do Log Analytics. A tabela já deve existir no workspace. Para tabelas personalizadas, crie o nome da tabela com o prefixo Custom-. No momento, 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 ao DCR

O cluster do 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 pelo Sistema para o 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 a 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 na borda define os detalhes da instância de pipeline na borda e implanta os fluxos de dados necessários para receber e enviar a telemetria para a nuvem.

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

Propriedade	Description
Geral
`name`	Nome da instância de pipeline. Deve ser exclusivo na assinatura.
`location`	Local da instância de pipeline.
`extendedLocation`
Receptores	Uma entrada para cada receptor. Cada entrada especifica o tipo de dados que está sendo recebido, a porta em que ele escutará e um nome exclusivo que será usado na seção `pipelines` da configuração.
`type`	Tipo de dados recebidos. As opções atuais são `OTLP` e `Syslog`.
`name`	Nome do receptor referenciado na seção `service`. Deve ser exclusivo para a instância de pipeline.
`endpoint`	Endereço e porta em que o receptor escuta. Use `0.0.0.0` para todos os endereços.
Processadores	Reservado para uso futuro.
Exportadores	Uma entrada para cada destino.
`type`	O único tipo com suporte no momento é `AzureMonitorWorkspaceLogs`.
`name`	Deve ser exclusivo para a instância de pipeline. O nome é usado na seção `pipelines` da configuração.
`dataCollectionEndpointUrl`	URL do DCE para a qual o pipeline na borda enviará os dados. Você pode localizá-la 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 exibição JSON do DCR no portal do Azure, copie o valor da ID imutável na seção Geral.
- `stream`	Nome do fluxo no 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.
- `schema`	Esquema dos dados enviados para o pipeline de nuvem. 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 é recomendável para cada extensão de pipeline.
Pipelines	Uma entrada para cada fluxo de dados. Cada entrada corresponde a um `receiver` com um `exporter`.
`name`	O nome do pipeline.
`receivers`	Um ou mais receptores para escutar os dados a serem recebidos.
`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 você 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 do ARM para configurar todos os componentes

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

Componente	Tipo	Descrição
Espaço de trabalho do Log Analytics	`Microsoft.OperationalInsights/workspaces`	Remova esta seção se você estiver usando um workspace do Log Analytics existente. O único parâmetro necessário é o nome do workspace. A ID imutável para o workspace, 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 você estiver usando um DCE existente. O único parâmetro necessário é o nome do DCE. A URL de ingestão de logs para o DCE, que é necessária para outros componentes, será criada automaticamente.
Extensão de pipeline de borda	`Microsoft.KubernetesConfiguration/extensions`	O único parâmetro necessário é o nome da extensão do pipeline.
Local personalizado	`Microsoft.ExtendedLocation/customLocations`	Local personalizado do cluster do Kubernetes habilitado para Arc para criar o personalizado
Instância de pipeline de borda	`Microsoft.monitor/pipelineGroups`	A instância de pipeline de borda que inclui a configuração do ouvinte, os exportadores e os fluxos de dados. Você deve modificar as propriedades da instância de pipeline antes de implantar o modelo.
DCR (regra de coleta de dados)	`Microsoft.Insights/dataCollectionRules`	O único parâmetro necessário é o nome do 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": {}
}

Exemplo de arquivo de parâmetro

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

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

No portal do Azure, navegue até o menu de serviços do Kubernetes e selecione o cluster do Kubernetes habilitado para Arc. Selecione Serviços e entradas e verifique se você vê os seguintes serviços:

<pipeline name>-external-service
<pipeline name>-service

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

Verificar pulsação

Cada pipeline configurado na sua instância de pipeline enviará um registro de pulsação para a tabela Heartbeat no seu workspace do Log Analytics a cada minuto. O conteúdo da coluna OSMajorVersion deve corresponder ao nome da instância de pipeline. Se houver vários workspaces na instância de 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 de pipeline de borda forem instaladas, você precisará configurar os 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. Use o comando a seguir para recuperar esse endereço:

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

Se o aplicativo que gera logs for externo ao cluster, copie o valor de external-ip do serviço <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.

Observação

Se o campo external-ip estiver definido como pendente, você precisará configurar um IP externo para essa entrada manualmente de acordo com a configuração do cluster.

Cliente	Descrição
syslog	Atualize os clientes do Syslog para enviar dados para o ponto de extremidade do pipeline e a porta do fluxo de dados do Syslog.
OTLP	O pipeline de borda do Azure Monitor expõe um ponto de extremidade do OTLP baseado em gRPC na porta 4317. Configurar a instrumentação para enviar para esse ponto de extremidade do OTLP dependerá da própria biblioteca de instrumentação. Confira Ponto de extremidade ou coletor do OTLP para obter a documentação de OpenTelemetry. O método de variável de ambiente está documentado na Configuração do Exportador do OTLP.

Cliente

Descrição

syslog

Atualize os clientes do Syslog para enviar dados para o ponto de extremidade do pipeline e a porta do fluxo de dados do Syslog.

OTLP

O pipeline de borda do Azure Monitor expõe um ponto de extremidade do OTLP baseado em gRPC na porta 4317. Configurar a instrumentação para enviar para esse ponto de extremidade do OTLP dependerá da própria biblioteca de instrumentação. Confira Ponto de extremidade ou coletor do OTLP para obter a documentação de OpenTelemetry. O método de variável de ambiente está documentado na Configuração do Exportador do OTLP.

Verificar os dados

A etapa final é verificar se os dados foram recebidos no workspace do Log Analytics. Você pode realizar essa verificação executando uma consulta no workspace do Log Analytics para recuperar os dados da tabela.

Próximas etapas

Leia mais sobre o pipeline do Azure Monitor.

Compartilhar via