Partager via


Scénarios Azure Functions

Nous élaborons souvent des systèmes pour réagir à une série d’événements critiques. Qu'il s'agisse de générer une API web, de répondre à des modifications de base de données, de traiter des flux d'événements ou des messages, Azure Functions vous permet de les implémenter.

Dans de nombreux cas, une fonction s’intègre à un tableau de services cloud pour fournir des implémentations riches en fonctionnalités. Vous trouverez ci-dessous un ensemble de scénarios courants (mais en aucun cas exhaustif) relatifs à Azure Functions.

Sélectionnez en haut de l'article votre langage de développement.

Traiter des chargements de fichiers

Il existe plusieurs manières d’utiliser ces fonctions pour traiter des fichiers à l’entrée ou à l’extérieur d’un conteneur de stockage d’objets blob. Pour en savoir davantage sur les options de déclenchement d'un conteneur de blobs, consultez la section Travailler avec des blobs figurant dans la documentation sur les meilleures pratiques.

Par exemple, dans le cadre d’une solution de vente au détail, un système partenaire peut envoyer des informations de catalogue de produits sous forme de fichiers dans le stockage d’objets blob. Vous pouvez utiliser une fonction déclenchée par un objet blob pour valider, transformer et traiter les fichiers à mesure de leur téléchargement dans le système principal.

Diagramme d'un processus de téléchargement de fichiers à l'aide d'Azure Functions.

Les tutoriels suivants utilisent un déclencheur Azure Event Grid pour traiter des fichiers dans un conteneur d’objets blob :

Par exemple, à l’aide du déclencheur d’objet blob et d’un abonnement aux événements sur des conteneurs d’objets blob :

[FunctionName("ProcessCatalogData")]
public static async Task Run([BlobTrigger("catalog-uploads/{name}", Source = BlobTriggerSource.EventGrid, Connection = "<NAMED_STORAGE_CONNECTION>")]Stream myCatalogData, string name, ILogger log)
{
    log.LogInformation($"C# Blob trigger function Processed blob\n Name:{name} \n Size: {myCatalogData.Length} Bytes");

    using (var reader = new StreamReader(myCatalogData))
    {
        var catalogEntry = await reader.ReadLineAsync();
        while(catalogEntry !=null)
        {
            // Process the catalog entry
            // ...

            catalogEntry = await reader.ReadLineAsync();
        }
    }
}

Traitement des flux et des événements en temps réel

Tant de données de télémétrie sont générées et collectées à partir d’applications Cloud, d’appareils IoT et d’appareils réseau. Azure Functions peut traiter ces données en quasi temps réel comme chemin d’accès chaud, puis les stocker dans Azure Cosmos DB à utiliser dans un tableau de bord d’analyse.

Vos fonctions peuvent également utiliser des déclencheurs d’événements à faible latence, comme Azure Event Grid, et des sorties en temps réel comme SignalR pour traiter les données en quasi-temps réel.

Diagramme d'un processus de flux en temps réel à l'aide d'Azure Functions.

Par exemple, le déclencheur de hub d'événements permet de lire un hub d'événements et la liaison de sortie permet d'écrire dans un hub d'événements après le dégroupage et la transformation des événements :

[FunctionName("ProcessorFunction")]
public static async Task Run(
    [EventHubTrigger(
        "%Input_EH_Name%",
        Connection = "InputEventHubConnectionString",
        ConsumerGroup = "%Input_EH_ConsumerGroup%")] EventData[] inputMessages,
    [EventHub(
        "%Output_EH_Name%",
        Connection = "OutputEventHubConnectionString")] IAsyncCollector<SensorDataRecord> outputMessages,
    PartitionContext partitionContext,
    ILogger log)
{
    var debatcher = new Debatcher(log);
    var debatchedMessages = await debatcher.Debatch(inputMessages, partitionContext.PartitionId);

    var xformer = new Transformer(log);
    await xformer.Transform(debatchedMessages, partitionContext.PartitionId, outputMessages);
}

Machine Learning et intelligence artificielle

Outre le traitement des données, Azure Functions permet de déduire des modèles. L’extension de liaison Azure OpenAI permet d’intégrer facilement les fonctionnalités et les comportements du service Azure OpenAI dans vos exécutions de code de fonction.

Les fonctions peuvent se connecter à des ressources OpenAI pour activer les complétions de texte et de conversation, utiliser des assistants et tirer parti des incorporations et de la recherche sémantique.

Une fonction peut également appeler un modèle TensorFlow ou des services Azure AI pour traiter et classifier un flux d’images.

Diagramme d'un processus d'apprentissage automatique et d'IA à l'aide d'Azure Functions.

Exécuter des tâches planifiées

Functions vous permet d’exécuter votre code selon une planification cron que vous définissez.

Découvrez de quelle manière Créer une fonction dans le portail Microsoft Azure exécuté selon une planification.

Une base de données relative aux clients des services financiers, par exemple, peut être analysée toutes les 15 minutes afin de détecter les doublons et éviter l'envoi de plusieurs communications au même client.

Diagramme d'une tâche planifiée prévoyant le nettoyage d'une base de données toutes les 15 minutes par une fonction dé-dupliquant les entrées sur la base de la logique commerciale.

[FunctionName("TimerTriggerCSharp")]
public static void Run([TimerTrigger("0 */15 * * * *")]TimerInfo myTimer, ILogger log)
{
    if (myTimer.IsPastDue)
    {
        log.LogInformation("Timer is running late!");
    }
    log.LogInformation($"C# Timer trigger function executed at: {DateTime.Now}");

    // Perform the database deduplication
}

Créer une API web évolutive

Une fonction déclenchée par HTTP définit un point de terminaison HTTP. Ces points de terminaison exécutent un code de fonction capable de se connecter à d'autres services directement ou à l'aide d'extensions de liaison. Vous pouvez composer les points de terminaison dans une API web.

Vous pouvez également utiliser un point de terminaison de fonction déclenché par HTTP comme intégration de webhook, comme des webhooks GitHub. De cette manière, vous pouvez créer des fonctions traitant des données à partir d’événements GitHub. Pour plus d’informations, consultez Surveiller les événements GitHub à l’aide d’un webhook avec Azure Functions.

Diagramme illustrant le traitement d'une requête HTTP à l'aide d'Azure Functions.

Par exemple, consultez les articles suivants :

[FunctionName("InsertName")]
public static async Task<IActionResult> Run(
    [HttpTrigger(AuthorizationLevel.Function, "post")] HttpRequest req,
    [CosmosDB(
        databaseName: "my-database",
        collectionName: "my-container",
        ConnectionStringSetting = "CosmosDbConnectionString")]IAsyncCollector<dynamic> documentsOut,
    ILogger log)
{
    string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
    dynamic data = JsonConvert.DeserializeObject(requestBody);
    string name = data?.name;

    if (name == null)
    {
        return new BadRequestObjectResult("Please pass a name in the request body json");
    }

    // Add a JSON document to the output container.
    await documentsOut.AddAsync(new
    {
        // create a random ID
        id = System.Guid.NewGuid().ToString(), 
        name = name
    });

    return new OkResult();
}

Générer un workflow serverless

Functions correspond souvent au composant de calcul dans une topologie de flux de travail serverless, comme un workflow Logic Apps. Vous pouvez également créer des orchestrations longues à l’aide de l’extension Durable Functions. Pour plus d’informations, consultez Aperçu de Durable Functions.

Un diagramme de combinaison d'une série de flux de travail sans serveur spécifiques à l'aide d'Azure Functions.

Répondre à des modifications de base de données

Certains processus peuvent nécessiter l'enregistrement, l'audit ou une autre opération en cas de modification des données stockées. Les déclencheurs Functions fournissent un excellent moyen d’être averti des modifications de données pour initier une telle opération.

Diagramme d'une fonction utilisée pour répondre aux modifications de la base de données.

Penchez-vous sur les exemples suivants :

Créer des systèmes de messages fiables

Functions avec les services de messagerie Azure permet de créer des solutions de messagerie avancées pilotées par les événements.

Par exemple, les déclencheurs sur les files d'attente du Stockage Microsoft Azure vous permettent d'enchaîner une série d'exécutions de fonctions. Vous pouvez également utiliser des files d’attente et des déclencheurs Service Bus pour un système de commande en ligne.

Diagramme illustrant l'utilisation d'Azure Functions dans un système de messagerie fiable.

L’article suivant explique de quelle manière écrire une sortie dans une file d’attente de stockage.

Et ces articles expliquent de quelle manière déclencher à partir d’une file d’attente ou d’une rubrique Microsoft Azure Service Bus.

Étapes suivantes