Démarrage rapide : Traiter des événements en temps réel à l’aide d’Azure Functions

Dans cet article, vous utilisez Azure Developer CLI (azd) pour créer une fonction de déclencheur Event Hubs pour le traitement des événements en temps réel dans Azure Functions. Après avoir vérifié le code localement, vous le déployez sur une nouvelle application de fonction serverless s’exécutant dans un plan Flex Consumption dans Azure.

La source du projet utilise azd pour créer l’application de fonction et les ressources associées et déployer votre code sur Azure. Ce déploiement suit les meilleures pratiques actuelles pour les déploiements de Azure Functions sécurisés et évolutifs.

Par défaut, le plan Flex Consumption suit un modèle de facturation de paiement à l’utilisation , ce qui signifie que vous pouvez suivre cet article et que vous n’avez qu’un petit coût de quelques cents USD ou moins dans votre compte Azure.

Cet article prend en charge la version 4 du modèle de programmation Node.js pour Azure Functions.

Cet article prend en charge la version 2 du modèle de programmation Python pour Azure Functions.

Prerequisites

SDK .NET 8

kit de développement Java 21
- Définissez la variable d’environnement JAVA_HOME sur l’emplacement d’installation de la version correcte du kit de développement Java (JDK).
Apache Maven 3.8.x

Node.js 22 ou version ultérieure

PowerShell 7.4

Python 3.11 ou version ultérieure

Émulateur de stockage Azurite
CLI Azure pour développeurs
outils de base Azure Functions
Azure CLI
Un compte Azure avec un abonnement actif. Créez un compte gratuitement.

Initialiser le projet

Utilisez la azd init commande pour créer un projet de code Azure Functions local à partir d’un modèle.

Dans votre terminal local ou à l’invite de commandes, exécutez cette commande azd init dans un dossier vide :

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

Cette commande extrait les fichiers projet du référentiel de modèles et initialise le projet dans le dossier actif. L’indicateur -e définit un nom pour l’environnement actuel. Dans azd, l’environnement gère un contexte de déploiement unique pour votre application et vous pouvez en définir plusieurs. Le nom de l’environnement est également utilisé dans le nom du groupe de ressources que vous créez dans Azure.

Dans votre terminal local ou à l’invite de commandes, exécutez cette commande azd init dans un dossier vide :

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

Dans votre terminal local ou à l’invite de commandes, exécutez cette commande azd init dans un dossier vide :

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

Créer et activer un environnement virtuel

Dans le dossier racine, exécutez ces commandes pour créer et activer un environnement virtuel nommé .venv :

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

Si Python n’installe pas le package venv sur votre distribution Linux, exécutez la commande suivante :

sudo apt-get install python3-venv

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

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

Dans votre terminal local ou à l’invite de commandes, exécutez cette commande azd init dans un dossier vide :

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

Dans votre terminal local ou à l’invite de commandes, exécutez cette commande azd init dans un dossier vide :

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

Dans votre terminal local ou à l’invite de commandes, exécutez cette commande azd init dans un dossier vide :

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

Créer des ressources Azure

Avant de pouvoir exécuter votre fonction localement, vous devez créer un espace de noms Event Hubs et un hub dans Azure. Permet azd provision de créer ces ressources et de configurer vos paramètres locaux en ajoutant le fichier local.settings.json requis.

Exécutez la commande ci-après pour vous connecter à Azure :
```
azd auth login
```
Suivez les invites pour vous authentifier à l’aide de votre compte Azure.
À partir du dossier racine, exécutez la commande suivante pour créer vos ressources Azure :
```
azd provision
```

Lorsque vous y êtes invité, fournissez ces paramètres de déploiement requis :

Paramètre	Description
Abonnement Azure	Abonnement dans lequel vous créez vos ressources.
Emplacement Azure	Région Azure où vous allez créer le groupe de ressources qui contient les nouvelles ressources Azure. Seules sont montrées les régions qui prennent actuellement en charge le plan Consommation flexible.
vnetEnabled	Utilisez une valeur de `False` pour éviter la surcharge supplémentaire liée à la création de ressources de réseau virtuel.

La azd provision commande crée les ressources Azure requises, notamment un espace de noms Event Hubs et un hub, une application de fonction Flex Consumption, Application Insights et un compte de stockage. Il configure également votre fichier local.settings.json avec les informations de connexion Event Hubs.

Exécuter dans votre environnement local

Dans une fenêtre de terminal distincte, démarrez l’émulateur de stockage Azurite :
```
azurite
```
Le processus hôte Functions local utilise l’émulateur Azurite pour la connexion de stockage interne (AzureWebJobsStorage) requise par le runtime.

Pour démarrer l’application de fonction, exécutez ces commandes dans un terminal ou une invite de commandes pour accéder au dossier du src projet et démarrer l’application de fonction :
```
cd src
func start
```

Pour démarrer l’application de fonction, exécutez cette commande dans un terminal ou une invite de commandes :
```
func start
```

Pour générer et démarrer l’application de fonction, exécutez ces commandes dans un terminal ou une invite de commandes :
```
mvn clean package
mvn azure-functions:run
```

Pour installer les dépendances et démarrer l’application de fonction, exécutez ces commandes dans un terminal ou une invite de commandes :
```
npm install
npm start  
```

Pour installer les dépendances et démarrer l’application de fonction, exécutez ces commandes dans un terminal ou une invite de commandes :
```
cd src
npm install
npm start  
```

Pour démarrer l’application de fonction, exécutez cette commande dans un terminal ou une invite de commandes :
```
func start
```

Si vous y êtes invité, autorisez Core Tools (func.exe) à être appelé à travers le pare-feu.

Lorsque l’hôte Functions démarre dans votre dossier de projet local, il écrit des informations sur vos fonctions dans la sortie du terminal.

Cet exemple inclut une fonction de déclencheur du minuteur qui génère automatiquement des articles d’actualités toutes les 10 secondes et les envoie à Event Hubs. La fonction de déclencheur Event Hubs traite ensuite ces événements et effectue l’analyse des sentiments et le suivi de l’engagement.

Vous voyez une sortie similaire à cet exemple :

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

Lorsque vous avez terminé, appuyez sur Ctrl + C dans la fenêtre du terminal pour arrêter le processus hôte func.exe.
Fermez la fenêtre dans laquelle Azurite est exécutée.

Exécutez deactivate pour arrêter l’environnement virtuel.

Examiner le code (facultatif)

Vous pouvez consulter le code qui définit la fonction de déclencheur Event Hubs :

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}");

Vous pouvez consulter le projet de modèle complet ici.

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()));
        }
    }
}

Vous pouvez consulter le projet de modèle complet ici.

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
});

Vous pouvez consulter le projet de modèle complet ici.

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
});

Vous pouvez consulter le projet de modèle complet ici.

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

Le déclencheur est défini dans le function.json correspondant.

Vous pouvez consulter le projet de modèle complet ici.

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

Vous pouvez consulter le projet de modèle complet ici.

Après avoir vérifié votre fonction localement, il est temps de le publier sur Azure.

Déployer sur Azure

Ce projet est configuré pour utiliser la azd up commande pour déployer votre code sur une nouvelle application de fonction dans un plan Flex Consumption dans Azure. Étant donné que vous avez déjà provisionné des ressources, cette commande déploie votre code sur l’application de fonction existante.

Conseil / Astuce

Ce projet comprend un ensemble de fichiers Bicep que azd utilise pour créer un déploiement sécurisé dans le cadre d'un plan Flex Consumption qui suit les meilleures pratiques.

À partir du dossier racine du référentiel, exécutez la commande suivante pour déployer votre projet de code sur l’application de fonction dans Azure :

azd deploy

Le déploiement empaquette votre code et le déploie sur l'application de fonctions. Une fois la commande terminée, vous voyez des liens vers les ressources que vous avez créées.

Vérifier le déploiement

Une fois le déploiement terminé, votre fonction de déclencheur Event Hubs démarre automatiquement le traitement des événements lorsqu’ils arrivent dans le hub d’événements.

Dans le portail Azure, accédez à votre nouvelle application de fonction.
Sélectionnez Flux de journal dans le menu de gauche pour surveiller vos exécutions de fonction en temps réel.
Vous voyez les entrées de journal qui affichent vos événements de traitement de fonction de déclencheur Event Hubs générés par le déclencheur minuteur.

Redéployer votre code

Exécutez la commande azd up autant de fois que nécessaire pour approvisionner vos ressources Azure et déployer des mises à jour de code sur votre application de fonction.

Note

Les fichiers de code déployés sont toujours remplacés par le dernier package de déploiement.

Vos réponses initiales aux invites d’azd et toutes les variables d’environnement générées par azd sont stockées localement dans votre environnement nommé. Utilisez la commande azd env get-values pour passer en revue toutes les variables de votre environnement qui ont été utilisées lors de la création de ressources Azure.

Nettoyer les ressources

Lorsque vous avez terminé d’utiliser votre application de fonction et vos ressources associées, utilisez cette commande pour supprimer l’application de fonction et ses ressources associées d’Azure et éviter d’entraîner d’autres coûts :

azd down --no-prompt

Note

L’option --no-prompt indique à azd de supprimer votre groupe de ressources sans confirmation de votre part.

Cette commande n’affecte pas votre projet de code local.

Commentaires

Cette page a-t-elle été utile ?

Last updated on 2026-05-05

Démarrage rapide : Traiter des événements en temps réel à l’aide d’Azure Functions

Prerequisites

Initialiser le projet

Créer et activer un environnement virtuel

Créer des ressources Azure

Exécuter dans votre environnement local

Examiner le code (facultatif)

Déployer sur Azure

Vérifier le déploiement

Redéployer votre code

Nettoyer les ressources

Articles connexes

Commentaires

Ressources supplémentaires