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

Article
03/05/2024

Visual Studio vous permet de développer, de tester et de déployer des fonctions de bibliothèque de classes C# dans Azure. S’il s’agit de votre première expérience avec Azure Functions, consultez Présentation 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 sur l'utilisation de Visual Studio pour développer des fonctions de bibliothèque de classe C# et les publier dans Azure. Il existe deux modèles de développement de fonctions de bibliothèque de classes C# : le modèle Worker isolé et le modèle In-process.

La version de l’article que vous lisez porte sur le modèle Worker isolé. Vous pouvez choisir 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 choisir votre modèle préféré en haut de l’article.

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 n’avez pas d’abonnement Azure, créez un compte gratuit Azure 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 Créer un projet, entrez functions dans la zone de recherche, choisissez le modèle Azure Functions, puis sélectionnez Suivant.
Dans Configurer votre nouveau projet, entrez un Nom de projet, puis sélectionnez Créer. 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.

Pour les paramètres Créer une application Azure Functions, utilisez les valeurs du tableau suivant :

Paramètre	valeur	Description
Version de .NET	.NET 6 (isolé)	Cette valeur crée un projet de fonction qui s’exécute dans un processus Worker isolé. Le processus Worker isolé prend en charge d’autres versions non LTS de .NET, mais également .NET Framework. Pour plus d’informations, consultez Vue d’ensemble des versions du runtime Azure Functions.
Modèle de fonction	Déclencheur HTTP	Cette valeur crée une fonction déclenchée par une requête HTTP.
Compte de stockage (AzureWebJobsStorage)	Émulateur de stockage	Étant donné qu’une application de fonction dans Azure nécessite un compte de stockage, celui-ci est attribué ou créé quand vous publiez votre projet sur Azure. Un déclencheur HTTP n’utilise pas de chaîne de connexion de compte Stockage Azure ; tous les autres types de déclencheurs nécessitent une chaîne de connexion de compte Stockage Azure valide.
Niveau d’autorisation	Anonyme	La fonction créée peut être déclenchée par n’importe quel client sans fournir une clé. Ce paramètre d’autorisation facilite le test de votre nouvelle fonction. Pour plus d’informations, consultez Niveau d’autorisation.

Capture d’écran des paramètres de projet Azure Functions

Paramètre	valeur	Description
Version de .NET	.NET 6	Cette valeur crée un projet de fonction qui s’exécute dans un processus interne avec la version 4.x du runtime d’Azure Functions. Pour plus d’informations, consultez Vue d’ensemble des versions du runtime Azure Functions.
Modèle de fonction	Déclencheur HTTP	Cette valeur crée une fonction déclenchée par une requête HTTP.
Compte de stockage (AzureWebJobsStorage)	Émulateur de stockage	Étant donné qu’une application de fonction dans Azure nécessite un compte de stockage, celui-ci est attribué ou créé quand vous publiez votre projet sur Azure. Un déclencheur HTTP n’utilise pas de chaîne de connexion de compte Stockage Azure ; tous les autres types de déclencheurs nécessitent une chaîne de connexion de compte Stockage Azure valide.
Niveau d’autorisation	Anonyme	La fonction créée peut être déclenchée par n’importe quel client sans fournir une clé. Ce paramètre d’autorisation facilite le test de votre nouvelle fonction. Pour plus d’informations, consultez Niveau d’autorisation.

Capture d’écran des paramètres de projet Azure Functions

Veillez à définir le Niveau d’autorisation sur Anonyme. Si vous choisissez le niveau par défaut Fonction, vous êtes invité à présenter la clé de fonction dans les requêtes 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.

Une fois que vous avez créé un projet Azure Functions, le modèle de projet crée un projet C#, installe les packages NuGet Microsoft.Azure.Functions.Worker et Microsoft.Azure.Functions.Worker.Sdk, puis définit la version cible de .NET Framework.

