Implantar recursos de observabilidade e configurar logs

A observabilidade das Operações IoT do Azure fornece visibilidade em cada camada da sua configuração e fornece informações sobre o comportamento real dos problemas, o que aumenta a eficácia da engenharia de confiabilidade do site. O Operações IoT do Azure oferece observabilidade através de dashboards Grafana personalizados, desenhados especificamente e hospedados no Azure, impulsionados pelo serviço gerido Azure Monitor para Prometheus e pelo Container Insights.

Este artigo mostra como implantar recursos de observabilidade do Operações IoT do Azure, configurar o Azure Managed Prometheus e o Grafana e habilitar o monitoramento abrangente para seu cluster do Azure Arc. Pode implementar todos os recursos de observabilidade usando um script automatizado, ou seguir os passos manuais para uma configuração personalizada.

Pré-requisitos

• Um cluster Kubernetes habilitado para Arc.
• CLI do Azure instalada em sua máquina de cluster. Para obter instruções, consulte Como instalar a CLI do Azure.
• Leme instalado em sua máquina de cluster. Para obter instruções, consulte Instalar Helm.
• Kubectl instalado em sua máquina de cluster. Para obter instruções, consulte Instalar ferramentas do Kubernetes.

Os CLI do Azure exemplos deste artigo usam variáveis de ambiente para que possas definir cada valor uma vez e depois copiar e colar os comandos as-is. Se estiver a usar o ambiente Operações IoT do Azure Codespaces do quickstart, estas variáveis já estão definidas para si e pode saltar este passo. Caso contrário, defina as seguintes variáveis de ambiente no seu shell antes de executar os comandos.

Os seguintes scripts definem as variáveis de ambiente mais usadas:

SUBSCRIPTION_ID=<subscription-id>
RESOURCE_GROUP=<resource-group-name>
AIO_INSTANCE_NAME=<instance-name>
CLUSTER_NAME=<cluster-name>
LOCATION=<region>

$SUBSCRIPTION_ID = "<subscription-id>"
$RESOURCE_GROUP = "<resource-group-name>"
$AIO_INSTANCE_NAME = "<instance-name>"
$CLUSTER_NAME = "<cluster-name>"
$LOCATION = "<region>"

Só precisa de definir as variáveis que este artigo utiliza. Este artigo pode usar variáveis adicionais de ambiente para nomes de recursos que escolher. O artigo explica como posicioná-los onde são apresentados.

Implementar com o script automatizado

Para configurar todos os recursos de observabilidade num único passo, use o script automatizado deploy-observability-resources.sh . O script automatiza os passos deste artigo, desde a criação de recursos Azure até à configuração da observabilidade. Podes executar o script várias vezes em segurança. Ignora recursos que já existem e atualiza os recursos que precisam de alterações.

1. Descarregue o script:

   curl -fsSL -o deploy-observability-resources.sh \
     https://raw.githubusercontent.com/Azure/azure-iot-operations/main/scripts/observability/deploy-observability-resources.sh
   chmod +x deploy-observability-resources.sh
   

2. Defina as variáveis de ambiente necessárias e execute o script:

   export RESOURCE_GROUP=<RESOURCE_GROUP>
   export CLUSTER_NAME=<CLUSTER_NAME>
   export INSTANCE_NAME=<INSTANCE_NAME>
   export WORKSPACE_NAME=<WORKSPACE_NAME>
   export GRAFANA_NAME=<GRAFANA_NAME>
   export LOGS_WORKSPACE_NAME=<LOGS_WORKSPACE_NAME>
   export LOCATION=<LOCATION>
   
   ./deploy-observability-resources.sh
   

   Defina LOCATION para a região Azure para provisionamento de novos recursos. Se todos os recursos já existirem, LOCATION é opcional.

   Variable	Descrição
   RESOURCE_GROUP	Grupo de recursos do Azure para operações de IoT do Azure e recursos de monitorização.
   CLUSTER_NAME	Nome do cluster Kubernetes habilitado por Arc onde o Operações IoT do Azure é implementado.
   INSTANCE_NAME	Nome da instância Operações IoT do Azure a configurar.
   WORKSPACE_NAME	Nome para o espaço de trabalho do Azure Monitor (será criado caso não exista).
   GRAFANA_NAME	Nome para a instância Azure Managed Grafana (criada se não existir).
   LOGS_WORKSPACE_NAME	Nome para o espaço de trabalho de Log Analytics (se não existir, criado).
   LOCATION	Região Azure para novos recursos. Opcional se todos os recursos já existirem.

