OpenTelemetry dans le Kit de développement logiciel (SDK) Azure pour les caisses Rust

Lorsque vous travaillez avec les bibliothèques du Kit de développement logiciel (SDK) Azure pour Rust, vous avez besoin d'une visibilité sur les opérations du SDK pour déboguer des problèmes, suivre les performances et comprendre comment votre application interagit avec Azure. Cet article explique comment implémenter des stratégies efficaces de journalisation et de télémétrie basées sur OpenTelemetry qui fournissent des insights sur les fonctionnements internes des applications Rust sur Azure.

Télémétrie pour les développeurs Azure

Les crates du SDK Azure pour Rust offrent une observabilité complète grâce à l'intégration d'OpenTelemetry, que nous recommandons pour la surveillance et le traçage distribué. Que vous résolvez les problèmes de flux d’authentification, de surveillance des cycles de demande d’API ou d’analyse des goulots d’étranglement des performances, ce guide couvre les outils et techniques OpenTelemetry dont vous avez besoin pour obtenir une visibilité sur vos opérations du Kit de développement logiciel (SDK) Azure.

Les crates du SDK Azure pour Rust utilisent OpenTelemetry comme approche standard de l’observabilité, offrant :

• Télémétrie standard : utiliser des formats OpenTelemetry compatibles avec les plateformes de surveillance
• Suivi distribué : suivre les demandes entre plusieurs services et ressources Azure
• Exportateurs avancés : Envoyer des données à Jaeger, Prometheus, Grafana et d’autres plateformes d’observabilité
• Corrélation entre les services : propager automatiquement le contexte de trace entre les microservices
• Surveillance de la production : conçue pour les environnements de production à grande échelle avec des optimisations d’échantillonnage et de performances

Configurer OpenTelemetry pour les enregistrements

Pour utiliser OpenTelemetry, vous avez besoin du paquet azure_core_opentelemetry. Le package azure_core à lui seul n’inclut pas la prise en charge d’OpenTelemetry.

1. Connectez-vous à Azure CLI :

   az login
   

2. Créez des ressources Azure Monitor à l’aide d’Azure CLI :

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

3. Configurez votre projet Rust. Ajoutez les dépendances requises à votre 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"] }
   

   Note

   La opentelemetry-otlp caisse est incluse pour exporter des données de télémétrie vers un collecteur OpenTelemetry, qui peut ensuite transférer les données vers Azure Monitor. L’exportation directe d’Azure Monitor à partir d’applications Rust n’est pas prise en charge.

4. Créez votre application principale avec la configuration OpenTelemetry. Pour plus d’informations, consultez la documentation azure_core_opentelemetry .

5. Définissez les variables d’environnement requises et exécutez votre application :

   # 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
   

Après avoir configuré OpenTelemetry dans votre application et l’exécuter, vous pouvez ajouter une instrumentation personnalisée et surveiller les données de télémétrie.

Exporter des données de télémétrie vers Azure Monitor

Étant donné que Rust n’a pas d’exportateur Azure Monitor OpenTelemetry direct, vous devez implémenter une approche indirecte pour obtenir vos données de télémétrie dans Azure Monitor. Voici les méthodes recommandées :

Option 1 : Collecteur OpenTelemetry (recommandé)

Le collecteur OpenTelemetry agit comme une couche intermédiaire qui peut recevoir des données de télémétrie de votre application Rust et les transférer à Azure Monitor :

1. Déployez le collecteur OpenTelemetry dans votre environnement (en tant que sidecar, agent ou passerelle)
2. Configurer votre application Rust pour l’exporter vers le collecteur à l’aide du protocole OTLP (OpenTelemetry Protocol)
3. Configurer le collecteur avec l’exportateurAzure Monitor pour transférer des données vers Application Insights

Option 2 : Azure Storage + API d’ingestion de données

Pour les scénarios où vous avez besoin d’un contrôle supplémentaire sur le traitement des données :

1. Exporter des données de télémétrie vers stockage Azure (Stockage Blob ou Data Lake)
2. Traiter les données à l’aide d’Azure Functions, de Logic Apps ou d’applications personnalisées
3. Importer des données traitées dans Azure Monitor à l’aide de l’API d’ingestion de journaux

Option 3 : Event Hubs Streaming

Pour le traitement des données de télémétrie en temps réel :

1. Transmettre en continu des données de télémétrie vers Azure Event Hubs depuis votre application Rust
2. Traiter des événements à l’aide d’Azure Stream Analytics, d’Azure Functions ou de consommateurs personnalisés
3. Transférer les données de télémétrie traitées vers Azure Monitor ou Application Insights

Personnaliser les données de télémétrie

