Bagikan melalui

Tutorial: Memantau Azure Functions dengan pelacakan terdistribusi OpenTelemetry

Artikel ini menunjukkan dukungan OpenTelemetry pada Azure Functions, yang memungkinkan pelacakan terdistribusi dalam berbagai panggilan fungsi dengan menggunakan integrasi Application Insights dan dukungan OpenTelemetry. Untuk membantu Anda memulai, templat Azure Developer CLI (azd) digunakan untuk membuat proyek kode serta penyebaran Azure untuk menjalankan aplikasi Anda.

Dalam tutorial ini, Anda menggunakan azd alat untuk:

  • Menginisialisasi proyek dengan dukungan OpenTelemetry dari templat.
  • Tinjau kode yang memungkinkan integrasi OpenTelemetry.
  • Jalankan dan verifikasi aplikasi berkemampuan OpenTelemetry Anda secara lokal.
  • Buat aplikasi fungsi dan sumber daya terkait di Azure.
  • Sebarkan proyek kode Anda ke aplikasi fungsi di Azure.
  • Verifikasi pelacakan terdistribusi di Application Insights.

Sumber daya Azure yang diperlukan yang dibuat oleh templat ini mengikuti praktik terbaik saat ini untuk penyebaran aplikasi fungsi yang aman dan dapat diskalakan di Azure. Perintah yang sama azd juga menyebarkan proyek kode Anda ke aplikasi fungsi baru Anda di Azure.

Secara bawaan, paket Konsumsi Flex mengikuti model penagihan bayar untuk apa yang Anda gunakan, yang berarti menyelesaikan panduan ini dikenakan biaya kecil berupa beberapa sen USD atau kurang di akun Azure Anda.

Penting

Artikel ini saat ini hanya mendukung C#, Python, dan TypeScript. Untuk menyelesaikan panduan memulai cepat, pilih salah satu bahasa yang didukung di bagian atas artikel ini.

Prasyarat

Menginisialisasi proyek

azd init Gunakan perintah untuk membuat proyek kode Azure Functions lokal dari templat yang menyertakan pelacakan terdistribusi OpenTelemetry.

  1. Di terminal lokal atau prompt perintah Anda, jalankan perintah ini azd init di folder kosong:

    azd init --template functions-quickstart-python-azd-otel -e flexquickstart-otel

    Perintah ini menarik file proyek dari repositori templat dan menginisialisasi proyek di folder saat ini. Bendera -e menetapkan nama untuk lingkungan saat ini. Di azd, lingkungan mempertahankan konteks penyebaran unik untuk aplikasi Anda, dan Anda dapat menentukan lebih dari satu. Nama lingkungan juga muncul di nama grup sumber daya yang Anda buat di Azure.

  1. Di terminal lokal atau prompt perintah Anda, jalankan perintah ini azd init di folder kosong:

    azd init --template functions-quickstart-typescript-azd-otel -e flexquickstart-otel

    Perintah ini menarik file proyek dari repositori templat dan menginisialisasi proyek di folder saat ini. Bendera -e menetapkan nama untuk lingkungan saat ini. Di azd, lingkungan mempertahankan konteks penyebaran unik untuk aplikasi Anda, dan Anda dapat menentukan lebih dari satu. Nama lingkungan juga muncul di nama grup sumber daya yang Anda buat di Azure.

  1. Di terminal lokal atau prompt perintah Anda, jalankan perintah ini azd init di folder kosong:

    azd init --template functions-quickstart-dotnet-azd-otel -e flexquickstart-otel

    Perintah ini menarik file proyek dari repositori templat dan menginisialisasi proyek di folder saat ini. Bendera -e menetapkan nama untuk lingkungan saat ini. Di azd, lingkungan mempertahankan konteks penyebaran unik untuk aplikasi Anda, dan Anda dapat menentukan lebih dari satu. Nama lingkungan juga muncul di nama grup sumber daya yang Anda buat di Azure.

Meninjau kode

Templat membuat skenario pelacakan terdistribusi lengkap dengan tiga fungsi yang bekerja sama. Mari kita tinjau aspek terkait OpenTelemetry utama:

Konfigurasi OpenTelemetry

File tersebut mengaktifkan OpenTelemetry untuk Functions host:

{
  "version": "2.0",
  "telemetryMode": "OpenTelemetry",
  "extensions": {
    "serviceBus": {
        "maxConcurrentCalls": 10
    }
  },
  "extensionBundle": {
    "id": "Microsoft.Azure.Functions.ExtensionBundle",
    "version": "[4.*, 5.0.0)"
  }
}

Pengaturan kunci "telemetryMode": "OpenTelemetry" memungkinkan terjadinya pelacakan secara terdistribusi sepanjang panggilan fungsi.

File src/OTelSample/host.json mengaktifkan OpenTelemetry untuk host Function.

{
  "version": "2.0",
  "telemetryMode": "OpenTelemetry",
  "logging": {
    "OpenTelemetry": {
      "logLevel": {
        "Host.General": "Warning"
      }
    }
  }
}

Pengaturan utama "telemetryMode": "OpenTelemetry" memungkinkan pelacakan terdistribusi di seluruh panggilan fungsi.

Dependensi untuk OpenTelemetry

File src/otel-sample/requirements.txt ini mencakup paket yang diperlukan untuk integrasi OpenTelemetry:

azure-functions
azure-monitor-opentelemetry
requests

Paket ini azure-monitor-opentelemetry menyediakan integrasi OpenTelemetry dengan Application Insights.

File src/otel-sample/package.json ini mencakup paket yang diperlukan untuk integrasi OpenTelemetry:

{
  "dependencies": {
    "@azure/functions": "^4.0.0",
    "@azure/functions-opentelemetry-instrumentation": "^0.1.0",
    "@azure/monitor-opentelemetry-exporter": "^1.0.0",
    "axios": "^1.6.0"
  }
}

Paket @azure/functions-opentelemetry-instrumentation dan @azure/monitor-opentelemetry-exporter menyediakan integrasi OpenTelemetry dengan Application Insights.

File .csproj ini mencakup paket yang diperlukan untuk integrasi OpenTelemetry:

<PackageReference Include="Azure.Monitor.OpenTelemetry.Exporter" Version="1.4.0" />
<PackageReference Include="Microsoft.Azure.Functions.Worker.OpenTelemetry" Version="1.4.0" />
<PackageReference Include="OpenTelemetry.Instrumentation.Http" Version="1.10.0" />

Paket-paket ini menyediakan integrasi OpenTelemetry dengan Application Insights dan instrumentasi HTTP untuk pelacakan terdistribusi.

Implementasi fungsi

Fungsi dalam src/otel-sample/function_app.py menunjukkan alur pelacakan terdistribusi:

Fungsi HTTP pertama

@app.function_name("first_http_function")
@app.route(route="first_http_function", auth_level=func.AuthLevel.ANONYMOUS)
def first_http_function(req: func.HttpRequest) -> func.HttpResponse:
    logging.info('Python HTTP trigger function (first) processed a request.')

    # Call the second function
    base_url = f"{req.url.split('/api/')[0]}/api"
    second_function_url = f"{base_url}/second_http_function"

    response = requests.get(second_function_url)
    second_function_result = response.text

    result = {
        "message": "Hello from the first function!",
        "second_function_response": second_function_result
    }

    return func.HttpResponse(
        json.dumps(result),
        status_code=200,
        mimetype="application/json"
    )

Fungsi HTTP Kedua

@app.function_name("second_http_function")
@app.route(route="second_http_function", auth_level=func.AuthLevel.ANONYMOUS)
@app.service_bus_queue_output(arg_name="outputsbmsg", queue_name="%ServiceBusQueueName%",
                              connection="ServiceBusConnection")
def second_http_function(req: func.HttpRequest, outputsbmsg: func.Out[str]) -> func.HttpResponse:
    logging.info('Python HTTP trigger function (second) processed a request.')

    message = "This is the second function responding."

    # Send a message to the Service Bus queue
    queue_message = "Message from second HTTP function to trigger ServiceBus queue processing"
    outputsbmsg.set(queue_message)
    logging.info('Sent message to ServiceBus queue: %s', queue_message)

    return func.HttpResponse(
        message,
        status_code=200
    )