Une fois que vous avez créé un projet Azure Functions, le modèle de projet crée un projet C#, installe le package NuGet Microsoft.NET.Sdk.Functions et définit la version cible de .NET Framework.

Le nouveau projet comporte les fichiers suivants :

host.json : 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.
local.settings.json : tient à jour les paramètres utilisés lors de l’exécution locale des fonctions. Ces paramètres ne sont pas utilisés lors de l’exécution dans Azure. Pour en savoir plus, voir Fichier de paramètres locaux.

Important

Étant donné que le fichier local.settings.json peut contenir des secrets, vous devez l’exclure du contrôle de code source du projet. Veillez à ce que le paramètre Copier dans le répertoire de sortie de ce fichier soit défini sur Copier si plus récent.

Pour plus d’informations, consultez Structure de projet dans le guide du processus Worker isolé.

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

Utiliser les paramètres d’application localement

Lors de l’exécution dans une application de fonction dans Azure, les paramètres requis par vos fonctions sont stockés de manière sécurisée dans les paramètres de l’application. Lors du développement local, ces paramètres sont, à la place, ajoutés à la collection Values 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 Values dans le fichier local.settings.json de votre projet sont destinés à refléter des éléments des paramètres d’application de votre application de fonction dans Azure.

Visual Studio ne charge pas automatiquement les paramètres dans le fichier 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 collection ConnectionStrings ne sont jamais 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 de Functions utilise un compte de stockage Azure en interne. Pour tous les types de déclencheurs autres que HTTP et Webhooks, définissez la clé Values.AzureWebJobsStorage sur une chaîne de connexion de compte de stockage Azure valide. Votre application de fonction peut également utiliser l’émulateur Azurite pour le paramètre de connexion AzureWebJobsStorage nécessaire au projet. Pour utiliser l’émulateur, définissez la valeur de AzureWebJobsStorage sur UseDevelopmentStorage=true. Modifiez ce paramètre afin de lui associer une chaîne de connexion au compte de stockage réel avant le déploiement. Pour plus d’informations, consultez Émulateur de stockage local.

Pour définir la chaîne de connexion de compte de stockage :

Dans le portail Azure, accédez à votre compte de stockage.
Sous l’onglet Clés d’accès, sous Sécurité + mise en réseau, copiez la Chaîne de connexion de key1.
Dans votre projet, ouvrez le fichier local.settings.json et définissez la valeur de la clé AzureWebJobsStorage 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 la fonction 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 le champ Nom, nommez la classe, puis sélectionnez Ajouter.
Choisissez votre déclencheur, définissez les propriétés de liaison nécessaires, puis sélectionnez Ajouter. L’exemple suivant montre les paramètres pour la création d’une fonction de déclencheur Stockage File d’attente.

Pour un déclencheur du service Stockage Azure, cochez la case Configurer la connexion. Vous êtes alors invité à choisir entre utiliser un émulateur de stockage Azurite ou référencer un compte de stockage Azure approvisionné. Sélectionnez Suivant. Si vous avez choisi un compte de stockage, Visual Studio tente de se connecter à votre compte Azure et d’obtenir la chaîne de connexion. Choisissez Save connection string value in Local user secrets file (Enregistrer la valeur de chaîne de connexion dans le fichier de secrets de l’utilisateur local), puis sélectionnez Terminer pour créer 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 fichier local.settings.json, fait référence à l’émulateur Azure ou à un compte de stockage Azure.

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

Vous voyez une méthode Run() statique 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: {message.MessageText}");
        }
    }
}

Vous voyez une méthode Run() statique 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 l’exemple précédent, un attribut QueueTrigger est appliqué au premier paramètre, indiquant une fonction de déclencheur Stockage File d’attente. 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. Pour plus d’informations, consultez Liaisons de stockage File d’attente Azure pour Azure Functions.

Utilisez la procédure ci-dessus pour ajouter des 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 Concepts des 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. Ajoutez des liaisons à une fonction comme suit :

