Démarrage rapide : Créer une API web évolutive à l’aide d’Azure Functions

Dans ce guide de démarrage rapide, vous utilisez les outils en ligne de commande Du développeur Azure pour créer une API web évolutive avec des points de terminaison de fonction qui répondent aux requêtes HTTP. Après avoir testé le code localement, vous le déployez sur une nouvelle application de fonction serverless que vous créez et qui s’exécute dans un plan Consommation flexible dans Azure Functions.

La source du projet utilise Azure Developer CLI (azd) pour simplifier le déploiement de votre code sur Azure. Ce déploiement suit les bonnes pratiques actuelles pour les déploiements Azure Functions sécurisés et scalables.

Par défaut, le plan Flex Consumption suit un modèle de facturation avec paiement à l’utilisation , ce qui signifie que l’exécution de ce guide de démarrage rapide entraîne un petit coût de quelques cents USD ou moins dans votre compte Azure.

Prerequisites

Compte Azure avec un abonnement actif. Créez un compte gratuitement.
Azure Developer CLI
Azure Functions Core Tools

Kit de développement Java 17
- Si vous utilisez une autre version prise en charge de Java, vous devez mettre à jour le fichier pom.xml du projet.
- La JAVA_HOME variable d’environnement doit être définie sur l’emplacement d’installation de la version correcte du Kit de développement Java (JDK).
Apache Maven 3.8.x

Node.js 20

Un outil de test HTTP sécurisé pour envoyer des requêtes avec des charges utiles JSON à vos points de terminaison de fonction. Cet article utilise curl.

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 -e httpendpoint-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. Il est également utilisé dans le nom du groupe de ressources que vous créez dans Azure.
Exécutez cette commande pour accéder au dossier de l’application http :
```
cd http
```

Créez un fichier nommé local.settings.json dans le http dossier qui contient ces données JSON :

{
    "IsEncrypted": false,
    "Values": {
        "AzureWebJobsStorage": "UseDevelopmentStorage=true",
        "FUNCTIONS_WORKER_RUNTIME": "dotnet-isolated"
    }
}

Ce fichier est requis lors d’une exécution locale.

Dans votre terminal local ou à l’invite de commandes, exécutez cette commande azd init dans un dossier vide :
```
azd init --template azure-functions-java-flex-consumption-azd -e httpendpoint-java 
```
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. Il est également utilisé dans le nom du groupe de ressources que vous créez dans Azure.
Exécutez cette commande pour accéder au dossier de l’application http :
```
cd http
```

Créez un fichier nommé local.settings.json dans le http dossier qui contient ces données JSON :

{
    "IsEncrypted": false,
    "Values": {
        "AzureWebJobsStorage": "UseDevelopmentStorage=true",
        "FUNCTIONS_WORKER_RUNTIME": "java"
    }
}

Ce fichier est requis lors d’une exécution locale.

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 -e httpendpoint-js
```
Cette commande extrait les fichiers projet du référentiel de modèles et initialise le projet dans le dossier racine. 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. Il est également utilisé dans le nom du groupe de ressources que vous créez dans Azure.

Créez un fichier nommé local.settings.json dans le dossier racine qui contient ces données JSON :

{
    "IsEncrypted": false,
    "Values": {
        "AzureWebJobsStorage": "UseDevelopmentStorage=true",
        "FUNCTIONS_WORKER_RUNTIME": "node"
    }
}

Ce fichier est requis lors d’une exécution locale.

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 -e httpendpoint-ps
```
Cette commande extrait les fichiers projet du référentiel de modèles et initialise le projet dans le dossier racine. 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. Il est également utilisé dans le nom du groupe de ressources que vous créez dans Azure.
Exécutez cette commande pour accéder au dossier de l’application src :
```
cd src
```

Créez un fichier nommé local.settings.json dans le src dossier qui contient ces données JSON :