Pemicu Antrean Bus Layanan

@app.service_bus_queue_trigger(arg_name="azservicebus", queue_name="%ServiceBusQueueName%",
                               connection="ServiceBusConnection") 
def servicebus_queue_trigger(azservicebus: func.ServiceBusMessage):
    logging.info('Python ServiceBus Queue trigger start processing a message: %s',
                azservicebus.get_body().decode('utf-8'))
    time.sleep(5)  # Simulate processing work
    logging.info('Python ServiceBus Queue trigger end processing a message')

Konfigurasi OpenTelemetry disiapkan di src/otel-sample/index.ts:

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

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

const tracerProvider = new NodeTracerProvider({ 
  resource, 
  spanProcessors: [new SimpleSpanProcessor(new AzureMonitorTraceExporter())] 
});
tracerProvider.register();

const loggerProvider = new LoggerProvider({
  resource,
  processors: [new SimpleLogRecordProcessor(new AzureMonitorLogExporter())],
});

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

Fungsi didefinisikan dalam src/otel-sample/src/functions folder:

Fungsi HTTP pertama

export async function firstHttpFunction(
  request: HttpRequest,
  context: InvocationContext
): Promise<HttpResponseInit> {
  context.log("TypeScript HTTP trigger function (first) processed a request.");

  try {
    // Call the second function
    const baseUrl = request.url.split("/api/")[0];
    const secondFunctionUrl = `${baseUrl}/api/second_http_function`;

    const response = await axios.get(secondFunctionUrl);
    const secondFunctionResult = response.data;

    const result = {
      message: "Hello from the first function!",
      second_function_response: secondFunctionResult,
    };

    return {
      status: 200,
      body: JSON.stringify(result),
      headers: { "Content-Type": "application/json" },
    };
  } catch (error) {
    return {
      status: 500,
      body: JSON.stringify({ error: "Failed to process request" }),
    };
  }
}

Fungsi HTTP Kedua

export async function secondHttpFunction(
  request: HttpRequest,
  context: InvocationContext
): Promise<HttpResponseInit> {
  context.log("TypeScript HTTP trigger function (second) processed a request.");

  const message = "This is the second function responding.";

  // Send a message to the Service Bus queue
  const queueMessage =
    "Message from second HTTP function to trigger ServiceBus queue processing";

  context.extraOutputs.set(serviceBusOutput, queueMessage);
  context.log("Sent message to ServiceBus queue:", queueMessage);

  return {
    status: 200,
    body: message,
  };
}

Pemicu Antrean Bus Layanan

export async function serviceBusQueueTrigger(
  message: unknown,
  context: InvocationContext
): Promise<void> {
  context.log("TypeScript ServiceBus Queue trigger start processing a message:", message);

  // Simulate processing time
  await new Promise((resolve) => setTimeout(resolve, 5000));

  context.log("TypeScript ServiceBus Queue trigger end processing a message");
}

Konfigurasi OpenTelemetry disiapkan di src/OTelSample/Program.cs:

using Azure.Monitor.OpenTelemetry.Exporter;
using Microsoft.Azure.Functions.Worker;
using Microsoft.Azure.Functions.Worker.OpenTelemetry;
using OpenTelemetry.Trace;

var builder = FunctionsApplication.CreateBuilder(args);

builder.ConfigureFunctionsWebApplication();

builder.Logging.AddOpenTelemetry(logging =>
{
    logging.IncludeFormattedMessage = true;
    logging.IncludeScopes = true;
});

builder.Services.AddOpenTelemetry()    
    .WithTracing(tracing =>
    {
        tracing.AddHttpClientInstrumentation();
    });

builder.Services.AddOpenTelemetry().UseAzureMonitorExporter();
builder.Services.AddOpenTelemetry().UseFunctionsWorkerDefaults();

builder.Services.AddHttpClient();

builder.Build().Run();

Fungsi didefinisikan dalam file kelas terpisah:

Fungsi HTTP pertama

