Démarrage rapide : Créer une fonction dans Azure à partir de la ligne de commande

Dans cet article, vous utilisez des outils en ligne de commande locaux pour créer une fonction qui répond aux requêtes HTTP. Après avoir vérifié votre code localement, vous le déployez sur un plan d’hébergement Flex Consumption serverless dans Azure Functions.

Le fait de suivre ce guide de démarrage rapide entraîne une petite dépense de quelques cents USD tout au plus dans votre compte Azure.

Veillez à sélectionner votre langage de développement préféré en haut de l’article.

Prerequisites

Un compte Azure avec un abonnement actif. Créez un compte gratuitement.

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

Allez
Rust

Go, version la plus récente recommandée. Utilisez la commande go version pour vérifier la version que vous utilisez.

Azure CLI
Le jq processeur JSON de ligne de commande, utilisé pour analyser la sortie JSON et est également disponible dans Azure Cloud Shell.

Installer Azure Functions Core Tools

La méthode recommandée pour installer Core Tools dépend du système d’exploitation de votre ordinateur de développement local.

Les étapes suivantes utilisent un programme d’installation Windows (MSI) pour installer Core Tools v4.x. Pour plus d’informations sur les autres programmes d’installation basés sur des packages, consultez le fichier Lisezmoi des outils principaux.

Téléchargez et exécutez le programme d’installation de Core Tools, selon votre version de Windows :

v4.x – Windows 64 bits (Recommandé. Le débogage de Visual Studio Code nécessite la version 64 bits.)
v4.x – Windows 32 bits

Si vous avez précédemment utilisé Windows installer (MSI) pour installer Core Tools sur Windows, vous devez désinstaller l’ancienne version de la fonction Ajout/suppression de programmes avant d’installer la dernière version.

Les étapes suivantes utilisent Homebrew pour installer les Outils Core sur macOS.

Installez Homebrew, s’il n’est pas déjà installé.

Installez le package Outils Core :

brew tap azure/functions
brew install azure-functions-core-tools@4
# if upgrading on a machine that has 2.x or 3.x installed:
brew link --overwrite azure-functions-core-tools@4

Les étapes suivantes utilisent APT pour installer Core Tools sur votre distribution Linux Ubuntu/Debian. Pour les autres distributions Linux, consultez le fichier Lisez-moi Outils Core.

Installez la clé GPG du référentiel de packages Microsoft pour valider l’intégrité du package :

curl https://packages.microsoft.com/keys/microsoft.asc | gpg --dearmor > microsoft.gpg
sudo mv microsoft.gpg /etc/apt/trusted.gpg.d/microsoft.gpg

Configurez la liste de sources APT avant d’effectuer une mise à jour d’APT.

Ubuntu

sudo sh -c 'echo "deb [arch=amd64] https://packages.microsoft.com/repos/microsoft-ubuntu-$(lsb_release -cs 2>/dev/null)-prod $(lsb_release -cs 2>/dev/null) main" > /etc/apt/sources.list.d/dotnetdev.list'

Debian

sudo sh -c 'echo "deb [arch=amd64] https://packages.microsoft.com/debian/$(lsb_release -rs 2>/dev/null | cut -d'.' -f 1)/prod $(lsb_release -cs 2>/dev/null) main" > /etc/apt/sources.list.d/dotnetdev.list'

Consultez le fichier /etc/apt/sources.list.d/dotnetdev.list pour obtenir l’une des chaînes de version Linux appropriées dans le tableau suivant :

Distribution Linux	Version
Debian 12	`bookworm`
Debian 11	`bullseye`
Debian 10	`buster`
Debian 9	`stretch`
Ubuntu 24.04	`noble`
Ubuntu 22.04	`jammy`
Ubuntu 20.04	`focal`
Ubuntu 19.04	`disco`
Ubuntu 18.10	`cosmic`
Ubuntu 18.04	`bionic`
Ubuntu 17.04	`zesty`
Ubuntu 16.04/Linux Mint 18	`xenial`

Démarrez la mise à jour des sources APT :
```
sudo apt-get update
```

