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

• C#
• Java
• JavaScript
• PowerShell
• Python
• TypeScript
• Autres (Go/Rust)

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.

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.

Configurer votre environnement

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

Go

• 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.

Rust

• 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.

• Chaîne d’outils Rust avec rustup. Utilisez la commande rustc --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.

1. 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....

2. 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.

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

   Prompt	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.

Go

1. 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).

2. 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))
   }
   

3. Appuyez sur Ctrl+Maj+' ou sélectionnez Nouveau terminal dans le menu Terminal pour ouvrir un nouveau terminal intégré dans VS Code.

4. 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
   

   

Rust

1. Appuyez sur Ctrl+Maj+' ou sélectionnez Nouveau terminal dans le menu Terminal pour ouvrir un nouveau terminal intégré dans VS Code.

2. 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
   

3. 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"] }
   

4. 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
   }
   

5. 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.

1. Ouvrez host.json.

2. Dans la section customHandler.description, définissez la valeur de defaultExecutablePath sur handler (sur Windows, définissez-la sur handler.exe).

3. 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é.

4. 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.

1. Dans le terminal intégré, démarrez l’application de fonction en utilisant Azure Functions Core Tools.

   func start
   

2. 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

3. Une réponse est retournée, semblable à celle-ci dans un navigateur :

   

4. Les informations relatives à la requête s’affichent dans le panneau Terminal.

   

5. 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.

Connexion à Azure

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

1. 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.

2. 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éé.

3. 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.

Go

1. 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

   GOOS=linux GOARCH=amd64 go build handler.go
   

   Linux

   GOOS=linux GOARCH=amd64 go build handler.go
   

   Windows

   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.

Rust

1. 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"
   

2. 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 .
   

3. 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.

4. 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.

1. Sélectionnez l’icône Azure dans la barre Activité. Ensuite, dans la zone Ressources, sélectionnez l’icône + et choisissez l’option Créer une application de fonction dans Azure.

   

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

   Prompt	Sélection
   Sélectionner un abonnement	choisissez l’abonnement à utiliser. Vous ne verrez pas cela si vous n’avez qu’un abonnement visible sous Ressources.
   Entrer un nom global unique pour l’application de fonction	Tapez un nom valide dans un chemin d’URL. Le système vérifie que le nom que vous tapez est unique dans Azure Functions.
   Sélectionner une pile d’exécution	Choisissez Gestionnaire personnalisé.
   Sélectionnez un emplacement pour les nouvelles ressources	Pour de meilleures performances, choisissez une région proche de vous.

   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é.

   

3. 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.

   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.

1. Dans la palette de commandes, entrez puis sélectionnez Azure Functions : Déployer sur une application de fonction.

2. 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.

3. 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

1. 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.

2. Sélectionnez votre nouvelle ressource d’application de fonction et HttpExample comme fonction.

3. Dans Entrer le corps de la requête, tapez { "name": "Azure" }, puis appuyez sur Entrée pour envoyer ce message de requête à votre fonction.

4. Lorsque 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.

1. 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.

2. Choisissez votre application de fonction et appuyez sur Entrée. La page de l’application de fonction s’ouvre dans le portail Azure.

3. Sous l’onglet Vue d’ensemble, sélectionnez le lien nommé à côté de Groupe de ressources.

   

4. 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.

5. 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