OpenTelemetry fournit une infrastructure flexible pour personnaliser les données de télémétrie en fonction des besoins de votre application. Utilisez ces stratégies pour améliorer vos données de télémétrie :

Instrumenter le code de votre application

L’ajout d’instrumentation personnalisée à votre code d’application vous aide à mettre en corrélation votre logique métier avec les opérations du Kit de développement logiciel (SDK) Azure. Cette corrélation facilite la compréhension du flux complet des opérations.

Analyse des performances

OpenTelemetry fournit des insights détaillés sur les modèles de performances du Kit de développement logiciel (SDK) Azure. Ces insights vous aident à identifier et à résoudre les goulots d’étranglement des performances.

Diagnostic d’erreur

OpenTelemetry capture un contexte d’erreur riche qui dépasse les messages d’erreur simples. Ce contexte vous aide à comprendre non seulement ce qui a échoué, mais pourquoi et dans quelles circonstances.

Comprendre la propagation des erreurs du Kit de développement logiciel (SDK) : tracez la façon dont les erreurs se propagent dans le code de votre application et les couches du Kit de développement logiciel (SDK) Azure. Cette trace vous aide à comprendre le chemin d’erreur complet et à identifier la cause racine.

Consigner les échecs transitoires et permanents : faire la distinction entre les échecs transitoires (tels que les délais d'expiration du réseau susceptibles de réussir lors de nouvelles tentatives) et les échecs permanents (comme les erreurs d'authentification nécessitant des modifications de configuration). Cette distinction vous aide à créer des applications résilientes.

Comprendre les logs, les métriques et les alertes

Vos applications et services génèrent des données de télémétrie pour vous aider à surveiller leur intégrité, leurs performances et leur utilisation. Azure catégorise cette télémétrie en journaux, métriques et alertes.

Azure propose quatre types de télémétrie :

Choisissez la télémétrie appropriée pour votre question :

Afficher les données de télémétrie dans Azure Monitor

Après avoir configuré OpenTelemetry dans votre application Rust et configuré un mécanisme d’exportation intermédiaire, vous pouvez afficher les données de télémétrie dans Azure Monitor via Application Insights. Étant donné que Rust n’a pas de fonctionnalités d’exportation Azure Monitor directes, vous devez implémenter l’une des approches suivantes :

• OpenTelemetry Collector : configurez le collecteur OpenTelemetry pour recevoir des données de votre application Rust et les transférer à Azure Monitor
• Intégration du stockage Azure : exporter les données de télémétrie vers Stockage Azure et utiliser les API d’ingestion de données Azure Monitor pour importer les données
• Diffusion en streaming avec Event Hubs : diffuser en continu des données de télémétrie via Azure Event Hubs et les traiter pour l’ingestion par Azure Monitor.

Une fois que vos données de télémétrie atteignent Azure Monitor via l’une de ces méthodes, vous pouvez l’analyser :

1. Accédez à Application Insights dans le portail Azure :

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

2. Consulter les traces et les journaux :

   • Accéder à larecherche de transactions>
   • Rechercher des traces avec des noms d’opération comme get_keyvault_secrets
   • Consultez la section Journaux et exécutez des requêtes KQL :

   traces
   | where timestamp > ago(1h)
   | where message contains "Azure operations" or message contains "secrets"
   | order by timestamp desc
   

3. Afficher les traces distribuées :

   • Accéder à Application Map pour afficher les dépendances de service
   • Sélectionner Performances pour afficher le minutage de l’opération
   • Utilisez les détails de la transaction de bout en bout pour voir les flux de demandes complets

4. Requêtes KQL personnalisées pour votre application 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
   

Surveiller en temps réel

Configurez la supervision dynamique pour voir les données à mesure qu’elles arrivent :

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

Optimisation des coûts

Vous pouvez réduire considérablement votre coût pour Azure Monitor en comprenant les meilleures pratiques pour les options de configuration et les opportunités de réduction de la quantité de données collectées par Azure Monitor.

Stratégies clés pour les applications Rust :

• Utiliser les niveaux de journal appropriés : configurer les niveaux de journal OpenTelemetry de manière appropriée pour la production afin de réduire le volume
• Implémenter l’échantillonnage : configurer l’échantillonnage OpenTelemetry pour les applications à volume élevé
• Filtrer les données sensibles : éviter la journalisation des secrets, des jetons ou des charges utiles volumineuses qui augmentent les coûts
• Surveiller l’ingestion des données : passez régulièrement en revue l’utilisation et les coûts des données Application Insights

Ressources et étapes suivantes

• Instructions relatives au Kit de développement logiciel (SDK) Azure pour Rust
• La documentation d'OpenTelemetry Rust
• Service Azure Monitor