Installez le package Outils Core :

sudo apt-get install azure-functions-core-tools-4

Créer et activer un environnement virtuel

Dans le dossier approprié, exécutez les commandes suivantes pour créer et activer un environnement virtuel nommé .venv. Veillez à utiliser l’une des versions de Python prises en charge par Azure Functions.

python -m venv .venv

source .venv/bin/activate

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

sudo apt-get install python3-venv

py -m venv .venv

.venv\scripts\activate

py -m venv .venv

.venv\scripts\activate

Vous devez exécuter toutes les commandes suivantes dans cet environnement virtuel activé.

Créer un projet et une fonction de code local

Dans Azure Functions, votre projet de code est une application qui contient une ou plusieurs fonctions individuelles qui répondent chacune à un déclencheur spécifique. Toutes les fonctions d’un projet partagent les mêmes configurations et sont déployées en tant qu’unité sur Azure. Dans cette section, vous créez un projet de code qui contient une fonction unique.

Dans un terminal ou une invite de commandes, exécutez cette func init commande pour créer un projet d’application de fonction dans le dossier actif :
```
func init --worker-runtime dotnet-isolated 
```

Dans un terminal ou une invite de commandes, exécutez cette func init commande pour créer un projet d’application de fonction dans le dossier actif :
```
func init --worker-runtime node --language javascript 
```

Dans un terminal ou une invite de commandes, exécutez cette func init commande pour créer un projet d’application de fonction dans le dossier actif :
```
func init --worker-runtime powershell 
```

Dans un terminal ou une invite de commandes, exécutez cette func init commande pour créer un projet d’application de fonction dans le dossier actif :
```
func init --worker-runtime python 
```

Dans un terminal ou une invite de commandes, exécutez cette func init commande pour créer un projet d’application de fonction dans le dossier actif :
```
func init --worker-runtime node --language typescript 
```

Dans un terminal ou une invite de commandes, exécutez cette func init commande pour créer un projet d’application de fonction dans le dossier actif :
```
func init --worker-runtime custom 
```

Dans un dossier vide, exécutez cette mvn commande pour générer le projet de code à partir d’un archétype Azure Functions Maven :
- Bash
- PowerShell
- Cmd
```
mvn archetype:generate -DarchetypeGroupId=com.microsoft.azure -DarchetypeArtifactId=azure-functions-archetype -DjavaVersion=17
```
```
mvn archetype:generate "-DarchetypeGroupId=com.microsoft.azure" "-DarchetypeArtifactId=azure-functions-archetype" "-DjavaVersion=17" 
```
```
mvn archetype:generate "-DarchetypeGroupId=com.microsoft.azure" "-DarchetypeArtifactId=azure-functions-archetype" "-DjavaVersion=17"
```
Important
- Utilisez -DjavaVersion=11 si vous voulez que vos fonctions s’exécutent sur Java 11. Pour en savoir plus, consultez les versions de Java.
- Définissez la JAVA_HOME variable d’environnement sur l’emplacement d’installation de la version correcte du JDK pour terminer cet article.

Maven vous invite à entrer les valeurs nécessaires pour terminer la génération du projet lors du déploiement.
Fournissez les valeurs suivantes à l’invite :

Prompt	Value	Description
groupId	`com.fabrikam`	Valeur qui identifie de façon unique votre projet parmi tous les projets, avec respect des règles de nommage de package pour Java.
artifactId	`fabrikam-functions`	Valeur qui correspond au nom du fichier jar, sans numéro de version.
version	`1.0-SNAPSHOT`	Choisissez la valeur par défaut.
package	`com.fabrikam`	Valeur qui correspond au package Java pour le code de fonction généré. Utilisez la valeur par défaut.

Tapez Y ou appuyez sur Entrée pour confirmer.

Maven crée les fichiers projet dans un nouveau dossier avec un nom d’artifactId, qui dans cet exemple est fabrikam-functions.
Accédez au dossier du projet :
```
cd fabrikam-functions
```
Vous pouvez consulter le code généré par le modèle pour votre nouvelle fonction de déclencheur HTTP dans Function.java dans le répertoire du projet \src\main\java\com\fabrikam .

