Aller au contenu

Les applications serverless

Introduction

Le serverless (« sans serveur ») est un modèle d’exécution des applications dans lequel Microsoft, en tant que fournisseur cloud, prend en charge la gestion des serveurs et de l’infrastructure nécessaire à leur fonctionnement.

Ce modèle permet de se concentrer sur les traitements à exécuter, souvent déclenchés par une requête HTTP, un événement ou une planification. Azure Functions permet d’implémenter ces traitements sous forme de fonctions, en C#, Python ou JavaScript. Azure Logic Apps permet d’automatiser des processus sous la forme de workflows. Les possibilités d’adaptation automatique à la charge et les modalités de facturation dépendent du service et de l’offre choisis.

Notions à connaître

Les applications de fonction

Une application de fonction (Function App) est la ressource Azure qui héberge et exécute une ou plusieurs fonctions.

Les clés d'accès

Azure Functions utilise des clés d’accès permettent de limiter l’appel des fonctions HTTP aux applications ou aux personnes qui possèdent une clé valide. Un client transmet cette clé avec chaque requête et Azure se charge de la vérifier avant d’exécuter la fonction.

Ainsi, elles constituent ainsi un moyen simple de contrôler l’accès à un traitement, par exemple lorsqu’une application appelle une fonction pour générer un document ou traiter des données.

Ces clés doivent rester confidentielles et peuvent être renouvelées ou supprimées pour retirer un accès. Toutefois, elles ne permettent toutefois pas d’identifier l’utilisateur, et cela peut être pris en charge par Microsoft Entra ID.

Implémenter une fonction

Dans cette section, je vous propose d'implémenter un serverless avec Visual Studio. Il sera déclenché par une requête HTTP. Nous l’exécuterons et la testerons localement, puis la déploierons dans Azure.

Création du projet

Dans Visual Studio, créons un projet de type Azure Functions que nous appelons TestServerless. Voici la configuration :

Azure Serverless - Options de création du projet dans Visual Studio

Voici la description des options :

Option Description
.NET 10.0 Isolé (prise en charge à long terme) Le code de la fonction s’exécute dans un processus distinct du runtime Azure Functions
Http trigger La fonction est déclenchée par une requête HTTP
Orchestration Aspire désactivée Le projet n’est pas intégré à une orchestration Aspire
Utiliser Azurite L’émulateur de stockage Azure est utilisé pour le stockage nécessaire au runtime lors de l’exécution locale
Prise en charge du conteneur désactivée Le projet est créé sans configuration de conteneur
Authorization level : Function Sur Azure, l’appel de la fonction nécessite une clé d’accès. Celle-ci n’est pas exigée lors des tests locaux

La classe Program

Voici l'implémentation simplifiée de la classe Program :

using Azure.Monitor.OpenTelemetry.Exporter;
using Microsoft.Azure.Functions.Worker.Builder;
using Microsoft.Azure.Functions.Worker.OpenTelemetry;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;

var builder = FunctionsApplication.CreateBuilder(args);

builder.ConfigureFunctionsWebApplication();

if (!string.IsNullOrEmpty(Environment.GetEnvironmentVariable("APPLICATIONINSIGHTS_CONNECTION_STRING")))
{
    builder.Services.AddOpenTelemetry()
        .UseFunctionsWorkerDefaults()
        .UseAzureMonitorExporter();
}

builder.Build().Run();

Cette implémentation constitue le point d’entrée de l’application Azure Functions :

  • Il prépare l’environnement d’exécution et configure l’intégration avec ASP.NET Core pour les fonctions déclenchées par des requêtes HTTP.

  • Si la variable d’environnement APPLICATIONINSIGHTS_CONNECTION_STRING est renseignée, il configure OpenTelemetry pour transmettre les données de diagnostic à Application Insights.

  • Il construit et démarre l’hôte chargé de l’exécution des fonctions.

Implémentation de la fonction

Voici l'implémentation de la fonction :

using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Azure.Functions.Worker;
using Microsoft.Extensions.Logging;

namespace TestServerless;

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

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

    [Function("Function1")]
    public IActionResult Run([HttpTrigger(AuthorizationLevel.Function, "get", "post")] HttpRequest req)
    {
        _logger.LogInformation("C# HTTP trigger function processed a request.");

        return new OkObjectResult("Welcome to Azure Functions!");
    }
}

Les éléments principaux sont :

  • [Function("Hello")] : définit le nom de la fonction.
  • [HttpTrigger(...)] : déclenche son exécution lors d’une requête HTTP GET.
  • AuthorizationLevel.Function : exige une clé d’accès lorsque la fonction est hébergée sur Azure.
  • OkObjectResult : renvoie une réponse HTTP 200 OK.

Test l'implémentation en local

Pour tester l'implémentation de la fonction, démarrer l'exécution du projet. Une fenêtre de console apparaît et indique l'URL de notre fonction :

http://localhost:7118/api/Function1

Nous ouvrons un navigateur Web et exécutons cette URL et voyons apparaître le message Welcome to Azure Functions!.

Déploiement dans Azure

Pour déployer dans Azure, vous devez avoir au préalable avoir créer une application de fonctions, au sein de laquelle notre fonction serverless sera déployée.

Dans Visual Studio, un assistant vous aide à déployer la fonction serverless. Il est accessible via l'élément Publier du menu contextuel du projet contenant la fonction.

Test

Dans une fenêtre PowerShell, nous pouvons exécuter une instruction envoyant une requête HTTP à Azure. Voici un prototype de cette instruction :

Invoke-RestMethod -Uri https://azure-app-function-001-hqh2eeh9a4gcd4g6.francecentral-01.azurewebsites.net/api/Function1?Code=<cle>

où :

  • azure-app-function-001-hqh2eeh9a4gcd4g6 est l'étiquette DNS identifiant l’application.

  • La clé est accessible depuis le portail Azure.