Connecter Azure Functions à Stockage Azure à l’aide des outils en ligne de commandeConnect Azure Functions to Azure Storage using command line tools

Dans cet article, vous intégrez une file d’attente Stockage Azure à la fonction et au compte de stockage que vous avez créés dans le guide de démarrage rapide précédent.In this article, you integrate an Azure Storage queue with the function and storage account you created in the previous quickstart article. Vous effectuez cette intégration à l’aide d’une liaison de sortie qui écrit les données d’une requête HTTP dans un message en file d’attente.You achieve this integration by using an output binding that writes data from an HTTP request to a message in the queue. Le fait de suivre les instructions de cet article n’entraîne aucun coût supplémentaire au-delà des quelques cents USD du guide de démarrage rapide précédent.Completing this article incurs no additional costs beyond the few USD cents of the previous quickstart. Pour en savoir plus sur les liaisons, consultez Concepts des déclencheurs et liaisons Azure Functions.To learn more about bindings, see Azure Functions triggers and bindings concepts.

Configurer votre environnement localConfigure your local environment

Avant de commencer, vous devez terminer l’article Démarrage rapide : Créer un projet Azure Functions à partir de la ligne de commande.Before you begin, you must complete the article, Quickstart: Create an Azure Functions project from the command line. Si vous avez déjà nettoyé les ressources à la fin de cet article, suivez à nouveau les étapes pour recréer l’application Functions et les ressources associées dans Azure.If you already cleaned up resources at the end of that article, go through the steps again to recreate the function app and related resources in Azure.

Avant de commencer, vous devez terminer l’article Démarrage rapide : Créer un projet Azure Functions à partir de la ligne de commande.Before you begin, you must complete the article, Quickstart: Create an Azure Functions project from the command line. Si vous avez déjà nettoyé les ressources à la fin de cet article, suivez à nouveau les étapes pour recréer l’application Functions et les ressources associées dans Azure.If you already cleaned up resources at the end of that article, go through the steps again to recreate the function app and related resources in Azure.

Avant de commencer, vous devez terminer l’article Démarrage rapide : Créer un projet Azure Functions à partir de la ligne de commande.Before you begin, you must complete the article, Quickstart: Create an Azure Functions project from the command line. Si vous avez déjà nettoyé les ressources à la fin de cet article, suivez à nouveau les étapes pour recréer l’application Functions et les ressources associées dans Azure.If you already cleaned up resources at the end of that article, go through the steps again to recreate the function app and related resources in Azure.

Avant de commencer, vous devez terminer l’article Démarrage rapide : Créer un projet Azure Functions à partir de la ligne de commande.Before you begin, you must complete the article, Quickstart: Create an Azure Functions project from the command line. Si vous avez déjà nettoyé les ressources à la fin de cet article, suivez à nouveau les étapes pour recréer l’application Functions et les ressources associées dans Azure.If you already cleaned up resources at the end of that article, go through the steps again to recreate the function app and related resources in Azure.

Avant de commencer, vous devez terminer l’article Démarrage rapide : Créer un projet Azure Functions à partir de la ligne de commande.Before you begin, you must complete the article, Quickstart: Create an Azure Functions project from the command line. Si vous avez déjà nettoyé les ressources à la fin de cet article, suivez à nouveau les étapes pour recréer l’application Functions et les ressources associées dans Azure.If you already cleaned up resources at the end of that article, go through the steps again to recreate the function app and related resources in Azure.

Avant de commencer, vous devez terminer l’article Démarrage rapide : Créer un projet Azure Functions à partir de la ligne de commande.Before you begin, you must complete the article, Quickstart: Create an Azure Functions project from the command line. Si vous avez déjà nettoyé les ressources à la fin de cet article, suivez à nouveau les étapes pour recréer l’application Functions et les ressources associées dans Azure.If you already cleaned up resources at the end of that article, go through the steps again to recreate the function app and related resources in Azure.

Récupérer la chaîne de connexion de Stockage AzureRetrieve the Azure Storage connection string