Utilisez cette func new commande pour ajouter une fonction à votre projet :
```
func new --name HttpExample --template "HTTP trigger" --authlevel "function"
```
Un nouveau fichier de code est ajouté à votre projet. Dans ce cas, l’argument --name est le nom unique de votre fonction (HttpExample) et l’argument --template spécifie un déclencheur HTTP.

Le dossier racine du projet contient différents fichiers pour le projet, y compris les fichiers de configurations nommés local.settings.json et host.json. Étant donné que local.settings.json peut contenir des secrets téléchargés depuis Azure, le fichier est exclu du contrôle de code source par défaut dans le fichier .gitignore.

Créer et générer votre fonction

Le fichier function.json dans le dossier HttpExample déclare une fonction de déclencheur HTTP. Vous terminez la fonction en ajoutant un gestionnaire et en le compilant en un exécutable.

Allez
Rust

Appuyez sur Ctrl+N (Cmd+N sur macOS) pour créer un fichier. Enregistrez-le comme handler.go dans la racine de l’application de fonction (dans le même dossier que host.json).

Dans handler.go, ajoutez le code suivant et enregistrez le fichier. Il s’agit de votre gestionnaire personnalisé Go.

package main

import (
    "fmt"
    "log"
    "net/http"
    "os"
)

func helloHandler(w http.ResponseWriter, r *http.Request) {
    message := "This HTTP triggered function executed successfully. Pass a name in the query string for a personalized response.\n"
    name := r.URL.Query().Get("name")
    if name != "" {
        message = fmt.Sprintf("Hello, %s. This HTTP triggered function executed successfully.\n", name)
    }
    fmt.Fprint(w, message)
}

func main() {
    listenAddr := ":8080"
    if val, ok := os.LookupEnv("FUNCTIONS_CUSTOMHANDLER_PORT"); ok {
        listenAddr = ":" + val
    }
    http.HandleFunc("/api/HttpExample", helloHandler)
    log.Printf("About to listen on %s. Go to https://127.0.0.1%s/", listenAddr, listenAddr)
    log.Fatal(http.ListenAndServe(listenAddr, nil))
}

Appuyez sur Ctrl+Maj+' ou sélectionnez Nouveau terminal dans le menu Terminal pour ouvrir un nouveau terminal intégré dans VS Code.
Compilez votre gestionnaire personnalisé à l’aide de la commande suivante. Un fichier exécutable nommé handler (handler.exe sur Windows) est généré dans le dossier racine de l’application de fonction.
```
go build handler.go
```

Appuyez sur Ctrl+Maj+' ou sélectionnez Nouveau terminal dans le menu Terminal pour ouvrir un nouveau terminal intégré dans VS Code.
Dans la racine de l’application de fonction (le même dossier que host.json), initialisez un projet Rust nommé handler.
```
cargo init --name handler
```
Dans Cargo.toml, ajoutez les dépendances suivantes nécessaires pour suivre ce guide de démarrage rapide. L’exemple utilise le framework de serveur web warp.
```
[dependencies]
warp = "0.3"
tokio = { version = "1", features = ["rt", "macros", "rt-multi-thread"] }
```

Dans src/main.rs, ajoutez le code suivant et enregistrez le fichier. Il s’agit de votre gestionnaire personnalisé Rust.

use std::collections::HashMap;
use std::env;
use std::net::Ipv4Addr;
use warp::{http::Response, Filter};

#[tokio::main]
async fn main() {
    let example1 = warp::get()
        .and(warp::path("api"))
        .and(warp::path("HttpExample"))
        .and(warp::query::<HashMap<String, String>>())
        .map(|p: HashMap<String, String>| match p.get("name") {
            Some(name) => Response::builder().body(format!("Hello, {}. This HTTP triggered function executed successfully.", name)),
            None => Response::builder().body(String::from("This HTTP triggered function executed successfully. Pass a name in the query string for a personalized response.")),
        });

    let port_key = "FUNCTIONS_CUSTOMHANDLER_PORT";
    let port: u16 = match env::var(port_key) {
        Ok(val) => val.parse().expect("Custom Handler port is not a number!"),
        Err(_) => 3000,
    };

    warp::serve(example1).run((Ipv4Addr::LOCALHOST, port)).await
}

