Partager via

Utiliser OpenTelemetry avec Azure Functions

  • Article

Important

La prise en charge d’OpenTelemetry pour Azure Functions est actuellement en préversion.

Cet article explique comment configurer votre application de fonction pour exporter les données de journal et de trace dans un format OpenTelemetry. Azure Functions génère des données de télémétrie sur vos exécutions de fonction à partir du processus hôte Functions et du processus Worker propre au langage dans lequel votre code de fonction s’exécute. Par défaut, ces données de télémétrie sont envoyées à Application Insights à l’aide du Kit de développement logiciel (SDK) Application Insights. Toutefois, vous pouvez choisir d’exporter ces données à l’aide de la sémantique OpenTelemetry. Bien que vous puissiez toujours utiliser un format OpenTelemetry pour envoyer vos données à Application Insights, vous pouvez désormais exporter les mêmes données vers tout autre point de terminaison conforme à OpenTelemetry.

Conseil

N’oubliez pas de choisir le langage de votre choix en haut de l’article, afin que cet article cible le langage de développement approprié.

Actuellement, il n’existe aucune prise en charge de client OpenTelemetry optimisée pour les applications Java.

OpenTelemetry n’est actuellement pas pris en charge pour les applications in-process C#.

Vous pouvez obtenir ces avantages en activant OpenTelemetry dans votre application de fonction :

  • Corrélation entre les traces et les journaux générés à la fois sur l’hôte et dans le code de votre application.
  • Génération de données de télémétrie exportables cohérente et basée sur des normes.
  • Intégration à d’autres fournisseurs qui peuvent consommer des données conformes à OpenTelemetry.

OpenTelemetry est activé au niveau de l’application de fonction, à la fois dans la configuration de l’hôte (host.json) et dans votre projet de code. Functions fournit également une expérience cliente optimisée pour l’exportation des données OpenTelemetry à partir de votre code de fonction qui s’exécute dans un processus Worker propre au langage.

1. Activer OpenTelemetry dans l’hôte Functions

Lorsque vous activez la sortie OpenTelemetry dans le fichier host.json de l’application de fonction, votre hôte exporte la sortie OpenTelemetry, quelle que soit la pile de langage utilisée par votre application.

Pour activer la sortie OpenTelemetry à partir de l’hôte Functions, mettez à jour le fichier host.json dans votre projet de code de façon à ajouter un élément "telemetryMode": "openTelemetry" à la collection racine. Avec OpenTelemetry activé, votre fichier host.json peut ressembler à ceci :

{
    "version": "2.0",
    "logging": {
        "applicationInsights": {
            "samplingSettings": {
                "isEnabled": true,
                "excludedTypes": "Request"
            },
            "enableLiveMetricsFilters": true
        }
    },
    "telemetryMode": "openTelemetry"
}

2. Configurer les paramètres de l’application

Lorsque OpenTelemetry est activé dans le fichier host.json, les points de terminaison auxquels les données sont envoyées sont déterminés en fonction des paramètres d’application pris en charge par OpenTelemetry disponibles dans les variables d’environnement de votre application.

Créez des paramètres d’application spécifiques dans votre application de fonction en fonction de la destination de sortie OpenTelemetry. Lorsque des paramètres de connexion sont fournis à la fois pour Application Insights et pour un exportateur de protocole OpenTelemetry (OTLP), les données OpenTelemetry sont envoyées aux deux points de terminaison.

APPLICATIONINSIGHTS_CONNECTION_STRING : chaîne de connexion pour un espace de travail Application Insights. Lorsque ce paramètre existe, les données OpenTelemetry sont envoyées à cet espace de travail. Ce paramètre est le même que celui utilisé pour se connecter à Application Insights sans OpenTelemetry activé. Si votre application n’a pas encore ce paramètre, vous devrez peut-être activer l’intégration d’Application Insights.

3. Activer OpenTelemetry dans votre application