public class FirstHttpTrigger
{
    private readonly ILogger<FirstHttpTrigger> _logger;
    private readonly IHttpClientFactory _httpClientFactory;

    public FirstHttpTrigger(ILogger<FirstHttpTrigger> logger, IHttpClientFactory httpClientFactory)
    {
        _logger = logger;
        _httpClientFactory = httpClientFactory;
    }

    [Function("first_http_function")]
    public async Task<IActionResult> Run(
         [HttpTrigger(AuthorizationLevel.Anonymous, "get", "post")] HttpRequestData req)
    {
        _logger.LogInformation("first_http_function function processed a request.");

        var baseUrl = $"{req.Url.AbsoluteUri.Split("/api/")[0]}/api";
        var targetUri = $"{baseUrl}/second_http_function";

        var client = _httpClientFactory.CreateClient();
        var response = await client.GetAsync(targetUri);
        var content = await response.Content.ReadAsStringAsync();

        return new OkObjectResult($"Called second_http_function, status: {response.StatusCode}, content: {content}");
    }
}

Fungsi HTTP Kedua

public class SecondHttpTrigger
{
    private readonly ILogger<SecondHttpTrigger> _logger;

    public SecondHttpTrigger(ILogger<SecondHttpTrigger> logger)
    {
        _logger = logger;
    }

    [Function("second_http_function")]
    public MultiResponse Run([HttpTrigger(AuthorizationLevel.Anonymous, "get", "post")] HttpRequestData req)
    {
        _logger.LogInformation("second_http_function function processed a request.");

        return new MultiResponse
        {
            Messages = new string[] { "Hello" },
            HttpResponse = req.CreateResponse(System.Net.HttpStatusCode.OK)
        };
    }
}

public class MultiResponse
{
    [ServiceBusOutput("%ServiceBusQueueName%", Connection = "ServiceBusConnection")]
    public string[]? Messages { get; set; }

    [HttpResult]
    public HttpResponseData? HttpResponse { get; set; }
}

Pemicu Antrean Bus Layanan

public class ServiceBusQueueTrigger
{
    private readonly ILogger<ServiceBusQueueTrigger> _logger;

    public ServiceBusQueueTrigger(ILogger<ServiceBusQueueTrigger> logger)
    {
        _logger = logger;
    }

    [Function("servicebus_queue_trigger")]
    public async Task Run(
        [ServiceBusTrigger("%ServiceBusQueueName%", Connection = "ServiceBusConnection")]
        ServiceBusReceivedMessage message,
        ServiceBusMessageActions messageActions)
    {
        _logger.LogInformation("Message ID: {id}", message.MessageId);
        _logger.LogInformation("Message Body: {body}", message.Body);

        // Complete the message
        await messageActions.CompleteMessageAsync(message);
    }
}

Alur pelacakan terdistribusi

Arsitektur ini membuat skenario pelacakan terdistribusi lengkap, dengan perilaku ini:

  1. Fungsi HTTP pertama menerima permintaan HTTP dan memanggil fungsi HTTP kedua
  2. Fungsi HTTP kedua merespons dan mengirim pesan ke Azure Service Bus
  3. Pemicu Azure Service Bus memproses pesan dengan penundaan untuk mensimulasikan pekerjaan pemrosesan

Aspek utama dari implementasi OpenTelemetry:

  • Integrasi OpenTelemetry: File ini memungkinkan aktivasi host.json OpenTelemetry dengan "telemetryMode": "OpenTelemetry"
  • Penautan fungsi: Fungsi pertama memanggil yang kedua menggunakan permintaan HTTP, membuat jejak berkorelasi
  • Integrasi Azure Service Bus: Fungsi kedua memberikan output ke Azure Service Bus, yang memicu fungsi ketiga
  • Autentikasi anonim: Fungsi HTTP menggunakan auth_level=func.AuthLevel.ANONYMOUS, sehingga tidak ada kunci fungsi yang diperlukan

