OpenTelemetry in Azure SDK per le casse Rust

Quando si lavora con i crate di Azure SDK per Rust, è necessaria visibilità sulle operazioni sdk per eseguire il debug dei problemi, monitorare le prestazioni e comprendere in che modo l'applicazione interagisce con i servizi di Azure. Questo articolo illustra come implementare strategie efficaci di registrazione e telemetria basate su OpenTelemetry che forniscono informazioni dettagliate sulle attività interne delle applicazioni Rust in Azure.

Telemetria per sviluppatori di Azure

I pacchetti Azure SDK per Rust offrono un'osservabilità completa tramite l'integrazione OpenTelemetry, consigliata per il monitoraggio e la tracciatura distribuita. Che si tratti di risoluzione dei problemi relativi ai flussi di autenticazione, al monitoraggio dei cicli delle richieste API o all'analisi dei colli di bottiglia delle prestazioni, questa guida illustra gli strumenti e le tecniche OpenTelemetry necessari per ottenere visibilità sulle operazioni di Azure SDK.

Azure SDK per i pacchetti Rust utilizza OpenTelemetry come approccio standard per l'osservabilità, fornendo:

Telemetria standard del settore: usare formati OpenTelemetry compatibili con le piattaforme di monitoraggio
Traccia distribuita: tenere traccia delle richieste tra più servizi e risorse di Azure
Esportazioni avanzate: inviare dati a Jaeger, Prometheus, Grafana e altre piattaforme osservabili
Correlazione tra i servizi: propagare automaticamente il contesto di traccia tra microservizi
Monitoraggio della produzione: progettato per ambienti di produzione su larga scala con ottimizzazioni di campionamento e prestazioni

Importante

Attualmente, Microsoft non fornisce un esportatore OpenTelemetry diretto di Azure Monitor per le applicazioni Rust. La Distribuzione OpenTelemetry di Azure Monitor supporta solo .NET, Java, Node.js e Python. Per le applicazioni Rust, è necessario esportare i dati OpenTelemetry in un sistema intermedio( ad esempio Archiviazione di Azure, Hub eventi o Agente di raccolta OpenTelemetry) e quindi importarli in Monitoraggio di Azure usando i metodi di inserimento supportati.

Configurare la registrazione di OpenTelemetry

Per usare OpenTelemetry, è necessario il azure_core_opentelemetry crate. Il azure_core pacchetto da solo non include il supporto di OpenTelemetry.

Accedere all'interfaccia della riga di comando di Azure:
```
az login
```

Creare risorse di Monitoraggio di Azure usando l'interfaccia della riga di comando di 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"

