OpenTelemetry no SDK do Azure para crates de Rust

Ao trabalhar com o SDK do Azure para crates do Rust, você precisa de visibilidade das operações do SDK para depurar problemas, monitorar o desempenho e entender como seu aplicativo interage com os serviços do Azure. Este artigo mostra como implementar estratégias eficazes de registro em log e telemetria baseadas em OpenTelemetry que fornecem insights sobre o funcionamento interno de aplicativos Rust no Azure.

Telemetria para desenvolvedores do Azure

Os crates do Azure SDK para Rust fornecem uma observabilidade abrangente por meio da integração com OpenTelemetry, que recomendamos para cenários de monitoramento e rastreamento distribuído. Se você estiver solucionando problemas de fluxos de autenticação, monitorando ciclos de solicitação de API ou analisando gargalos de desempenho, este guia aborda as ferramentas e técnicas do OpenTelemetry necessárias para obter visibilidade das operações do SDK do Azure.

Os pacotes (crates) do SDK do Azure para Rust utilizam o OpenTelemetry como abordagem padrão para observabilidade, fornecendo:

Telemetria padrão do setor: usar formatos OpenTelemetry compatíveis com plataformas de monitoramento
Rastreamento distribuído: acompanhar solicitações em vários serviços e recursos do Azure
Exportadores avançados: enviar dados para Jaeger, Prometheus, Grafana e outras plataformas de observabilidade
Correlação entre serviços: propagar automaticamente o contexto de rastreamento entre microsserviços
Monitoramento de produção: criado para ambientes de produção de alta escala com otimizações de amostragem e desempenho

Importante

Atualmente, a Microsoft não fornece um exportador direto do Azure Monitor OpenTelemetry para aplicativos Rust. A Distribuição opentelemetry do Azure Monitor dá suporte apenas a .NET, Java, Node.js e Python. Para aplicativos Rust, você precisa exportar dados OpenTelemetry para um sistema intermediário (como o Armazenamento do Azure, Hubs de Eventos ou o Coletor OpenTelemetry) e importar esses dados para o Azure Monitor usando métodos de ingestão com suporte.

Configurar o registro em log do OpenTelemetry

Para usar o OpenTelemetry, você precisa da azure_core_opentelemetry caixa. O azure_core pacote sozinho não inclui suporte ao OpenTelemetry.

Faça logon na CLI do Azure:
```
az login
```

Crie recursos do Azure Monitor usando a CLI do Azure:

# Set variables
RESOURCE_GROUP="rust-telemetry-rg"
LOCATION="eastus"
APP_INSIGHTS_NAME="rust-app-insights"
LOG_ANALYTICS_WORKSPACE="rust-logs-workspace"

# Create resource group
az group create --name $RESOURCE_GROUP --location $LOCATION

# Create Log Analytics workspace
WORKSPACE_ID=$(az monitor log-analytics workspace create \
  --resource-group $RESOURCE_GROUP \
  --workspace-name $LOG_ANALYTICS_WORKSPACE \
  --location $LOCATION \
  --query id -o tsv)

# Create Application Insights instance
az extension add --name application-insights
INSTRUMENTATION_KEY=$(az monitor app-insights component create \
  --app $APP_INSIGHTS_NAME \
  --location $LOCATION \
  --resource-group $RESOURCE_GROUP \
  --workspace $WORKSPACE_ID \
  --query instrumentationKey -o tsv)

# Get connection string
CONNECTION_STRING=$(az monitor app-insights component show \
  --app $APP_INSIGHTS_NAME \
  --resource-group $RESOURCE_GROUP \
  --query connectionString -o tsv)

echo "Application Insights Connection String: $CONNECTION_STRING"

Configure seu projeto do Rust. Adicione as dependências necessárias ao seu Cargo.toml:
```
[dependencies]
azure_core_opentelemetry = "*"
azure_security_keyvault_secrets = "*"
azure_identity = "*"
opentelemetry = "0.31"
opentelemetry_sdk = "0.31"
opentelemetry-otlp = "0.31"  # For exporting to OpenTelemetry Collector
tokio = { version = "1.47.1", features = ["full"] }
```
Observação

O opentelemetry-otlp crate é incluído para exportar dados de telemetria para um Coletor OpenTelemetry, que pode encaminhar os dados para o Azure Monitor. Não há suporte para a exportação direta do Azure Monitor de aplicativos Rust.
Crie seu aplicativo principal com a configuração OpenTelemetry. Consulte a documentação do azure_core_opentelemetry para obter detalhes.

Defina as variáveis de ambiente necessárias e execute seu aplicativo:

# Set Key Vault URL (replace with your actual Key Vault URL)
export AZURE_KEYVAULT_URL="https://mykeyvault.vault.azure.net/"

# Run the application
cargo run