Anda dapat meninjau proyek templat lengkap di sini.

  • Integrasi OpenTelemetry: File index.ts mengonfigurasi OpenTelemetry dengan eksportir Azure Monitor untuk jejak dan log
  • Penautan fungsi: Fungsi pertama memanggil yang kedua menggunakan axios dengan propagasi pelacakan otomatis
  • Integrasi Service Bus: Fungsi kedua memberikan output ke Service Bus menggunakan pengikatan output yang memicu fungsi ketiga.
  • Identitas terkelola: Semua koneksi Bus Layanan menggunakan identitas terkelola alih-alih string koneksi
  • Simulasi pemrosesan: Penundaan 5 detik dalam pemicu Azure Service Bus mensimulasikan pekerjaan pemrosesan pesan

Anda dapat meninjau proyek templat lengkap di sini.

  • Integrasi OpenTelemetry: File Program.cs mengonfigurasi OpenTelemetry dengan pengekspor Azure Monitor
  • Penautan fungsi: Fungsi pertama memanggil yang kedua menggunakan HttpClient dengan instrumentasi OpenTelemetry
  • Integrasi Service Bus: Fungsi kedua menghasilkan output ke Service Bus menggunakan pengikatan output, yang memicu fungsi ketiga
  • Identitas terkelola: Semua koneksi Bus Layanan menggunakan identitas terkelola alih-alih string koneksi
  • .NET 8 Pekerja Terisolasi: Menggunakan model Pekerja Terisolasi .NET Azure Functions terbaru untuk performa dan fleksibilitas yang lebih baik

Anda dapat meninjau proyek templat lengkap di sini.

Setelah Anda memverifikasi fungsi Anda secara lokal, saatnya untuk menerbitkannya ke Azure.

Sebarkan ke Azure

Proyek ini dikonfigurasi untuk menggunakan perintah azd up untuk menerapkan proyek ini ke aplikasi fungsi baru dalam paket Konsumsi Flex di Azure dengan dukungan OpenTelemetry.

Petunjuk / Saran

Proyek ini mencakup sekumpulan file Bicep yang digunakan azd untuk membuat penyebaran aman ke rencana konsumsi Flex sesuai praktik terbaik, termasuk koneksi identitas terkelola.

  1. Jalankan perintah ini untuk membuat azd sumber daya Azure yang diperlukan di Azure dan menyebarkan proyek kode Anda ke aplikasi fungsi baru:

    azd up

    Folder akar berisi file definisi yang azure.yaml diperlukan oleh azd.

    Jika Anda belum masuk, Anda diminta untuk mengautentikasi dengan akun Azure Anda.

  2. Saat diminta, berikan parameter penyebaran yang diperlukan ini:

    Pengaturan Description
    langganan Azure Langganan tempat sumber daya Anda dibuat.
    Lokasi Azure Wilayah Azure untuk membuat grup sumber daya yang berisi sumber daya Azure baru. Hanya wilayah yang saat ini mendukung paket Konsumsi Flex yang ditampilkan.

    Perintah menggunakan azd up respons Anda terhadap perintah ini dengan file konfigurasi Bicep untuk menyelesaikan tugas penyebaran ini:

    • Buat dan konfigurasikan sumber daya Azure yang diperlukan ini (setara dengan azd provision):

      • Rencana Konsumsi Fleksibel Azure Functions dan aplikasi fungsi tersebut dengan OpenTelemetry telah diaktifkan
      • Azure Storage (wajib) dan Application Insights (disarankan)
      • Namespace Service Bus dan antrean untuk demonstrasi pelacakan terdistribusi
      • Mengakses kebijakan dan peran untuk akun Anda
      • Koneksi layanan ke layanan menggunakan identitas terkelola (bukan string koneksi tersimpan)

    • Paketkan dan sebarkan kode Anda ke kontainer penyebaran (setara dengan azd deploy). Aplikasi kemudian dimulai dan berjalan dalam paket yang disebarkan.

    Setelah perintah berhasil diselesaikan, Anda akan melihat tautan ke sumber daya yang Anda buat.

Menguji pelacakan terdistribusi

Sekarang Anda dapat menguji fungsionalitas pelacakan terdistribusi OpenTelemetry dengan memanggil fungsi yang Anda sebarkan dan mengamati telemetri di Application Insights.

