Développer Azure Functions à l’aide de Visual Studio

Visual Studio offre un moyen de développer, tester et déployer des fonctions de bibliothèque de classes C# sur Azure. Si cette expérience est votre première avec Azure Functions, consultez la vue d’ensemble d’Azure Functions.

Pour vous lancer tout de suite, envisagez d’effectuer le démarrage rapide Functions pour Visual Studio.

Cet article fournit des informations détaillées sur l’utilisation de Visual Studio pour développer des fonctions de bibliothèque de classes C# et les publier sur Azure. Il existe deux modèles pour développer des fonctions de bibliothèque de classes C# : le modèle worker isolé et le modèle in-process.

Vous lisez la version du modèle de travailleur isolé de cet article. Vous pouvez sélectionner votre modèle préféré en haut de l’article.

La version de l’article que vous lisez porte sur le modèle In-process. Vous pouvez sélectionner votre modèle préféré en haut de l’article.

Important

La prise en charge du modèle in-process se termine le 10 novembre 2026. Nous vous recommandons de migrer vos applications vers le modèle worker isolé.

Sauf indication contraire, les procédures et exemples présentés correspondent à Visual Studio 2022. Pour plus d’informations sur les versions de Visual Studio 2022, consultez les notes de publication ou les notes de publication en préversion.

Prérequis

Visual Studio 2022, y compris la charge de travail de développement Azure.
Les autres ressources dont vous avez besoin, tel qu’un compte de stockage Azure, sont créées dans votre abonnement au cours du processus de publication.
Si vous ne disposez pas d’un compte Azure, créez-en un gratuitement avant de commencer.

Créer un projet Azure Functions

Le modèle de projet Azure Functions dans Visual Studio crée un projet de bibliothèque de classe C# que vous pouvez publier dans une application de fonction dans Azure. Vous pouvez utiliser une application de fonction pour regrouper des fonctions en une unité logique afin de faciliter la gestion, le déploiement, la mise à l’échelle et le partage des ressources.

Dans le menu de Visual Studio, sélectionnez Fichier>Nouveau>Projet.
Dans la boîte de dialogue Créer un projet , entrez des fonctions dans la zone de recherche, sélectionnez le modèle Azure Functions , puis sélectionnez Suivant.
Dans la boîte de dialogue Configurer votre nouveau projet , pour le nom du projet, entrez un nom pour votre projet, puis sélectionnez Suivant. Le nom d’application de la fonction doit être valide en tant qu’espace de noms C#, afin de ne pas utiliser des traits d’union, des traits de soulignement ou d’autres caractères non alphanumériques.

Dans la boîte de dialogue Informations supplémentaires , effectuez les actions répertoriées dans le tableau suivant :

Paramètre	Action	Descriptif
Fonctions worker	Sélectionnez .NET 8.0 isolé (support à long terme).	Visual Studio crée un projet de fonction qui s’exécute dans un processus de travail isolé. Le processus worker isolé prend également en charge d’autres versions de .NET et .NET Framework qui n’offrent pas de prise en charge à long terme (LTS). Pour plus d’informations, consultez Vue d’ensemble des versions du runtime Azure Functions.
Fonction	Sélectionnez Déclencheur Http.	Visual Studio crée une fonction déclenchée par une requête HTTP.
Utiliser Azurite pour le compte de stockage d’exécution (AzureWebJobsStorage)	Activez cette case à cocher.	Étant donné qu’une application de fonction dans Azure nécessite un compte de stockage, il en est attribué ou créé un quand vous publiez votre projet sur Azure. Un déclencheur HTTP n’utilise pas de chaîne de connexion de compte de stockage. Tous les autres types de déclencheurs nécessitent une chaîne de connexion de compte de stockage valide.
Niveau d’autorisation	Sélectionnez Anonyme.	Lorsque vous utilisez ce paramètre d’autorisation, n’importe quel client peut déclencher la fonction créée sans fournir de clé. Cette configuration facilite le test de votre nouvelle fonction. Pour plus d’informations, consultez Niveau d’autorisation.

Paramètre	Action	Descriptif
Fonctions worker	Sélectionnez .NET 8.0 in-process (support à long terme).	Visual Studio crée un projet de fonction qui s’exécute en cours avec la version 4.x du runtime Functions. Pour plus d’informations, consultez Vue d’ensemble des versions du runtime Azure Functions.
Fonction	Sélectionnez Déclencheur Http.	Visual Studio crée une fonction déclenchée par une requête HTTP.
Utiliser Azurite pour le compte de stockage d’exécution (AzureWebJobsStorage)	Activez cette case à cocher.	Étant donné qu’une application de fonction dans Azure nécessite un compte de stockage, il en est attribué ou créé un quand vous publiez votre projet sur Azure. Un déclencheur HTTP n’utilise pas de chaîne de connexion de compte de stockage. Tous les autres types de déclencheurs nécessitent une chaîne de connexion de compte de stockage valide.
Niveau d’autorisation	Sélectionner Anonyme	Lorsque vous utilisez ce paramètre d’autorisation, n’importe quel client peut déclencher la fonction créée sans fournir de clé. Cette configuration facilite le test de votre nouvelle fonction. Pour plus d’informations, consultez Niveau d’autorisation.