Compilez un fichier binaire pour votre gestionnaire personnalisé. Un fichier exécutable nommé handler (handler.exe sur Windows) est généré dans le dossier racine de l’application de fonction.
```
cargo build --release
cp target/release/handler .
```

Configurer votre application de fonction

L’hôte de la fonction doit être configuré pour exécuter le fichier binaire de votre gestionnaire personnalisé au démarrage.

Ouvrez host.json.
Dans la section customHandler.description, définissez la valeur de defaultExecutablePath sur handler (sur Windows, définissez-la sur handler.exe).
Dans la section customHandler, ajoutez une propriété nommée enableForwardingHttpRequest et définissez sa valeur sur true. Pour les fonctions composées uniquement d’un déclencheur HTTP, ce paramètre simplifie la programmation en vous permettant d’utiliser une requête HTTP classique au lieu de la charge utile des demandes du gestionnaire personnalisé.

Vérifiez que la section customHandler ressemble à cet exemple. Enregistrez le fichier.

"customHandler": {
  "description": {
    "defaultExecutablePath": "handler",
    "workingDirectory": "",
    "arguments": []
  },
  "enableForwardingHttpRequest": true
}

L’application de fonction est configurée pour démarrer l’exécutable de votre gestionnaire personnalisé.

Exécuter la fonction localement

Vérifiez votre nouvelle fonction en exécutant le projet localement et en appelant le point de terminaison de fonction.

Utilisez cette commande pour démarrer l’hôte d’exécution Azure Functions local à la racine du dossier du projet :

func start

npm install
npm start

mvn clean package  
mvn azure-functions:run

Vers la fin de la sortie, les lignes suivantes s’affichent :

 ...

 Now listening on: http://0.0.0.0:7071
 Application started. Press Ctrl+C to shut down.

 Http Functions:

         HttpExample: [GET,POST] http://localhost:7071/api/HttpExample
 ...

Copiez l’URL de votre HttpExample fonction à partir de cette sortie dans un navigateur et accédez à l’URL de la fonction. Vous devez recevoir une réponse indiquant un succès avec un message « hello world ».

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.
Lorsque vous avez terminé, utilisez Ctrl+C et choisissez y d’arrêter l’hôte de fonctions.

Créer des ressources Azure de prise en charge pour votre fonction

Avant de pouvoir déployer votre code de fonction sur Azure, vous devez créer ces ressources :

Un groupe de ressources, qui est un conteneur logique pour les ressources associées.
Un compte de stockage par défaut, utilisé par l’hôte Functions pour maintenir l’état et d’autres informations sur vos fonctions.
Identité managée affectée par l’utilisateur, que l’hôte Functions utilise pour se connecter au compte de stockage par défaut.
Une application de fonction, qui fournit l’environnement d’exécution de votre code de fonction. Une application de fonction est mappée à votre projet de fonction local. Elle vous permet de regrouper les fonctions en tant qu’unité logique pour faciliter la gestion, le déploiement et le partage des ressources.

Utilisez les commandes Azure CLI dans ces étapes pour créer les ressources requises.

