Schnellstart: Verarbeiten von Echtzeitereignissen mithilfe von Azure Functions

In diesem Artikel verwenden Sie die Azure Developer CLI (azd), um eine Event Hubs-Triggerfunktion für die Echtzeitereignisverarbeitung in Azure Functions zu erstellen. Nachdem Sie den Code lokal überprüft haben, stellen Sie ihn in einer neuen serverlosen Funktions-App bereit, die in einem Flex-Verbrauchsplan in Azure ausgeführt wird.

Die Projektquelle verwendet azd , um die Funktions-App und zugehörige Ressourcen zu erstellen und Ihren Code in Azure bereitzustellen. Diese Bereitstellung folgt den aktuellen bewährten Methoden für sichere und skalierbare Azure Functions Bereitstellungen.

Standardmäßig folgt der Flex-Verbrauchsplan einem Zahlung nach Nutzung-Abrechnungsmodell, was bedeutet, dass Sie diese Aufgabe abschließen können und nur geringe Kosten von wenigen US-Cent oder weniger in Ihrem Azure-Konto verursachen.

Dieser Artikel unterstützt Version 4 des Node.js-Programmiermodells für Azure Functions.

Dieser Artikel unterstützt Version 2 des Python-Programmiermodells für Azure Functions.

Voraussetzungen

.NET 8 SDK

Java 21 Developer Kit
- Legen Sie die JAVA_HOME Umgebungsvariable auf den Installationsspeicherort der richtigen Version des Java Development Kit (JDK) fest.
Apache Maven 3.8.x

Node.js 22 oder höher

PowerShell 7.4

Python 3.11 oder höher

Azurite-Speicheremulator
Azure Developer CLI
Azure Functions Core Tools
Azure CLI
Ein Azure-Konto mit einem aktiven Abonnement. Kostenlos ein Konto erstellen.

Initialisieren des Projekts

Verwenden Sie den azd init Befehl, um ein lokales Azure Functions-Codeprojekt aus einer Vorlage zu erstellen.

Führen Sie in Ihrem lokalen Terminal oder in der Eingabeaufforderung diesen azd init-Befehl in einem leeren Ordner aus:

azd init --template functions-quickstart-dotnet-azd-eventhub -e eventhub-dotnet

Mit diesem Befehl werden die Projektdateien aus dem Vorlagen-Repository abgerufen und das Projekt im aktuellen Ordner initialisiert. Das -e-Flag legt einen Namen für die aktuelle Umgebung fest. In azdder Umgebung wird ein eindeutiger Bereitstellungskontext für Ihre App verwaltet, und Sie können mehrere definieren. Der Umgebungsname wird auch im Namen der Ressourcengruppe verwendet, die Sie in Azure erstellen.

Führen Sie in Ihrem lokalen Terminal oder in der Eingabeaufforderung diesen azd init-Befehl in einem leeren Ordner aus:

azd init --template functions-quickstart-typescript-azd-eventhub -e eventhub-ts

Führen Sie in Ihrem lokalen Terminal oder in der Eingabeaufforderung diesen azd init-Befehl in einem leeren Ordner aus:

azd init --template functions-quickstart-python-azd-eventhub -e eventhub-py

Erstellen und Aktivieren einer virtuellen Umgebung

Führen Sie im Stammordner die folgenden Befehle aus, um eine virtuelle Umgebung mit dem Namen „.venv“ zu erstellen und zu aktivieren:

python3 -m venv .venv
source .venv/bin/activate

Wenn Python das venv-Paket nicht in Ihrer Linux-Verteilung installiert, führen Sie den folgenden Befehl aus:

sudo apt-get install python3-venv

py -m venv .venv
source .venv/scripts/activate

py -m venv .venv
.venv\scripts\activate

Führen Sie in Ihrem lokalen Terminal oder in der Eingabeaufforderung diesen azd init-Befehl in einem leeren Ordner aus:

azd init --template functions-quickstart-java-azd-eventhub -e eventhub-java

Führen Sie in Ihrem lokalen Terminal oder in der Eingabeaufforderung diesen azd init-Befehl in einem leeren Ordner aus:

azd init --template functions-quickstart-javascript-azd-eventhub -e eventhub-js

Führen Sie in Ihrem lokalen Terminal oder in der Eingabeaufforderung diesen azd init-Befehl in einem leeren Ordner aus:

azd init --template functions-quickstart-powershell-azd-eventhub -e eventhub-ps

Azure-Ressourcen erstellen

Bevor Sie Ihre Funktion lokal ausführen können, müssen Sie einen Event Hubs-Namespace und einen Hub in Azure erstellen. Verwenden Sie azd provision diese Ressourcen und konfigurieren Sie Ihre lokalen Einstellungen, indem Sie die erforderliche Datei local.settings.json hinzufügen.

Führen Sie den folgenden Befehl aus, um sich bei Azure anzumelden:
```
azd auth login
```
Folgen Sie den Anweisungen zur Authentifizierung mithilfe Ihres Azure-Kontos.
Führen Sie im Stammordner den folgenden Befehl aus, um Ihre Azure-Ressourcen zu erstellen:
```
azd provision
```

Wenn Sie dazu aufgefordert werden, stellen Sie die folgenden erforderlichen Bereitstellungsparameter bereit:

Parameter	Beschreibung
Azure-Abonnement	Abonnement, in dem Sie Ihre Ressourcen erstellen.
Azure-Standort	Azure Region, in der die Ressourcengruppe erstellt werden soll, die die neuen Azure Ressourcen enthält. Es werden nur Regionen angezeigt, die den Flex-Verbrauchsplan derzeit unterstützen.
vnetEnabled	Verwenden Sie den Wert `False`, um den zusätzlichen Aufwand beim Erstellen virtueller Netzwerkressourcen zu vermeiden.

Der azd provision Befehl erstellt die erforderlichen Azure-Ressourcen, einschließlich eines Event Hubs-Namespaces und Hubs, einer Flex Consumption Function App, Application Insights und eines Speicherkontos. Außerdem wird Ihre local.settings.json-Datei mit den Verbindungsinformationen für die Event Hubs konfiguriert.

Ausführen in Ihrer lokalen Umgebung

Starten Sie in einem separaten Terminalfenster den Azurite-Speicheremulator:
```
azurite
```
Der Hostprozess für lokale Funktionen verwendet den Azurite-Emulator für die interne Speicherverbindung (AzureWebJobsStorage), die von der Laufzeit benötigt wird.

Führen Sie zum Starten der Funktions-App die folgenden Befehle in einem Terminal oder einer Eingabeaufforderung aus, um zum Projektordner zu src navigieren und die Funktions-App zu starten:
```
cd src
func start
```

Um die Funktions-App zu starten, führen Sie diesen Befehl in einer Terminal- oder Eingabeaufforderung aus:
```
func start
```

Führen Sie zum Erstellen und Starten der Funktions-App die folgenden Befehle in einer Terminal- oder Eingabeaufforderung aus:
```
mvn clean package
mvn azure-functions:run
```

Um Abhängigkeiten zu installieren und die Funktions-App zu starten, führen Sie die folgenden Befehle in einem Terminal oder einer Eingabeaufforderung aus:
```
npm install
npm start  
```

Um Abhängigkeiten zu installieren und die Funktions-App zu starten, führen Sie die folgenden Befehle in einem Terminal oder einer Eingabeaufforderung aus:
```
cd src
npm install
npm start  
```

Um die Funktions-App zu starten, führen Sie diesen Befehl in einer Terminal- oder Eingabeaufforderung aus:
```
func start
```

Wenn Sie dazu aufgefordert werden, lassen Sie core Tools (func.exe) über die Firewall aufgerufen werden.

Wenn der Funktionshost in Ihrem lokalen Projektordner gestartet wird, schreibt er Informationen zu Ihren Funktionen in die TerminalAusgabe.