Veillez à configurer le projet pour un développement local.
Ajoutez le package d’extension NuGet approprié pour la liaison spécifique en recherchant les exigences de package NuGet spécifiques à la liaison dans l’article de référence de la liaison. Par exemple, recherchez les exigences de package pour le déclencheur Event Hubs dans l’article de référence de la liaison Event Hubs.
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 cet exemple, remplacez <BINDING_TYPE> par le nom spécifique à l’extension de liaison et <TARGET_VERSION> par une version spécifique du package, par exemple 4.0.0. 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 l’exemple suivant, un message de file d’attente déclenche la fonction, et la liaison de sortie crée un nouveau message de file d’attente avec le même texte 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 placeriez plutôt cet attribut dans 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 de file d’attente 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.

Exécuter des fonctions localement

Azure Functions Core Tools vous permet d’exécuter un projet Azure Functions sur votre ordinateur de développement local. Quand vous appuyez sur F5 pour déboguer un projet de fonctions, l’hôte des fonctions 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 Utiliser Azure Functions 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 des outils principaux, les projets de modèles in-process doivent faire référence à la version 4.5.0 ou à une version ultérieure de Microsoft.NET.Sdk.Functions. Si une version antérieure est utilisée, la commande func start génère une erreur.

Pour démarrer votre fonction dans Visual Studio en mode débogage :

Appuyez sur F5. Si vous y êtes invité, acceptez la requête dans Visual Studio pour télécharger et installer Azure Functions Core (CLI) Tools. Vous devrez peut-être aussi activer une exception de pare-feu afin de permettre aux outils de prendre en charge les requêtes HTTP.
Avec le projet en cours d’exécution, testez votre code comme vous testeriez 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é avec Visual Studio, consultez Tests des fonctions.

Publication dans Azure

Lorsque vous publiez votre projet de fonctions sur Azure, Visual Studio utilise le déploiement zip pour déployer les fichiers projet. Dans la mesure du possible, sélectionnez également Exécuter à partir d’un package pour 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.

N’effectuez pas le déploiement sur Azure Functions à l’aide de Web Deploy (msdeploy).

La procédure suivante vous permet de publier votre projet dans une Function App sur Azure.

Dans l’Explorateur de solutions, cliquez avec le bouton droit sur le projet, puis sélectionnez Publier. Dans Cible, sélectionnez Azure, puis Suivant.
Dans Cible spécifique, sélectionnez Application de fonction Azure (Windows). Une application de fonction qui s’exécute sur Windows est créée. Cliquez sur Suivant.
Dans la page Instance de Functions, sélectionnez Créer une fonction Azure.

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

Paramètre	valeur	Description
Nom	Nom globalement unique	Nom qui identifie uniquement votre nouvelle application de fonction. Acceptez ce nom ou entrez un nouveau nom. Les caractères valides sont `a-z`, `0-9` et `-`.
Abonnement	Votre abonnement	Sélectionnez l’abonnement Azure à utiliser. Acceptez cet abonnement ou sélectionnez-en un nouveau dans la liste déroulante.
Groupe de ressources	Nom de votre groupe de ressources	Groupe de ressources dans lequel vous souhaitez créer votre application de fonction. Sélectionnez Nouveau pour créer un groupe de ressources. Vous pouvez également choisir d’utiliser un groupe de ressources existant dans la liste déroulante.
Type de plan	Consommation	Quand vous publiez votre projet dans une application de fonction qui s’exécute dans un Plan Consommation, vous payez uniquement pour les exécutions de votre application de fonction. D’autres plans d’hébergement occasionnent des coûts plus élevés.
Lieu	Emplacement du service d’application	Sélectionnez un Emplacement dans une région Azure proche de vous ou d’autres services auxquels vos fonctions accèdent.
Stockage Azure	Compte de stockage à usage général	Un compte de stockage Azure est obligatoire par le runtime Functions. Sélectionnez Nouveau pour configurer un compte de stockage universel. Vous pouvez également choisir d’utiliser un compte existant qui répond aux exigences relatives aux comptes de stockage.
Application Insights	Instance Application Insights	Vous devez activer l’intégration d’Azure 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 choisir d’utiliser une instance existante.