Veillez à définir le Niveau d’autorisation sur Anonyme. Si vous sélectionnez le niveau de fonction par défaut, vous devez présenter la clé de fonction dans les demandes d’accès à votre point de terminaison de fonction.

Sélectionnez Créer pour créer le projet de fonction et la fonction de déclencheur HTTP.

Après avoir créé un projet Functions, le modèle de projet crée un projet C#, installe les Microsoft.Azure.Functions.Worker packages NuGet et Microsoft.Azure.Functions.Worker.Sdk définit l’infrastructure cible.

Après avoir créé un projet Functions, le modèle de projet crée un projet C#, installe le Microsoft.NET.Sdk.Functions package NuGet et définit l’infrastructure cible.

Le nouveau projet comporte les fichiers suivants :

host.json: ce fichier vous permet de configurer l’hôte Functions. Ces paramètres s’appliquent lors de l’exécution en local et dans Azure. Pour plus d’informations, consultez l’article de référence sur host.json reference.
local.settings.json: ce fichier gère les paramètres que vous utilisez lorsque vous exécutez des fonctions localement. Ces paramètres ne sont pas utilisés lorsque votre application s’exécute dans Azure. Pour plus d’informations, consultez Utiliser les paramètres d’application localement.

Important

Étant donné que le fichier local.settings.json peut contenir des secrets, vous devez l’exclure du contrôle de code source de votre projet. Dans la boîte de dialogue Propriétés de ce fichier, vérifiez que le paramètre Copier dans le répertoire de sortie est défini sur Copier si plus récent.

Pour plus d’informations, consultez la structure du projet dans le guide de travail isolé.

Pour plus d’informations, consultez Projet de bibliothèque de classes Azure Functions.

Utiliser les paramètres d’application localement

Lorsque votre application de fonction s’exécute dans Azure, les paramètres requis par vos fonctions sont stockés chiffrés dans les paramètres de l’application. Pendant le développement local, ces paramètres sont ajoutés à la Values collection dans le fichier local.settings.json . Le fichier local.settings.json stocke également les paramètres utilisés par les outils de développement locaux.

Les éléments de la collection dans le Values fichier local.settings.json de votre projet sont destinés à mettre en miroir les éléments dans les paramètres d’application de votre application de fonction dans Azure.

Visual Studio ne charge pas automatiquement les paramètres dans local.settings.json lorsque vous publiez le projet. Pour vous assurer que ces paramètres existent également dans votre application de fonction dans Azure, chargez-les après avoir publié votre projet. Pour plus d’informations, consultez Paramètres de l’application de fonction. Les valeurs d’une ConnectionStrings collection ne sont pas publiées.

Votre code peut aussi lire les valeurs des paramètres d’application de fonction en tant que variables d’environnement. Pour en savoir plus, voir Variables d’environnement.

Configurer le projet pour un développement local

Le runtime Functions utilise un compte de stockage en interne. Pendant le développement, vous pouvez utiliser un compte de stockage valide pour ce compte interne, ou utiliser l’émulateur Azurite.

Pour tous les types de déclencheurs autres que HTTP et webhooks, vous devez définir la valeur de la Values.AzureWebJobsStorage clé dans le fichier local.settings.json :

Pour un compte de stockage, définissez la valeur sur la chaîne de connexion de votre compte de stockage.
Pour l’émulateur, définissez la valeur UseDevelopmentStorage=truesur .

Si vous utilisez l’émulateur, remplacez ce paramètre par une chaîne de connexion de compte de stockage réelle avant le déploiement. Pour plus d’informations, consultez Émulateur de stockage local.

Pour définir la chaîne de connexion du compte de stockage, procédez comme suit :

Connectez-vous au portail Azure, puis accédez à votre compte de stockage.
Sélectionnez Sécurité +> réseau. Sous key1, copiez la valeur de la chaîne de connexion .
Dans votre projet Visual Studio, ouvrez le fichier local.settings.json . Définissez la valeur de la AzureWebJobsStorage clé sur la chaîne de connexion que vous avez copiée.
Répétez l’étape précédente pour ajouter des clés uniques au tableau Values pour les autres connexions requises par vos fonctions.

Ajouter une fonction à votre projet

Dans les fonctions de bibliothèque de classes C#, les liaisons utilisées par les fonctions sont définies en appliquant des attributs dans le code. Lorsque vous créez vos déclencheurs de fonction à partir des modèles fournis, les attributs des déclencheurs sont appliqués pour vous.

Dans l’Explorateur de solutions, cliquez avec le bouton droit sur le nœud du projet et sélectionnez Ajouter>Nouvelle fonction Azure.
Dans la boîte de dialogue Ajouter un nouvel élément , sélectionnez Fonction Azure, puis Sélectionnez Ajouter.
Sélectionnez un déclencheur, puis définissez les propriétés de liaison requises. Si vous sélectionnez un déclencheur de service de stockage et que vous souhaitez configurer la connexion, cochez la case pour configurer la connexion de déclencheur. L’exemple suivant montre les paramètres pour la création d’une fonction de déclencheur Stockage File d’attente.
Sélectionnez Ajouter. Si vous cochez la case pour configurer une connexion de stockage à l’étape précédente, la page Se connecter à la dépendance s’affiche. Sélectionnez un émulateur de stockage Azurite ou Stockage Azure, puis sélectionnez Suivant.
- Si vous sélectionnez un émulateur de stockage Azurite, la page Se connecter à l’émulateur Azurite de stockage s’affiche. Procédez comme suit :
  1. Cliquez sur Suivant.
  2. Dans la page Résumé des modifications , sélectionnez Terminer. Visual Studio configure la dépendance et crée la classe de déclencheur.