Vous avez créé auparavant un compte de stockage Azure que l’application de fonction va utiliser.Earlier, you created an Azure Storage account for use by the function app. La chaîne de connexion pour ce compte est stockée de manière sécurisée dans les paramètres d’application au sein d’Azure.The connection string for this account is stored securely in app settings in Azure. En téléchargeant le paramètre dans le fichier local.settings.json, vous pouvez utiliser cette connexion pour écrire dans une file d’attente de stockage du même compte au moment de l’exécution locale de la fonction.By downloading the setting into the local.settings.json file, you can use that connection write to a Storage queue in the same account when running the function locally.

  1. À partir de la racine du projet, exécutez la commande suivante, en remplaçant <app_name> par le nom de votre application de fonction créée dans le guide de démarrage rapide précédent.From the root of the project, run the following command, replacing <app_name> with the name of your function app from the previous quickstart. Cette commande remplace toutes les valeurs existantes dans le fichier.This command will overwrite any existing values in the file.

    func azure functionapp fetch-app-settings <app_name>
    
  2. Ouvrez local.settings.json et recherchez la valeur nommée AzureWebJobsStorage, qui est la chaîne de connexion du compte de stockage.Open local.settings.json and locate the value named AzureWebJobsStorage, which is the Storage account connection string. Vous utilisez le nom AzureWebJobsStorage et la chaîne de connexion dans d’autres sections de cet article.You use the name AzureWebJobsStorage and the connection string in other sections of this article.

Important

Dans la mesure où local.settings.json contient des secrets téléchargés à partir d’Azure, excluez toujours ce fichier du contrôle de code source.Because local.settings.json contains secrets downloaded from Azure, always exclude this file from source control. Le fichier .gitignore créé avec un projet Functions local exclut le fichier par défaut.The .gitignore file created with a local functions project excludes the file by default.

Inscrire des extensions de liaisonRegister binding extensions

À l’exception des déclencheurs HTTP et de minuterie, les liaisons sont implémentées sous la forme de packages d’extension.With the exception of HTTP and timer triggers, bindings are implemented as extension packages. Exécutez la commande dotnet add package suivante dans la fenêtre de terminal pour ajouter le package d’extension de Stockage à votre projet.Run the following dotnet add package command in the Terminal window to add the Storage extension package to your project.

dotnet add package Microsoft.Azure.WebJobs.Extensions.Storage --version 3.0.4

Vous pouvez maintenant ajouter la liaison de sortie de stockage à votre projet.Now, you can add the storage output binding to your project.

Ajouter une définition de liaison de sortie à la fonctionAdd an output binding definition to the function

Bien qu’une fonction ne puisse avoir qu’un seul déclencheur, elle peut avoir plusieurs liaisons d’entrée et de sortie. Ainsi, vous pouvez vous connecter à d’autres services et ressources Azure sans avoir à écrire du code d’intégration personnalisé.Although a function can have only one trigger, it can have multiple input and output bindings, which let you connect to other Azure services and resources without writing custom integration code.

Vous déclarez ces liaisons dans le fichier function.json situé dans le dossier de la fonction.You declare these bindings in the function.json file in your function folder. Compte tenu du guide de démarrage rapide précédent, votre fichier function.json situé dans le dossier HttpExample contient deux liaisons dans la collection bindings :From the previous quickstart, your function.json file in the HttpExample folder contains two bindings in the bindings collection:

"bindings": [
    {
        "authLevel": "function",
        "type": "httpTrigger",
        "direction": "in",
        "name": "req",
        "methods": [
            "get",
            "post"
        ]
    },
    {
        "type": "http",
        "direction": "out",
        "name": "res"
    }
]
"scriptFile": "__init__.py",
"bindings": [
    {
        "authLevel": "function",
        "type": "httpTrigger",
        "direction": "in",
        "name": "req",
        "methods": [
            "get",
            "post"
        ]
    },
    {
        "type": "http",
        "direction": "out",
        "name": "$return"
    }
"bindings": [
  {
    "authLevel": "function",
    "type": "httpTrigger",
    "direction": "in",
    "name": "Request",
    "methods": [
      "get",
      "post"
    ]
  },
  {
    "type": "http",
    "direction": "out",
    "name": "Response"
  }
]

Chaque liaison a au moins un type, une direction et un nom.Each binding has at least a type, a direction, and a name. Dans l’exemple ci-dessus, la première liaison est de type httpTrigger, et sa direction est in.In the example above, the first binding is of type httpTrigger with the direction in. Pour la direction in, name spécifie le nom d’un paramètre d’entrée qui est envoyé à la fonction quand il est appelé par le déclencheur.For the in direction, name specifies the name of an input parameter that's sent to the function when invoked by the trigger.

La deuxième liaison dans la collection est nommée res.The second binding in the collection is named res. Cette liaison http est une liaison de sortie (out) qui est utilisée pour écrire la réponse HTTP.This http binding is an output binding (out) that is used to write the HTTP response.

Pour écrire dans une file d’attente Stockage Azure à partir de cette fonction, ajoutez une liaison out de type queue nommée msg, comme indiqué dans le code ci-dessous :To write to an Azure Storage queue from this function, add an out binding of type queue with the name msg, as shown in the code below:

    {
      "authLevel": "function",
      "type": "httpTrigger",
      "direction": "in",
      "name": "req",
      "methods": [
        "get",
        "post"
      ]
    },
    {
      "type": "http",
      "direction": "out",
      "name": "res"
    },
    {
      "type": "queue",
      "direction": "out",
      "name": "msg",
      "queueName": "outqueue",
      "connection": "AzureWebJobsStorage"
    }
  ]
}