Capture d’écran de la boîte de dialogue Créer App Service.

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.
Dans Instance de Functions, vérifiez que la case Exécuter à partir du fichier de package est cochée. Votre application de fonction est déployée en utilisant Zip Deploy avec le mode Exécuter à partir du fichier de package activé. Zip Deploy est la méthode de déploiement recommandée pour votre projet Functions, car elle offre de meilleures performances.
Sélectionnez Terminer puis, dans le volet Publier, sélectionnez Publier pour déployer le package contenant vos fichiers projet sur votre nouvelle application de fonction dans Azure.

Une fois le déploiement terminé, l’URL racine de l’application de fonction dans Azure est affichée sous l’onglet Publier.
Sous l’onglet Publier, dans la section Hébergement, 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 ses paramètres automatiquement quand vous publiez le projet. Les paramètres que vous ajoutez au fichier local.settings.json doivent être également ajoutés à l’application de fonction dans Azure.

Le moyen le plus simple de charger les paramètres requis sur votre application de fonction dans Azure consiste à développer les points de suspension en regard de la section Hébergement, et à sélectionner le lien Gérer les paramètres d’Azure App Service qui s’affiche une fois votre projet correctement publié.

Paramètres dans la fenêtre Publier

La sélection de ce lien affiche la boîte de dialogue Paramètres de l’application de l’application de fonction, dans laquelle vous pouvez ajouter des paramètres ou modifier des paramètres existants.

Paramètres de l’application

Local affiche une valeur de paramètre dans le fichier local.settings.json, et Distant affiche une valeur de paramètre active dans l’application de fonction dans Azure. Sélectionnez Ajouter le paramètre pour créer un nouveau paramètre d’application. Utilisez le lien Insérer une valeur locale pour copier une valeur de paramètre dans le champ Distant. Les modifications en attente sont écrites dans le fichier de paramètres local et l’application de fonction lorsque vous sélectionnez OK.

Notes

Par défaut, le fichier local.settings.json n’est pas archivé dans le contrôle de code source. Cela signifie que, si vous clonez un projet Functions local à partir du contrôle de code source, le projet n’a pas de fichier local.settings.json. Dans ce cas, vous devez créer manuellement ce fichier à la racine du projet pour que la boîte de dialogue Paramètres d’application fonctionne comme prévu.

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

Remote Debugging

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 part du principe que vous avez déjà publié dans votre application de fonction à l’aide d’une configuration de mise en production.

Considérations relatives au débogage à distance

Le débogage à distance n’est pas recommandé sur un service de production.
Si vous avez activé le débogage pour Uniquement mon code, désactivez-le.
Évitez les arrêts longs aux points d'arrêt avec le débogage à distance. Azure considère qu'un processus arrêté pendant plus de quelques minutes ne répond pas, et l'arrête définitivement.
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 tarifs de bande passante, consultez les tarifs Azure.
Le débogage à distance est automatiquement désactivé dans votre application de fonction après 48 heures. Après 48 heures, vous devez réactiver le débogage à distance.

Attacher le débogueur

La façon dont vous attachez le débogueur dépend de votre mode d’exécution. Lors du débogage d’une application de processus worker isolée, vous devez actuellement attacher le débogueur distant à un processus .NET distinct, et plusieurs autres étapes de configuration sont requises.

Lorsque vous avez terminé, vous devez désactiver le débogage à distance.

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

Dans l’onglet Publier, sélectionnez les points de suspension (...) dans la section Hébergement, puis choisissez Télécharger le profil de publication. Cette action télécharge une copie du profil de publication et ouvre l’emplacement de téléchargement. Vous avez besoin de ce fichier, qui contient les informations d’identification utilisées pour s’attacher à votre processus worker isolé s’exécutant dans Azure.

