Démarrage rapide : Créer une fonction Go ou Rust dans Azure à l’aide de Visual Studio Code

2025-05-22

Dans cet article, vous allez utiliser Visual Studio Code pour créer une fonction de gestionnaire personnalisé qui répond aux requêtes HTTP. Après avoir testé le code localement, vous le déployez dans l’environnement serverless d’Azure Functions.

Les gestionnaires personnalisés peuvent être utilisés pour créer des fonctions dans n’importe quel langage ou runtime en exécutant un processus serveur HTTP. Cet article prend en charge à la fois Go et Rust.

Conseil

L’exécution de ce guide de démarrage rapide crée une application qui s’exécute dans un plan Elastic Premium, ce qui peut entraîner des coûts dans votre compte Azure même si vous ne l’utilisez pas. Vous devez nettoyer les ressources pour supprimer l’application de fonction, le plan App Service et les ressources associées une fois l’article terminé.

Configurer votre environnement

Avant de commencer, veillez à disposer des éléments suivants :

Allez
Rouille

Compte Azure avec un abonnement actif. Créez un compte gratuitement.
Visual Studio Code sur l’une des plateformes prises en charge.
Extension Azure Functions pour Visual Studio Code.
Go, version la plus récente recommandée. Utilisez la commande go version pour vérifier la version que vous utilisez.

Installer ou mettre à jour Core Tools

L’extension Azure Functions pour Visual Studio Code s’intègre à Azure Functions Core Tools afin que vous puissiez exécuter et déboguer vos fonctions localement dans Visual Studio Code à l’aide du runtime Azure Functions. Avant la mise en route, il est judicieux d’installer Core Tools localement ou de mettre à jour une installation existante pour utiliser la dernière version.

Dans Visual Studio Code, appuyez sur F1 pour ouvrir la palette de commandes, puis recherchez et exécutez la commande Azure Functions : Install ou Update Core Tools.

Cette commande tente de démarrer une installation basée sur un package de la dernière version de Core Tools ou de mettre à jour une installation basée sur un package existant. Si npm ou Homebrew n’est pas installé sur votre ordinateur local, vous devezinstaller ou mettre à jour manuellement Core Tools.

Créer votre projet local

Dans cette section, vous allez utiliser Visual Studio Code pour créer un projet de gestionnaires personnalisés Azure Functions local. Plus loin dans cet article, vous allez publier votre code de fonction sur Azure.

Dans Visual Studio Code, appuyez sur F1 pour ouvrir la palette de commandes, puis recherchez et exécutez la commande Azure Functions: Create New Project....
Choisissez l’emplacement de répertoire pour votre espace de travail de projet et optez pour Sélectionner. Vous devez créer un dossier ou choisir un dossier vide pour l’espace de travail du projet. Ne choisissez pas de dossier de projet qui fait déjà partie d’un espace de travail.

Quand vous y êtes invité, indiquez les informations suivantes :

Invite	Sélection
Sélectionner un langage pour votre projet de fonction	Choisissez `Custom Handler`.
Sélectionner un modèle pour la première fonction de votre projet	Choisissez `HTTP trigger`.
Fournir un nom de fonction	Tapez `HttpExample`.
Niveau d’autorisation	Choisissez l’option `Anonymous`, qui permet à quiconque d’appeler le point de terminaison de votre fonction. Pour plus d’informations, consultez Niveau d’autorisation.
Sélectionner la façon dont vous souhaitez ouvrir votre projet	Choisissez `Open in current window`.

À l’aide de ces informations, Visual Studio Code génère un projet Azure Functions avec un déclencheur HTTP. Vous pouvez voir les fichiers de projet locaux dans l’Explorateur.

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
Rouille

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

Vous pouvez exécuter ce projet sur votre ordinateur de développement local avant de publier sur Azure.

Dans le terminal intégré, démarrez l’application de fonction en utilisant Azure Functions Core Tools.
```
func start
```
Avec Core Tools en cours d’exécution, accédez à l’URL suivante pour exécuter une requête GET, qui inclut la chaîne de requête ?name=Functions.

http://localhost:7071/api/HttpExample?name=Functions
Une réponse est retournée, semblable à celle-ci dans un navigateur :
Les informations relatives à la requête s’affichent dans le panneau Terminal.
Appuyez sur Ctrl+C pour arrêter Core Tools.

Après avoir vérifié que la fonction s’exécute correctement sur votre ordinateur local, il est temps d’utiliser Visual Studio Code pour publier le projet directement sur Azure.

Avant de pouvoir créer des ressources Azure ou de publier votre application, vous devez vous connecter à Azure.

Si vous n’êtes pas encore connecté, dans la Barre d’activité, sélectionnez l’icône Azure. Ensuite, sous Ressources, sélectionnez Se connecter à Azure.

