Freigeben über

Verwenden von OpenTelemetry mit Azure Functions

  • Artikel

Wichtig

Die OpenTelemetry-Unterstützung für Azure Functions befindet sich derzeit in der Vorschau.

In diesem Artikel erfahren Sie, wie Sie Ihre Funktions-App so konfigurieren, dass Protokoll- und Ablaufverfolgungsdaten in einem OpenTelemetry-Format exportiert werden. Azure Functions generiert Telemetriedaten zu Ihren Funktionsausführungen sowohl aus dem Functions-Hostprozess als auch aus dem sprachspezifischen Arbeitsprozess, in dem Ihr Funktionscode ausgeführt wird. Standardmäßig werden diese Telemetriedaten mithilfe des Application Insights SDK an Application Insights gesendet. Sie können diese Daten jedoch mithilfe der OpenTelemetry-Semantik exportieren. Sie können zwar weiterhin ein OpenTelemetry-Format verwenden, um Ihre Daten an Application Insights zu senden, aber Sie können jetzt auch dieselben Daten in einen anderen mit OpenTelemetry kompatiblen Endpunkt exportieren.

Tipp

Da sich dieser Artikel auf ihre Entwicklungssprache bezieht, denken Sie daran, am Anfang des Artikels die richtige Sprache auszuwählen.

Derzeit gibt es keine clientoptimierte OpenTelemetry-Unterstützung für Java-Apps.

OpenTelemetry wird derzeit für C#-In-Process-Apps nicht unterstützt.

Sie können diese Vorteile erhalten, indem Sie OpenTelemetry in Ihrer Funktions-App aktivieren:

  • Korrelation über Ablaufverfolgungen und Protokolle hinweg, die sowohl auf dem Host als auch im Anwendungscode generiert werden.
  • Konsistente, standardsbasierte Generierung exportierter Telemetriedaten.
  • Integriert sich in andere Anbieter, die mit OpenTelemetry kompatible Daten nutzen können.

OpenTelemetry ist auf Funktions-App-Ebene aktiviert, sowohl in der Hostkonfiguration (host.json) als auch im Codeprojekt. Funktionen bieten auch eine clientoptimierte Oberfläche zum Exportieren von OpenTelemetry-Daten aus Ihrem Funktionscode, der in einem sprachspezifischen Arbeitsprozess ausgeführt wird.

1. Aktivieren von OpenTelemetry im Functions-Host

Wenn Sie die OpenTelemetry-Ausgabe in der host.json-Datei der Funktions-App aktivieren, exportiert Ihr Host die OpenTelemetry-Ausgabe unabhängig von dem von Ihrer App verwendeten Sprachstack.

Um die OpenTelemetry-Ausgabe vom Funktionshost zu aktivieren, aktualisieren Sie die host.json Datei in Ihrem Codeprojekt, um der Stammauflistung ein "telemetryMode": "openTelemetry"-Element hinzuzufügen. Wenn OpenTelemetry aktiviert ist, sieht ihre host.json Datei möglicherweise wie folgt aus:

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

2. Konfigurieren von Anwendungseinstellungen

Wenn OpenTelemetry in der Datei host.json aktiviert ist, werden die Endpunkte, an die Daten gesendet werden, auf der Grundlage der von OpenTelemetry unterstützten Anwendungseinstellungen bestimmt, die in den Umgebungsvariablen Ihrer App verfügbar sind.

Erstellen Sie bestimmte Anwendungseinstellungen in Ihrer Funktions-App basierend auf dem OpenTelemetry-Ausgabeziel. Wenn Verbindungseinstellungen sowohl für Application Insights als auch für einen OTLP-Exporter (OpenTelemetry-Protokoll) bereitgestellt werden, werden OpenTelemetry-Daten an beide Endpunkte gesendet.

APPLICATIONINSIGHTS_CONNECTION_STRING: die Verbindungszeichenfolge für einen Application Insights-Arbeitsbereich. Wenn diese Einstellung vorhanden ist, werden OpenTelemetry-Daten an diesen Arbeitsbereich gesendet. Diese Einstellung ist die gleiche, mit der Sie eine Verbindung zu Application Insights herstellen, ohne dass OpenTelemetry aktiviert ist. Wenn Ihre App noch nicht über diese Einstellung verfügt, müssen Sie möglicherweise die Application Insights-Integration aktivieren.

3. Aktivieren von OpenTelemetry in Ihrer App

Wenn der Functions-Host für die Verwendung von OpenTelemetry konfiguriert ist, sollten Sie den Anwendungscode auch so aktualisieren, dass OpenTelemetry-Daten ausgegeben werden. Das Aktivieren von OpenTelemetry sowohl im Host als auch im Anwendungscode ermöglicht eine bessere Korrelation zwischen Ablaufverfolgungen und Protokollen, die sowohl vom Hostprozess der Funktionen als auch vom Spracharbeitsprozess ausgegeben werden.