Configurare il progetto Rust. Aggiungi le dipendenze necessarie a 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"] }
```
Annotazioni

La opentelemetry-otlp crate è inclusa per l'esportazione dei dati di telemetria a un OpenTelemetry Collector, che può quindi inoltrare i dati a Monitoraggio di Azure. L'esportazione diretta da applicazioni Rust verso Azure Monitor non è supportata.
Creare l'applicazione principale con la configurazione OpenTelemetry. Per informazioni dettagliate, vedere la documentazione azure_core_opentelemetry .

Impostare le variabili di ambiente necessarie ed eseguire l'applicazione:

# 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

Dopo aver configurato OpenTelemetry nell'applicazione ed eseguirlo, è possibile aggiungere strumentazione personalizzata e monitorare i dati di telemetria.

Esportare dati di telemetria in Azure Monitor

Poiché Rust non ha un esportatore diretto per OpenTelemetry di Azure Monitor, è necessario implementare un approccio indiretto per trasmettere i dati di telemetria ad Azure Monitor. Ecco i metodi consigliati:

Opzione 1: Agente di raccolta OpenTelemetry (scelta consigliata)

L'agente di raccolta OpenTelemetry funge da livello intermedio che può ricevere dati di telemetria dall'applicazione Rust e inoltrarlo a Monitoraggio di Azure:

Distribuire l'OpenTelemetry Collector nell'ambiente (come sidecar, agente o gateway)
Configura la tua applicazione Rust per esportare al Collector tramite OTLP (OpenTelemetry Protocol)
Configurare il Collector con l'esportatoredi Monitoraggio di Azure per inoltrare i dati ad Application Insights

Opzione 2: Archiviazione di Azure + API di inserimento dati

Per gli scenari in cui è necessario un maggiore controllo sull'elaborazione dei dati:

Esportare la telemetria in Archiviazione di Azure (Archiviazione BLOB o Data Lake)
Elaborare i dati usando Funzioni di Azure, App per la logica o applicazioni personalizzate
Inserire dati elaborati in Monitoraggio di Azure usando l'API di inserimento dei log

Opzione 3: Streaming di Hub eventi

Per l'elaborazione dei dati di telemetria in tempo reale:

Trasmettere i dati di telemetria a Hub eventi di Azure dall'applicazione Rust
Elaborare eventi usando Analisi di flusso di Azure, Funzioni di Azure o consumatori personalizzati
Inviare la telemetria elaborata a Azure Monitor o Application Insights

Personalizzare i dati di telemetria

OpenTelemetry offre un framework flessibile per personalizzare i dati di telemetria in base alle esigenze dell'applicazione. Usare queste strategie per migliorare i dati di telemetria:

Implementazione di strumenti nel codice dell'applicazione

L'aggiunta di strumentazione personalizzata al codice dell'applicazione consente di correlare la logica di business con le operazioni di Azure SDK. Questa correlazione semplifica la comprensione del flusso completo delle operazioni.

Technique	Scopo	Implementation
Intervalli personalizzati per le operazioni di Azure	Creare una gerarchia chiara che illustra la correlazione tra la logica dell'applicazione e le operazioni di Azure	Incapsulare le chiamate all'SDK Azure usando i metodi di creazione di span di OpenTelemetry
Correlare la logica dell'applicazione con le chiamate SDK	Connettere le operazioni aziendali alle chiamate di Azure SDK sottostanti	Usare il contesto span per collegare le operazioni aziendali con chiamate al servizio di Azure attivate
Creare tracce diagnostiche	Acquisire un contesto importante per la telemetria tra flussi di lavoro	Aggiungere campi strutturati (ID utenti, ID richieste, identificatori di oggetto aziendale) a sezioni.

Analisi di prestazioni

OpenTelemetry fornisce informazioni dettagliate sui modelli di prestazioni di Azure SDK. Queste informazioni dettagliate consentono di identificare e risolvere i colli di bottiglia delle prestazioni.

Tipo di analisi	Cosa rivela	Uso
Durata dell'operazione SDK	Durata delle diverse operazioni di Azure	Usare l'intervallo di tempo che OpenTelemetry acquisisce automaticamente per identificare le operazioni lente
Colli di bottiglia delle chiamate al servizio	Dove l'applicazione impiega tempo in attesa delle risposte di Azure	Confrontare la tempistica tra i servizi e le operazioni di Azure per individuare i problemi di prestazioni
Modelli di operazioni simultanee	Sovrapposizione e dipendenze tra le operazioni	Analizzare i dati di telemetria per comprendere le opportunità di parallelizzazione quando si effettuano più chiamate di Azure

Diagnosi degli errori

OpenTelemetry acquisisce un contesto di errore avanzato che va oltre i semplici messaggi di errore. Questo contesto consente di comprendere non solo ciò che ha avuto esito negativo, ma perché e in quali circostanze.

Comprendere la propagazione degli errori dell'SDK: Traccia come gli errori si propagano attraverso il codice dell'applicazione e nei livelli di Azure SDK. Questa traccia consente di comprendere il percorso di errore completo e di identificare la causa radice.

Registrare errori temporanei e permanenti: distinguere tra errori temporanei (ad esempio timeout di rete che potrebbero avere esito positivo nei tentativi) e errori permanenti (ad esempio errori di autenticazione che richiedono modifiche alla configurazione). Questa distinzione consente di creare applicazioni resilienti.

Informazioni su log, metriche e avvisi

Le tue applicazioni e servizi generano dati di telemetria per aiutarti a monitorare il loro stato, le prestazioni e l'utilizzo. Azure classifica questi dati di telemetria in log, metriche e avvisi.

Azure offre quattro tipi di dati di telemetria:

Tipo di telemetria	Cosa ti dà	Dove trovarla per ogni servizio
Metriche	Dati numerici, serie temporali (CPU, memoria e così via)	Metriche nel portale o `az monitor metrics` nell'interfaccia della riga di comando
Avvisi	Notifiche proattive quando si raggiungono le soglie	Avvisi nel portale o nel `az monitor metrics alert` CLI
Registrazioni	Eventi e diagnostica basati su testo (Web, app)	Log del servizio app, Monitoraggio funzioni, Diagnostica app contenitore
Log personalizzati	Dati di telemetria dell'applicazione personalizzati tramite App Insights	Tabella Log (traccia) della risorsa di Application Insights

Selezionare i dati di telemetria corretti per la domanda:

Scenario	Utilizzare i log...	Utilizzare le metriche...	Usare gli avvisi...
"L'app Web è stata avviata ed è funzionante?"	Log del server Web di App Service (Log)	N/A	N/A
La mia funzione sta andando in timeout o fallendo?	Log chiamate di funzione (monitoraggio)	Metrica della durata dell'esecuzione della funzione	Avviso relativo a "Errori >di funzione 0"
Quanto è occupato il mio servizio e può espandersi?	N/A	Velocità effettiva del servizio/CPU nelle metriche	Avviso di autoscaling quando la CPU supera il > 70%
Quali eccezioni sta generando il mio codice?	Log di traccia personalizzati su Application Insights	N/A	Avviso in "ServerExceptions >0"
"Ho superato i limiti di transazione o quota?"	N/A	Metriche correlate alla quota (operazioni, controllo del flusso)	Avviso su "ThrottlingCount >0"

Visualizzare i dati di telemetria in Monitoraggio di Azure

Dopo aver configurato OpenTelemetry nell'applicazione Rust e aver configurato un meccanismo di esportazione intermedio, è possibile visualizzare i dati di telemetria in Monitoraggio di Azure tramite Application Insights. Poiché Rust non dispone di funzionalità di esportazione dirette di Monitoraggio di Azure, è necessario implementare uno di questi approcci:

OpenTelemetry Collector: configura il collector OpenTelemetry per ricevere dati dalla tua applicazione Rust e inoltrarli ad Azure Monitor.
Integrazione di Archiviazione di Azure: esportare i dati di telemetria in Archiviazione di Azure e usare le API di inserimento dati di Monitoraggio di Azure per importare i dati
Event Hubs streaming: trasmettere i dati di telemetria tramite Azure Event Hubs ed elaborarli per l'inserimento in Azure Monitor

Dopo che i dati di telemetria raggiungono Monitoraggio di Azure tramite uno di questi metodi, è possibile analizzarli:

Passare ad Application Insights nel portale di Azure:

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

Visualizzare tracce e log:
- Passare a Application Insights>Ricerca transazioni
- Cercare tracce con nomi di operazione come get_keyvault_secrets
- Controllare la sezione Log ed eseguire query KQL:
```
traces
| where timestamp > ago(1h)
| where message contains "Azure operations" or message contains "secrets"
| order by timestamp desc
```
Visualizzare le tracce distribuite:
- Vai a Mappa delle Applicazioni per visualizzare le dipendenze del servizio
- Selezionare Prestazioni per vedere le tempistiche delle operazioni.
- Utilizzare i dettagli delle transazioni end-to-end per visualizzare i flussi di richieste completi

Query KQL personalizzate per l'applicazione 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

Monitorare in tempo reale

Configurare il monitoraggio in tempo reale per visualizzare i dati non appena arrivano:

# 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)

Ottimizzazione dei costi

È possibile ridurre significativamente i costi per Monitoraggio di Azure comprendendo le procedure consigliate per le opzioni di configurazione e le opportunità per ridurre la quantità di dati raccolti da Monitoraggio di Azure.

Strategie chiave per le applicazioni Rust:

Usare i livelli di log appropriati: configurare i livelli di log OpenTelemetry in modo appropriato per la produzione per ridurre il volume
Implementare il campionamento: configurare il campionamento OpenTelemetry per applicazioni con volumi elevati
Filtrare i dati sensibili: evitare di registrare segreti, token o payload di grandi dimensioni che aumentano i costi
Monitorare l'inserimento dati: esaminare regolarmente l'utilizzo e i costi dei dati di Application Insights

Risorse e passaggi successivi

Commenti e suggerimenti

Questa pagina è stata utile?

Last updated on 2025-10-20