Tutoriel : Bien démarrer avec Azure FunctionsTutorial: Getting started with Azure Functions

Dans cet atelier, vous allez apprendre à créer des fonctions Azure à l’aide de Visual Studio pour Mac.In this lab, you'll learn how to get started building Azure Functions using Visual Studio for Mac. Vous verrez également comment les intégrer à des tables de stockage Azure, qui figurent parmi les nombreux types de liaisons et de déclencheurs à la disposition des développeurs Azure Functions.You'll also integrate with Azure storage tables, which represent one of the many kinds of bindings and triggers available to Azure Functions developers.

ObjectifsObjectives

  • Créer et déboguer des fonctions Azure localesCreate and debug local Azure Functions
  • Intégrer des fonctions à des ressources de stockage web et AzureIntegrate with web and Azure storage resources
  • Orchestrer un flux de travail impliquant plusieurs fonctions AzureOrchestrate a workflow involving multiple Azure Functions

Configuration requiseRequirements

Exercice 1 : Création d’un projet Azure FunctionsExercise 1: Creating an Azure Functions project

  1. Lancez Visual Studio pour Mac.Launch Visual Studio for Mac.

  2. Sélectionnez Fichier > Nouvelle solution.Select File > New Solution.

  3. Dans la catégorie Cloud > Général , sélectionnez le modèle Azure Functions.From the Cloud > General category, select the Azure Functions template. Vous allez utiliser C# pour créer une bibliothèque de classes .NET qui héberge Azure Functions.You will use C# to create a .NET class library that hosts Azure Functions. Cliquez sur Suivant.Click Next.

    Sélection du modèle Azure Functions

  4. Tapez AzureFunctionsLab dans le champ Nom du projet , puis cliquez sur Créer.Set the Project Name to "AzureFunctionsLab" and click Create.

    Nommage et création d’un projet de fonction Azure

  5. Développez les nœuds dans la fenêtre de la solution.Expand the nodes in the Solution Window. Le modèle de projet par défaut inclut des références NuGet à une variété de packages AzureWebJobs, ainsi qu’au package Newtonsoft.Json.The default project template includes NuGet references to a variety of Azure WebJobs packages, as well as the Newtonsoft.Json package.

    Il comprend également trois fichiers : - host.json pour décrire les options de configuration globales pour l’hôte. - local.settings.json pour configurer les paramètres de service.There are also three files: - host.json for describing the global configuration options for the host - local.settings.json for configuring service settings. - Le modèle de projet crée également un HttpTrigger par défaut.- The project template also creates a default HttpTrigger. Pour les besoins de cet atelier, supprimez le fichier HttpTrigger.cs du projet.For the sake of this lab, you should delete the HttpTrigger.cs file from the project.

    Ouvrez local.settings.json.Open local.settings.json. Il contient par défaut deux paramètres de chaîne de connexion vides.It defaults to having two empty connection string settings.

    fenêtre de solution affichant local.settings.jssur le fichier