Die Art und Weise, wie Sie Ihre Anwendung zur Verwendung von OpenTelemetry instrumentieren, hängt vom OpenTelemetry-Zielendpunkt ab:

  1. Führen Sie die folgenden Befehle aus, um die erforderlichen Assemblys in Ihrer App zu installieren:

    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. Fügen Sie in Ihrer Program.cs-Projektdatei diese using-Anweisung hinzu:

    using Azure.Monitor.OpenTelemetry.AspNetCore;

  3. Fügen Sie im Delegat ConfigureServices diese Dienstkonfiguration hinzu:

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

    Zum Exportieren in beide OpenTelemetry-Endpunkte rufen Sie sowohl UseAzureMonitor als auch UseOtlpExporter auf.

Java-Workeroptimierungen sind für OpenTelemetry noch nicht verfügbar, daher gibt es in Ihrem Java-Code nichts zu konfigurieren.

  1. Installieren Sie diese npm-Pakete in Ihrem Projekt:

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

  1. Erstellen Sie eine Codedatei in Ihrem Projekt, kopieren Sie den folgenden Code, fügen Sie ihn in diese neue Datei ein, und speichern Sie die Datei unter 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. Aktualisieren Sie das Feld main in Ihrer package.json Datei, um diese neue Datei src/index.js einzuschließen, die wie folgt aussehen kann:

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

  1. Erstellen Sie eine Codedatei in Ihrem Projekt, kopieren Sie den folgenden Code, fügen Sie ihn in diese neue Datei ein, und speichern Sie die Datei unter 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. Aktualisieren Sie das Feld main in Ihrer package.json-Datei, um die Ausgabe dieser neuen src/index.ts-Datei einzuschließen, die wie folgt aussehen kann:

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

Wichtig

Die OpenTelemetry-Ausgabe für Application Insights vom Sprachworker wird für PowerShell-Apps derzeit nicht unterstützt. Sie sollten vielleicht stattdessen einen OTLP-Exporter-Endpunkt verwenden. Wenn Ihr Host für die OpenTelemetry-Ausgabe in Application Insights konfiguriert ist, werden die vom PowerShell-Workerprozess generierten Protokolle weiterhin weitergeleitet, die verteilte Ablaufverfolgung wird derzeit jedoch nicht unterstützt.

Diese Anweisungen gelten nur für einen OTLP-Exporter:

  1. Fügen Sie eine Anwendungseinstellung mit dem Namen OTEL_FUNCTIONS_WORKER_ENABLED mit einem Wert von True hinzu.

  2. Erstellen Sie einen App-Ebene Modules Ordner im Stammverzeichnis Ihrer App, und führen Sie den folgenden Befehl aus:

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

    Dadurch wird das erforderliche AzureFunctions.PowerShell.OpenTelemetry.SDK-Modul direkt in Ihrer App installiert. Sie können die Datei requirements.psd1 nicht verwenden, um diese Abhängigkeit automatisch zu installieren, da verwaltete Abhängigkeiten derzeit in der Vorschau des Flex-Verbrauchsplans nicht unterstützt werden.

  3. Fügen Sie diesen Code zur Datei „profile.ps1“ hinzu:

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

  1. Fügen Sie diesen Eintrag in Ihrer requirements.txt-Datei hinzu:

    azure.monitor.opentelemetry

  2. Fügen Sie diesen Code zu Ihrer function_app.py Haupteinstiegspunktdatei hinzu:

    from azure.monitor.opentelemetry import configure_azure_monitor 
configure_azure_monitor()

Überlegungen zu OpenTelemetry

Wenn Sie Ihre Daten mithilfe von OpenTelemetry exportieren, sollten Sie diese aktuellen Überlegungen berücksichtigen.

  • Wenn der Host für die Verwendung von OpenTelemetry konfiguriert ist, werden nur Protokolle und Ablaufverfolgungen exportiert. Hostmetriken werden derzeit nicht exportiert.

  • Sie können Ihr App-Projekt derzeit nicht lokal mit Core Tools ausführen, wenn OpenTelemetry im Host aktiviert ist. Sie müssen Ihren Code derzeit in Azure bereitstellen, um Ihre OpenTelemetry-bezogenen Updates zu überprüfen.

  • Derzeit werden nur HTTP-Trigger und Azure SDK-basierte Trigger mit OpenTelemetry-Ausgaben unterstützt.

Zugehöriger Inhalt

Überwachen von Azure FunctionsFlex-Verbrauchsplan