- Si vous sélectionnez Stockage Azure, la page Se connecter au stockage Azure s’affiche. Procédez comme suit :
  1. Sélectionnez un compte de stockage, puis sélectionnez Suivant. Visual Studio tente de se connecter à votre compte Azure et de récupérer un point de terminaison.
  2. Cliquez sur Suivant.
  3. Dans la page Résumé des modifications , sélectionnez Terminer. Visual Studio configure la dépendance et crée la classe de déclencheur.
Cet exemple de déclencheur utilise un paramètre d’application pour la connexion au stockage avec une clé nommée QueueStorage. Cette clé, stockée dans le fichierlocal.settings.json, fait référence à l’émulateur Azurite ou à un compte de stockage.

Examinez la classe qui vient d’être ajoutée. Par exemple, la classe C# suivante représente une fonction de déclencheur de stockage file d’attente de base :

Une Run() méthode est attribuée avec Function. Cet attribut indique que la méthode est le point d’entrée de la fonction.

using System;
using Azure.Storage.Queues.Models;
using Microsoft.Azure.Functions.Worker;
using Microsoft.Extensions.Logging;

namespace Company.Function;

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

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

    [Function(nameof(QueueTriggerCSharp))]
    public void Run([QueueTrigger("PathValue", Connection = "ConnectionValue")] QueueMessage message)
    {
        _logger.LogInformation("C# Queue trigger function processed: {messageText}", message.MessageText);
    }
}

Une méthode statique Run() est attribuée avec FunctionName. Cet attribut indique que la méthode est le point d’entrée de la fonction.

using System;
using Microsoft.Azure.WebJobs;
using Microsoft.Azure.WebJobs.Host;
using Microsoft.Extensions.Logging;

namespace Company.Function
{
    public class QueueTriggerCSharp
    {
        [FunctionName("QueueTriggerCSharp")]
        public void Run([QueueTrigger("PathValue", Connection = "ConnectionValue")]string myQueueItem, ILogger log)
        {
            log.LogInformation($"C# Queue trigger function processed: {myQueueItem}");
        }
    }
}

Un attribut spécifique à la liaison est appliqué à chaque paramètre de liaison fourni à la méthode de point d’entrée. L’attribut accepte les informations de liaison en tant que paramètres.

Dans le code précédent, le premier paramètre a un attribut QueueTrigger appliqué, ce qui indique une fonction de déclencheur de file d'attente de stockage. Le nom de la file d’attente et le nom de paramètre de la chaîne de connexion sont transmis en tant que paramètres à l’attribut QueueTrigger. Dans votre classe :

Le paramètre de nom de file d’attente doit correspondre au nom de la file d’attente que vous utilisez à une étape antérieure pour créer le déclencheur, par exemple myqueue-items.
Le nom du paramètre de chaîne de connexion doit correspondre à celui que vous utilisez dans une étape précédente pour créer le déclencheur, par exemple QueueStorage.

Pour plus d’informations, consultez le déclencheur de stockage de file d'attente Azure pour Azure Functions.

Utilisez la procédure précédente pour ajouter d’autres fonctions à votre projet d’application de fonction. Chaque fonction dans le projet peut avoir un déclencheur différent, mais une fonction ne doit avoir qu’un seul déclencheur. Pour plus d’informations, consultez déclencheurs et liaisons Azure Functions.

Ajouter des liaisons

Comme avec les déclencheurs, les liaisons d’entrée et de sortie sont ajoutées à votre fonction en tant qu’attributs de liaison. Pour ajouter des liaisons à une fonction, procédez comme suit :

Veillez à configurer le projet pour un développement local.
Ajoutez le package d’extension NuGet approprié pour chaque liaison spécifique. Pour connaître les exigences de package NuGet spécifiques à la liaison, consultez l’article de référence de la liaison. Par exemple, pour les exigences de package pour le déclencheur Azure Event Hubs, consultez Liaisons et déclencheurs Azure Event Hubs pour Azure Functions.
Utilisez la commande suivante dans la console Gestionnaire de package pour installer un package spécifique :
```
Install-Package Microsoft.Azure.Functions.Worker.Extensions.<BINDING_TYPE> -Version <TARGET_VERSION>
```
```
Install-Package Microsoft.Azure.WebJobs.Extensions.<BINDING_TYPE> -Version <TARGET_VERSION>
```
Dans ce code, remplacez <BINDING_TYPE> par le nom spécifique de l’extension de liaison, puis remplacez <TARGET_VERSION> par une version spécifique du package, par 4.0.0exemple . Les versions valides sont répertoriées sur les pages de chaque package sur NuGet.org.
Si la liaison requiert des paramètres de l’application, ajoutez-les à la collection Values dans le fichier de paramètres local.