La deuxième liaison dans la collection est de type http, et sa direction est out. Dans ce cas, le name spécial de $return indique que cette liaison utilise la valeur retournée par la fonction au lieu de fournir un paramètre d’entrée.The second binding in the collection is of type http with the direction out, in which case the special name of $return indicates that this binding uses the function's return value rather than providing an input parameter.

Pour écrire dans une file d’attente Stockage Azure à partir de cette fonction, ajoutez une liaison out de type queue nommée msg, comme indiqué dans le code ci-dessous :To write to an Azure Storage queue from this function, add an out binding of type queue with the name msg, as shown in the code below:

"bindings": [
  {
    "authLevel": "anonymous",
    "type": "httpTrigger",
    "direction": "in",
    "name": "req",
    "methods": [
      "get",
      "post"
    ]
  },
  {
    "type": "http",
    "direction": "out",
    "name": "$return"
  },
  {
    "type": "queue",
    "direction": "out",
    "name": "msg",
    "queueName": "outqueue",
    "connection": "AzureWebJobsStorage"
  }
]

La deuxième liaison dans la collection est nommée res.The second binding in the collection is named res. Cette liaison http est une liaison de sortie (out) qui est utilisée pour écrire la réponse HTTP.This http binding is an output binding (out) that is used to write the HTTP response.

Pour écrire dans une file d’attente Stockage Azure à partir de cette fonction, ajoutez une liaison out de type queue nommée msg, comme indiqué dans le code ci-dessous :To write to an Azure Storage queue from this function, add an out binding of type queue with the name msg, as shown in the code below:

    {
      "authLevel": "function",
      "type": "httpTrigger",
      "direction": "in",
      "name": "Request",
      "methods": [
        "get",
        "post"
      ]
    },
    {
      "type": "http",
      "direction": "out",
      "name": "Response"
    },
    {
      "type": "queue",
      "direction": "out",
      "name": "msg",
      "queueName": "outqueue",
      "connection": "AzureWebJobsStorage"
    }
  ]
}

Dans ce cas, msg est fourni à la fonction en tant qu’argument de sortie.In this case, msg is given to the function as an output argument. Pour un type queue, vous devez également spécifier le nom de la file d’attente dans queueName et fournir le nom de la connexion Stockage Azure (à partir de local.settings.json) dans connection.For a queue type, you must also specify the name of the queue in queueName and provide the name of the Azure Storage connection (from local.settings.json) in connection.

Dans un projet de bibliothèque de classes C#, les liaisons sont définies comme attributs de liaison sur la méthode de fonction.In a C# class library project, the bindings are defined as binding attributes on the function method. Le fichier function.json nécessaire à Functions est ensuite généré automatiquement en fonction de ces attributs.The function.json file required by Functions is then auto-generated based on these attributes.

Ouvrez le fichier projet HttpExample.cs, puis ajoutez le paramètre suivant à la définition de la méthode Run :Open the HttpExample.cs project file and add the following parameter to the Run method definition:

[Queue("outqueue"),StorageAccount("AzureWebJobsStorage")] ICollector<string> msg,