Si vous êtes déjà connecté et que vous pouvez voir vos abonnements existants, accédez à la section suivante. Si vous n’avez pas encore de compte Azure, Créez un compte Azure. Les étudiants peuvent sélectionner Créer un compte Azure for Students.
Quand vous y êtes invité dans le navigateur, sélectionnez votre compte Azure et connectez-vous avec vos informations d’identification de compte Azure. Si vous créez un compte, vous pouvez vous connecter une fois votre compte créé.
Une fois la connexion réussie, vous pouvez fermer la nouvelle fenêtre de navigateur. Les abonnements qui appartiennent à votre compte Azure sont affichés dans la barre latérale.

Compiler le gestionnaire personnalisé pour Azure

Dans cette section, vous allez publier votre projet sur Azure dans une application de fonction exécutant Linux. Dans la plupart des cas, vous devez recompiler votre fichier binaire et ajuster votre configuration pour qu’elle corresponde à la plateforme cible avant la publication sur Azure.

Allez
Rouille

Dans le terminal intégré, compilez le gestionnaire en Linux/x64. Un fichier binaire nommé handler est créé dans la racine de l’application de fonction.
- macOS
- Linux
- Windows
```
GOOS=linux GOARCH=amd64 go build handler.go
```
```
GOOS=linux GOARCH=amd64 go build handler.go
```
```
set GOOS=linux
set GOARCH=amd64
go build handler.go
```
Modifiez defaultExecutablePath dans host.json en remplaçant handler.exe par handler. Cela indique à l’application de fonction d’exécuter le binaire Linux.

Créez un fichier au niveau de .cargo/config. Ajoutez le contenu suivant et enregistrez le fichier.
```
[target.x86_64-unknown-linux-musl]
linker = "rust-lld"
```
Dans le terminal intégré, compilez le gestionnaire en Linux/x64. Un fichier binaire nommé handler est créé. Copiez-le dans la racine de l’application de fonction.
```
rustup target add x86_64-unknown-linux-musl
cargo build --release --target=x86_64-unknown-linux-musl
cp target/x86_64-unknown-linux-musl/release/handler .
```
Si vous utilisez Windows, modifiez defaultExecutablePath dans host.json en remplaçant handler.exe par handler. Cela indique à l’application de fonction d’exécuter le binaire Linux.
Ajoutez la ligne suivante au fichier .funcignore :
```
target
```
Cela empêche la publication du contenu du dossier cible.

Créer l’application de fonction dans Azure

Dans cette section, vous créez une application de fonction et les ressources associées dans votre abonnement Azure.

Dans la palette de commandes, entrez Azure Functions : Créer une application de fonction dans Azure...(Advanced).
Si vous n’êtes pas connecté, vous êtes invité à le faire avec Se connecter à Azure. Vous pouvez également créer un compte Azure gratuit. Une fois la connexion établie à partir du navigateur, revenez à Visual Studio Code.

Suivez les invites et fournissez ces informations :

Invite	Sélection
Entrez un nom globalement unique pour la nouvelle application de fonction.	Tapez un nom global unique identifiant votre nouvelle application de fonction et sélectionnez Entrée. Les caractères valides pour un nom d’application de fonction sont `a-z`, `0-9` et `-`.
Sélectionnez un plan d’hébergement.	Choisissez le plan d’hébergementPremium, qui fournit un hébergement serverless sur Linux qui est mis à l’échelle dynamiquement selon les besoins.
Sélectionnez un emplacement pour les nouvelles ressources.	Sélectionnez un emplacement dans une région proche de chez vous, ou proche d’autres services auxquels vos fonctions ont accès. Seules les régions qui prennent en charge votre plan d’hébergement choisi sont affichées.
Sélectionnez une pile de runtime.	Sélectionnez Gestionnaire personnalisé.
Sélectionnez un système d’exploitation.	Sélectionnez Linux , car l’application a été compilée pour s’exécuter sur Linux.
Sélectionnez un plan App Service Linux	Pour les plans Elastic Premium, vous devez créer explicitement un plan App Service, entrer le nom du plan et sélectionner le niveau tarifaire EP1 .
Sélectionner le type d’authentification des ressources	Sélectionnez Identité managée, qui est l’option la plus sécurisée pour la connexion au compte de stockage hôte par défaut. Lorsque vous utilisez des identités managées avec un plan Elastic Premium, l’accès à la clé secrète au stockage hôte par défaut reste activé pour l’accès Azure Files. Pour plus d’informations, consultez Exécuter sans Azure Files.
Sélectionnez un compte de stockage.	Choisissez Créer un nouveau compte de stockage et, à l'invite, entrez un nom globalement unique pour le nouveau compte de stockage utilisé par votre application de fonction. Les noms des comptes de stockage doivent comporter entre 3 et 24 caractères, et contenir uniquement des lettres minuscules et des chiffres.
Sélectionnez une ressource Application Insights pour votre application.	Choisissez Créer une nouvelle ressource Application Insights et, à l'invite, entrez un nom pour l'instance utilisée pour stocker les données d'exécution de vos fonctions.
Sélectionner une identité assignée par l'utilisateur	Choisissez Créer une nouvelle identité assignée à l'utilisateur. Cette identité est utilisée lors de l’accès au compte de stockage hôte par défaut à l’aide de l’authentification Microsoft Entra ID.