Exercice 2 : Création d’un compte de stockage AzureExercise 2: Creating an Azure storage account

  1. Connectez-vous à votre compte Azure à l’adresse https://portal.azure.com .Log on to your Azure account at https://portal.azure.com.

  2. Sous la section Favoris située à gauche de l’écran, sélectionnez Comptes de stockage :Under the Favorites section, located on the left of the screen, select Storage Accounts :

    Section Favoris du portail Azure montrant l’élément Comptes de stockage

  3. Sélectionnez Ajouter pour créer un compte de stockage :Select Add to create a new storage account:

    Bouton permettant d’ajouter un nouveau compte de stockage

  4. Entrez un nom global unique dans le champ Nom et réutilisez-le comme Groupe de ressources.Enter a globally unique name for the Name and reuse it for the Resource group. Vous pouvez conserver tous les autres éléments par défaut.You can keep all the other items as their default.

    Détails du nouveau compte de stockage

  5. Cliquez sur Créer.Click Create. La création d’un compte de stockage peut prendre quelques minutes.It might take a few minutes to create the storage account. Vous recevrez une notification une fois l’opération terminée.You'll get a notification once it has been successfully created.

    Notification de la réussite du déploiement

  6. Sélectionnez le bouton Accéder à la ressource dans la notification.Select the Go to resource button from the notification.

  7. Sélectionnez l’onglet Clés d’accès.Select the Access keys tab.

    Paramètre de clé d’accès

  8. Copiez la première Chaîne de connexion.Copy the first Connection String. Cette chaîne permet d’intégrer le stockage Azure à vos fonctions Azure par la suite.This string is used to integrate Azure storage with your Azure Functions later on.

    Informations pour la clé numéro 1

  9. Revenez à Visual Studio pour Mac , puis collez la chaîne de connexion complète comme paramètre AzureWebJobsStorage dans local.settings.json.Return to Visual Studio for Mac and paste the full connection string in as the AzureWebJobsStorage setting in local.settings.json. Vous pouvez maintenant référencer le nom du paramètre dans les attributs des fonctions qui ont besoin d’accéder à ses ressources.Now you can reference the name of the setting in attributes for functions that need access to its resources.

    Fichier de paramètres locaux avec clé de connexion entrée