Si vous ne l’avez pas déjà fait, connectez-vous à Azure :
```
az login
```
La commande az login vous connecte à votre compte Azure. Ignorez cette étape lors de l’exécution dans Azure Cloud Shell.
Si ce n’est déjà fait, utilisez cette az extension add commande pour installer l’extension Application Insights :
```
az extension add --name application-insights
```
Utilisez cette commande az group create pour créer un groupe de ressources nommé AzureFunctionsQuickstart-rg dans votre région choisie :
```
az group create --name "AzureFunctionsQuickstart-rg" --location "<REGION>"
```
Dans cet exemple, remplacez <REGION> par une région proche de vous qui prend en charge le plan Flex Consumption. Utilisez la commande az functionapp list-flexconsumption-locations pour afficher la liste des régions actuellement prises en charge.
Utilisez cette commande az storage account create pour créer un compte de stockage à usage général dans votre groupe de ressources et région :
```
az storage account create --name <STORAGE_NAME> --location "<REGION>" --resource-group "AzureFunctionsQuickstart-rg" \
--sku "Standard_LRS" --allow-blob-public-access false --allow-shared-key-access false
```
Dans cet exemple, remplacez <STORAGE_NAME> par un nom qui vous convient et unique dans stockage Azure. Les noms doivent contenir entre 3 et 24 caractères, et comporter uniquement des lettres minuscules. Standard_LRS spécifie un compte universel, qui est pris en charge par Functions. Ce nouveau compte est accessible uniquement à l’aide d’identités authentifiées par Microsoft Entra qui ont reçu des autorisations pour des ressources spécifiques.
Utilisez ce script pour créer une identité managée affectée par l’utilisateur, analyser les propriétés JSON retournées de l’objet à l’aide de jq, et accorder les autorisations de Storage Blob Data Owner dans le compte de stockage par défaut :
```
output=$(az identity create --name "func-host-storage-user" --resource-group "AzureFunctionsQuickstart-rg" --location <REGION> \
--query "{userId:id, principalId: principalId, clientId: clientId}" -o json)

userId=$(echo $output | jq -r '.userId')
principalId=$(echo $output | jq -r '.principalId')
clientId=$(echo $output | jq -r '.clientId')

storageId=$(az storage account show --resource-group "AzureFunctionsQuickstart-rg" --name <STORAGE_NAME> --query 'id' -o tsv)
az role assignment create --assignee-object-id $principalId --assignee-principal-type ServicePrincipal \
--role "Storage Blob Data Owner" --scope $storageId
```
Si vous n’avez pas l’utilitaire jq dans votre interpréteur de commandes Bash local, il est disponible dans Azure Cloud Shell. Dans cet exemple, remplacez <STORAGE_NAME> et <REGION> par respectivement le nom de votre compte de stockage par défaut et la région.

La commande az identity create crée une identité nommée func-host-storage-user. Le retour principalId est utilisé pour attribuer des autorisations à cette nouvelle identité dans le compte de stockage par défaut à l’aide de la az role assignment create commande. La az storage account show commande est utilisée pour obtenir l’ID du compte de stockage.

Utilisez cette commande az functionapp create pour créer l’application de fonction dans Azure :

az functionapp create --resource-group "AzureFunctionsQuickstart-rg" --name <APP_NAME> --flexconsumption-location <REGION> \
--runtime dotnet-isolated --runtime-version <LANGUAGE_VERSION> --storage-account <STORAGE_NAME> \
--deployment-storage-auth-type UserAssignedIdentity --deployment-storage-auth-value "func-host-storage-user"

az functionapp create --resource-group "AzureFunctionsQuickstart-rg" --name <APP_NAME> --flexconsumption-location <REGION> \
--runtime java --runtime-version <LANGUAGE_VERSION> --storage-account <STORAGE_NAME> \
--deployment-storage-auth-type UserAssignedIdentity --deployment-storage-auth-value "func-host-storage-user"

az functionapp create --resource-group "AzureFunctionsQuickstart-rg" --name <APP_NAME> --flexconsumption-location <REGION> \
--runtime node --runtime-version <LANGUAGE_VERSION> --storage-account <STORAGE_NAME> \
--deployment-storage-auth-type UserAssignedIdentity --deployment-storage-auth-value "func-host-storage-user"

az functionapp create --resource-group "AzureFunctionsQuickstart-rg" --name <APP_NAME> --flexconsumption-location <REGION> \
--runtime python --runtime-version <LANGUAGE_VERSION> --storage-account <STORAGE_NAME> \
--deployment-storage-auth-type UserAssignedIdentity --deployment-storage-auth-value "func-host-storage-user"