La fonction utilise ces valeurs quand elle s’exécute localement. Lorsque la fonction s’exécute dans l’application de fonction dans Azure, elle utilise les paramètres de l’application de fonction. Visual Studio facilite la publication de paramètres locaux sur Azure.

Ajoutez l’attribut de liaison correspondant à la signature de méthode. Dans le code suivant, un message de file d’attente déclenche la Run fonction. La liaison de sortie crée ensuite un nouveau message de file d’attente avec le même texte, mais dans une autre file d'attente.

 public class QueueTrigger
{
    private readonly ILogger _logger;

    public QueueTrigger(ILoggerFactory loggerFactory)
    {
        _logger = loggerFactory.CreateLogger<QueueTrigger>();
    }

    [Function("CopyQueueMessage")]
    [QueueOutput("myqueue-items-destination", Connection = "QueueStorage")]
    public string Run([QueueTrigger("myqueue-items-source", Connection = "QueueStorage")] string myQueueItem)
    {
        _logger.LogInformation($"C# Queue trigger function processed: {myQueueItem}");
        return myQueueItem;
    }
}

L’attribut QueueOutput définit la liaison dans la méthode. Pour plusieurs liaisons de sortie, vous placez plutôt cet attribut sur une propriété de chaîne de l’objet retourné. Pour plus d’informations, consultez Plusieurs liaisons de sortie.

public static class SimpleExampleWithOutput
{
    [FunctionName("CopyQueueMessage")]
    public static void Run(
        [QueueTrigger("myqueue-items-source", Connection = "QueueStorage")] string myQueueItem, 
        [Queue("myqueue-items-destination", Connection = "QueueStorage")] out string myQueueItemCopy,
        ILogger log)
    {
        log.LogInformation($"CopyQueueMessage function processed: {myQueueItem}");
        myQueueItemCopy = myQueueItem;
    }
}

L’attribut Queue du paramètre out définit la liaison de sortie.

La connexion au Stockage Queue est obtenue à partir du paramètre QueueStorage. Pour plus d’informations, consultez l’article de référence pour la liaison spécifique.

Pour obtenir la liste complète des liaisons prises en charge par les fonctions, consultez Liaisons prises en charge. Pour obtenir un exemple plus complet de ce scénario, consultez Connecter des fonctions au stockage Azure à l’aide de Visual Studio.

Exécuter des fonctions localement

Vous pouvez utiliser Azure Functions Core Tools pour exécuter des projets Functions sur votre ordinateur de développement local. Lorsque vous sélectionnez F5 pour déboguer un projet Functions, l’hôte Functions local (func.exe) commence à écouter sur un port local (généralement 7071). Tous les points de terminaison de fonction appelables sont écrits dans la sortie, et vous pouvez les utiliser pour tester vos fonctions. Pour plus d’informations, consultez Développer Azure Functions localement à l’aide de Core Tools. Vous êtes invité à installer ces outils la première fois que vous démarrez une fonction dans Visual Studio.

Important

À partir de la version 4.0.6517 de Core Tools, les projets de modèles in-process doivent référencer la version 4.5.0 ou ultérieure de Microsoft.NET.Sdk.Functions. Si vous utilisez une version antérieure, la func start commande génère une erreur.

Pour démarrer votre fonction dans Visual Studio en mode débogage, procédez comme suit :

Sélectionnez F5. Si vous y êtes invité, acceptez la demande de Visual Studio pour télécharger et installer Azure Functions Core Tools. Vous devrez peut-être également activer une exception de pare-feu afin que les outils puissent gérer les requêtes HTTP.
Lorsque le projet s’exécute, testez votre code de la même façon que vous testez une fonction déployée.

Lors de l’exécution de Visual Studio en mode débogage, les points d’arrêt sont atteints comme prévu.

Pour un scénario de test plus détaillé qui utilise Visual Studio, consultez Les fonctions de test, plus loin dans cet article.

Publication dans Azure

Lorsque vous publiez votre projet Functions sur Azure, Visual Studio utilise le déploiement zip pour déployer les fichiers projet. Si possible, vous devez également sélectionner Exécuter à partir du fichier de package afin que le projet s’exécute dans le package de déploiement (.zip). Pour plus d’informations, consultez Exécuter vos fonctions à partir d’un fichier de package dans Azure.

Ne pas déployer sur Functions à l’aide du Déploiement Web (msdeploy).

Procédez comme suit pour publier votre projet dans une application de fonction dans Azure :

Dans l’Explorateur de solutions, cliquez avec le bouton droit sur le projet, puis sélectionnez Publier.
Dans la page Publier , effectuez les sélections suivantes :
- Sur Cible, sélectionnez Azure, puis sélectionnez Suivant.
- Sur une cible spécifique, sélectionnez Application de fonction Azure, puis sélectionnez Suivant.
- Sur l’instance Functions, sélectionnez Créer nouveau.

Créez une instance en utilisant les valeurs spécifiées dans le tableau suivant :