Menggunakan fungsi pada Azure

Anda dapat memanggil titik akhir fungsi Anda di Azure dengan membuat permintaan HTTP ke URL mereka. Karena fungsi HTTP dalam templat ini dikonfigurasi dengan akses anonim, tidak ada kunci fungsi yang diperlukan.

  1. Di terminal lokal atau prompt perintah Anda, jalankan perintah ini untuk mendapatkan nama fungsi aplikasi dan membangun URL:

    APP_NAME=$(azd env get-value AZURE_FUNCTION_NAME)
echo "Function URL: https://$APP_NAME.azurewebsites.net/api/first_http_function"

    Perintah azd env get-value mendapatkan nama aplikasi fungsi Anda dari lingkungan lokal.

  2. Uji fungsi di browser Anda dengan menavigasi ke URL:

    https://your-function-app.azurewebsites.net/api/first_http_function

    Ganti your-function-app dengan nama aplikasi fungsi aktual Anda dari langkah sebelumnya. Permintaan tunggal ini membuat jejak terdistribusi yang mengalir melalui ketiga fungsi.

Melihat pelacakan terdistribusi di Application Insights

Setelah memanggil fungsi, Anda dapat mengamati jejak terdistribusi lengkap di Application Insights:

Nota

Mungkin perlu waktu beberapa menit agar data telemetri muncul di Application Insights setelah memanggil fungsi Anda. Jika Anda tidak segera melihat data, tunggu beberapa menit dan refresh tampilan.

  1. Buka sumber daya Application Insights Anda di portal Microsoft Azure (Anda dapat menemukannya di grup sumber daya yang sama dengan aplikasi fungsi Anda).

  2. Buka Peta aplikasi untuk melihat jejak terdistribusi di ketiga fungsi. Anda seharusnya melihat alur dari permintaan HTTP melalui fungsi Anda dan ke Service Bus.

  3. Periksa pencarian Transaksi untuk menemukan permintaan Anda dan lihat garis waktu pelacakan lengkap. Cari transaksi dari aplikasi fungsi Anda.

  4. Pilih transaksi tertentu untuk melihat jejak end-to-end yang menunjukkan:

    • Permintaan HTTP ke first_http_function
    • Panggilan HTTP internal ke second_http_function
    • Pesan dari Service Bus sedang dikirim
    • Memproses servicebus_queue_trigger pesan dari Service Bus

  5. Dalam detail pelacakan, Anda dapat melihat:

    • Informasi waktu: Berapa lama waktu yang diperlukan setiap langkah
    • Dependensi: Koneksi antar fungsi
    • Log: Log aplikasi berkorelasi dengan jejak
    • Metrik performa: Waktu respons dan throughput

Contoh ini menunjukkan pelacakan terdistribusi end-to-end di beberapa Azure Functions dengan integrasi OpenTelemetry, memberikan visibilitas lengkap ke perilaku dan performa aplikasi Anda.

Menyebarkan ulang kode Anda

Jalankan azd up perintah sebanyak yang Anda butuhkan untuk menyediakan sumber daya Azure Anda dan menyebarkan pembaruan kode ke aplikasi fungsi Anda.

Nota

Paket penyebaran terbaru selalu menimpa file kode yang telah disebarkan.

Respons awal Anda terhadap azd perintah dan variabel lingkungan apa pun yang dihasilkan oleh azd disimpan secara lokal di lingkungan bernama Anda. azd env get-values Gunakan perintah untuk meninjau semua variabel di lingkungan Anda yang digunakan perintah saat membuat sumber daya Azure.

Membersihkan sumber daya

Setelah selesai bekerja dengan aplikasi fungsi dan sumber daya terkait, gunakan perintah ini untuk menghapus aplikasi fungsi dan sumber daya terkait dari Azure dan hindari menimbulkan biaya lebih lanjut:

azd down --no-prompt

Nota

Opsi ini --no-prompt menginstruksikan azd untuk menghapus grup sumber daya Anda tanpa konfirmasi dari Anda.

Perintah ini tidak memengaruhi proyek kode lokal Anda.

Konten terkait

  • Last updated on