{
    "IsEncrypted": false,
    "Values": {
        "AzureWebJobsStorage": "UseDevelopmentStorage=true",
        "FUNCTIONS_WORKER_RUNTIME": "powershell",
        "FUNCTIONS_WORKER_RUNTIME_VERSION": "7.2"
    }
}

Ce fichier est requis lors d’une exécution locale.

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 -e httpendpoint-ts
```
Cette commande extrait les fichiers projet du référentiel de modèles et initialise le projet dans le dossier racine. 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.

Créez un fichier nommé local.settings.json dans le dossier racine qui contient ces données JSON :

{
    "IsEncrypted": false,
    "Values": {
        "AzureWebJobsStorage": "UseDevelopmentStorage=true",
        "FUNCTIONS_WORKER_RUNTIME": "node"
    }
}

Ce fichier est requis lors d’une exécution locale.

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-http-azd -e httpendpoint-py
```
Cette commande extrait les fichiers projet du référentiel de modèles et initialise le projet dans le dossier racine. 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.

Créez un fichier nommé local.settings.json dans le dossier racine qui contient ces données JSON :

{
    "IsEncrypted": false,
    "Values": {
        "AzureWebJobsStorage": "UseDevelopmentStorage=true",
        "FUNCTIONS_WORKER_RUNTIME": "python"
    }
}

Ce fichier est requis lors d’une exécution locale.

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

Exécuter dans votre environnement local

Exécutez cette commande à partir du dossier de votre application dans un terminal ou à l’invite de commandes :
```
func start
```
```
mvn clean package
mvn azure-functions:run
```
```
npm install
func start  
```
```
npm install
npm start  
```
Lorsque l’hôte Functions démarre dans votre dossier de projet local, il écrit les points de terminaison d’URL de vos fonctions déclenchées par requête HTTP dans la sortie du terminal.

Note

Étant donné que l’autorisation de clé d’accès n’est pas appliquée lors de l’exécution localement, l’URL de la fonction retournée n’inclut pas la valeur de clé d’accès et vous n’en avez pas besoin pour appeler votre fonction.
Dans votre navigateur, accédez au point de terminaison httpget, qui doit ressembler à cette URL :

http://localhost:7071/api/httpget
À partir d’une nouvelle fenêtre d’invite de commandes ou de terminal, exécutez cette commande curl pour envoyer une requête POST avec une charge utile JSON au point de terminaison httppost :
```
curl -i http://localhost:7071/api/httppost -H "Content-Type: text/json" -d @testdata.json
```
```
curl -i http://localhost:7071/api/httppost -H "Content-Type: text/json" -d "@src/functions/testdata.json"
```
Cette commande lit les données de la charge utile JSON à partir du fichier projet testdata.json. Vous trouverez des exemples des deux requêtes HTTP dans le fichier projet test.http.
Lorsque vous avez terminé, appuyez sur Ctrl + C dans la fenêtre du terminal pour arrêter le processus hôte func.exe.

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

Examiner le code (facultatif)

Vous pouvez consulter le code qui définit les deux points de terminaison de fonction de déclencheur HTTP :

httpget
httppost

       [Function("httpget")]
       public IActionResult Run([HttpTrigger(AuthorizationLevel.Function, "get")]
         HttpRequest req,
         string name)
       {
           var returnValue = string.IsNullOrEmpty(name)
               ? "Hello, World."
               : $"Hello, {name}.";

           _logger.LogInformation($"C# HTTP trigger function processed a request for {returnValue}.");

           return new OkObjectResult(returnValue);
       }

@FunctionName("httpget")
public HttpResponseMessage run(
        @HttpTrigger(
            name = "req",
            methods = {HttpMethod.GET},
            authLevel = AuthorizationLevel.FUNCTION)
            HttpRequestMessage<Optional<String>> request,
        final ExecutionContext context) {
    context.getLogger().info("Java HTTP trigger processed a request.");

    // Parse query parameter
    String name = Optional.ofNullable(request.getQueryParameters().get("name")).orElse("World");

    return request.createResponseBuilder(HttpStatus.OK).body("Hello, " + name).build();
}