Paramètre	Valeur	Descriptif
Nom	Un nom globalement unique	Le nom doit identifier de manière unique votre nouvelle application de fonction. Acceptez le nom suggéré ou entrez un nouveau nom. Les caractères suivants sont valides : `a-z`, `0-9`et `-`.
Nom d’abonnement	Nom de votre abonnement	L’application de fonction est créée dans un abonnement Azure. Acceptez l’abonnement par défaut ou sélectionnez-en un autre dans la liste.
Groupe de ressources	Nom de votre groupe de ressources	L’application de fonction est créée dans un groupe de ressources. Sélectionnez Nouveau pour créer un groupe de ressources. Vous pouvez également sélectionner un groupe de ressources existant dans la liste.
Type de plan	Consommation flexible	Lorsque vous publiez votre projet sur une application de fonction qui s’exécute dans un plan Flex Consumption, vous pouvez payer uniquement pour les exécutions de votre application de fonctions. D’autres plans d’hébergement peuvent entraîner des coûts plus élevés. IMPORTANT : Lors de la création d’un plan Flex Consumption, vous devez d’abord sélectionner un plan App Service , puis réélectionner Flex Consumption pour effacer un problème avec la boîte de dialogue.
Système d’exploitation	Linux	Le plan Flex Consumption nécessite actuellement Linux.
Lieu	Emplacement du service d’application	Sélectionnez un emplacement dans une région Azure prise en charge par le plan Flex Consumption. Lorsqu’une région non prise en charge est sélectionnée, le bouton Créer est grisé.
Taille de la mémoire de l’instance	2048	Taille de mémoire des instances de machine virtuelle dans lesquelles l’application s’exécute est unique au plan Flex Consumption.
Stockage Azure	Un compte de stockage à usage général	Le runtime Functions nécessite un compte de stockage. Sélectionnez Nouveau pour configurer un compte de stockage universel. Vous pouvez également utiliser un compte existant qui répond aux exigences du compte de stockage.
Application Insights	Instance d'Application Insights	Vous devez activer l’intégration d’Application Insights pour votre application de fonction. Sélectionnez Nouveau pour créer une instance dans un espace de travail Log Analytics nouveau ou existant. Vous pouvez également utiliser une instance existante.

Capture d’écran de la boîte de dialogue Créer une application de fonction. Les champs du nom, de l’abonnement, du groupe de ressources, du plan et d’autres paramètres sont renseignés.

Sélectionnez Créer pour créer une application de fonction et les ressources associées dans Azure. L’état de la création des ressources est affiché dans le coin inférieur gauche de la fenêtre.
Sélectionnez Terminer. La fenêtre de déroulement de la création du profil de publication s’affiche. Lorsque le profil est créé, sélectionnez Fermer.
Dans la page de profil de publication, sélectionnez Publier pour déployer le package qui contient vos fichiers projet dans votre nouvelle application de fonction dans Azure.

Une fois le déploiement terminé, l’URL racine de l’application de fonction dans Azure s’affiche sur la page de profil de publication.
Dans la page de profil de publication, accédez à la section Hébergement . Sélectionnez les points de suspension (...), puis sélectionnez Ouvrir dans le portail Azure. La nouvelle ressource Azure d’application de fonction s’ouvre dans le portail Azure.

Paramètres Function App

Visual Studio ne charge pas automatiquement les paramètres de l’application lorsque vous publiez votre projet. Si vous ajoutez des paramètres au fichier local.settings.json , vous devez également les ajouter à l’application de fonction dans Azure.

Le moyen le plus simple de charger les paramètres requis dans votre application de fonction dans Azure consiste à les gérer dans Visual Studio. Dans la page de profil de publication, accédez à la section Hébergement . Sélectionnez les points de suspension (...), puis sélectionnez Gérer les paramètres Azure App Service.

Lorsque vous effectuez la sélection, la boîte de dialogue Paramètres de l’application s’ouvre pour l’application de fonction. Vous pouvez utiliser cette boîte de dialogue pour ajouter des paramètres d’application ou modifier des paramètres existants.

Capture d’écran de la boîte de dialogue Paramètres de l’application montrant les valeurs locales et distantes pour différents paramètres et contrôles pour l’ajout et la modification de valeurs.

Pour chaque paramètre, la valeur locale est la valeur du fichier local.settings.json , et la valeur distante est la valeur de l’application de fonction dans Azure.

Pour créer un paramètre d’application, sélectionnez Ajouter un paramètre.
Pour copier une valeur de paramètre du champ Local vers le champ Distant , sélectionnez Insérer une valeur dans Local.

Les modifications en attente sont écrites dans le fichier de paramètres local et l’application de fonction lorsque vous sélectionnez OK.

Remarque

Par défaut, le fichier local.settings.json n’est pas enregistré dans la gestion de code source. Par conséquent, si vous clonez un projet Functions local à partir du contrôle de code source, le projet n’a pas de fichier local.settings.json . Vous devez créer manuellement le fichier local.settings.json à la racine du projet afin que la boîte de dialogue Paramètres de l’application fonctionne comme prévu.

Vous pouvez également gérer les paramètres d’application d’une des manières suivantes :

Utilisez le portail Azure.
Utilisez l’option--publish-local-settings de publication dans Azure Functions Core Tools.
Utilisez Azure CLI.

Débogage à distance

Pour déboguer votre application de fonction à distance, vous devez publier une configuration de débogage de votre projet. Vous devez également activer le débogage à distance dans votre application de fonction dans Azure.