Attention

Le fichier publishsettings contient vos informations d’identification (non codées) utilisées pour gérer votre application de fonction. Pour des raisons de sécurité, il est recommandé de stocker ce fichier temporairement en dehors de vos répertoires sources (par exemple, dans le dossier Bibliothèques\Documents), puis de le supprimer une fois qu’ils ne sont plus nécessaires. Si un utilisateur malveillant accède au fichier .publishsettings, il peut modifier, créer et supprimer votre application de fonction.
À nouveau, sous l’onglet Publier, sélectionnez les points de suspension (...) dans la section Hébergement, puis choisissez Attacher le débogueur.

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

Remarque

Étant donné que le débogueur distant n’est pas en mesure de se connecter au processus hôte, vous pouvez voir une erreur. Dans tous les cas, le débogage par défaut ne s’infiltrera pas dans votre code.
Dans Visual Studio, copiez l’URL du Site sous Hébergement dans la page Publier.
Dans le menu Débogage, sélectionnez Attacher au processus, puis, dans la fenêtre Attacher au processus, collez l’URL dans la Cible de connexion, supprimez https:// et ajoutez le port :4024.

Vérifiez que votre cible ressemble à <FUNCTION_APP>.azurewebsites.net:4024 et appuyez sur Entrée.
Si vous y êtes invité, autorisez l’accès à Visual Studio par le biais de votre pare-feu local.
Lorsque vous êtes invité à entrer des informations d’identification, au lieu des informations d’identification de l’utilisateur local, choisissez un autre compte (Plus de choix sur Windows). Fournissez les valeurs userName et userPWD à partir du profil publié pour Adresse e-mail et Mot de passe dans la boîte de dialogue d’authentification sur Windows. Une fois qu’une connexion sécurisée est établie avec le serveur de déploiement, les processus disponibles sont affichés.
Cochez la case Afficher le processus de tous les utilisateurs, puis choisissez dotnet.exe, et sélectionnez Attacher. Une fois l’opération terminée, vous êtes attaché au code de votre bibliothèque de classes C# s’exécutant dans un processus worker 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 :

Sous l’onglet Publier, sélectionnez les points de suspension (...) dans la section Hébergement, puis choisissez Attacher le débogueur.

Visual Studio se connecte à votre application de fonction et active le débogage à distance, s’il ne l’est pas déjà. 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.

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 oublieriez de le faire.

Dans l’onglet Publier dans votre projet, sélectionnez les points de suspension (...) dans la section Hébergement, puis choisissez Ouvrir dans le portail Azure. Cette action ouvre l’application de fonction dans le portail Azure sur lequel votre projet est déployé.
Dans l’application de fonction, sélectionnez Configuration sous Paramètres, choisissez Paramètres généraux, définissez Débogage à distance sur Désactivé, puis sélectionnez Enregistrer et Continuer.

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.

Surveillance des fonctions

Il est recommandé de superviser l’exécution de vos fonctions en intégrant votre application de fonction à Azure Application Insights. Vous devez activer cette intégration au moment de créer votre application de fonction, pendant la publication Visual Studio.

Si, pour une raison quelconque, l’intégration n’a pas été faite pendant la publication, vous devez quand même activer l’intégration d’Application Insights pour votre application de fonction dans Azure.

Pour en savoir plus sur la surveillance à l’aide d’Application Insights, consultez Surveiller l’exécution des fonctions Azure.

Tester les fonctions

Cette section vous explique comment créer un projet de modèle In-process C# que vous pouvez tester avec xUnit.

Tester Azure Functions avec C# dans Visual Studio

1. Configurer

Suivez ces étapes pour configurer l’environnement, y compris le projet d’application et les fonctions, ce qui est nécessaire pour effectuer les tests :