az functionapp create --resource-group "AzureFunctionsQuickstart-rg" --name <APP_NAME> --flexconsumption-location <REGION> \
--runtime python --runtime-version <LANGUAGE_VERSION> --storage-account <STORAGE_NAME> \
--deployment-storage-auth-type UserAssignedIdentity --deployment-storage-auth-value "func-host-storage-user"

az functionapp create --resource-group "AzureFunctionsQuickstart-rg" --name <APP_NAME> --flexconsumption-location <REGION> \
--runtime other --storage-account <STORAGE_NAME> \
--deployment-storage-auth-type UserAssignedIdentity --deployment-storage-auth-value "func-host-storage-user"

Dans cet exemple, remplacez ces espaces réservés par les valeurs appropriées :

<APP_NAME>: nom global unique qui vous convient. <APP_NAME> représente également le domaine DNS par défaut pour l’application de fonction.
<STORAGE_NAME>: nom du compte que vous avez utilisé à l’étape précédente.
<REGION>: votre région actuelle.
<LANGUAGE_VERSION>: utilisez la même version de pile linguistique prise en charge que celle que vous avez vérifiée localement, le cas échéant.

Cette commande crée une application de fonction s’exécutant dans votre runtime de langage spécifié sur Linux dans le plan de consommation Flex, qui est gratuite pour la quantité d’utilisation que vous impliquez ici. La commande crée également une instance Azure Application Insights associée dans le même groupe de ressources. Vous pouvez l’utiliser pour surveiller les exécutions de votre application de fonction et afficher les journaux d’activité. Pour plus d’informations, consultez Surveiller l’exécution des fonctions Azure. L’instance n’entraîne aucun coût tant que vous ne l’activez pas.

Utilisez ce script pour ajouter votre identité managée affectée par l’utilisateur au rôle Éditeur de métriques de surveillance dans votre instance Application Insights :
```
appInsights=$(az monitor app-insights component show --resource-group "AzureFunctionsQuickstart-rg" \
    --app <APP_NAME> --query "id" --output tsv)
principalId=$(az identity show --name "func-host-storage-user" --resource-group "AzureFunctionsQuickstart-rg" \
    --query principalId -o tsv)
az role assignment create --role "Monitoring Metrics Publisher" --assignee $principalId --scope $appInsights
```
Dans cet exemple, remplacez <APP_NAME> par le nom de votre application de fonction. La commande az role assignment create ajoute votre utilisateur au rôle. L'ID de ressource de votre instance Application Insights et l'ID principal de votre utilisateur sont obtenus à l'aide des commandes az monitor app-insights component show et az identity show, respectivement.

Mettre à jour les paramètres de l’application

Pour permettre à l’hôte Functions de se connecter au compte de stockage par défaut à l’aide de secrets partagés, remplacez le AzureWebJobsStorage paramètre de chaîne de connexion par plusieurs paramètres préfixés AzureWebJobsStorage__par . Ces paramètres définissent un paramètre complexe que votre application utilise pour se connecter au stockage et à Application Insights avec une identité managée affectée par l’utilisateur.

Utilisez ce script pour obtenir l’ID client de l’identité managée affectée par l’utilisateur et l’utiliser pour définir des connexions d’identité managée à la fois au stockage et à Application Insights :

clientId=$(az identity show --name func-host-storage-user \
    --resource-group AzureFunctionsQuickstart-rg --query 'clientId' -o tsv)
az functionapp config appsettings set --name <APP_NAME> --resource-group "AzureFunctionsQuickstart-rg" \
    --settings AzureWebJobsStorage__accountName=<STORAGE_NAME> \
    AzureWebJobsStorage__credential=managedidentity AzureWebJobsStorage__clientId=$clientId \
    APPLICATIONINSIGHTS_AUTHENTICATION_STRING="ClientId=$clientId;Authorization=AAD"

Dans ce script, remplacez <APP_NAME> par le nom de votre application de fonction et <STORAGE_NAME> par le nom de votre compte de stockage, respectivement.