const { app } = require('@azure/functions');

app.http('httpget', {
    methods: ['GET'],
    authLevel: 'function',
    handler: async (request, context) => {
        context.log(`Http function processed request for url "${request.url}"`);

        const name = request.query.get('name') || await request.text() || 'world';

        return { body: `Hello, ${name}!` };
    }
});

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

export async function httpGetFunction(request: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
    context.log(`Http function processed request for url "${request.url}"`);

    const name = request.query.get('name') || await request.text() || 'world';

    return { body: `Hello, ${name}!` };
};

app.http('httpget', {
    methods: ['GET'],
    authLevel: 'function',
    handler: httpGetFunction
});

Ce fichier function.json définit la fonction httpget :

{
  "bindings": [
    {
      "authLevel": "function",
      "type": "httpTrigger",
      "direction": "in",
      "name": "Request",
      "methods": [
        "get"
      ],
      "route": "httpget"
    },
    {
      "type": "http",
      "direction": "out",
      "name": "Response"
    }
  ]
}

Ce fichier run.ps1 implémente le code de fonction :

using namespace System.Net

# Input bindings are passed in via param block.
param($Request, $TriggerMetadata)

# Write to the Azure Functions log stream.
Write-Host "PowerShell HTTP trigger function processed a request."

# Interact with query parameters
$name = $Request.Query.name

$body = "This HTTP triggered function executed successfully. Pass a name in the query string for a personalized response."

if ($name) {
    $body = "Hello, $name. This HTTP triggered function executed successfully."
}

# Associate values to output bindings by calling 'Push-OutputBinding'.
Push-OutputBinding -Name Response -Value ([HttpResponseContext]@{
    StatusCode = [HttpStatusCode]::OK
    Body = $body
})

@app.route(route="httpget", methods=["GET"])
def http_get(req: func.HttpRequest) -> func.HttpResponse:
    name = req.params.get("name", "World")

    logging.info(f"Processing GET request. Name: {name}")

    return func.HttpResponse(f"Hello, {name}!")

[Function("httppost")]
public IActionResult Run([HttpTrigger(AuthorizationLevel.Function, "post")] HttpRequest req,
    [FromBody] Person person)
{
    _logger.LogInformation($"C# HTTP POST trigger function processed a request for url {req.Body}");

    if (string.IsNullOrEmpty(person.Name) | string.IsNullOrEmpty(person.Age.ToString()) | person.Age == 0)
    {
        _logger.LogInformation("C# HTTP POST trigger function processed a request with no name/age provided.");
        return new BadRequestObjectResult("Please provide both name and age in the request body.");
    }

    var returnValue = $"Hello, {person.Name}! You are {person.Age} years old.";
    
    _logger.LogInformation($"C# HTTP POST trigger function processed a request for {person.Name} who is {person.Age} years old.");
    return new OkObjectResult(returnValue);
}