Avec l’hôte Functions configuré pour utiliser OpenTelemetry, vous devez également mettre à jour le code de votre application afin de générer des données OpenTelemetry. L’activation d’OpenTelemetry dans l’hôte et dans le code de votre application permet une meilleure corrélation entre les traces et les journaux émis par le processus hôte Functions et à partir de votre processus Worker de langage.

La façon dont vous instrumentez votre application pour utiliser OpenTelemetry dépend de votre point de terminaison OpenTelemetry cible :

  1. Exécutez ces commandes pour installer les assemblys requis dans votre application :

    dotnet add package Microsoft.Azure.Functions.Worker.OpenTelemetry --version 1.0.0-preview1 
dotnet add package OpenTelemetry.Extensions.Hosting 
dotnet add package Azure.Monitor.OpenTelemetry.AspNetCore

  2. Dans votre fichier projet Program.cs, ajoutez cette instruction using :

    using Azure.Monitor.OpenTelemetry.AspNetCore;

  3. Dans le délégué ConfigureServices, ajoutez cette configuration de service :

    services.AddOpenTelemetry()
.UseFunctionsWorkerDefaults()
.UseAzureMonitor();

    Pour exporter vers les deux points de terminaison OpenTelemetry, appelez UseAzureMonitor et UseOtlpExporter.

Les optimisations de Worker Java ne sont pas encore disponibles pour OpenTelemetry. Il n’y a donc rien à configurer dans votre code Java.

  1. Installez ces packages npm dans votre projet :

    npm install @opentelemetry/api 
npm install @opentelemetry/auto-instrumentations-node 
npm install @azure/monitor-opentelemetry-exporter 
npm install @azure/functions-opentelemetry-instrumentation

  1. Créez un fichier de code dans votre projet, copiez et collez le code suivant dans ce nouveau fichier, puis enregistrez le fichier sous src/index.js :

    const { AzureFunctionsInstrumentation } = require('@azure/functions-opentelemetry-instrumentation');
const { AzureMonitorLogExporter, AzureMonitorTraceExporter } = require('@azure/monitor-opentelemetry-exporter');
const { getNodeAutoInstrumentations, getResourceDetectors } = require('@opentelemetry/auto-instrumentations-node');
const { registerInstrumentations } = require('@opentelemetry/instrumentation');
const { detectResourcesSync } = require('@opentelemetry/resources');
const { LoggerProvider, SimpleLogRecordProcessor } = require('@opentelemetry/sdk-logs');
const { NodeTracerProvider, SimpleSpanProcessor } = require('@opentelemetry/sdk-trace-node');

const resource = detectResourcesSync({ detectors: getResourceDetectors() });

const tracerProvider = new NodeTracerProvider({ resource });
tracerProvider.addSpanProcessor(new SimpleSpanProcessor(new AzureMonitorTraceExporter()));
tracerProvider.register();

const loggerProvider = new LoggerProvider({ resource });
loggerProvider.addLogRecordProcessor(new SimpleLogRecordProcessor(new AzureMonitorLogExporter()));

registerInstrumentations({
    tracerProvider,
    loggerProvider,
    instrumentations: [getNodeAutoInstrumentations(), new AzureFunctionsInstrumentation()],
});

  2. Mettez à jour le champ main dans votre fichier package.json de façon à inclure ce nouveau fichier src/index.js, qui peut ressembler à ceci :

    "main": "src/{index.js,functions/*.js}"

  1. Créez un fichier de code dans votre projet, copiez et collez le code suivant dans ce nouveau fichier, puis enregistrez le fichier sous src/index.ts :

    import { AzureFunctionsInstrumentation } from '@azure/functions-opentelemetry-instrumentation';