Cette section suppose qu’une configuration de débogage de votre application de fonctions est publiée.

Considérations relatives au débogage à distance

Le débogage à distance n’est pas recommandé sur un service de production.
Pour utiliser le débogage à distance, vous devez héberger votre application de fonction dans un plan Premium ou App Service.
Le débogage à distance n’est actuellement pris en charge que lors de l’exécution de votre application C# sur Windows.
Si la fonctionnalité Just My Code est activée dans Visual Studio, désactivez-la. Pour obtenir des instructions, consultez Activer ou désactiver uniquement mon code.
Évitez les longues pauses aux points d’arrêt lorsque vous utilisez le débogage distant. Lorsqu’un processus est arrêté pendant plus de quelques minutes, Azure le traite comme un processus non répond et l’arrête.
Pendant le débogage, le serveur envoie des données à Visual Studio, ce qui peut affecter les frais de bande passante. Pour plus d’informations sur les taux de bande passante, consultez la calculatrice de prix.
Le débogage à distance est automatiquement désactivé dans votre application de fonction après 48 heures. Après ce point, vous devez réactiver le débogage à distance.

Attachez le débogueur

Lorsque vous déboguez une application de processus worker isolée, vous devez actuellement attacher le débogueur distant à un processus .NET distinct. Plusieurs autres étapes de configuration sont également requises.

Pour attacher un débogueur distant à une application de fonction s’exécutant dans un processus distinct de l’hôte Functions, procédez comme suit :

Dans la page de profil de publication, accédez à la section Hébergement . Sélectionnez l'ellipse (...), puis sélectionnez Attachez le débogueur.

Visual Studio se connecte à votre application de fonction et active le débogage à distance s’il n’est pas déjà activé.

Remarque

Étant donné que le débogueur distant ne peut pas se connecter au processus hôte, un message d’erreur peut apparaître. Dans tous les cas, le débogueur local ne peut pas accéder à vos points d’arrêt ni vous permettre d’inspecter des variables ou d’effectuer un pas à pas dans le code.
Dans le menu Débogage de Visual Studio, sélectionnez Attacher au processus.
Dans la boîte de dialogue Attacher au processus , procédez comme suit :
1. En regard du type de connexion, sélectionnez Microsoft Azure App Services.
2. En regard de la cible de connexion, sélectionnez Rechercher.
Dans la boîte de dialogue Azure Attach to Process , recherchez et sélectionnez votre application de fonction, puis sélectionnez OK.
Si vous y êtes invité, autorisez l’accès à Visual Studio par le biais de votre pare-feu local.
Dans la boîte de dialogue Attacher au processus , sélectionnez Afficher les processus pour tous les utilisateurs. Sélectionnez dotnet.exe, puis sélectionnez Attacher.

Une fois l’opération terminée, vous êtes attaché à votre code de bibliothèque de classes C# s’exécutant dans un processus de travail isolé. À ce stade, vous pouvez déboguer votre application de fonction comme en temps normal.

Pour attacher un débogueur distant à une application de fonction en cours d’exécution avec l’hôte Functions, procédez comme suit.

Dans la page de profil de publication, accédez à la section Hébergement . Sélectionnez l'ellipse (...), puis sélectionnez Attachez le débogueur.

Visual Studio se connecte à votre application de fonction et active le débogage à distance s’il n’est pas déjà activé. Il localise et attache également le débogueur au processus hôte de l’application. À ce stade, vous pouvez déboguer votre application de fonction comme en temps normal.

Une fois le débogage terminé, vous devez désactiver le débogage à distance.

Désactiver le débogage à distance

Une fois que vous avez terminé le débogage à distance de votre code, vous devez désactiver le débogage à distance dans le portail Azure. Le débogage à distance est automatiquement désactivé après 48 heures, au cas où vous oubliez.

Dans la page de profil de publication, accédez à la section Hébergement . Sélectionnez les points de suspension (...), puis sélectionnez Ouvrir dans le portail Azure. Le portail Azure s’ouvre sur l’application de fonction sur où votre projet est déployé.
Dans l’application de fonction, sélectionnez Configuration des paramètres>, puis accédez à l’onglet Paramètres généraux. En regard du débogage à distance, sélectionnez Désactivé. Sélectionnez Enregistrer, puis continuez.

Une fois l’application de fonction redémarrée, vous ne pouvez plus vous connecter à distance à vos processus distants. Vous pouvez utiliser ce même onglet dans le portail Azure pour activer le débogage à distance en dehors de Visual Studio.

Surveiller des fonctions

La méthode recommandée pour surveiller vos fonctions consiste à intégrer votre application de fonction à Application Insights. Vous devez activer cette intégration lorsque vous créez votre application de fonction pendant la publication de Visual Studio.

Si l’intégration n’est pas configurée pendant la publication pour une raison quelconque, vous devez toujours activer l’intégration d’Application Insights pour votre application de fonction dans Azure.

Pour plus d’informations sur l’utilisation d’Application Insights pour la surveillance, consultez Surveiller les exécutions dans Azure Functions.

Fonctions de test

Cette section explique comment créer un projet de modèle in-process C# que vous pouvez tester à l’aide de xUnit, un outil de test unitaire open source pour .NET.