Créez une nouvelle application Functions et nommez-la Functions.
Créez une fonction HTTP à partir du modèle et nommez-la MyHttpTrigger.
Créez une fonction de minuteur à partir du modèle et nommez-la MyTimerTrigger.
Créez une application de test xUnit dans la solution et nommez-la Functions.Tests. Supprimez les fichiers de test par défaut.
Utilisez NuGet pour ajouter des références à partir de l’application de test à Microsoft.AspNetCore.Mvc
Faites référence à l’application Functions à partir de l’application Functions.Tests.

Une fois les projets créés, vous pouvez créer les classes servant à exécuter les tests automatisés.

2. Créer des classes de test

Chaque fonction utilise une instance de ILogger pour gérer la journalisation des messages. Certains tests ne consignent pas les messages ou ne se soucient pas de la manière dont la journalisation est implémentée. D'autres tests doivent évaluer les messages consignés afin de déterminer si un test a abouti.

Créez une classe sous le nom ListLogger, qui contient une liste interne de messages à évaluer pendant les tests. Pour implémenter l’interface ILogger requise, la classe a besoin d’une portée. La classe suivante imite une portée pour les cas de test à passer à la classe ListLogger.

Créez une classe dans votre projet Functions.Tests sous le nom NullScope.cs et ajoutez ce code :

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 sous le nom ListLogger.cs et ajoutez ce code :

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 classe ListLogger implémente les membres suivants comme contractés par l'interface ILogger :

BeginScope : Les étendues ajoutent du contexte à votre journalisation. Dans ce cas, le test pointe vers l’instance statique de la classe NullScope pour permettre le bon fonctionnement du test.
IsEnabled : La valeur par défaut false est indiquée.
Log : Cette méthode utilise la fonction formatter fournie pour mettre en forme le message, puis ajoute le texte qui en résulte à la collection Logs.

La collection Logs est une instance List<string> initialisée dans le constructeur.

Créez un fichier de code dans le projet Functions.Tests sous le nom LoggerTypes.cs et ajoutez ce code :
```
namespace Functions.Tests
{
    public enum LoggerTypes
    {
        Null,
        List
    }
}
```
Cette énumération spécifie le type d'enregistreur d'événements utilisé par les tests.

Créez une classe dans le projet Functions.Tests sous le nom TestFactory.cs et ajoutez ce code :

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", "Bill" },
                new object[] { "name", "Paul" },
                new object[] { "name", "Steve" }

            };
        }

        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 :

Données : Cette propriété renvoie une collection IEnumerable d’exemples de données. Les paires clé/valeur représentent les valeurs transmises dans une chaîne de requête.
CreateDictionary : Cette méthode accepte une paire clé/valeur en tant qu’arguments et renvoie une nouvelle Dictionary utilisée pour créer QueryCollection afin de 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 d'une chaîne de requête donnée.
CreateLogger : En fonction du type d'enregistreur d’événements, cette méthode renvoie une classe d’enregistreur d’événements utilisée à des fins de test. Le ListLogger effectue le suivi des messages consignés disponibles à des fins d'évaluation lors des tests.

Créez une classe dans le projet Functions.Tests sous le nom FunctionsTests.cs et ajoutez ce code :

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", "Bill");
            var response = (OkObjectResult)await MyHttpTrigger.Run(request, logger);
            Assert.Equal("Hello, Bill. 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);
        }
    }
}

Les membres implémentés dans cette classe sont :

Http_trigger_should_return_known_string : Ce test crée une requête avec les valeurs de chaîne de requête de name=Bill vers une fonction HTTP et vérifie que la réponse attendue est renvoyée.
Http_trigger_should_return_string_from_member_data : Ce test utilise les 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 s’assurer que le message attendu est présent.

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

3. Exécuter les tests

Pour exécuter les tests, accédez à l’Explorateur de tests, puis sélectionnez Exécuter tous les tests dans l’affichage.