Le paramètre msg est un type ICollector<T>, qui représente une collection de messages écrits dans une liaison de sortie quand la fonction se termine.The msg parameter is an ICollector<T> type, which represents a collection of messages that are written to an output binding when the function completes. Dans ce cas, la sortie est une file d’attente de stockage nommée outqueue.In this case, the output is a storage queue named outqueue. La chaîne de connexion pour le compte de stockage est définie par StorageAccountAttribute.The connection string for the Storage account is set by the StorageAccountAttribute. Cet attribut indique le paramètre qui contient la chaîne de connexion du compte de stockage et qui peut être appliqué au niveau de la classe, de la méthode ou du paramètre.This attribute indicates the setting that contains the Storage account connection string and can be applied at the class, method, or parameter level. Dans ce cas, vous pourriez omettre StorageAccountAttribute, car vous utilisez déjà le compte de stockage par défaut.In this case, you could omit StorageAccountAttribute because you are already using the default storage account.

La définition de la méthode Run doit maintenant se présenter comme ceci :The Run method definition should now look like the following:

[FunctionName("HttpExample")]
public static async Task<IActionResult> Run(
    [HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)] HttpRequest req, 
    [Queue("outqueue"),StorageAccount("AzureWebJobsStorage")] ICollector<string> msg, 
    ILogger log)

Dans un projet Java, les liaisons sont définies comme annotations de liaison sur la méthode de fonction.In a Java project, the bindings are defined as binding annotations on the function method. Le fichier function.json est ensuite généré automatiquement en fonction de ces annotations.The function.json file is then autogenerated based on these annotations.

Accédez à l’emplacement de votre code de fonction sous src/main/java, ouvrez le fichier projet Function.java, puis ajoutez le paramètre suivant à la définition de la méthode run :Browse to the location of your function code under src/main/java, open the Function.java project file, and add the following parameter to the run method definition:

@QueueOutput(name = "msg", queueName = "outqueue", connection = "AzureWebJobsStorage") OutputBinding<String> msg

Le paramètre msg est un type OutputBinding<T>, qui représente une collection de chaînes écrites en tant que messages à une liaison de sortie quand la fonction se termine.The msg parameter is an OutputBinding<T> type, which represents a collection of strings that are written as messages to an output binding when the function completes. Dans ce cas, la sortie est une file d’attente de stockage nommée outqueue.In this case, the output is a storage queue named outqueue. La chaîne de connexion pour le compte de stockage est définie par la méthode connection.The connection string for the Storage account is set by the connection method. Au lieu de passer la chaîne de connexion proprement dite, vous passez le paramètre d’application qui contient la chaîne de connexion du compte de stockage.Rather than the connection string itself, you pass the application setting that contains the Storage account connection string.

La définition de la méthode run doit maintenant ressembler à l’exemple suivant :The run method definition should now look like the following example:

@FunctionName("HttpTrigger-Java")
public HttpResponseMessage run(
        @HttpTrigger(name = "req", methods = {HttpMethod.GET, HttpMethod.POST}, authLevel = AuthorizationLevel.FUNCTION)  
        HttpRequestMessage<Optional<String>> request, 
        @QueueOutput(name = "msg", queueName = "outqueue", connection = "AzureWebJobsStorage") 
        OutputBinding<String> msg, final ExecutionContext context) {
    ...
}

Pour plus d’informations sur les détails des liaisons, consultez Concepts des déclencheurs et liaisons Azure Functions et Configuration de la sortie de la file d’attente.For more information on the details of bindings, see Azure Functions triggers and bindings concepts and queue output configuration.

Ajouter du code pour utiliser la liaison de sortieAdd code to use the output binding

Avec la liaison de file d’attente définie, vous pouvez à présent mettre à jour votre fonction pour qu’elle reçoive le paramètre de sortie msg et écrive des messages dans la file d’attente.With the queue binding defined, you can now update your function to receive the msg output parameter and write messages to the queue.

Mettez à jour HttpExample\__init__.py pour correspondre au code suivant, en ajoutant le paramètre msg à la définition de fonction et msg.set(name) sous l’instruction if name:.Update HttpExample\__init__.py to match the following code, adding the msg parameter to the function definition and msg.set(name) under the if name: statement.

import logging

import azure.functions as func