Depois de configurar o OpenTelemetry em seu aplicativo e executá-lo, você pode adicionar instrumentação personalizada e monitorar os dados de telemetria.

Exportar telemetria para o Azure Monitor

Como o Rust não tem um exportador direto do OpenTelemetry do Azure Monitor, você precisa implementar uma abordagem indireta para obter seus dados de telemetria no Azure Monitor. Aqui estão os métodos recomendados:

Opção 1: Coletor OpenTelemetry (Recomendado)

O Coletor OpenTelemetry atua como uma camada intermediária que pode receber telemetria do aplicativo Rust e encaminhá-la para o Azure Monitor:

Implantar o Coletor OpenTelemetry em seu ambiente (como sidecar, agente ou gateway)
Configurar seu aplicativo Rust para exportar para o Coletor usando OTLP (Protocolo OpenTelemetry)
Configurar o Coletor com o exportador do Azure Monitor para encaminhar dados para o Application Insights

Opção 2: Armazenamento do Azure + API de Ingestão de Dados

Para cenários em que você precisa de mais controle sobre o processamento de dados:

Exportar telemetria para o Armazenamento do Azure (Blob Storage ou Data Lake)
Processar os dados usando Azure Functions, Logic Apps ou aplicativos personalizados
Ingerir dados processados no Azure Monitor usando a API de Ingestão de Logs

Opção 3: Streaming de Hubs de Eventos

Para processamento de telemetria em tempo real:

Transmitir telemetria para Hubs de Eventos do Azure do aplicativo Rust
Processar eventos usando o Azure Stream Analytics, o Azure Functions ou consumidores personalizados
Encaminhar a telemetria processada para o Azure Monitor ou o Application Insights

Personalizar dados de telemetria

O OpenTelemetry fornece uma estrutura flexível para personalizar dados de telemetria para atender às necessidades do aplicativo. Use estas estratégias para aprimorar sua telemetria:

Instrumentando o código da aplicação

Adicionar instrumentação personalizada ao código do aplicativo ajuda você a correlacionar sua lógica de negócios com as operações do SDK do Azure. Essa correlação facilita a compreensão do fluxo completo de operações.

Technique	Propósito	Implementation
Intervalos personalizados para operações do Azure	Criar uma hierarquia clara que mostra como a lógica do aplicativo se relaciona com as operações do Azure	Encapsular chamadas do SDK do Azure usando os métodos de criação de span do OpenTelemetry
Correlacionar lógica de aplicativo com chamadas do SDK	Conectar operações de negócios com chamadas subjacentes do SDK do Azure	Usar o contexto de abrangência para vincular operações de negócios com chamadas de serviço do Azure que são disparadas
Criar indicadores de diagnóstico	Capturar informações contextuais cruciais para a telemetria em toda a cadeia de fluxos de trabalho	Adicionar campos estruturados (IDs de usuário, IDs de solicitação, identificadores de objeto de negócios) a spans

Análise de desempenho

O OpenTelemetry fornece insights detalhados sobre os padrões de desempenho do SDK do Azure. Esses insights ajudam você a identificar e resolver gargalos de desempenho.

Tipo de análise	O que revela	Como usar
Duração da operação do SDK	Quanto tempo diferentes as operações do Azure levam	Usar o tempo de intervalo que o OpenTelemetry captura automaticamente para identificar operações lentas
Gargalos de chamada de serviço	Onde seu aplicativo gasta tempo aguardando respostas do Azure	Comparar o tempo entre serviços e operações do Azure para encontrar problemas de desempenho
Padrões de operação simultâneos	Sobreposição e dependências entre operações	Analisar dados de telemetria para entender as oportunidades de paralelização ao fazer várias chamadas do Azure

Diagnóstico de erro

O OpenTelemetry captura um contexto de erro avançado que vai além de mensagens de erro simples. Esse contexto ajuda você a entender não apenas o que falhou, mas por que e sob quais circunstâncias.

Entenda a propagação de erros do SDK: rastreie como os erros são gerados por meio do código do aplicativo e das camadas do SDK do Azure. Esse rastreamento ajuda você a entender o caminho de erro completo e identificar a causa raiz.

Log transitório versus falhas permanentes: Distingue entre falhas temporárias (como timeouts de rede que podem ser resolvidas com uma nova tentativa) e falhas permanentes (como erros de autenticação que precisam de alterações de configuração). Essa distinção ajuda você a criar aplicativos resilientes.

Entender logs, métricas e alertas

Seus aplicativos e serviços geram dados de telemetria para ajudar a monitorar seu estado, desempenho e uso. O Azure categoriza essa telemetria em logs, métricas e alertas.

O Azure oferece quatro tipos de telemetria:

Tipo de telemetria	O que isso te oferece	Onde encontrá-lo para cada serviço
Métricas	Dados numéricos de série temporal (CPU, memória etc.)	Métricas no portal ou na CLI
Alerts	Notificações proativas quando os limites são atingidos	Alertas no portal ou `az monitor metrics alert` na CLI
Logs	Eventos e diagnósticos baseados em texto (Web, aplicativo)	Serviço de Aplicativo Logs, Monitor de Funções, Diagnósticos de Aplicativos de Contêiner
Logs personalizados	Sua própria telemetria de aplicativo por meio do App Insights	Tabela Logs (Rastreamento) do recurso do Application Insights

Escolha a telemetria certa para sua pergunta:

Scenario	Usar logs...	Use métricas	Use alertas...
"Meu aplicativo Web iniciou e respondeu?"	Logs do servidor Web do Serviço de Aplicativo (Logs)	N/A	N/A
"Minha função está atingindo o tempo limite ou falhando?"	Logs de invocação de função (Monitor)	Métrica de duração da execução da função	Alerta sobre "Erro de Função >0"
"Quão ocupado está meu serviço e ele pode ser dimensionado?"	N/A	Taxa de transferência de serviço/CPU em Métricas	Alerta de autoescala para CPU% > 70%
"Quais são as exceções que meu código está lançando?"	Logs de rastreamento personalizados no Application Insights	N/A	Alerta em "ServerExceptions >0"
"Excedi meus limites de transação ou cota?"	N/A	Métricas relacionadas à cota (Transações, Limitação)	Alerta em "ThrottlingCount >0"

Exibir os dados de telemetria no Azure Monitor

Depois de configurar o OpenTelemetry em seu aplicativo Rust e configurar um mecanismo de exportação intermediário, você pode exibir os dados de telemetria no Azure Monitor por meio do Application Insights. Como o Rust não tem recursos diretos de exportação do Azure Monitor, você precisará implementar uma destas abordagens:

Coletor OpenTelemetry: configure o Coletor OpenTelemetry para receber dados do aplicativo Rust e encaminhá-los para o Azure Monitor
Integração do Armazenamento do Azure: exportar telemetria para o Armazenamento do Azure e usar APIs de ingestão de dados do Azure Monitor para importar os dados
Transmissão de Hubs de Eventos: transmitir a telemetria através dos Azure Event Hubs e processá-la para ingestão pelo Azure Monitor

Depois que os dados de telemetria chegarem ao Azure Monitor por meio de um destes métodos, você poderá analisá-los:

Navegue até o Application Insights no portal do Azure:

az monitor app-insights component show \
  --app $APP_INSIGHTS_NAME \
  --resource-group $RESOURCE_GROUP \
  --query "{name:name,appId:appId,instrumentationKey:instrumentationKey}"

Exibir rastreamentos e logs:
- Ir para apesquisa de transações do >
- Procure por traços com nomes de operações como get_keyvault_secrets
- Verifique a seção Logs e execute consultas KQL:
```
traces
| where timestamp > ago(1h)
| where message contains "Azure operations" or message contains "secrets"
| order by timestamp desc
```
Exibir rastreamentos distribuídos:
- Vá para o Mapa do Aplicativo para ver as dependências do serviço
- Selecione Desempenho para ver o tempo da operação
- Usar detalhes da transação de ponta a ponta para ver fluxos de solicitação completos

Consultas KQL personalizadas para seu aplicativo Rust:

// View all custom logs from your Rust app
traces
| where customDimensions.["service.name"] == "rust-azure-app"
| order by timestamp desc

// View Azure SDK HTTP operations
dependencies
| where type == "HTTP"
| where target contains "vault.azure.net"
| order by timestamp desc

// Monitor error rates
traces
| where severityLevel >= 3  // Warning and above
| summarize count() by bin(timestamp, 1m), severityLevel
| render timechart

Monitorar em tempo real

Configure o monitoramento dinâmico para ver os dados conforme eles chegam:

# Stream live logs (requires Azure CLI)
az monitor app-insights events show \
  --app $APP_INSIGHTS_NAME \
  --resource-group $RESOURCE_GROUP \
  --event traces \
  --start-time $(date -u -d '1 hour ago' +%Y-%m-%dT%H:%M:%S)

Otimização de custos

Você pode reduzir significativamente seu custo para o Azure Monitor entendendo as práticas recomendadas para opções de configuração e oportunidades para reduzir a quantidade de dados coletados pelo Azure Monitor.

Principais estratégias para aplicativos Rust:

Use os níveis de log apropriados: Configure adequadamente os níveis de log do OpenTelemetry para produção, a fim de reduzir o volume
Implementar amostragem: Configurar a amostragem OpenTelemetry para aplicativos de alto volume
Filtrar dados confidenciais: evite segredos de log, tokens ou grandes cargas que aumentam os custos
Monitorar a ingestão de dados: examine regularmente os custos e o uso de dados do Application Insights

Recursos e próximas etapas

Comentários

Esta página foi útil?

Last updated on 2025-10-20