Exemple 3 : Création et débogage d’une fonction AzureExample 3: Creating and debugging an Azure Function

  1. Vous êtes prêt à ajouter du code.You're now ready to start adding some code. Quand vous utilisez une bibliothèque de classes .NET, les fonctions Azure sont ajoutées comme méthodes statiques.When working with a .NET class library, Azure Functions are added as static methods. Dans la fenêtre de la solution, cliquez avec le bouton droit sur le nœud de projet AzureFunctions et sélectionnez Ajouter > fonction Ajouter :From the Solution Window , right-click the AzureFunctions project node and select Add > Add Function :

    Option Ajouter une fonction

  2. Dans la boîte de dialogue Nouvelle fonction Azure, sélectionnez le modèle Generic WebHook.In the New Azure Functions dialog, select the Generic webhook template. Tapez Add dans le champ Nom , puis cliquez sur OK pour créer votre fonction :Set the Name to Add and click Ok to create your function:

    Boîte de dialogue Nouvelle fonction Azure

  3. En haut du nouveau fichier, ajoutez les directives using ci-dessous :At the top of the new file, add the using directives below:

    using Microsoft.Azure.WebJobs.Extensions.Http;
    using System.Web;
    using Microsoft.WindowsAzure.Storage.Table;
    
  4. Supprimez la méthode Run existante et ajoutez la méthode ci-dessous à la classe comme fonction Azure :Remove the existing Run method and add the method below to the class as your Azure Function:

    [FunctionName("Add")]
    public static int Run(
    [HttpTrigger(AuthorizationLevel.Function, "get", Route = null)]
    HttpRequestMessage req,
    TraceWriter log)
    {
        int x = 1;
        int y = 2;
    
        return x + y;
    }
    
  5. Passons en revue la définition de la méthode élément par élément.Let's walk through the method definition piece by piece.

    La première chose que vous voyez est l’attribut FunctionName. Celui-ci marque la méthode comme étant une fonction Azure.The first thing you'll see is the FunctionName attribute that marks this method as an Azure Function. L’attribut désigne le nom public de la fonction.The attribute designates the public name of the function. Le nom de l’attribut ne doit pas forcément correspondre au nom réel de la méthode.The attribute name doesn't need to match the actual method name.

    Nouvelle méthode Run avec l’attribut FunctionName mis en surbrillance

  6. Ensuite, la méthode est marquée comme étant une méthode publique statique ( public static ). Cette étape est obligatoire.Next, the method is marked as a public static method, which is required. Vous remarquerez également que la valeur de retour est un entier. Sauf spécification contraire à l’aide des attributs de méthode, toute valeur de retour non void d’une fonction Azure est retournée au client sous forme de texte.You'll also notice that the return value is an int. Unless otherwise specified using method attributes, any non-void return value of an Azure Function is returned to the client as text. Par défaut, elle est retournée au format XML , mais vous pourrez la retourner au format JSON plus loin dans cet atelier.By default it's returned as XML , but can be changed to JSON , which you'll do later on in the lab.

    Nouvelle méthode Run avec mise en surbrillance de l’initialisation de la méthode

  7. Le premier paramètre est marqué avec l’attribut HttpTrigger , ce qui indique que cette méthode est appelée par une requête HTTP.The first parameter is marked with the HttpTrigger attribute, which indicates that this method is invoked by an HTTP request. L’attribut spécifie également le niveau d’autorisation de la méthode, ainsi que les verbes pris en charge (uniquement "GET" dans ce cas).The attribute also specifies the authorization level of the method, as well as the verbs it supports (only "GET" in this case). Vous pouvez éventuellement définir une Route qui substitue le chemin à la méthode et qui permet d’extraire automatiquement des variables du chemin.You may also optionally define a Route that overrides the path to the method and offers a way to automatically extract variables from the path. Comme Route a ici la valeur Null, le chemin à cette méthode est par défaut /api/Add.Since the Route is null here, the path to this method will default to /api/Add.

    Nouvelle méthode Run avec mise en surbrillance du paramètre

  8. Le dernier paramètre de la méthode est un TraceWriter qui peut être utilisé pour journaliser les messages relatifs aux diagnostics et aux erreurs.The final parameter to the method is a TraceWriter that can be used to log messages for diagnostics and errors.

    Nouvelle méthode Run avec mise en surbrillance de TraceWriter

  9. Cliquez dans la marge de la ligne return de la méthode pour définir un point d’arrêt :Set a breakpoint on the return line of the method by clicking in the margin of the line:

    Point d’arrêt défini au niveau de la ligne return

  10. Générez et exécutez le projet dans une session de débogage. Pour cela, appuyez sur F5 ou sélectionnez Exécuter > Démarrer le débogage.Build and run the project in a debug session by pressing F5 or selecting Run > Start Debugging. Vous pouvez également cliquer sur le bouton Exécuter.You could alternatively click the Run button. Ces options effectuent toutes la même tâche.These options all perform the same task. Le reste de cet atelier fait référence à F5 , mais vous pouvez utiliser la méthode qui vous convient le mieux.The rest of this lab references F5 , but you can use the method you find most comfortable.

    Générer et exécuter le projet

  11. L’exécution du projet ouvre automatiquement l’application Terminal.Running the project will automatically open the Terminal application.

  12. Le projet passe par un processus de détection des fonctions Azure basé sur des attributs de méthode et une convention de fichier, laquelle est traitée plus loin dans cet article.The project goes through a process of detecting Azure Functions based on method attributes and a file convention that is covered later in this article. Dans ce cas, il détecte une seule fonction Azure et « génère » 1 fonction de travail.In this case, it detects a single Azure Function and "generates" 1 job function.

    Sortie de fonction Azure dans Terminal

  13. Au bas des messages de démarrage, l’hôte Azure Functions affiche les URL des API des déclencheurs HTTP.At the bottom of the startup messages, the Azure Functions host prints the URLs of any HTTP trigger APIs. Il ne doit y en avoir qu’une.There should only be one. Copiez cette URL et collez-la sous un nouvel onglet du navigateur.Copy that URL and paste it in a new browser tab.

    URL d’API de fonction Azure

  14. Le point d’arrêt doit se déclencher immédiatement.The breakpoint should trigger immediately. La requête web a été routée à la fonction et peut désormais être déboguée.The web request has been routed to the function and can now be debugged. Pointez avec la souris sur la variable x pour afficher sa valeur.Mouse over the x variable to see its value.

    Point d’arrêt déclenché

  15. Supprimez le point d’arrêt en suivant la même méthode que celle utilisée plus haut pour l’ajouter (cliquez sur la marge ou sélectionnez la ligne et appuyez sur F9 ).Remove the breakpoint using the same method used to add it earlier (click on the margin or select the line and press F9 ).

  16. Appuyez sur F5 pour continuer l’exécution.Press F5 to continue running.

  17. Le navigateur affiche le résultat XML de la méthode.In the browser, the XML result of the method will be rendered. Comme prévu, l’opération d’addition codée en dur produit une somme plausible.As expected, the hardcoded addition operation produces a plausible sum. Si vous voyez seulement « 3 » dans Safari, accédez à Safari > Préférences > Avancées et cochez la case Afficher le menu Développement dans la barre de menus. Ensuite, rechargez la page.Note, if you only see "3" in Safari, go to Safari > Preferences > Advanced and tick the " Show Develop menu in menu bar " checkbox and reload the page.

  18. Dans Visual Studio pour Mac , cliquez sur le bouton Arrêter pour mettre fin à la session de débogage.In Visual Studio for Mac , click the Stop button to end the debug session. Pour que les nouveaux changements entrent en vigueur, n’oubliez pas de redémarrer (arrêter, puis exécuter) la session de débogage.To ensure that new changes are picked up, don't forget to restart (stop and then run) the debugging session.

    Option Arrêter le débogage

  19. Dans la méthode Run , remplacez les définitions x et y par le code ci-dessous.In the Run method, replace the x and y definitions with the code below. Ce code extrait les valeurs de la chaîne de requête de l’URL de manière à ce que l’opération d’addition puisse être exécutée dynamiquement en fonction des paramètres fournis.This code extracts values from the URL's query string so that the addition operation can be performed dynamically based on the provided parameters.

    var query = HttpUtility.ParseQueryString(req.RequestUri.Query);
    
    int x = int.Parse(query["x"]);
    
    int y = int.Parse(query["y"]);
    
    return x + y;
    
  20. Exécutez l'application.Run the application.

  21. Revenez à la fenêtre du navigateur et ajoutez la chaîne /?x=2&y=3 à l’URL.Return to the browser window and append the string /?x=2&y=3 to the URL. L’URL complète doit maintenant être http://localhost:7071/api/Add?x=2&y=3.The whole URL should now be http://localhost:7071/api/Add?x=2&y=3. Accédez à la nouvelle URL.Navigate to the new URL.

  22. Le résultat doit à présent refléter les nouveaux paramètres.This time the result should reflect the new parameters. N’hésitez pas à exécuter le projet avec des valeurs différentes.Feel free to run the project with different values. Notez qu’aucune vérification des erreurs n’est effectuée. Tout paramètre non valide ou manquant génère donc une erreur.Note that there isn't any error checking, so invalid or missing parameters will throw an error.

  23. Arrêtez la session de débogage.Stop the debugging session.