Dieses Beispiel enthält eine Timertriggerfunktion, die nachrichtenartikel automatisch alle 10 Sekunden generiert und an Event Hubs sendet. Die Event Hubs-Triggerfunktion verarbeitet dann diese Ereignisse und führt eine Stimmungsanalyse und die Verfolgung des Engagements durch.

Sie sehen eine Ausgabe ähnlich wie in diesem Beispiel:

 [2026-03-02T22:37:30.151Z] Executing 'Functions.EventHubsTrigger'
 [2026-03-02T22:37:30.159Z] Trigger Details: PartitionId: 24, OffsetString: 0, EnqueueTimeUtc: 2026-03-02T22:37:29.1790000+00:00, SequenceNumber: 0, Count: 1, Offset: 0, PartionId: 24
 [2026-03-02T22:37:30.169Z] ⭐ High-engagement article NEWS-20260302-0580CB82 (Views: 6123, Sentiment: 0.57) featured!
 [2026-03-02T22:37:30.174Z] 🔥 Viral article: NEWS-20260302-0580CB82 - 6,123 views
 [2026-03-02T22:37:30.181Z] 🌟 Featured article: NEWS-20260302-0580CB82
 [2026-03-02T22:37:30.185Z] ✅ Successfully processed article NEWS-20260302-0580CB82 - 'Technology Breakthrough in Renewable Energy Technology' by Sarah Johnson
 [2026-03-02T22:37:30.191Z] 📰 Processed 1 news articles, 0 failed in batch of 1
 [2026-03-02T22:37:30.196Z] 📊 NEWS BATCH SUMMARY: 1 articles | Total Views: 6,123 | Avg Views: 6,123 | Avg Sentiment: 0.57 | Status: [Featured: 1]
 [2026-03-02T22:37:30.200Z] 📂 Top Categories: [Health: 1] | Top Sources: [Innovation Weekly: 1]
 [2026-03-02T22:37:30.204Z] 🔥 Viral articles in batch: 1
 [2026-03-02T22:37:30.207Z] Executed 'Functions.EventHubsTrigger' (Succeeded, Duration=55ms)

Wenn Sie fertig sind, drücken Sie STRG+C im Terminalfenster, um den func.exe-Hostprozess zu beenden.
Schließen Sie das Fenster, in dem Azurite läuft.

Führen Sie deactivate aus, um die virtuelle Umgebung zu beenden.

Überprüfen des Codes (optional)

Sie können den Code überprüfen, der die Event Hubs-Triggerfunktion definiert:

using System.Text.Json;
using Azure.Messaging.EventHubs;
using Microsoft.Azure.Functions.Worker;
using Microsoft.Extensions.Logging;

namespace function_app;

public class EventHubsTrigger
{
    private readonly ILogger<EventHubsTrigger> _logger;
    private readonly NewsProcessingService _newsService;

    public EventHubsTrigger(ILogger<EventHubsTrigger> logger, NewsProcessingService newsService)
    {
        _logger = logger;
        _newsService = newsService;
    }

    [Function(nameof(EventHubsTrigger))]
    public async Task Run([EventHubTrigger("news", Connection = "EventHubConnection")] EventData[] input)
    {
        var processedArticles = new List<NewsArticle>();
        var failedEvents = 0;
        
        foreach (var message in input)
        {
            try
            {
                var messageBody = message.EventBody.ToString();

                // Parse the news article event
                var article = ParseNewsArticleEvent(messageBody);

                if (article != null)
                {
                    processedArticles.Add(article);
                }
                else
                {
                    failedEvents++;
                }
            }
            catch (Exception ex)
            {
                failedEvents++;
                _logger.LogWarning($"Error processing message: {ex.Message}");
            }
        }

        // Log summary of this execution
        _logger.LogInformation($"📰 Processed {processedArticles.Count} news articles, {failedEvents} failed in batch of {input.Length}");

Hier können Sie das vollständige Vorlagenprojekt überprüfen.

package com.function;

import com.microsoft.azure.functions.*;
import com.microsoft.azure.functions.annotation.*;

import java.time.Instant;
import java.util.*;
import java.util.logging.Logger;

/**
 * Azure Function that processes messages from an input Event Hub,
 * adds metadata, and sends processed messages to an output Event Hub.
 */
public class EventHubsTriggerFunction {

    @FunctionName("EventHubsTrigger")
    public void run(
            @EventHubTrigger(
                name = "messages",
                eventHubName = "%INPUT_EVENTHUB_NAME%",
                connection = "EventHubConnection",
                cardinality = Cardinality.MANY)
            List<String> messages,
            @EventHubOutput(
                name = "output",
                eventHubName = "%OUTPUT_EVENTHUB_NAME%",
                connection = "EventHubConnection")
            OutputBinding<List<String>> output,
            final ExecutionContext context) {

        Logger logger = context.getLogger();
        logger.info(String.format("🔄 Event hub function processing %d message(s)", messages.size()));

        List<String> processedMessages = new ArrayList<>();

        for (String message : messages) {
            try {
                logger.info("📨 Processing event: " + message);

                // Create processed message with additional metadata
                String processedMessage = String.format(
                    "{\"id\":\"%s\",\"message\":%s,\"timestamp\":\"%s\"}",
                    UUID.randomUUID().toString(),
                    message,
                    Instant.now().toString());

                processedMessages.add(processedMessage);
                logger.info("\u2728 Message processed: " + processedMessage);

            } catch (Exception e) {
                logger.severe("\u274C Error processing message: " + e.getMessage());
            }
        }

        // Send processed messages to output Event Hub
        if (!processedMessages.isEmpty()) {
            output.setValue(processedMessages);
            logger.info(String.format("📤 Sent %d message(s) to output Event Hub", processedMessages.size()));
        }
    }
}

Hier können Sie das vollständige Vorlagenprojekt überprüfen.

const { app, output } = require("@azure/functions");

const eventHubOutput = output.eventHub({
    connection: 'EventHubConnection',
    eventHubName: '%OUTPUT_EVENTHUB_NAME%'
});

async function EventHubsTrigger(messages, context) {
    context.log(`🔄 Event hub function processing ${messages.length} message(s)`);
    
    const processedMessages = [];
    
    for (const message of messages) {
        try {
            // Parse the incoming message
            const eventData = typeof message === 'string' ? JSON.parse(message) : message;
            context.log('📨 Processing event:', eventData);
            
            // Create processed message with additional metadata
            const processedMessage = {
                id: eventData.id || crypto.randomUUID(),
                message: eventData.message || JSON.stringify(eventData),
                timestamp: new Date().toISOString()
            };
            
            processedMessages.push(processedMessage);
            context.log('✨ Message processed:', processedMessage);
            
        } catch (error) {
            context.error(`❌ Error processing message: ${error}`);
        }
    }
    
    // Send processed messages to output Event Hub
    if (processedMessages.length > 0) {
        context.extraOutputs.set(eventHubOutput, processedMessages);
        context.log(`📤 Sent ${processedMessages.length} message(s) to output Event Hub`);
    }
}

app.eventHub('EventHubsTrigger', {
    connection: 'EventHubConnection',
    eventHubName: '%INPUT_EVENTHUB_NAME%',
    cardinality: 'many',
    extraOutputs: [eventHubOutput],
    handler: EventHubsTrigger
});

Hier können Sie das vollständige Vorlagenprojekt überprüfen.

import { app, InvocationContext, output } from "@azure/functions";

interface EventMessage {
    id: string;
    message: string;
    timestamp: string;
}

const eventHubOutput = output.eventHub({
    connection: 'EventHubConnection',
    eventHubName: '%OUTPUT_EVENTHUB_NAME%'
});

export async function EventHubsTrigger(messages: unknown[], context: InvocationContext): Promise<void> {
    context.log(`🔄 Event hub function processing ${messages.length} message(s)`);
    
    const processedMessages: EventMessage[] = [];
    
    for (const message of messages) {
        try {
            // Parse the incoming message
            const eventData = typeof message === 'string' ? JSON.parse(message) : message;
            context.log('📨 Processing event:', eventData);
            
            // Create processed message with additional metadata
            const processedMessage: EventMessage = {
                id: eventData.id || crypto.randomUUID(),
                message: eventData.message || JSON.stringify(eventData),
                timestamp: new Date().toISOString()
            };
            
            processedMessages.push(processedMessage);
            context.log('✨ Message processed:', processedMessage);
            
        } catch (error) {
            context.error(`❌ Error processing message: ${error}`);
        }
    }
    
    // Send processed messages to output Event Hub
    if (processedMessages.length > 0) {
        context.extraOutputs.set(eventHubOutput, processedMessages);
        context.log(`📤 Sent ${processedMessages.length} message(s) to output Event Hub`);
    }
}

app.eventHub('EventHubsTrigger', {
    connection: 'EventHubConnection',
    eventHubName: '%INPUT_EVENTHUB_NAME%',
    cardinality: 'many',
    extraOutputs: [eventHubOutput],
    handler: EventHubsTrigger
});

Hier können Sie das vollständige Vorlagenprojekt überprüfen.

param($InputEvents, $TriggerMetadata)

Write-Host "🔄 Event hub function processing $($InputEvents.Count) message(s)"

$processedMessages = @()

foreach ($message in $InputEvents) {
    try {
        # Parse the incoming message
        $eventData = $message | ConvertFrom-Json -ErrorAction SilentlyContinue
        if (-not $eventData) {
            $eventData = @{ message = $message }
        }

        Write-Host "📨 Processing event: $($eventData | ConvertTo-Json -Compress)"

        # Create processed message with additional metadata
        $processedMessage = @{
            id        = if ($eventData.id) { $eventData.id } else { [guid]::NewGuid().ToString() }
            message   = if ($eventData.message) { $eventData.message } else { ($eventData | ConvertTo-Json -Compress) }
            timestamp = (Get-Date).ToUniversalTime().ToString('o')
        }

        $processedMessages += $processedMessage
        Write-Host "✨ Message processed: $($processedMessage | ConvertTo-Json -Compress)"
    }
    catch {
        Write-Error "❌ Error processing message: $_"
    }
}

# Send processed messages to output Event Hub
if ($processedMessages.Count -gt 0) {
    Push-OutputBinding -Name OutputEvents -Value ($processedMessages | ConvertTo-Json -Compress)
    Write-Host "📤 Sent $($processedMessages.Count) message(s) to output Event Hub"
}

Der Trigger wird im entsprechenden function.json definiert.

Hier können Sie das vollständige Vorlagenprojekt überprüfen.

import azure.functions as func
import logging
import json
from datetime import datetime, timezone
import random
import uuid
from typing import List

app = func.FunctionApp()

# News article data model
class NewsArticle:
            title=random.choice(titles_templates).format(topic=topic),
            content=f"Comprehensive coverage of the latest developments in {topic}. " * random.randint(10, 20),
            author=random.choice(authors),
            source=random.choice(sources),
            category=random.choice(categories),
            published_date=datetime.now(timezone.utc),
            view_count=random.randint(100, 10000),
            sentiment_score=round(random.uniform(-1.0, 1.0), 2),
            status=random.choice(["Published", "Featured"]),
            tags=[random.choice(topics) for _ in range(random.randint(3, 5))]
        )
        articles.append(article)
    
    # Send articles to Event Hub
    events_json = json.dumps([article.to_dict() for article in articles])
    event.set(events_json)
    
    logging.info(f'✅ HIGH-THROUGHPUT: Successfully generated {num_articles} news articles in ~10 seconds')


# Event Hub trigger - processes news articles
@app.event_hub_message_trigger(arg_name="events", event_hub_name="news",
                                connection="EventHubConnection")
def EventHubsTrigger(events: List[func.EventHubEvent]):
    """Process news articles from Event Hub with sentiment analysis and engagement tracking"""
    
    # Handle both single event and list of events
    if not isinstance(events, list):
        events = [events]
    
    batch_articles = []
    failed_count = 0
    
    for event in events:
        try:
            # Parse the event data
            event_data = json.loads(event.get_body().decode('utf-8'))
            
            # Handle both single article and array of articles
            articles = event_data if isinstance(event_data, list) else [event_data]
            
            for article_data in articles:
                # Process each article
                article_id = article_data.get('ArticleId')
                title = article_data.get('Title')
                author = article_data.get('Author')

Hier können Sie das vollständige Vorlagenprojekt überprüfen.

Nachdem Sie Ihre Funktion lokal überprüft haben, ist es an der Zeit, sie in Azure zu veröffentlichen.

In Azure bereitstellen

Dieses Projekt ist so konfiguriert, dass der azd up Befehl verwendet wird, um Ihren Code in einer neuen Funktions-App in einem Flex-Verbrauchsplan in Azure bereitzustellen. Da Sie bereits Ressourcen bereitgestellt haben, stellt dieser Befehl Ihren Code in der vorhandenen Funktions-App bereit.

Tipp

Dieses Projekt enthält eine Reihe von Bicep-Dateien, die azd verwendet, um eine sichere Bereitstellung für einen Flex-Verbrauchsplan, der den bewährten Methoden folgt, zu erstellen.

Führen Sie im Repositorystammordner den folgenden Befehl aus, um Ihr Codeprojekt in der Funktions-App in Azure bereitzustellen:

azd deploy

Die Bereitstellung verpackt Ihren Code und stellt ihn in der Funktions-App bereit. Nach Abschluss des Befehls werden Links zu den von Ihnen erstellten Ressourcen angezeigt.

Überprüfen der Bereitstellung

Nach Abschluss der Bereitstellung beginnt Ihre Event Hub Triggerfunktion automatisch mit der Verarbeitung von Ereignissen, sobald sie im Event Hub eingehen.

Wechseln Sie im Azure-Portal zu Ihrer neuen Funktions-App.
Wählen Sie im linken Menü "Protokolldatenstrom" aus, um die Funktionsausführungen in Echtzeit zu überwachen.
Es werden Logeinträge angezeigt, in denen zu sehen ist, wie Ihre Event-Hubs-Triggerfunktion Ereignisse verarbeitet, die vom Timer-Trigger generiert werden.

Erneutes Bereitstellen Ihres Codes

Führen Sie den azd up Befehl so oft aus, wie Sie ihre Azure-Ressourcen bereitstellen und Codeupdates für Ihre Funktions-App bereitstellen müssen.

Hinweis

Bereitgestellte Codedateien werden immer vom neuesten Bereitstellungspaket überschrieben.

Ihre anfänglichen Antworten auf azd-Eingabeaufforderungen und alle von Ihnen generierten azd-Umgebungsvariablen werden lokal in Ihrer benannten Umgebung gespeichert. Verwenden Sie den azd env get-values-Befehl, um alle Variablen in Ihrer Umgebung zu überprüfen, die beim Erstellen von Azure-Ressourcen verwendet wurden.

Bereinigen von Ressourcen

Wenn Sie mit der Arbeit mit Ihrer Funktions-App und verwandten Ressourcen fertig sind, verwenden Sie diesen Befehl, um die Funktions-App und die zugehörigen Ressourcen aus Azure zu löschen und weitere Kosten zu vermeiden:

azd down --no-prompt

Hinweis

Die --no-prompt-Option weist azd an, Ihre Ressourcengruppe ohne Bestätigung von Ihnen zu löschen.

Dieser Befehl wirkt sich nicht auf Ihr lokales Codeprojekt aus.

Feedback

War diese Seite hilfreich?

Last updated on 2026-05-05

Schnellstart: Verarbeiten von Echtzeitereignissen mithilfe von Azure Functions

Voraussetzungen

Initialisieren des Projekts

Erstellen und Aktivieren einer virtuellen Umgebung

Azure-Ressourcen erstellen

Ausführen in Ihrer lokalen Umgebung

Überprüfen des Codes (optional)

In Azure bereitstellen

Überprüfen der Bereitstellung

Erneutes Bereitstellen Ihres Codes

Bereinigen von Ressourcen

Verwandte Artikel

Feedback

Zusätzliche Ressourcen