L’extension montre l'état des ressources individuelles au fur et à mesure qu’elles sont créées dans Azure, dans le panneau Azure : journal d’activité.

Journal de création de ressource Azure

Quand la création est terminée, les ressources Azure suivantes sont créées dans votre abonnement. Les ressources sont nommées en fonction du nom de votre application de fonction :
- Un groupe de ressources, qui est un conteneur logique pour les ressources associées.
- Un compte Stockage Azure standard, qui conserve l’état et d’autres informations spécifiques à vos projets.
- Une application de fonction, qui fournit l’environnement d’exécution de votre code de fonction. Une application de fonction vous permet de regrouper des fonctions en une unité logique pour faciliter la gestion, le déploiement et le partage des ressources au sein du même plan d’hébergement.
- Un plan Azure App Service, qui définit l’hôte sous-jacent pour votre application de fonction.
- Une instance Application Insights connectée à l’application de fonction et qui fait le suivi de l’utilisation de vos fonctions dans l’application.
- Identité managée associée par l'utilisateur qui est ajoutée au rôle de Contributeur aux données blob de stockage dans le nouveau compte de stockage hôte par défaut.
Une notification s’affiche après que votre application de fonction a été créée et que le package de déploiement a été appliqué.

Conseil

Par défaut, les ressources Azure nécessaires pour votre application de fonction sont créées selon le nom que vous avez saisi pour votre application de fonction. Par défaut, les ressources sont créées avec l’application de fonction dans le même nouveau groupe de ressources. Si vous voulez personnaliser les noms des ressources associées ou réutiliser des ressources existantes, publiez le projet en utilisant les options de création avancées.

Déployer le projet dans Azure

Important

Le déploiement vers une application de fonction existante remplace toujours le contenu de cette application dans Azure.

Dans la palette de commandes, entrez puis sélectionnez Azure Functions : Déployer sur une application de fonction.
Sélectionnez l’application de fonction que vous venez de créer. Quand vous êtes invité à remplacer les déploiements précédents, sélectionnez Déployer pour déployer le code de votre fonction sur la nouvelle ressource de l’application de fonction.
Une fois le déploiement terminé, sélectionnez Afficher la sortie pour voir les résultats de la création et du déploiement, y compris les ressources Azure que vous avez créées. Si vous manquez la notification, sélectionnez l’icône de cloche dans le coin inférieur droit pour la voir à nouveau.

Exécuter la fonction dans Azure

Appuyez sur F1 pour afficher la palette de commandes, puis recherchez et exécutez la commande Azure Functions:Execute Function Now.... Si vous y êtes invité, sélectionnez votre abonnement.
Sélectionnez votre nouvelle ressource d’application de fonction, et HttpExample en tant que fonction.
Dans Entrer le corps de la demande, tapez { "name": "Azure" }, puis appuyez sur Entrée pour envoyer ce message de requête à votre fonction.
Quand la fonction s’exécute dans Azure, la réponse s’affiche dans la zone de notification. Développez la notification pour passer en revue la réponse complète.

Nettoyer les ressources

Quand vous passerez à l’étape suivante et ajouterez une liaison de file d’attente Stockage Azure à votre fonction, vous devrez conserver toutes vos ressources en place, car vous allez tirer parti de ce que vous avez déjà fait.

Sinon, vous pouvez utiliser les étapes suivantes pour supprimer l’application de fonction et ses ressources connexes afin d’éviter des coûts supplémentaires.

Dans Visual Studio Code, appuyez sur F1 pour ouvrir la palette de commandes. Dans la palette de commandes, recherchez et sélectionnez Azure: Open in portal.
Choisissez votre application de fonction et appuyez sur Entrée. La page de l’application de fonction s’ouvre dans le portail Azure.
Sous l’onglet Vue d’ensemble, sélectionnez le lien nommé à côté de Groupe de ressources.
Dans la page Groupe de ressources, passez en revue la liste des ressources incluses et vérifiez qu’elles correspondent à celles que vous souhaitez supprimer.
Sélectionnez Supprimer le groupe de ressources et suivez les instructions.

Cette opération peut prendre quelques minutes. Une fois terminée, une notification s’affiche pendant quelques secondes. Vous pouvez également sélectionner l’icône représentant une cloche en haut de la page pour afficher la notification.

Pour en savoir plus sur les coûts de Functions, consultez Estimation des coûts d’un plan Consommation.

Étapes suivantes

En savoir plus sur les gestionnaires personnalisés Azure Functions

Partager via