Exercice 4 : Utilisation de function.jsonExercise 4: Working with function.json

  1. Dans un exercice précédent, il est mentionné que Visual Studio pour Mac « génère » une fonction de travail pour la fonction Azure définie dans la bibliothèque.In an earlier exercise, it was mentioned that Visual Studio for Mac "generated" a job function for the Azure Function defined in the library. Cela vient du fait qu’Azure Functions n’utilise pas réellement les attributs de méthode au moment de l’exécution. Au lieu de cela, il utilise une convention de système de fichiers au moment de la compilation pour configurer où et comment les fonctions Azure sont mises à disposition.This is because Azure Functions doesn't actually use the method attributes at runtime, but rather uses a compile-time file system convention to configure where and how Azure Functions are made available. Dans la fenêtre de la solution, cliquez avec le bouton droit sur le nœud de votre projet et sélectionnez révéler dans le Finder.From the Solution Window , right-click on your project node and select Reveal in Finder.

    Option Révéler dans le Finder

  2. Descendez dans le système de fichiers jusqu’à ce que vous arriviez à bin/Debug/netstandard2.0.Navigate down the file system until you reach bin/Debug/netstandard2.0. Vous devriez trouver un dossier nommé Add.There should be a folder named Add. Ce dossier a été créé pour correspondre à l’attribut de nom de fonction dans le code C#.This folder was created to correspond with the function name attribute in the C# code. Développez le dossier Add pour révéler un fichier function.json unique.Expand the Add folder to reveal a single function.json file. Ce fichier est utilisé par le runtime pour héberger et gérer la fonction Azure.This file is used by the runtime to host and manage the Azure Function. Pour les autres modèles de langage ne prenant pas en charge la compilation (comme Script C# ou JavaScript), vous devez créer et tenir à jour manuellement ces dossiers.For other language models without compile-time support (such as C# script or JavaScript), these folders must be manually created and maintained. Pour les développeurs C#, ils sont automatiquement générés à partir des métadonnées d’attribut au moment de la génération.For C# developers, they are automatically generated from attribute metadata upon build. Cliquez avec le bouton droit sur le fichier function.json et sélectionnez-le pour l’ouvrir dans Visual Studio.Right-click on function.json and select to open it in Visual Studio.

    function.json dans le répertoire de fichiers

  3. Si vous avez suivi les étapes précédentes de ce tutoriel, vous devez avoir des connaissances de base des attributs C#.Given the previous steps of this tutorial, you should have a basic understanding of C# attributes. Le code JSON qui suit doit donc vous sembler familier.Taking that into account, this JSON should look familiar. Toutefois, quelques éléments n’ont pas été abordés dans les exercices précédents.However, there are a few items that were not covered in earlier exercises. Par exemple, chaque liaison ( binding ) doit avoir une direction définie.For example, each binding must have its direction set. Comme vous l’aurez deviné, "in" signifie que le paramètre est une entrée, tandis que "out" indique que le paramètre est une valeur de retour (par le biais de $return ) ou un paramètre out de la méthode.As you might infer, "in" means that the parameter is input, whereas "out" indicates that the parameter is either a return value (via $return ) or an out parameter to the method. Vous devez également spécifier le scriptFile (par rapport à cet emplacement final) et la méthode entryPoint (publique et statique) dans l’assembly.You also need to specify the scriptFile (relative to this final location) and the entryPoint method (public and static) within the assembly. Au cours des prochaines étapes, vous allez ajouter un chemin de fonction personnalisé à l’aide de ce modèle. Vous devez donc copier le contenu de ce fichier dans le Presse-papiers.In the next few steps you'll add a custom function path using this model, so copy the contents of this file to the clipboard.

    Fichier function.json ouvert dans Visual Studio pour Mac

  4. Dans la fenêtre de la solution, cliquez avec le bouton droit sur le nœud de projet AzureFunctionsLab , puis sélectionnez Ajouter > nouveau dossier.In the Solution Window , right-click the AzureFunctionsLab project node and select Add > New Folder. Nommez le nouveau dossier Adder.Name the new folder Adder. Selon la convention par défaut, le nom de ce dossier définit le chemin à l’API (par exemple, api/Adder ).By default convention, the name of this folder will define the path to the API, such as api/Adder.

    Option Nouveau dossier

  5. Cliquez avec le bouton sur le dossier Adder et sélectionnez Ajouter > Nouveau fichier.Right-click the Adder folder and select Add > New File.

    Option Nouveau fichier

  6. Sélectionnez la catégorie Web et le modèle Fichier JSON vide.Select the Web category and the Empty JSON File template. Tapez function dans le champ Nom , puis cliquez sur Nouveau.Set the Name to function and click New.

    Option Fichier JSON vide

  7. Collez le contenu de l’autre fichier function.json (créé au cours de l’étape 3) pour remplacer le contenu par défaut du fichier que vous venez de créer.Paste the contents of the other function.json (from step 3) in to replace the default contents of the newly created file.

  8. Supprimez les lignes suivantes dans la partie supérieure du fichier JSON :Remove the following lines from the top of the json file:

    "configurationSource":"attributes",
    "generatedBy":"Microsoft.NET.Sdk.Functions-1.0.13",
    
  9. À la fin de la première liaison (après la ligne "name": "req" ), ajoutez les propriétés ci-dessous.At the end of the first binding (after the "name": "req" line), add the properties below. N’oubliez pas d’ajouter une virgule à la ligne précédente.Don't forget to include a comma on the previous line. Cette propriété se substitue à la racine par défaut. Elle extrait ainsi les paramètres int du chemin d’accès et les place dans les paramètres de méthode nommés x et y.This property overrides the default root such that it will now extract int parameters from the path and place them into method parameters that are named x and y.

    "direction": "in",
    "route": "Adder/{x:int?}/{y:int?}"
    
  10. Ajoutez une autre liaison sous la première.Add another binding underneath the first. Cette liaison gère la valeur de retour de la fonction.This binding handles the return value of the function. N’oubliez pas d’ajouter une virgule à la ligne précédente :Don't forget to include a comma on the previous line:

    {
    "name": "$return",
    "type": "http",
    "direction": "out"
    }
    
  11. Changez également la propriété entryPoint située en bas du fichier de manière à ce qu’elle utilise une méthode appelée « Add2 » , comme indiqué ci-dessous.Also update the entryPoint property at the bottom of the file to use a method called "Add2" , such as shown below. Vous pouvez donc constater que le chemin api/Adder... peut mapper à une méthode appropriée avec un nom quelconque ( Add2 ici).This is to illustrate that the path api/Adder... could map to an appropriate method with any name ( Add2 here).

    "entryPoint": "<project-name>.<function-class-name>.Add2"
    
  12. Votre fichier function.json doit ressembler au code JSON suivant :Your final function.json file should look like the following json:

    {
    "bindings": [
        {
        "type": "httpTrigger",
        "methods": [
            "get"
        ],
        "authLevel": "function",
        "direction": "in",
        "name": "req",
        "route": "Adder/{x:int?}/{y:int?}"
        },
        {
        "name": "$return",
        "type": "http",
        "direction": "out"
        }
    ],
    "disabled": false,
    "scriptFile": "../bin/AzureFunctionsProject.dll",
    "entryPoint": "AzureFunctionsProject.Add.Add2"
    }
    
  13. Pour que tout fonctionne correctement, la dernière étape consiste à charger Visual Studio pour Mac de copier ce fichier dans le même chemin relatif du répertoire de sortie chaque fois qu’il change.The one final step required to make this all work is to instruct Visual Studio for Mac to copy this file to the same relative path in the output directory every time it changes. Veillez à ce que le fichier soit sélectionné, puis choisissez l’onglet des propriétés dans la barre de droite. Ensuite, pour Copier dans le répertoire de sortie , sélectionnez Copier si plus récent :With the file selected, choose the properties tab from the right-hand bar, and for Copy to output directory select Copy if newer :

    Options des propriétés pour le fichier json

  14. Dans Add.cs , remplacez la méthode Run (attribut inclus) par la méthode suivante pour obtenir la fonction attendue.In Add.cs , replace the Run method (including the attribute) with the following method to fulfill the expected function. Elle est très similaire à Run, mais elle n’utilise aucun attribut et contient des paramètres explicites pour x et y.It's very similar to Run, except that it uses no attributes and has explicit parameters for x and y.

    public static int Add2(
        HttpRequestMessage req,
        int x,
        int y,
        TraceWriter log)
    {
        return x + y;
    }
    
  15. Appuyez sur F5 pour générer et exécuter le projet.Press F5 to build and run the project.

  16. À mesure que la build s’achève et que la plateforme tourne, une deuxième route mappée à la méthode qui vient d’être ajoutée est désormais disponible pour les requêtes :As the build completes and platform spins up, it will now indicate that there is a second route available for requests that maps to the newly added method:

    URL pour les fonctions HTTP

  17. Retournez la fenêtre du navigateur et accédez à http://localhost:7071/api/Adder/3/5 .Return the browser window and navigate to http://localhost:7071/api/Adder/3/5.

  18. La méthode aboutit une fois de plus, tirant (pull) les paramètres du chemin et produisant une somme.This time the method works once again, pulling parameters from the path and producing a sum.

  19. Revenez à Visual Studio pour Mac et terminez la session de débogage.Return to Visual Studio for Mac and end the debugging session.

Exercice 5 : Utilisation des tables de stockage AzureExercise 5: Working with Azure storage tables

Les services que vous générez sont souvent beaucoup plus complexes que ceux que nous avons générés jusqu’à présent, et leur exécution nécessite des ressources importantes en termes de temps et/ou d’infrastructure.Often, the service you build might be much more complex than what we have built so far and require a significant amount of time and/or infrastructure to execute. Dans ce cas, il peut être judicieux d’accepter les demandes qui sont en file d’attente de traitement quand les ressources deviennent disponibles, ce qu’il est possible de faire avec Azure Functions.In that case, you might find it effective to accept requests that are queued for processing when the resources become available, which Azure Functions provides support for. Dans d’autres cas, vous pouvez stocker les données de manière centralisée.In other cases, you’ll want to store data centrally. Pour y parvenir rapidement, utilisez des tables de stockage Azure.Azure Storage tables let you do that quickly.

  1. Ajoutez la classe ci-dessous à Add.cs.Add the class below to Add.cs. Placez-la dans l’espace de noms, mais à l’extérieur de la classe existante.It should go inside the namespace, but outside the existing class.

    public class TableRow : TableEntity
    {
        public int X { get; set; }
        public int Y { get; set; }
        public int Sum { get; set; }
    }
    
  2. Dans la classe Add , ajoutez le code ci-dessous pour introduire une autre fonction.Within the Add class, add the code below to introduce another function. Notez que celle-ci est sans précédent dans la mesure où elle n’implique aucune réponse HTTP.Note that this one is unique so far in that it doesn't involve an HTTP response. La dernière ligne retourne un nouveau TableRow rempli avec des informations de clé qui permettront de le récupérer facilement par la suite ( PartitionKey et RowKey ), ses paramètres et la somme.The final line returns a new TableRow populated with some key information that will make it easy to retrieve later on ( PartitionKey and RowKey ), as well as its parameters and sum. Le code dans la méthode utilise également TraceWriter pour savoir plus facilement à quel moment la fonction s’exécute.The code within the method also uses the TraceWriter to make it easier to know when the function runs.

    [FunctionName("Process")]
    [return: Table("Results")]
    public static TableRow Process(
        [HttpTrigger(AuthorizationLevel.Function, "get",
            Route = "Process/{x:int}/{y:int}")]
        HttpRequestMessage req,
        int x,
        int y,
        TraceWriter log)
    {
        log.Info($"Processing {x} + {y}");
    
        return new TableRow()
        {
            PartitionKey = "sums",
            RowKey = $"{x}_{y}",
            X = x,
            Y = y,
            Sum = x + y
        };
    }
    
  3. Appuyez sur F5 pour générer et exécuter le projet.Press F5 to build and run the project.

  4. Dans l’onglet navigateur, accédez à http://localhost:7071/api/Process/4/6 .In the browser tab, navigate to http://localhost:7071/api/Process/4/6. Un autre message est placé dans la file d’attente, ce qui doit aboutir à l’ajout d’une nouvelle ligne à la table.This will put another message into the queue, which should eventually result in another row being added to the table.

  5. Revenez au Terminal et observez la requête entrante 4 + 6.Return to Terminal and watch for the incoming request for 4 + 6.

    Sortie du terminal montrant la requête d’addition

  6. Revenez au navigateur pour actualiser la requête à la même URL.Return to the browser to refresh the request to the same URL. Cette fois, vous devriez voir une erreur après la méthode Process.This time you'll see an error after the Process method. Cette erreur vient du fait que le code tente d’ajouter une ligne à la table Stockage Table Azure à l’aide d’une combinaison clé de partition/clé de ligne qui existe déjà.This is because the code is attempting to add a row to the Azure Table Storage table using a partition and row key combination that already exists.

    System.Private.CoreLib: Exception while executing function: Process. Microsoft.Azure.WebJobs.Host: Error while handling parameter $return after function returned:. Microsoft.Azure.WebJobs.Host: The specified entity already exists.
    
  7. Mettez fin à la session de débogage.End the debugging session.

  8. Pour atténuer l’erreur, ajoutez le paramètre suivant à la définition de méthode immédiatement avant le paramètre TraceWriter.To mitigate the error, add the following parameter to the method definition immediately before the TraceWriter parameter. Ce paramètre charge la plateforme Azure Functions pour tenter de récupérer un TableRow à partir de la table Results sur le PartitionKey utilisé pour stocker les résultats.This parameter instructs the Azure Functions platform to attempt to retrieve a TableRow from the Results table on the PartitionKey we've been using to store results. Toutefois, un tour de magie se produit quand vous constatez que RowKey est généré dynamiquement en fonction des autres paramètres x et y pour la même méthode.However, some of the real magic comes into play when you notice that the RowKey is being dynamically generated based on the other x and y parameters for the very same method. Si cette ligne existe déjà, tableRow l’a comme valeur au début de la méthode, sans aucun travail supplémentaire de la part du développeur.If that row already exists, then tableRow will have it when the method begins with no extra work required by the developer. Si la ligne n’existe pas, il a simplement la valeur Null.If the row doesn't exist, then it'll just be null. Ce niveau d’efficacité permet aux développeurs de concentrer leurs efforts sur ce qui compte le plus, à savoir la logique métier, et non l’infrastructure.This sort of efficiency enables developers to focus on the important business logic and not the infrastructure.

    [Table("Results", "sums", "{x}_{y}")]
    TableRow tableRow,
    
  9. Ajoutez le code ci-dessous au début de la méthode.Add the code below to the beginning of the method. Si tableRow n’est pas Null, nous avons déjà les résultats de l’opération faisant l’objet d’une requête et nous pouvons les retourner immédiatement.If tableRow isn't null, then we already have the results for the operation being requested and can return it immediately. Sinon, la fonction continue comme avant.Otherwise, the function continues as before. Même s’il ne s’agit peut-être pas de la meilleure façon de retourner les données, vous pouvez orchestrer des opérations extrêmement sophistiquées sur plusieurs niveaux scalables avec très peu de code.While this may not be the most robust way to return the data, it illustrates the point that you can orchestrate incredibly sophisticated operations across multiple scalable tiers with very little code.

    if (tableRow != null)
    {
        log.Info($"{x} + {y} already exists");
        return null;
    }
    
  10. Appuyez sur F5 pour générer et exécuter le projet.Press F5 to build and run the project.

  11. Dans l’onglet navigateur, actualisez l’URL à l’adresse http://localhost:7071/api/Process/4/6 .In the browser tab, refresh the URL at http://localhost:7071/api/Process/4/6. Étant donné que la ligne de table pour cet enregistrement existe, elle doit être retournée immédiatement et sans erreur.Since the table row for this record exists, it should return immediately and without error. Comme il n’y a pas de sortie HTTP, vous pouvez voir la sortie dans le Terminal.Since there is no HTTP output, you can see the output in Terminal.

    Sortie du Terminal montrant que la ligne de la table existe déjà

  12. Mettez à jour l’URL pour refléter une combinaison non encore testée, telle que http://localhost:7071/api/Process/5/7 .Update the URL to reflect a combination not yet tested, such as http://localhost:7071/api/Process/5/7. Notez le message dans le Terminal qui indique que la ligne de table est introuvable (comme prévu).Note the message in Terminal, which indicates that the table row was not found (as expected).

    Sortie du Terminal montrant un nouveau processus

  13. Revenez à Visual Studio pour Mac et terminez la session de débogage.Return to Visual Studio for Mac and end the debugging session.

RésuméSummary

Dans cet atelier, vous avez appris à créer des fonctions Azure à l’aide de Visual Studio pour Mac.In this lab, you've learned how to get started building Azure Functions with Visual Studio for Mac.