def main(req: func.HttpRequest, msg: func.Out[func.QueueMessage]) -> str:

    name = req.params.get('name')
    if not name:
        try:
            req_body = req.get_json()
        except ValueError:
            pass
        else:
            name = req_body.get('name')

    if name:
        msg.set(name)
        return func.HttpResponse(f"Hello {name}!")
    else:
        return func.HttpResponse(
            "Please pass a name on the query string or in the request body",
            status_code=400
        )

Le paramètre msg est une instance de la azure.functions.InputStream class.The msg parameter is an instance of the azure.functions.InputStream class. Sa méthode set écrit un message de type chaîne dans la file d’attente. Dans le cas présent, il s’agit du nom passé à la fonction dans la chaîne de requête de l’URL.Its set method writes a string message to the queue, in this case the name passed to the function in the URL query string.

Ajoutez le code qui utilise l’objet de liaison de sortie msg sur context.bindings pour créer un message de file d’attente.Add code that uses the msg output binding object on context.bindings to create a queue message. Ajoutez ce code avant l’instruction context.res.Add this code before the context.res statement.

// Add a message to the Storage queue,
// which is the name passed to the function.
context.bindings.msg = (req.query.name || req.body.name);

À ce stade, votre fonction doit se présenter comme suit :At this point, your function should look as follows:

module.exports = async function (context, req) {
    context.log('JavaScript HTTP trigger function processed a request.');

    if (req.query.name || (req.body && req.body.name)) {
        // Add a message to the Storage queue,
        // which is the name passed to the function.
        context.bindings.msg = (req.query.name || req.body.name);
        context.res = {
            // status: 200, /* Defaults to 200 */
            body: "Hello " + (req.query.name || req.body.name)
        };
    }
    else {
        context.res = {
            status: 400,
            body: "Please pass a name on the query string or in the request body"
        };
    }
};

Ajoutez le code qui utilise l’objet de liaison de sortie msg sur context.bindings pour créer un message de file d’attente.Add code that uses the msg output binding object on context.bindings to create a queue message. Ajoutez ce code avant l’instruction context.res.Add this code before the context.res statement.

context.bindings.msg = name;

À ce stade, votre fonction doit se présenter comme suit :At this point, your function should look as follows:

import { AzureFunction, Context, HttpRequest } from "@azure/functions"

const httpTrigger: AzureFunction = async function (context: Context, req: HttpRequest): Promise<void> {
    context.log('HTTP trigger function processed a request.');
    const name = (req.query.name || (req.body && req.body.name));

    if (name) {
        // Add a message to the storage queue, 
        // which is the name passed to the function.
        context.bindings.msg = name; 
        // Send a "hello" response.
        context.res = {
            // status: 200, /* Defaults to 200 */
            body: "Hello " + (req.query.name || req.body.name)
        };
    }
    else {
        context.res = {
            status: 400,
            body: "Please pass a name on the query string or in the request body"
        };
    }
};

export default httpTrigger;

Ajoutez du code qui utilise l’applet de commande Push-OutputBinding pour écrire du texte dans la file d’attente à l’aide de la liaison de sortie msg.Add code that uses the Push-OutputBinding cmdlet to write text to the queue using the msg output binding. Ajoutez ce code avant de définir l’état OK dans l’instruction if.Add this code before you set the OK status in the if statement.

$outputMsg = $name
Push-OutputBinding -name msg -Value $outputMsg

À ce stade, votre fonction doit se présenter comme suit :At this point, your function should look as follows:

using namespace System.Net

# Input bindings are passed in via param block.
param($Request, $TriggerMetadata)

# Write to the Azure Functions log stream.
Write-Host "PowerShell HTTP trigger function processed a request."

# Interact with query parameters or the body of the request.
$name = $Request.Query.Name
if (-not $name) {
    $name = $Request.Body.Name
}

if ($name) {
    # Write the $name value to the queue, 
    # which is the name passed to the function.
    $outputMsg = $name
    Push-OutputBinding -name msg -Value $outputMsg

    $status = [HttpStatusCode]::OK
    $body = "Hello $name"
}
else {
    $status = [HttpStatusCode]::BadRequest
    $body = "Please pass a name on the query string or in the request body."
}

# Associate values to output bindings by calling 'Push-OutputBinding'.
Push-OutputBinding -Name Response -Value ([HttpResponseContext]@{
    StatusCode = $status
    Body = $body
})