Depois de o script terminar, continue a implantar dashboards no Grafana para importar os dashboards curados.

Criar recursos no Azure

1. Registe fornecedores com a subscrição onde o cluster está localizado.

   Note

   Execute esta etapa apenas uma vez por assinatura. Para registar fornecedores de recursos, é necessário permissão para realizar a /register/action operação, que está incluída nos papéis de Contribuidor e Proprietário da subscrição. Para obter mais informações, consulte Tipos e provedores de recursos do Azure.

   az account set -s $SUBSCRIPTION_ID
   az provider register --namespace Microsoft.AlertsManagement
   az provider register --namespace Microsoft.Monitor
   az provider register --namespace Microsoft.Dashboard
   az provider register --namespace Microsoft.Insights
   az provider register --namespace Microsoft.OperationalInsights
   

2. Instalar extensões do CLI do Azure para a recolha de métricas em clusters com Azure Arc ativado e Azure Managed Grafana.

   az extension add --upgrade --name k8s-extension
   az extension add --upgrade --name amg
   

3. Crie um espaço de trabalho Azure Monitor para permitir a recolha de métricas para o seu cluster Kubernetes compatível com Azure Arc:

   AZURE_MONITOR_WORKSPACE_ID=$(az monitor account create --name $WORKSPACE_NAME --resource-group $RESOURCE_GROUP --location $LOCATION --query id -o tsv)
   

   O comando guarda o ID do espaço de trabalho do Azure Monitor em AZURE_MONITOR_WORKSPACE_ID. Você usa o ID quando habilita a coleta de métricas na próxima seção.

4. Crie uma instância Azure Managed Grafana para visualizar as suas métricas Prometheus:

   GRAFANA_ID=$(az grafana create --name $GRAFANA_NAME --resource-group $RESOURCE_GROUP --query id -o tsv)
   

   O comando guarda o ID do Grafana em GRAFANA_ID. Você usa o ID quando habilita a coleta de métricas na próxima seção.

5. Crie um espaço de trabalho do Log Analytics para o Container Insights:

   LOG_ANALYTICS_WORKSPACE_ID=$(az monitor log-analytics workspace create -g $RESOURCE_GROUP -n $LOGS_WORKSPACE_NAME --query id -o tsv)
   

   O comando guarda o ID do espaço de trabalho Log Analytics em LOG_ANALYTICS_WORKSPACE_ID. Usas o ID quando ativares a recolha de registos na secção seguinte.

Habilitar a coleta de métricas para o cluster

Atualize o cluster do Azure Arc para coletar métricas e enviá-las para o espaço de trabalho do Azure Monitor que você criou. Também ligas este espaço de trabalho à instância do Grafana:

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

Ative os logs do Container Insights para recolha de registos:

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

Depois de concluir essas etapas, você terá o Azure Monitor e o Grafana configurados e vinculados ao cluster para observabilidade e coleta de métricas.

Implantar o OpenTelemetry Collector

Defina e implante um coletor OpenTelemetry (OTel) em seu cluster Kubernetes habilitado para Arc.

1. Crie um arquivo chamado otel-collector-values.yaml e cole o seguinte código nele para definir um OpenTelemetry Collector:

   mode: deployment
   fullnameOverride: aio-otel-collector
   image:
     repository: otel/opentelemetry-collector
     tag: 0.143.0
   
   config:
     processors:
       memory_limiter:
         limit_percentage: 80
         spike_limit_percentage: 10
         check_interval: 60s
   
     receivers:
       otlp:
         protocols:
           grpc:
             endpoint: ":4317"
           http:
             endpoint: ":4318"
   
     exporters:
       prometheus:
         endpoint: ":8889"
         resource_to_telemetry_conversion:
           enabled: true
         add_metric_suffixes: false
   
     service:
       extensions:
         - health_check
   
       telemetry:
         metrics:
           level: none
   
       pipelines:
         metrics:
           receivers:
             - otlp
           exporters:
             - prometheus
   
   resources:
     limits:
       cpu: "100m"
       memory: "512Mi"
   
   ports:
     metrics:
       enabled: true
       containerPort: 8889
       servicePort: 8889
       protocol: TCP
   

2. otel-collector-values.yaml No arquivo, anote os seguintes valores que você usa no comando ao implantar o az iot ops create Operações IoT do Azure no cluster:

   • fullnameOverride
   • grpc.endpoint
   • check_interval

3. Salve e feche o arquivo.

4. Implante o coletor executando os seguintes comandos:

   kubectl get namespace azure-iot-operations || kubectl create namespace azure-iot-operations
   helm repo add open-telemetry https://open-telemetry.github.io/opentelemetry-helm-charts
   
   helm repo update
   helm upgrade --install aio-observability open-telemetry/opentelemetry-collector -f otel-collector-values.yaml --namespace azure-iot-operations
   

Configurar a coleção de métricas do Prometheus

Configure a coleção de métricas do Prometheus em seu cluster.

1. Crie um arquivo chamado ama-metrics-prometheus-config.yaml e cole a seguinte configuração:

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

2. Aplique o arquivo de configuração executando o seguinte comando:

   kubectl apply -f ama-metrics-prometheus-config.yaml
   

Configurar a configuração de observabilidade

Você pode configurar a configuração de observabilidade de sua implantação do Operações IoT do Azure a qualquer momento. Uma vez configurados os recursos de observabilidade, pode atualizar a configuração de observabilidade executando o az iot ops upgrade comando com o --ops-config parâmetro para especificar os novos valores de configuração:

az iot ops upgrade --resource-group $RESOURCE_GROUP --name $AIO_INSTANCE_NAME --ops-config observability.metrics.openTelemetryCollectorAddress=aio-otel-collector.azure-iot-operations.svc.cluster.local:4317 observability.metrics.exportIntervalSeconds=60

Implantar painéis no Grafana

O Operações IoT do Azure disponibiliza um painel de controlo de exemplo, concebido para lhe fornecer muitas das visualizações necessárias para compreender a saúde e o desempenho da sua implementação Operações IoT do Azure.

Complete os seguintes passos para instalar os dashboards Grafana curados pelo Operações IoT do Azure:

1. Clone ou descarregue o repositório explore-iot-operations para obter localmente o ficheiro JSON do Dashboard do Grafana: https://github.com/Azure-Samples/explore-iot-operations.

2. Inicie sessão na consola do Grafana. Você pode acessar o console por meio do portal do Azure ou usar o az grafana show comando para recuperar a URL.

   az grafana show --name $GRAFANA_NAME --resource-group $RESOURCE_GROUP --query url -o tsv
   

3. Na página inicial do Grafana, selecione o bloco Criar o seu primeiro painel.

4. Selecione Importar dashboard.

5. Navegue até ao diretório de dashboards de exemplo na sua cópia local do repositório Operações IoT do Azure, explore-iot-operations > samples > observability > grafana-dashboard, e depois selecione o ficheiro de dashboard aio-observability.json.

6. Quando o aplicativo solicitar, selecione sua fonte de dados Prometheus gerenciada.

7. Selecione Importar.

Passos seguintes

• Ative definições seguras para configurar a gestão de segredos e identidades geridas.
• Gerir certificados para comunicações externas.