Étape 1 : Configuration

Procédez comme suit pour configurer l’environnement, y compris le projet et les fonctions d’application, nécessaires pour prendre en charge vos tests :

Dans Visual Studio, créez un projet Azure Functions nommé Functions.
Créez une fonction HTTP à partir du modèle :
1. Dans l’Explorateur de solutions, cliquez avec le bouton droit sur le projet Functions , puis sélectionnez Ajouter>une nouvelle fonction Azure.
2. Dans la boîte de dialogue Ajouter un nouvel élément , sélectionnez Fonction Azure, puis Sélectionnez Ajouter.
3. Sélectionnez Déclencheur Http, puis sélectionnez Ajouter.
4. Renommez la nouvelle classe MyHttpTrigger.
Créez une fonction de minuteur à partir du modèle :
1. Dans l’Explorateur de solutions, cliquez avec le bouton droit sur le projet Functions , puis sélectionnez Ajouter>une nouvelle fonction Azure.
2. Dans la boîte de dialogue Ajouter un nouvel élément , sélectionnez Fonction Azure, puis Sélectionnez Ajouter.
3. Sélectionnez Déclencheur du minuteur, puis sélectionnez Ajouter.
4. Renommez la nouvelle classe MyTimerTrigger.
Créez une application xUnit Test dans la solution :
1. Dans l’Explorateur de solutions, cliquez avec le bouton droit sur la solution qui contient votre projet Functions , puis sélectionnez Ajouter>un nouveau projet.
2. Sélectionnez le modèle de projet de test xUnit , puis sélectionnez Suivant.
3. Nommez le projet Functions.Tests.
Supprimez les fichiers de test par défaut du projet Functions.Tests .
Utilisez NuGet pour ajouter une référence de l’application de test à Microsoft.AspNetCore.Mvc. Vous pouvez utiliser la console du Gestionnaire de package ou effectuer les étapes suivantes :
1. Dans l’Explorateur de solutions, cliquez avec le bouton droit sur le projet Functions.Tests , puis sélectionnez Gérer les packages NuGet.
2. Recherchez et installez Microsoft.AspNetCore.Mvc.
Dans l’application Functions.Tests , ajoutez une référence à l’application Functions :
1. Dans l’Explorateur de solutions, cliquez avec le bouton droit sur le projet Functions.Tests , puis sélectionnez Ajouter une>référence de projet.
2. Sélectionnez le projet Functions , puis sélectionnez OK.

Étape 2 : Créer des classes de test

Dans cette section, vous allez créer les classes que vous utilisez pour exécuter les tests automatisés.

Chaque fonction prend une implémentation de ILogger pour gérer la journalisation des messages. Dans certains tests, aucun message n’est journalisé, ou peu importe la façon dont la journalisation est implémentée. D’autres tests doivent évaluer les messages consignés pour déterminer si un test doit réussir.

Créez une classe dans votre projet Functions.Tests nommé NullScope et ajoutez le code suivant. Cette classe fournit une étendue fictive. Dans une étape ultérieure, vous créez une implémentation de cette étendue par ILogger.

using System;

namespace Functions.Tests
{
    public class NullScope : IDisposable
    {
        public static NullScope Instance { get; } = new NullScope();

        private NullScope() { }

        public void Dispose() { }
    }
}

Créez une classe dans votre projet Functions.Tests nommé ListLogger et ajoutez le code suivant. Cette classe gère une liste interne de messages à évaluer pendant le test. Pour implémenter l’interface requise ILogger, la classe utilise l’étendue fictive de la classe NullScope. Les cas de test passent l’étendue fictive à la classe ListLogger.
```
using Microsoft.Extensions.Logging;
using System;
using System.Collections.Generic;
using System.Text;

namespace Functions.Tests
{
    public class ListLogger : ILogger
    {
        public IList<string> Logs;

        public IDisposable BeginScope<TState>(TState state) => NullScope.Instance;

        public bool IsEnabled(LogLevel logLevel) => false;

        public ListLogger()
        {
            this.Logs = new List<string>();
        }

        public void Log<TState>(LogLevel logLevel,
                                EventId eventId,
                                TState state,
                                Exception exception,
                                Func<TState, Exception, string> formatter)
        {
            string message = formatter(state, exception);
            this.Logs.Add(message);
        }
    }
}
```
La ListLogger classe implémente les membres suivants, comme requis par l’interface ILogger :
- BeginScope : Les étendues ajoutent du contexte à votre journalisation. Dans ce cas, le test pointe vers l’instance statique de la NullScope classe pour permettre au test de fonctionner.
- IsEnabled: une valeur par défaut de false est fournie.
- Log: cette méthode utilise la fonction fournie formatter pour mettre en forme le message. La méthode ajoute ensuite le texte résultant à la Logs collection.
La collection Logs est une instance List<string> initialisée dans le constructeur.
Créez un fichier de code dans le projet Functions.Tests nommé LoggerTypes.cs et ajoutez le code suivant :
```
namespace Functions.Tests
{
    public enum LoggerTypes
    {
        Null,
        List
    }
}
```
Cette énumération spécifie le type d’enregistreur d’événements que les tests utilisent.