Ajoutez le code qui utilise l’objet de liaison de sortie msg pour créer un message de file d’attente.Add code that uses the msg output binding object to create a queue message. Ajoutez ce code avant que la méthode retourne.Add this code before the method returns.

if (!string.IsNullOrEmpty(name))
{
    // Add a message to the output collection.
    msg.Add(string.Format("Name passed to the function: {0}", name));
}

À ce stade, votre fonction doit se présenter comme suit :At this point, your function should look as follows:

[FunctionName("HttpExample")]
public static async Task<IActionResult> Run(
    [HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)] HttpRequest req, 
    [Queue("outqueue"),StorageAccount("AzureWebJobsStorage")] ICollector<string> msg, 
    ILogger log)
{
    log.LogInformation("C# HTTP trigger function processed a request.");

    string name = req.Query["name"];

    string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
    dynamic data = JsonConvert.DeserializeObject(requestBody);
    name = name ?? data?.name;

    if (!string.IsNullOrEmpty(name))
    {
        // Add a message to the output collection.
        msg.Add(string.Format("Name passed to the function: {0}", name));
    }
    return name != null
        ? (ActionResult)new OkObjectResult($"Hello, {name}")
        : new BadRequestObjectResult("Please pass a name on the query string or in the request body");
}

À présent, vous pouvez utiliser le nouveau paramètre msg pour écrire dans la liaison de sortie à partir de votre code de fonction.Now, you can use the new msg parameter to write to the output binding from your function code. Ajoutez la ligne de code suivante avant la réponse de réussite pour ajouter la valeur de name à la liaison de sortie msg.Add the following line of code before the success response to add the value of name to the msg output binding.

msg.setValue(name);

Lorsque vous utilisez une liaison de sortie, vous n’avez pas besoin de recourir au code du Kit de développement logiciel (SDK) Stockage Azure pour l’authentification, l’obtention d’une référence de file d’attente ou l’écriture de données.When you use an output binding, you don't have to use the Azure Storage SDK code for authentication, getting a queue reference, or writing data. La liaison de sortie de file d’attente et le runtime Functions effectuent ces tâches.The Functions runtime and queue output binding do those tasks for you.

Votre méthode run doit maintenant ressembler à l’exemple suivant :Your run method should now look like the following example:

public HttpResponseMessage run(
        @HttpTrigger(name = "req", methods = {HttpMethod.GET, HttpMethod.POST}, authLevel = AuthorizationLevel.ANONYMOUS) 
        HttpRequestMessage<Optional<String>> request, 
        @QueueOutput(name = "msg", queueName = "outqueue", 
        connection = "AzureWebJobsStorage") OutputBinding<String> msg, 
        final ExecutionContext context) {
    context.getLogger().info("Java HTTP trigger processed a request.");

    // Parse query parameter
    String query = request.getQueryParameters().get("name");
    String name = request.getBody().orElse(query);

    if (name == null) {
        return request.createResponseBuilder(HttpStatus.BAD_REQUEST)
        .body("Please pass a name on the query string or in the request body").build();
    } else {
        // Write the name to the message queue. 
        msg.setValue(name);

        return request.createResponseBuilder(HttpStatus.OK).body("Hello, " + name).build();
    }
}

Mettre à jour les testsUpdate the tests

Étant donné que l’archétype crée également un ensemble de tests, vous devez mettre à jour ces tests pour gérer le nouveau paramètre msg dans la signature de méthode run.Because the archetype also creates a set of tests, you need to update these tests to handle the new msg parameter in the run method signature.

Accédez à l’emplacement de votre code de test sous src/test/Java, ouvrez le fichier projet Function.java et remplacez la ligne de code sous //Invoke par le code suivant.Browse to the location of your test code under src/test/java, open the Function.java project file, and replace the line of code under //Invoke with the following code.

@SuppressWarnings("unchecked")
final OutputBinding<String> msg = (OutputBinding<String>)mock(OutputBinding.class);
final HttpResponseMessage ret = new Function().run(req, msg, context);

Notez que vous n’avez pas besoin d’écrire du code pour l’authentification, l’obtention d’une référence de file d’attente ou l’écriture de données.Observe that you don't need to write any code for authentication, getting a queue reference, or writing data. Toutes ces tâches d’intégration sont prises en charge de manière pratique dans le runtime d’Azure Functions et la liaison de sortie de file d’attente.All these integration tasks are conveniently handled in the Azure Functions runtime and queue output binding.