Exécutez la commande az functionapp config appsettings delete pour supprimer le paramètre de chaîne de connexion existant AzureWebJobsStorage , qui contient une clé secrète partagée :
```
az functionapp config appsettings delete --name <APP_NAME> --resource-group "AzureFunctionsQuickstart-rg" --setting-names AzureWebJobsStorage
```
Dans cet exemple, remplacez <APP_NAME> par les noms de votre application de fonction.

À ce stade, l’hôte Functions peut se connecter au compte de stockage en toute sécurité à l’aide d’identités managées au lieu de secrets partagés. Vous pouvez maintenant déployer votre code de projet sur les ressources Azure.

Déployer le projet de fonction sur Azure

Après avoir créé votre application de fonction dans Azure, vous êtes prêt à déployer votre projet de fonctions locales en utilisant la commande func azure functionapp publish.

Dans votre dossier de projet racine, exécutez cette commande func azure functionapp publish :

func azure functionapp publish <APP_NAME>

Dans cet exemple, remplacez <APP_NAME> par le nom de votre application. Un déploiement réussi donne des résultats similaires à la sortie suivante (tronquée pour des raisons de simplicité) :

 ...

 Getting site publishing info...
 Creating archive for current directory...
 Performing remote build for functions project.

 ...

 Deployment successful.
 Remote build succeeded!
 Syncing triggers...
 Functions in msdocs-azurefunctions-qs:
     HttpExample - [httpTrigger]
         Invoke url: https://msdocs-azurefunctions-qs.azurewebsites.net/api/httpexample

Dans votre terminal local ou invite de commandes, exécutez cette commande pour obtenir la valeur du point de terminaison d’URL, y compris la clé d’accès :
```
func azure functionapp list-functions <APP_NAME> --show-keys
```
Dans cet exemple, remplacez <APP_NAME> à nouveau par le nom de votre application.
Copiez l’URL et la clé de point de terminaison retournées, que vous utilisez pour appeler le point de terminaison de fonction.

Mettre à jour le fichier pom.xml

Une fois que vous avez créé votre application de fonction dans Azure, mettez à jour le fichier pom.xml afin que Maven puisse déployer sur votre nouvelle application. Sinon, Maven crée un nouvel ensemble de ressources Azure pendant le déploiement.

Dans Azure Cloud Shell, utilisez cette az functionapp show commande pour obtenir l’URL et l’ID du conteneur de déploiement de la nouvelle identité managée affectée par l’utilisateur :

az functionapp show --name <APP_NAME> --resource-group AzureFunctionsQuickstart-rg  \
    --query "{userAssignedIdentityResourceId: properties.functionAppConfig.deployment.storage.authentication.userAssignedIdentityResourceId, \
    containerUrl: properties.functionAppConfig.deployment.storage.value}"

Dans cet exemple, remplacez <APP_NAME> par les noms de votre application de fonction.

Dans le répertoire racine du projet, ouvrez le fichier pom.xml dans un éditeur de texte, recherchez l’élément properties et mettez à jour ces valeurs de propriété spécifiques :

Nom de la propriété	Value
`java.version`	Utilisez la même version de pile linguistique prise en charge que celle que vous avez vérifiée localement, comme `17`.
`azure.functions.maven.plugin.version`	`1.37.1`
`azure.functions.java.library.version`	`3.1.0`
`functionAppName`	Nom de votre application de fonction dans Azure.

Recherchez la configuration section du fragment XML et remplacez-la azure-functions-maven-plugin par ce fragment XML :

<configuration>
    <appName>${functionAppName}</appName>
    <resourceGroup>AzureFunctionsQuickstart-rg</resourceGroup>
    <pricingTier>Flex Consumption</pricingTier>
    <region>....</region>
    <runtime>
        <os>linux</os>
        <javaVersion>${java.version}</javaVersion>
    </runtime>
    <deploymentStorageAccount>...</deploymentStorageAccount>
    <deploymentStorageResourceGroup>AzureFunctionsQuickstart-rg</deploymentStorageResourceGroup>
    <deploymentStorageContainer>...</deploymentStorageContainer>
    <storageAuthenticationMethod>UserAssignedIdentity</storageAuthenticationMethod>
    <userAssignedIdentityResourceId>...</userAssignedIdentityResourceId>
    <appSettings>
        <property>
            <name>FUNCTIONS_EXTENSION_VERSION</name>
            <value>~4</value>
        </property>
    </appSettings>
</configuration>

Dans le nouvel élément configuration, effectuez ces remplacements spécifiques des valeurs d'ellipses (...) :

Configuration	Value
`region`	Code de région de votre application de fonction existante, par exemple `eastus`.
`deploymentStorageAccount`	nom de votre compte de stockage.
`deploymentStorageContainer`	Le nom du partage de déploiement, qui suit `\` dans la valeur `containerUrl` obtenue.
`userAssignedIdentityResourceId`	L’ID de ressource complet de votre identité managée, que vous avez obtenu.

Enregistrez vos modifications dans le fichier pom.xml .

Vous pouvez maintenant utiliser Maven pour déployer votre projet de code sur votre application existante.

Déployer le projet de fonction sur Azure

Dans l’invite de commandes, exécutez cette commande :
```
mvn clean package azure-functions:deploy
```
Une fois votre déploiement réussi, exécutez cette commande Core Tools pour obtenir la valeur du point de terminaison d’URL, y compris la clé d’accès :
```
func azure functionapp list-functions <APP_NAME> --show-keys
```
Dans cet exemple, remplacez <APP_NAME> à nouveau par le nom de votre application.
Copiez l’URL et la clé de point de terminaison retournées, que vous utilisez pour appeler le point de terminaison de fonction.

Appeler la fonction sur Azure

Étant donné que votre fonction utilise un déclencheur HTTP et prend en charge les requêtes GET, vous l’appelez en effectuant une requête HTTP à son URL à l’aide de la clé d’accès au niveau de la fonction. Il est plus simple d’exécuter une requête GET dans un navigateur.

Collez l’URL et la clé d’accès que vous avez copiées dans une barre d’adresses du navigateur.

L’URL du point de terminaison doit ressembler à cet exemple :

https://contoso-app.azurewebsites.net/api/httpexample?code=aabbccdd...

Dans ce cas, vous devez également fournir une clé d’accès dans la chaîne de requête lors de l’exécution d’une requête GET à l’URL du point de terminaison. L’utilisation d’une clé d’accès est recommandée pour limiter l’accès à partir de clients aléatoires. Lorsque vous effectuez une requête POST à l’aide d’un client HTTP, vous devez plutôt fournir la clé d’accès dans l’en-tête x-functions-key .

Quand vous accédez à cette URL, le navigateur doit afficher une sortie similaire à celle générée au moment de l’exécution locale de la fonction.

Nettoyer les ressources

Si vous passez à l’étape suivante, qui consiste à ajouter une liaison de sortie de file d’attente Stockage Azure, gardez toutes vos ressources en place, car vous allez tirer parti de ce que vous avez déjà fait.

Sinon, utilisez la commande suivante pour supprimer le groupe de ressources et toutes les ressources qu’il contient afin d’éviter les coûts supplémentaires.

Azure CLI
Azure PowerShell

az group delete --name AzureFunctionsQuickstart-rg

Remove-AzResourceGroup -Name AzureFunctionsQuickstart-rg

Étapes suivantes

Se connecter au Stockage File d’attente Azure

Rétroaction

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

Last updated on 2025-12-04

Partager via

Démarrage rapide : Créer une fonction dans Azure à partir de la ligne de commande

Prerequisites

Installer Azure Functions Core Tools

Créer et activer un environnement virtuel

Créer un projet et une fonction de code local

Créer et générer votre fonction

Configurer votre application de fonction

Exécuter la fonction localement

Créer des ressources Azure de prise en charge pour votre fonction

Mettre à jour les paramètres de l’application

Déployer le projet de fonction sur Azure

Mettre à jour le fichier pom.xml

Déployer le projet de fonction sur Azure

Appeler la fonction sur Azure

Nettoyer les ressources

Étapes suivantes

Rétroaction

Ressources additionnelles