import { AzureMonitorLogExporter, AzureMonitorTraceExporter } from '@azure/monitor-opentelemetry-exporter';
import { getNodeAutoInstrumentations, getResourceDetectors } from '@opentelemetry/auto-instrumentations-node';
import { registerInstrumentations } from '@opentelemetry/instrumentation';
import { detectResourcesSync } from '@opentelemetry/resources';
import { LoggerProvider, SimpleLogRecordProcessor } from '@opentelemetry/sdk-logs';
import { NodeTracerProvider, SimpleSpanProcessor } from '@opentelemetry/sdk-trace-node';

const resource = detectResourcesSync({ detectors: getResourceDetectors() });

const tracerProvider = new NodeTracerProvider({ resource });
tracerProvider.addSpanProcessor(new SimpleSpanProcessor(new AzureMonitorTraceExporter()));
tracerProvider.register();

const loggerProvider = new LoggerProvider({ resource });
loggerProvider.addLogRecordProcessor(new SimpleLogRecordProcessor(new AzureMonitorLogExporter()));

registerInstrumentations({
    tracerProvider,
    loggerProvider,
    instrumentations: [getNodeAutoInstrumentations(), new AzureFunctionsInstrumentation()],
});

  2. Mettez à jour le champ main dans votre fichier package.json de façon à inclure la sortie de ce nouveau fichier src/index.ts, qui peut ressembler à ceci :

    "main": "dist/src/{index.js,functions/*.js}"

Important

La sortie OpenTelemetry vers Application Insights à partir du Worker de langage n’est actuellement pas prise en charge pour les applications PowerShell. À la place, vous souhaiterez peut-être utiliser un point de terminaison d’exportateur OTLP. Lorsque votre hôte est configuré pour envoyer la sortie OpenTelemetry vers Application Insights, les journaux générés par le processus Worker PowerShell sont toujours transférés, mais le suivi distribué n’est pas pris en charge pour le moment.

Ces instructions s’appliquent uniquement à un exportateur OTLP :

  1. Ajoutez un paramètre d’application nommé OTEL_FUNCTIONS_WORKER_ENABLED avec la valeur True.

  2. Créez un dossier Modules au niveau de l’application à la racine de votre application, et exécutez la commande suivante :

    Save-Module -Name AzureFunctions.PowerShell.OpenTelemetry.SDK

    Cela installe le module AzureFunctions.PowerShell.OpenTelemetry.SDK requis directement dans votre application. Vous ne pouvez pas utiliser le fichier requirements.psd1 pour installer automatiquement cette dépendance, car les dépendances managées ne sont actuellement pas prises en charge dans la préversion du plan Consommation flexible.

  3. Ajoutez ce code à votre fichier profile.ps1 :

    Import-Module AzureFunctions.PowerShell.OpenTelemetry.SDK -Force -ErrorAction Stop 
Initialize-FunctionsOpenTelemetry

  1. Ajoutez cette entrée dans votre fichier requirements.txt :

    azure.monitor.opentelemetry

  2. Ajoutez ce code à votre fichier de point d’entrée principal function_app.py :

    from azure.monitor.opentelemetry import configure_azure_monitor 
configure_azure_monitor()

Considérations relatives à OpenTelemetry

Lorsque vous exportez vos données à l’aide d’OpenTelemetry, gardez à l’esprit les considérations actuelles suivantes.

  • Lorsque l’hôte est configuré de façon à utiliser OpenTelemetry, seuls les journaux et les traces sont exportés. Les métriques d’hôte ne sont pas exportées actuellement.

  • Vous ne pouvez pas exécuter votre projet d’application localement à l’aide de Core Tools quand OpenTelemetry est activé dans l’hôte. Vous devez actuellement déployer votre code sur Azure pour valider vos mises à jour liées à OpenTelemetry.

  • À l’heure actuelle, seuls les déclencheurs HTTP et les déclencheurs basés sur le kit SDK Azure sont pris en charge avec les sorties OpenTelemetry.

Contenu connexe

Superviser Azure FunctionsPlan Consommation flexible