Exécuter la fonction localementRun the function locally

  1. Exécutez votre fonction en démarrant l’hôte du runtime d’Azure Functions local à partir du dossier LocalFunctionProj :Run your function by starting the local Azure Functions runtime host from the LocalFunctionProj folder:

    func start
    

    Vers la fin de la sortie, les lignes suivantes doivent s’afficher :Toward the end of the output, the following lines should appear:

     ...
    
     Now listening on: http://0.0.0.0:7071
     Application started. Press Ctrl+C to shut down.
    
     Http Functions:
    
             HttpExample: [GET,POST] http://localhost:7071/api/HttpExample
     ...
    
     

    Notes

    Si HttpExample n’apparaît pas comme indiqué ci-dessus, cela signifie probablement que vous avez démarré l’hôte à partir d’un emplacement autre que le dossier racine du projet.If HttpExample doesn't appear as shown above, you likely started the host from outside the root folder of the project. Dans ce cas, utilisez Ctrl+C pour arrêter l’hôte, accédez au dossier racine du projet, puis réexécutez la commande précédente.In that case, use Ctrl+C to stop the host, navigate to the project's root folder, and run the previous command again.

  2. Copiez dans un navigateur l’URL de votre fonction HttpExample à partir de cette sortie, puis ajoutez la chaîne de requête ?name=<YOUR_NAME> pour obtenir une URL complète semblable à http://localhost:7071/api/HttpExample?name=Functions.Copy the URL of your HttpExample function from this output to a browser and append the query string ?name=<YOUR_NAME>, making the full URL like http://localhost:7071/api/HttpExample?name=Functions. Le navigateur doit afficher un message de réponse qui renvoie la valeur de votre chaîne de requête.The browser should display a response message that echoes back your query string value. Le terminal dans lequel vous avez démarré votre projet affiche également une sortie de journal quand vous effectuez des requêtes.The terminal in which you started your project also shows log output as you make requests.

  3. Quand vous avez terminé, utilisez Ctrl+C, puis choisissez y pour arrêter l’hôte Functions.When you're done, use Ctrl+C and choose y to stop the functions host.

Conseil

Au démarrage, l’hôte télécharge et installe l’extension de liaison de stockage et d’autres extensions de liaison Microsoft.During startup, the host downloads and installs the Storage binding extension and other Microsoft binding extensions. Cette installation a lieu, car les extensions de liaison sont activées par défaut dans le fichier host.json avec les propriétés suivantes :This installation happens because binding extensions are enabled by default in the host.json file with the following properties:

{
    "version": "2.0",
    "extensionBundle": {
        "id": "Microsoft.Azure.Functions.ExtensionBundle",
        "version": "[1.*, 2.0.0)"
    }
}

Si vous rencontrez des erreurs liées aux extensions de liaison, vérifiez que les propriétés ci-dessus sont présentes dans host.json.If you encounter any errors related to binding extensions, check that the above properties are present in host.json.

Voir le message dans la file d’attente Stockage AzureView the message in the Azure Storage queue