Créez une classe dans le projet Functions.Tests nommé TestFactory et ajoutez le code suivant :

using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Http.Internal;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Logging.Abstractions;
using Microsoft.Extensions.Primitives;
using System.Collections.Generic;

namespace Functions.Tests
{
    public class TestFactory
    {
        public static IEnumerable<object[]> Data()
        {
            return new List<object[]>
            {
                new object[] { "name", "Bernardo" },
                new object[] { "name", "Ananya" },
                new object[] { "name", "Vlad" }

            };
        }

        private static Dictionary<string, StringValues> CreateDictionary(string key, string value)
        {
            var qs = new Dictionary<string, StringValues>
            {
                { key, value }
            };
            return qs;
        }

        public static HttpRequest CreateHttpRequest(string queryStringKey, string queryStringValue)
        {
            var context = new DefaultHttpContext();
            var request = context.Request;
            request.Query = new QueryCollection(CreateDictionary(queryStringKey, queryStringValue));
            return request;
        }

        public static ILogger CreateLogger(LoggerTypes type = LoggerTypes.Null)
        {
            ILogger logger;

            if (type == LoggerTypes.List)
            {
                logger = new ListLogger();
            }
            else
            {
                logger = NullLoggerFactory.Instance.CreateLogger("Null Logger");
            }

            return logger;
        }
    }
}

La classe TestFactory implémente les membres suivants :

Data: cette propriété retourne une collection IEnumerable d’exemples de données. Les paires clé-valeur représentent des valeurs passées dans une chaîne de requête.
CreateDictionary: cette méthode accepte une paire clé-valeur comme argument. Elle retourne une nouvelle instance de Dictionary utilisée pour créer une instance de QueryCollection pour représenter les valeurs de chaîne de requête.
CreateHttpRequest: cette méthode crée une requête HTTP initialisée avec les paramètres de chaîne de requête donnés.
CreateLogger: Cette méthode retourne une implémentation de ILogger qui est utilisée pour les tests. L’implémentation ILogger dépend du type d’enregistreur d’événements spécifié. Si un type de liste est spécifié, l’instance ListLogger effectue le suivi des messages journalisés disponibles pour l’évaluation dans les tests.

Créez une classe dans le projet Functions.Tests nommé FunctionsTests et ajoutez le code suivant :

using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using Xunit;

namespace Functions.Tests
{
    public class FunctionsTests
    {
        private readonly ILogger logger = TestFactory.CreateLogger();

        [Fact]
        public async void Http_trigger_should_return_known_string()
        {
            var request = TestFactory.CreateHttpRequest("name", "Bernardo");
            var response = (OkObjectResult)await MyHttpTrigger.Run(request, logger);
            Assert.Equal("Hello, Bernardo. This HTTP triggered function executed successfully.", response.Value);
        }

        [Theory]
        [MemberData(nameof(TestFactory.Data), MemberType = typeof(TestFactory))]
        public async void Http_trigger_should_return_known_string_from_member_data(string queryStringKey, string queryStringValue)
        {
            var request = TestFactory.CreateHttpRequest(queryStringKey, queryStringValue);
            var response = (OkObjectResult)await MyHttpTrigger.Run(request, logger);
            Assert.Equal($"Hello, {queryStringValue}. This HTTP triggered function executed successfully.", response.Value);
        }

        [Fact]
        public void Timer_should_log_message()
        {
            var logger = (ListLogger)TestFactory.CreateLogger(LoggerTypes.List);
            new MyTimerTrigger().Run(null, logger);
            var msg = logger.Logs[0];
            Assert.Contains("C# Timer trigger function executed at", msg);
        }
    }
}

Cette classe implémente les membres suivants :

Http_trigger_should_return_known_string: ce test utilise la valeur name=Bernardo de chaîne de requête pour créer une requête à une fonction HTTP. Ce test vérifie que la réponse attendue est retournée.
Http_trigger_should_return_string_from_member_data: ce test utilise des attributs xUnit pour fournir des exemples de données à la fonction HTTP.
Timer_should_log_message: ce test crée une instance de ListLogger et la transmet à une fonction de minuteur. Une fois la fonction exécutée, le journal est vérifié pour vérifier que le message attendu est présent.

Pour accéder aux paramètres d’application dans vos tests, vous pouvez injecter une IConfiguration implémentation avec des valeurs de variables d’environnement fictifs dans votre fonction.

Étape 3 : Exécuter des tests

Pour exécuter les tests dans Visual Studio, sélectionnez Afficher>l’Explorateur de tests. Dans l’Explorateur de tests, sélectionnez Exécuter>Exécuter tous les tests visibles.

Capture d’écran de Visual Studio. L’Explorateur de tests indique que cinq tests ont réussi. Dans l’Explorateur de solutions, les projets Functions et Functions.Test sont visibles.

Étape 4 : Déboguer des tests

Pour déboguer les tests, définissez un point d’arrêt sur un test. Dans l’Explorateur de tests, sélectionnez Exécuter>Déboguer la dernière exécution.

Développer Azure Functions localement à l’aide de Core Tools

Guide du modèle In-process C#

Guide du modèle Worker isolé C#

Commentaires

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

Last updated on 2025-09-23