@FunctionName("httppost")
public HttpResponseMessage runPost(
        @HttpTrigger(
            name = "req",
            methods = {HttpMethod.POST},
            authLevel = AuthorizationLevel.FUNCTION)
            HttpRequestMessage<Optional<String>> request,
        final ExecutionContext context) {
    context.getLogger().info("Java HTTP trigger processed a POST request.");

    // Parse request body
    String name;
    Integer age;
    try {
        ObjectMapper mapper = new ObjectMapper();
        JsonNode jsonNode = mapper.readTree(request.getBody().orElse("{}"));
        name = Optional.ofNullable(jsonNode.get("name")).map(JsonNode::asText).orElse(null);
        age = Optional.ofNullable(jsonNode.get("age")).map(JsonNode::asInt).orElse(null);
        if (name == null || age == null) {
            return request.createResponseBuilder(HttpStatus.BAD_REQUEST)
                    .body("Please provide both name and age in the request body.").build();
        }
    } catch (Exception e) {
        context.getLogger().severe("Error parsing request body: " + e.getMessage());
        return request.createResponseBuilder(HttpStatus.BAD_REQUEST)
                .body("Error parsing request body").build();
    }

const { app } = require('@azure/functions');

app.http('httppost', {
    methods: ['POST'],
    authLevel: 'function',
    handler: async (request, context) => {
        context.log(`Http function processed request for url "${request.url}"`);

        try {
            const person = await request.json();
            const { name, age } = person;

            if (!name || !age) {
                return {
                    status: 400,
                    body: 'Please provide both name and age in the request body.'
                };
            }

            return {
                status: 200,
                body: `Hello, ${name}! You are ${age} years old.`
            };
        } catch (error) {
            return {
                status: 400,
                body: 'Invalid request body. Please provide a valid JSON object with name and age.'
            };
        }
    }
});

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

interface Person {
    name: string;
    age: number;
}

function isPerson(obj: any): obj is Person {
    return typeof obj === 'object' && obj !== null && 
           typeof obj.name === 'string' && 
           typeof obj.age === 'number';
}

export async function httpPostBodyFunction(request: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
    context.log(`Http function processed request for url "${request.url}"`);

        try {
            const data: any  = await request.json();
    
            if (!isPerson(data)) {
                return {
                    status: 400,
                    body: 'Please provide both name and age in the request body.'
                };
            }

            return {
                status: 200,
                body: `Hello, ${data.name}! You are ${data.age} years old.`
            };
        } catch (error) {
            return {
                status: 400,
                body: 'Invalid request body. Please provide a valid JSON object with name and age.'
            };
        }
};

app.http('httppost', {
    methods: ['POST'],
    authLevel: 'function',
    handler: httpPostBodyFunction
});

Ce fichier function.json définit la fonction httppost :

{
  "bindings": [
    {
      "authLevel": "function",
      "type": "httpTrigger",
      "direction": "in",
      "name": "Request",
      "methods": [
        "post"
      ],
      "route": "httppost"
    },
    {
      "type": "http",
      "direction": "out",
      "name": "Response"
    }
  ]
}

Ce fichier run.ps1 implémente le code de fonction :

using namespace System.Net

# Input bindings are passed in via param block.
param($Request, $TriggerMetadata)

# Write to the Azure Functions log stream.
Write-Host "PowerShell HTTP trigger function processed a request."

# Interact with the body of the request.
$name = $Request.Body.name
$age = $Request.Body.age
$status = [HttpStatusCode]::OK

$body = "This HTTP triggered function executed successfully. Pass a name in the request body for a personalized response."

if ( -not ($name -and $age)){
    $body = "Please provide both 'name' and 'age' in the request body."
    $status = [HttpStatusCode]::BadRequest
}
else {
    <# Action when all if and elseif conditions are false #>
    $body = "Hello, ${name}! You are ${age} years old."
}

# Associate values to output bindings by calling 'Push-OutputBinding'.
Push-OutputBinding -Name Response -Value ([HttpResponseContext]@{
    StatusCode = $status
    Body = $body
})

@app.route(route="httppost", methods=["POST"])
def http_post(req: func.HttpRequest) -> func.HttpResponse:
    try:
        req_body = req.get_json()
        name = req_body.get('name')
        age = req_body.get('age')
        
        logging.info(f"Processing POST request. Name: {name}")

        if name and isinstance(name, str) and age and isinstance(age, int):
            return func.HttpResponse(f"Hello, {name}! You are {age} years old!")
        else:
            return func.HttpResponse(
                "Please provide both 'name' and 'age' in the request body.",
                status_code=400
            )
    except ValueError:
        return func.HttpResponse(
            "Invalid JSON in request body",
            status_code=400
        )

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

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

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

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

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

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

Après avoir vérifié vos fonctions en local, il est temps de les publier sur Azure.

Déployer dans Azure

Ce projet est configuré pour utiliser la commande azd up visant à déployer ce projet dans une nouvelle application de fonction dans un plan Consommation flexible dans Azure.

Tip

Le projet inclut un ensemble de fichiers Bicep (dossier infra) que azd utilise pour créer un déploiement sécurisé dans un plan de consommation Flex qui suit les meilleures pratiques.

Exécutez cette commande pour qu’azd crée les ressources Azure requises dans Azure et déployer votre projet de code dans la nouvelle application de fonction :
```
azd up
```
Le dossier racine contient le fichier de définition azure.yaml exigé par azd.

Si vous n’êtes pas déjà connecté, vous êtes invité à vous authentifier auprès de votre compte Azure.

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

Parameter	Description
Abonnement Azure	Abonnement dans lequel vos ressources sont créées.
Emplacement Azure	Région Azure dans laquelle 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	Choisissez False. Lorsque la valeur est True , le déploiement crée votre application de fonction dans un nouveau réseau virtuel.

La azd up commande utilise les réponses que vous fournissez à ces invites, ainsi que les fichiers de configuration Bicep, pour accomplir ces tâches de déploiement :

Créez et configurez ces ressources Azure requises (équivalentes à azd provision) :
- Plan Consommation flexible et application de fonction
- Stockage Azure (obligatoire) et Application Insights (recommandé)
- Stratégies d’accès et rôles pour votre compte
- Connexions de service à service avec des identités managées (au lieu de chaînes de connexion stockées)
- (Option) Réseau virtuel pour exécuter en toute sécurité l’application de fonction et les autres ressources Azure
Empaquetez et déployez votre code sur le conteneur de déploiement (équivalent à azd deploy). L’application est ensuite démarrée et s’exécute dans le package déployé.

Une fois la commande terminée, vous voyez des liens vers les ressources que vous avez créées.

Appeler la fonction sur Azure

Vous pouvez maintenant appeler vos points de terminaison de fonction dans Azure en effectuant des requêtes HTTP à leurs URL à l’aide de votre outil de test HTTP ou à partir du navigateur (pour les requêtes GET). Lorsque vos fonctions s’exécutent dans Azure, l’autorisation par clé d’accès est appliquée et vous devez fournir une clé d’accès de fonction à votre requête.

Vous pouvez utiliser Core Tools pour obtenir les points de terminaison d’URL de vos fonctions s’exécutant dans Azure.

Dans votre terminal local ou à l’invite de commandes, exécutez ces commandes pour obtenir les valeurs des points de terminaison d’URL :

bash
Cmd

SET APP_NAME=$(azd env get-value AZURE_FUNCTION_NAME)
func azure functionapp list-functions $APP_NAME --show-keys

for /f "tokens=*" %i in ('azd env get-value AZURE_FUNCTION_NAME') do set APP_NAME=%i
func azure functionapp list-functions %APP_NAME% --show-keys

PowerShell
Cmd

$APP_NAME = azd env get-value AZURE_FUNCTION_NAME
func azure functionapp list-functions $APP_NAME --show-keys

for /f "tokens=*" %i in ('azd env get-value AZURE_FUNCTION_NAME') do set APP_NAME=%i
func azure functionapp list-functions %APP_NAME% --show-keys

La commande azd env get-value obtient le nom de votre application de fonction à partir de l’environnement local. Lorsque vous utilisez l’option --show-keys avec func azure functionapp list-functions, l'URL 'Invoke' retournée pour chaque point de terminaison inclut une clé d’accès au niveau de la fonction.

Comme précédemment, utilisez votre outil de test HTTP pour valider ces URL dans votre application de fonction s’exécutant dans Azure.

Redéployer votre code

Exécutez la azd up commande autant de fois que vous devez provisionner 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 azd env get-values commande pour passer en revue toutes les variables de votre environnement que vous avez 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.

Rétroaction

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

Last updated on 2025-12-04