Vous pouvez voir la file d’attente dans le portail Azure ou dans l’Explorateur Stockage Microsoft Azure.You can view the queue in the Azure portal or in the Microsoft Azure Storage Explorer. Vous pouvez également voir la file d’attente dans Azure CLI, en effectuant les étapes suivantes :You can also view the queue in the Azure CLI, as described in the following steps:

  1. Ouvrez le fichier local.setting.json du projet de fonction, et copiez la valeur de la chaîne de connexion.Open the function project's local.setting.json file and copy the connection string value. Dans une fenêtre de terminal ou une fenêtre Commande, exécutez la commande suivante pour créer une variable d’environnement nommée AZURE_STORAGE_CONNECTION_STRING, en collant votre chaîne de connexion spécifique à la place de <MY_CONNECTION_STRING>.In a terminal or command window, run the following command to create an environment variable named AZURE_STORAGE_CONNECTION_STRING, pasting your specific connection string in place of <MY_CONNECTION_STRING>. (Cette variable d’environnement signifie que vous n’avez pas besoin de fournir la chaîne de connexion pour les prochaines commandes à l’aide de l’argument --connection-string.)(This environment variable means you don't need to supply the connection string to each subsequent command using the --connection-string argument.)

    export AZURE_STORAGE_CONNECTION_STRING="<MY_CONNECTION_STRING>"
    
  2. (Facultatif) Utilisez la commande az storage queue list pour voir les files d’attente de stockage dans votre compte.(Optional) Use the az storage queue list command to view the Storage queues in your account. La sortie de cette commande doit inclure une file d’attente nommée outqueue, qui a été créée au moment où la fonction a écrit son premier message dans cette file d’attente.The output from this command should include a queue named outqueue, which was created when the function wrote its first message to that queue.

    az storage queue list --output tsv
    
  3. Utilisez la commande az storage message get pour lire le message de cette file d’attente, qui doit être le premier nom que vous avez utilisé quand vous avez précédemment testé la fonction.Use the az storage message get command to read the message from this queue, which should be the first name you used when testing the function earlier. La commande lit et supprime le premier message dans la file d’attente.The command reads and removes the first message from the queue.

    echo `echo $(az storage message get --queue-name outqueue -o tsv --query '[].{Message:content}') | base64 --decode`
    

    Étant donné que le corps du message stocké est encodé en base64, le message doit être décodé préalablement à son affichage.Because the message body is stored base64 encoded, the message must be decoded before it's displayed. Une fois que vous avez exécuté az storage message get, le message est supprimé de la file d’attente.After you execute az storage message get, the message is removed from the queue. S’il n’y avait qu’un seul message dans outqueue, vous ne récupérez pas de message à la deuxième exécution de cette commande et vous obtenez une erreur à la place.If there was only one message in outqueue, you won't retrieve a message when you run this command a second time and instead get an error.

Redéployer le projet sur AzureRedeploy the project to Azure

Une fois que vous avez vérifié localement que la fonction a écrit un message dans la file d’attente Stockage Azure, vous pouvez redéployer votre projet pour mettre à jour le point de terminaison exécuté sur Azure.Now that you've verified locally that the function wrote a message to the Azure Storage queue, you can redeploy your project to update the endpoint running on Azure.

Dans le dossier LocalFunctionsProj, utilisez la commande func azure functionapp publish pour redéployer le projet, en remplaçant <APP_NAME> par le nom de votre application.In the LocalFunctionsProj folder, use the func azure functionapp publish command to redeploy the project, replacing<APP_NAME> with the name of your app.

func azure functionapp publish <APP_NAME>

Dans le dossier de projet local, utilisez la commande Maven suivante pour republier votre projet :In the local project folder, use the following Maven command to republish your project:

mvn azure-functions:deploy

Vérifier dans AzureVerify in Azure

  1. Comme dans le guide de démarrage rapide précédent, utilisez un navigateur ou CURL pour tester la fonction redéployée.As in the previous quickstart, use a browser or CURL to test the redeployed function.

    Copiez l’URL d’appel complète affichée au sein de la sortie de la commande de publication dans la barre d’adresse d’un navigateur, en ajoutant le paramètre de requête &name=Functions.Copy the complete Invoke URL shown in the output of the publish command into a browser address bar, appending the query parameter &name=Functions. Le navigateur doit afficher une sortie similaire à celle générée au moment de l’exécution locale de la fonction.The browser should display similar output as when you ran the function locally.

    Sortie de la fonction exécutée sur Azure dans un navigateur

  2. Examinez à nouveau la file d’attente de stockage, comme indiqué dans la section précédente, pour vérifier qu’elle contient le nouveau message écrit.Examine the Storage queue again, as described in the previous section, to verify that it contains the new message written to the queue.

Nettoyer les ressourcesClean up resources

Quand vous avez terminé, utilisez la commande suivante pour supprimer le groupe de ressources et toutes les ressources qu’il contient afin d’éviter les coûts supplémentaires.After you've finished, use the following command to delete the resource group and all its contained resources to avoid incurring further costs.

az group delete --name AzureFunctionsQuickstart-rg

Étapes suivantesNext steps

Vous avez mis à jour votre fonction déclenchée via HTTP pour écrire des données dans une file d’attente de stockage.You've updated your HTTP triggered function to write data to a Storage queue. Pour en savoir plus sur le développement de fonctions à partir de la ligne de commande avec Core Tools et Azure CLI, consultez maintenant ces articles :Now you can learn more about developing Functions from the command line using Core Tools and Azure CLI: