Créer une fonction sur Linux avec un conteneur personnaliséCreate a function on Linux using a custom container

Dans ce tutoriel, vous allez créer et déployer du code Python sur Azure Functions en tant que conteneur Docker personnalisé en utilisant une image de base Linux.In this tutorial, you create and deploy Python code to Azure Functions as a custom Docker container using a Linux base image. Vous utilisez une image personnalisée généralement quand vos fonctions nécessitent une version d’un langage spécifique, ou quand elles ont une dépendance ou une configuration spécifique qui n’est pas fournie par l’image intégrée.You typically use a custom image when your functions require a specific language version or have a specific dependency or configuration that isn't provided by the built-in image.

Vous pouvez également utiliser un conteneur Azure App Service par défaut, comme décrit dans Créer votre première fonction hébergée sur Linux.You can also use a default Azure App Service container as described on Create your first function hosted on Linux. Les images de base prises en charge pour Azure Functions se trouvent dans le référentiel d’images de base Azure Functions.Supported base images for Azure Functions are found in the Azure Functions base images repo.

Dans ce tutoriel, vous allez apprendre à :In this tutorial, you learn how to:

  • Créer une application de fonction et un Dockerfile avec Azure Functions Core Tools.Create a function app and Dockerfile using the Azure Functions Core Tools.
  • Créer une image personnalisée à l’aide de DockerBuild a custom image using Docker.
  • Publier une image personnalisée dans un registre de conteneursPublish a custom image to a container registry.
  • Créer des ressources de prise en charge dans Azure pour l’application de fonctionCreate supporting resources in Azure for the function app
  • Déployer une application de fonction à partir de Docker HubDeploy a function app from Docker Hub.
  • Ajouter des paramètres d’application à l’application de fonctionAdd application settings to the function app.
  • Activer le déploiement continu.Enable continuous deployment.
  • Activer les connexions SSH au conteneur.Enable SSH connections to the container.
  • Ajouter une liaison de sortie de Stockage File d’attente.Add a Queue storage output binding.

Vous pouvez suivre ce tutoriel sur n’importe quel ordinateur exécutant Windows, Mac OS ou Linux.You can follow this tutorial on any computer running Windows, Mac OS, or Linux. Le suivi de ce tutoriel entraîne uun coût de quelques dollars USD dans votre compte Azure.Completing the tutorial will incur costs of a few US dollars in your Azure account.

Conditions préalables requisesPrerequisites

Vérification du prérequisPrerequisite check

  1. Dans un terminal ou une fenêtre de commande, exécutez func --version pour vérifier que la version d’Azure Functions Core Tools est bien 2.7.1846 ou ultérieure.In a terminal or command window, run func --version to check that the Azure Functions Core Tools are version 2.7.1846 or later.
  2. Exécutez az --version pour vérifier que vous disposez d’Azure CLI version 2.0.76 ou ultérieure.Run az --version to check that the Azure CLI version is 2.0.76 or later.
  3. Exécutez az login pour vous connecter à Azure et vérifier qu’il y a un abonnement actif.Run az login to sign in to Azure and verify an active subscription.
  4. Exécutez docker login pour vous connecter à Docker.Run docker login to sign in to Docker. Cette commande échoue si Docker n’est pas en cours d’exécution, auquel cas démarrez Docker et réessayez la commande.This command fails if Docker is not running, in which case start docker and retry the command.

Créer et tester un projet de fonction localCreate and test the local functions project

  1. Dans un terminal ou une invite de commandes, créez un dossier pour ce tutoriel à un emplacement approprié, puis accédez à ce dossier.In a terminal or command prompt, create a folder for this tutorial in an appropriate location, then navigate into that folder.

  2. Suivez les instructions de Créer et activer un environnement virtuel pour créer un environnement virtuel que vous allez utiliser dans ce tutoriel.Follow the instructions on Create and activate a virtual environment to create a virtual environment for use with this tutorial.

  3. Exécutez la commande suivante pour le langage que vous avez choisi pour créer un projet d’application de fonction dans un dossier nommé LocalFunctionsProject.Run the following command for your chosen language to create a function app project in a folder named LocalFunctionsProject. L’option --docker génère un Dockerfile pour le projet, qui définit un conteneur personnalisé approprié pour une utilisation avec Azure Functions et le runtime sélectionné.The --docker option generates a Dockerfile for the project, which defines a suitable custom container for use with Azure Functions and the selected runtime.

    func init LocalFunctionsProject --worker-runtime dotnet --docker
    
    func init LocalFunctionsProject --worker-runtime node --language javascript --docker
    
    func init LocalFunctionsProject --worker-runtime powershell --docker
    
    func init LocalFunctionsProject --worker-runtime python --docker
    
    func init LocalFunctionsProject --worker-runtime node --language typescript --docker
    
  4. Accédez au dossier du projet :Navigate into the project folder:

    cd LocalFunctionsProject
    
  5. Ajoutez une fonction à votre projet avec la commande suivante, où l’argument --name est le nom unique de votre fonction et où l’argument --template spécifie le déclencheur de la fonction.Add a function to your project by using the following command, where the --name argument is the unique name of your function and the --template argument specifies the function's trigger. func new crée un sous-dossier correspondant au nom de la fonction qui contient un fichier de code approprié au langage choisi du projet et un fichier de configuration nommé function.json.func new create a subfolder matching the function name that contains a code file appropriate to the project's chosen language and a configuration file named function.json.

    func new --name HttpExample --template "HTTP trigger"
    
  6. Pour tester la fonction localement, démarrez l’hôte du runtime Azure Functions local dans le dossier LocalFunctionsProject :To test the function locally, start the local Azure Functions runtime host in the LocalFunctionsProject folder:

    func start --build
    
    func start
    
    func start
    
    func start
    
    npm install
    
    npm start
    
  7. Une fois que le point de terminaison HttpExample apparaît dans la sortie, accédez à http://localhost:7071/api/HttpExample?name=Functions.Once you see the HttpExample endpoint appear in the output, navigate to http://localhost:7071/api/HttpExample?name=Functions. Le navigateur doit afficher un message comme « Hello, Functions » (qui varie légèrement selon le langage de programmation que vous avez choisi).The browser should display a message like "Hello, Functions" (varied slightly depending on your chosen programming language).

  8. Utilisez Ctrl-C pour arrêter l’hôte.Use Ctrl-C to stop the host.

Générer l’image conteneur et tester localementBuild the container image and test locally

  1. (Facultatif) Examinez le « Dockerfile » dans le dossier LocalFunctionsProj.(Optional) Examine the *Dockerfile" in the LocalFunctionsProj folder. Le Dockerfile décrit l’environnement nécessaire pour exécuter l’application de fonction sur Linux :The Dockerfile describes the required environment to run the function app on Linux:

    FROM microsoft/dotnet:2.2-sdk AS installer-env
    
    COPY . /src/dotnet-function-app
    RUN cd /src/dotnet-function-app && \
        mkdir -p /home/site/wwwroot && \
        dotnet publish *.csproj --output /home/site/wwwroot
    
    # To enable ssh & remote debugging on app service change the base image to the one below
    # FROM mcr.microsoft.com/azure-functions/dotnet:2.0-appservice 
    FROM mcr.microsoft.com/azure-functions/dotnet:2.0
    ENV AzureWebJobsScriptRoot=/home/site/wwwroot \
        AzureFunctionsJobHost__Logging__Console__IsEnabled=true
    
    COPY --from=installer-env ["/home/site/wwwroot", "/home/site/wwwroot"]
    
    # To enable ssh & remote debugging on app service change the base image to the one below
    # FROM mcr.microsoft.com/azure-functions/node:2.0-appservice
    FROM mcr.microsoft.com/azure-functions/node:2.0
    
    ENV AzureWebJobsScriptRoot=/home/site/wwwroot \
        AzureFunctionsJobHost__Logging__Console__IsEnabled=true
    
    COPY . /home/site/wwwroot
    
    RUN cd /home/site/wwwroot && \
    npm install    
    
    # To enable ssh & remote debugging on app service change the base image to the one below
    # FROM mcr.microsoft.com/azure-functions/powershell:2.0-appservice
    FROM mcr.microsoft.com/azure-functions/powershell:2.0
    ENV AzureWebJobsScriptRoot=/home/site/wwwroot \
        AzureFunctionsJobHost__Logging__Console__IsEnabled=true
    
    COPY . /home/site/wwwroot    
    
    # To enable ssh & remote debugging on app service change the base image to the one below
    # FROM mcr.microsoft.com/azure-functions/python:2.0-python3.7-appservice
    FROM mcr.microsoft.com/azure-functions/python:2.0-python3.7
    
    ENV AzureWebJobsScriptRoot=/home/site/wwwroot \
        AzureFunctionsJobHost__Logging__Console__IsEnabled=true
    
    COPY requirements.txt /
    RUN pip install -r /requirements.txt
    
    COPY . /home/site/wwwroot    
    
    # To enable ssh & remote debugging on app service change the base image to the one below
    # FROM mcr.microsoft.com/azure-functions/node:2.0-appservice
    FROM mcr.microsoft.com/azure-functions/node:2.0
    
    ENV AzureWebJobsScriptRoot=/home/site/wwwroot \
        AzureFunctionsJobHost__Logging__Console__IsEnabled=true
    
    COPY . /home/site/wwwroot
    
    RUN cd /home/site/wwwroot && \
    npm install    
    

    Notes

    La liste complète des images de base prises en charge pour Azure Functions se trouve sur la pages des images de base Azure Functions.The complete list of supported base images for Azure Functions can be found in the Azure Functions base image page.

  2. Dans le dossier LocalFunctionsProject, exécutez la commande docker build, puis spécifiez un nom, azurefunctionsimage, et une étiquette, v1.0.0.In the LocalFunctionsProject folder, run the docker build command, and provide a name, azurefunctionsimage, and tag, v1.0.0. Remplacez <docker_id> par votre ID de compte Docker Hub.Replace <docker_id> with your Docker Hub account ID. Cette commande génère l’image Docker pour le conteneur.This command builds the Docker image for the container.

    docker build --tag <docker_id>/azurefunctionsimage:v1.0.0 .
    

    Une fois la commande terminée, vous pouvez exécuter le nouveau conteneur localement.When the command completes, you can run the new container locally.

  3. Pour tester la génération, exécutez l’image dans un conteneur local avec la commande Docker run, en remplaçant à nouveau <docker_id> par votre ID Docker et en ajoutant l’argument pour les ports, -p 8080:80 :To test the build, run the image in a local container using the docker run command, replacing again <docker_id> with your Docker ID and adding the ports argument, -p 8080:80:

    docker run -p 8080:80 -it <docker_id>/azurefunctionsimage:v1.0.0
    
  4. Une fois que l’image s’exécute dans un conteneur local, ouvrez un navigateur sur http://localhost:8080, qui doit afficher l’image de l’espace réservé montrée ci-dessous.Once the image is running in a local container, open a browser to http://localhost:8080, which should display the placeholder image shown below. L’image apparaît à ce stade, car votre fonction est exécutée dans le conteneur local, comme ce serait le cas dans Azure, ce qui signifie qu’elle est protégée par une clé d’accès telle que définie dans function.json avec la propriété "authLevel": "function".The image appears at this point because your function is running in the local container, as it would in Azure, which means that it's protected by an access key as defined in function.json with the "authLevel": "function" property. Le conteneur n’a cependant pas encore été publié sur une application de fonction : la clé n’est donc pas encore disponible.The container hasn't yet been published to a function app in Azure, however, so the key isn't yet available. Si vous voulez effectuer tester localement, arrêtez Docker, changez la propriété d’autorisation en "authLevel": "anonymous", regénérez l’image, puis redémarrez Docker.If you want to test locally, stop docker, change the authorization property to "authLevel": "anonymous", rebuild the image, and restart docker. Ensuite, réinitialisez "authLevel": "function" dans function.json.Then reset "authLevel": "function" in function.json. Pour plus d’informations, consultez Clés d’autorisation.For more information, see authorization keys.

    Image d’espace réservé indiquant que le conteneur s’exécute localement

  5. Une fois que vous avez vérifié l’application de fonction dans le conteneur, arrêtez Docker avec Ctrl+C.After you have verified the function app in the container, stop docker with Ctrl+C.

Envoyer (push) l’image sur Docker HubPush the image to Docker Hub

Docker Hub est un registre de conteneurs qui héberge des images, et qui fournit des services d’image et de conteneur.Docker Hub is a container registry that hosts images and provides image and container services. Pour partager votre image, ce qui inclut un déploiement sur Azure, vous devez l’envoyer dans un registre.To share your image, which includes deploying to Azure, you must push it to a registry.

  1. Si vous ne vous êtes pas déjà connecté à Docker, utilisez la commande docker login, en remplaçant <docker_id> par votre ID Docker.If you haven't already signed in to Docker, do so with the docker login command, replacing <docker_id> with your Docker ID. Cette commande vous invite à entrer votre nom d’utilisateur et votre mot de passe.This command prompts you for your username and password. Un message « Connexion réussie » confirme que vous êtes connecté.A "Login Succeeded" message confirms that you're signed in.

    docker login
    
  2. Une fois connecté, envoyez l’image à Docker Hub en utilisant la commande docker push, en remplaçant à nouveau <docker_id> par votre ID Docker.After you've signed in, push the image to Docker Hub by using the docker push command, again replacing <docker_id> with your Docker ID.

    docker push <docker_id>/azurefunctionsimage:v1.0.0
    
  3. Selon la rapidité de votre réseau, le premier initial de l’image peut prendre quelques minutes (l’envoi des modifications suivantes est beaucoup plus rapide).Depending on your network speed, pushing the image the first time might take a few minutes (pushing subsequent changes is much faster). Pendant que vous attendez, vous pouvez passer à la section suivante et créer des ressources Azure dans un autre terminal.While you're waiting, you can proceed to the next section and create Azure resources in another terminal.

Créer des ressources Azure de support pour votre fonctionCreate supporting Azure resources for your function

Pour déployer votre code de fonction sur Azure, vous devez créer trois ressources :To deploy your function code to Azure, you need to create three resources:

  • Un groupe de ressources, qui est un conteneur logique pour les ressources associées.A resource group, which is a logical container for related resources.
  • Un compte de stockage Azure, qui conserve l’état et d’autres informations spécifiques à vos projets.An Azure Storage account, which maintains state and other information about your projects.
  • Une application Azure Functions, qui fournit l’environnement d’exécution de votre code de fonction.An Azure functions app, which provides the environment for executing your function code. Une application de fonction est mappée à votre projet de fonction local. Elle vous permet de regrouper les fonctions en tant qu’unité logique pour faciliter la gestion, le déploiement et le partage des ressources.A function app maps to your local function project and lets you group functions as a logical unit for easier management, deployment, and sharing of resources.

Vous utilisez les commandes Azure CLI pour créer ces éléments.You use Azure CLI commands to create these items. Chaque commande fournit une sortie JSON une fois l’opération terminée.Each command provides JSON output upon completion.

  1. Connectez-vous à Azure avec la commande az login :Sign in to Azure with the az login command:

    az login
    
  2. Créez un groupe de ressources avec la commande az group create.Create a resource group with the az group create command. L’exemple suivant crée un groupe de ressources nommé AzureFunctionsContainers-rg dans la région westeurope.The following example creates a resource group named AzureFunctionsContainers-rg in the westeurope region. (Vous créez généralement votre groupe de ressources et vos ressources dans une région près de chez vous, en utilisant une région disponible à partir de la commande az account list-locations.)(You generally create your resource group and resources in a region near you, using an available region from the az account list-locations command.)

    az group create --name AzureFunctionsContainers-rg --location westeurope
    

    Notes

    Vous ne pouvez pas héberger des applications Linux et Windows dans le même groupe de ressources.You can't host Linux and Windows apps in the same resource group. Si vous disposez d’un groupe de ressources existant nommé AzureFunctionsContainers-rg avec une application de fonction Windows ou une application web, vous devez utiliser un autre groupe de ressources.If you have an existing resource group named AzureFunctionsContainers-rg with a Windows function app or web app, you must use a different resource group.

  3. Créez un compte de stockage universel dans votre groupe de ressources et votre région à l’aide de la commande az storage account create.Create a general-purpose storage account in your resource group and region by using the az storage account create command. Dans l’exemple suivant, remplacez <storage_name> par un nom globalement unique qui vous convient.In the following example, replace <storage_name> with a globally unique name appropriate to you. Les noms doivent contenir entre 3 et 24 caractères, et comporter uniquement des lettres minuscules.Names must contain three to 24 characters numbers and lowercase letters only. Standard_LRS spécifie un compte universel standard.Standard_LRS specifies a typical general-purpose account.

    az storage account create --name <storage_name> --location westeurope --resource-group AzureFunctionsContainers-rg --sku Standard_LRS
    

    Le compte de stockage génère un coût de quelques cents USD seulement pour ce tutoriel.The storage account incurs only a few USD cents for this tutorial.

  4. Utilisez la commande pour créer un plan Premium pour Azure Functions nommé myPremiumPlan dans le niveau tarifaire Elastic Premium 1 (--sku EP1), dans la région Europe Ouest (-location westeurope ou utilisez une région appropriée proche de vous) et dans un conteneur Linux (--is-linux).Use the command to create a Premium plan for Azure Functions named myPremiumPlan in the Elastic Premium 1 pricing tier (--sku EP1), in the West Europe region (-location westeurope, or use a suitable region near you), and in a Linux container (--is-linux).

    az functionapp plan create --resource-group AzureFunctionsContainers-rg --name myPremiumPlan --location westeurope --number-of-workers 1 --sku EP1 --is-linux
    

    L’hébergement Linux pour les conteneurs de fonctions personnalisées est pris en charge sur les plans dédiés (App Service) et les plans Premium.Linux hosting for custom functions containers are supported on Dedicated (App Service) plans and Premium plans. Nous utilisons ici le plan Premium, qui peut être mis à l’échelle en fonction des besoins.We use the Premium plan here, which can scale as needed. Pour en savoir plus sur l’hébergement, consultez Comparaison des plans d’hébergement Azure Functions.To learn more about hosting, see Azure Functions hosting plans comparison. Pour calculer les coûts, consultez la page Tarification d’Azure Functions.To calculate costs, see the Functions pricing page.

    La commande provisionne également une instance Azure Application Insights associée dans le même groupe de ressources, avec laquelle vous pouvez superviser votre application de fonction et visualiser les journaux.The command also provisions an associated Azure Application Insights instance in the same resource group, with which you can monitor your function app and view logs. Pour plus d’informations, consultez Surveiller l’exécution des fonctions Azure.For more information, see Monitor Azure Functions. L’instance n’entraîne aucun coût tant que vous ne l’activez pas.The instance incurs no costs until you activate it.

Créer et configurer une application de fonction sur Azure avec l’imageCreate and configure a function app on Azure with the image

Une application de fonction sur Azure gère l’exécution de vos fonctions dans votre plan d’hébergement.A function app on Azure manages the execution of your functions in your hosting plan. Dans cette section, vous utilisez les ressources Azure de la section précédente pour créer une application de fonction à partir d’une image sur Docker Hub et pour la configurer avec une chaîne de connexion à Stockage Azure.In this section, you use the Azure resources from the previous section to create a function app from an image on Docker Hub and configure it with a connection string to Azure Storage.

  1. Créez l’application de fonction avec la commande az functionapp create.Create the Functions app using the az functionapp create command. Dans l’exemple suivant, remplacez <storage_name> par le nom que vous avez utilisé dans la section précédente pour le compte de stockage.In the following example, replace <storage_name> with the name you used in the previous section for the storage account. Remplacez aussi <app_name> par un nom globalement unique qui vous convient et <docker_id> par votre ID Docker.Also replace <app_name> with a globally unique name appropriate to you, and <docker_id> with your Docker ID.

    az functionapp create --name <app_name> --storage-account <storage_name> --resource-group AzureFunctionsContainers-rg --plan myPremiumPlan --deployment-container-image-name <docker_id>/azurefunctionsimage:v1.0.0
    

    Le paramètre deployment-container-image-name spécifie l’image à utiliser pour l’application de fonction.The deployment-container-image-name parameter specifies the image to use for the function app. Vous pouvez utiliser la commande az functionapp config container show pour voir des informations sur l’image utilisée pour le déploiement.You can use the az functionapp config container show command to view information about the image used for deployment. Vous pouvez aussi utiliser la commande az functionapp config container set pour déployer à partir d’une autre image.You can also use the az functionapp config container set command to deploy from a different image.

  2. Récupérez la chaîne de connexion pour le compte de stockage que vous avez créé avec la commande az storage account show-connection-string, en l’affectant à une variable de shell storageConnectionString :Retrieve the connection string for the storage account you created by using the az storage account show-connection-string command, assigning it to a shell variable storageConnectionString:

    az storage account show-connection-string --resource-group AzureFunctionsContainers-rg --name <storage_name> --query connectionString --output tsv
    
  3. Ajoutez ce paramètre à l’application de fonction à l’aide de la commande az functionapp config appsettings set.Add this setting to the function app by using the az functionapp config appsettings set command. Dans la commande suivante, remplacez <app_name> par le nom de votre application de fonction et <connection_string> par la chaîne de connexion récupérée à l’étape précédente (une longue chaîne codée qui commence par « DefaultEndpointProtocol= ») :In the following command, replace <app_name> with the name of your function app, and replace <connection_string> with the connection string from the previous step (a long encoded string that begins with "DefaultEndpointProtocol="):

    az functionapp config appsettings set --name <app_name> --resource-group AzureFunctionsContainers-rg --settings AzureWebJobsStorage=<connection_string>
    
  4. La fonction peut maintenant utiliser cette chaîne de connexion pour accéder au compte de stockage.The function can now use this connection string to access the storage account.

Conseil

Dans bash, vous pouvez utiliser une variable de shell pour capturer la chaîne de connexion, au lieu d’utiliser le Presse-papiers.In bash, you can use a shell variable to capture the connection string instead of using the clipboard. Pour commencer, utilisez la commande suivante pour créer une variable avec la chaîne de connexion :First, use the following command to create a variable with the connection string:

storageConnectionString=$(az storage account show-connection-string --resource-group AzureFunctionsContainers-rg --name <storage_name> --query connectionString --output tsv)

Ensuite, référencez la variable dans la deuxième commande :Then refer to the variable in the second command:

az functionapp config appsettings set --name <app_name> --resource-group AzureFunctionsContainers-rg --settings AzureWebJobsStorage=$storageConnectionString

Notes

Si vous publiez votre image personnalisée sur un compte de conteneur privé, vous devez utiliser à la place des variables d’environnement dans le Dockerfile pour la chaîne de connexion.If you publish your custom image to a private container account, you should use environment variables in the Dockerfile for the connection string instead. Pour plus d’informations, consultez l’instruction ENV.For more information, see the ENV instruction. Vous devez également définir les variables DOCKER_REGISTRY_SERVER_USERNAME et DOCKER_REGISTRY_SERVER_PASSWORD.You should also set the variables DOCKER_REGISTRY_SERVER_USERNAME and DOCKER_REGISTRY_SERVER_PASSWORD. Pour utiliser les valeurs, vous devez regénérer l’image, envoyer l’image vers le registre, puis redémarrer l’application de fonction sur Azure.To use the values, then, you must rebuild the image, push the image to the registry, and then restart the function app on Azure.

Vérifier vos fonctions sur AzureVerify your functions on Azure

Avec l’image déployée sur l’application de fonction sur Azure, vous pouvez désormais appeler la fonction via des requêtes HTTP.With the image deployed to the function app on Azure, you can now invoke the function through HTTP requests. Comme la définition de function.json inclut la propriété "authLevel": "function", vous devez d’abord obtenir la clé d’accès (également appelée « clé de fonction ») et l’inclure en tant que paramètre d’URL dans toutes les requêtes adressées au point de terminaison.Because the function.json definition includes the property "authLevel": "function", you must first obtain the access key (also called the "function key") and include it as a URL parameter in any requests to the endpoint.

  1. Récupérez l’URL de la fonction avec la clé (de fonction) d’accès en utilisant le portail Azure ou Azure CLI avec la commande az rest.Retrieve the function URL with the access (function) key by using the Azure portal, or by using the Azure CLI with the az rest command.)

    1. Connectez-vous au portail Azure, puis recherchez votre application de fonction en entrant son nom dans la zone Rechercher en haut de la page.Sign in to the Azure portal, then locate your function app by entering your function app name in the Search box at the top of the page. Dans les résultats, sélectionnez la ressource App Service.In the results, select the App Service resource.

    2. Dans le volet de navigation gauche, sous Fonctions (lecture seule) , sélectionnez le nom de votre fonction.In the left navigation panel, under Functions (Read Only), select the name of your function.

    3. Dans le volet d’informations, sélectionnez </> Obtenir l’URL de la fonction :In the details panel, select </> Get function URL:

      La commande Obtenir l’URL de la fonction sur le portail Azure

    4. Dans la fenêtre contextuelle, sélectionnez Par défaut (clé de fonction) puis Copier.In the popup, select default (Function key) and then Copy. La clé est la chaîne de caractères qui suit ?code=.The key is the string of characters following ?code=.

      Copie de l’URL de la fonction à partir du portail Azure

    Notes

    Dans la mesure où votre application de fonction est déployée en tant que conteneur, vous ne pouvez pas apporter de modifications à votre code de fonction dans le portail.Because your function app is deployed as a container, you can't make changes to your function code in the portal. Vous devez à la place mettre à jour le projet dans l’image locale, envoyer à nouveau l’image vers le registre, puis redéployer sur Azure.You must instead update the project in the local image, push the image to the registry again, and then redeploy to Azure. Vous pouvez configurer le déploiement continu dans une section ultérieure.You can set up continuous deployment in a later section.

  2. Collez l’URL de la fonction dans la barre d’adresse de votre navigateur, en ajoutant le paramètre &name=Azure à la fin de cette URL.Paste the function URL into your browser's address bar, adding the parameter &name=Azure to the end of this URL. Un texte similaire à « Hello Azure » doit apparaître dans le navigateur.Text like "Hello Azure" should appear in the browser.

    Réponse de la fonction dans le navigateur.

  3. Pour tester l’autorisation, supprimez le paramètre code= de l’URL et vérifiez que vous ne recevez pas de réponse de la fonction.To test authorization, remove the code= parameter from the URL and verify that you get no response from the function.

Activer le déploiement continu sur AzureEnable continuous deployment to Azure

Vous pouvez activer Azure Functions pour mettre à jour automatiquement votre déploiement d’une image chaque fois que vous mettez à jour l’image dans le registre.You can enable Azure Functions to automatically update your deployment of an image whenever you update the image in the registry.

  1. Activez le déploiement continu avec la commande az functionapp deployment container config, en remplaçant <app_name> par le nom de votre application de fonction :Enable continuous deployment by using az functionapp deployment container config command, replacing <app_name> with the name of your function app:

    az functionapp deployment container config --enable-cd --query CI_CD_URL --output tsv --name <app_name> --resource-group AzureFunctionsContainers-rg
    

    Cette commande active le déploiement continu et retourne l’URL du webhook de déploiement.This command enables continuous deployment and returns the deployment webhook URL. (Vous pouvez récupérer cette URL ultérieurement avec la commande az functionapp deployment container show-cd-url.)(You can retrieve this URL at any later time by using the az functionapp deployment container show-cd-url command.)

  2. Copiez l’URL du webhook de déploiement dans le Presse-papiers.Copy the deployment webhook URL to the clipboard.

  3. Ouvrez Docker Hub, connectez-vous, puis sélectionnez Référentiels dans la barre de navigation.Open Docker Hub, sign in, and select Repositories on the nav bar. Recherchez et sélectionnez l’image, sélectionnez l’onglet Webhooks, spécifiez un Nom de webhook, collez votre URL dans URL du webhook, puis sélectionnez Créer :Locate and select image, select the Webhooks tab, specify a Webhook name, paste your URL in Webhook URL, and then select Create:

    Ajoutez le webhook à votre référentiel DockerHub

  4. Avec le webhook défini, Azure Functions redéploie votre image chaque fois que vous la mettez à jour dans Docker Hub.With the webhook set, Azure Functions redeploys your image whenever you update it in Docker Hub.

Activer les connexions SSHEnable SSH connections

SSH permet d’établir une communication sécurisée entre un conteneur et un client.SSH enables secure communication between a container and a client. Avec le protocole SSH activé, vous pouvez vous connecter à votre conteneur en utilisant App Service Advanced Tools (Kudu).With SSH enabled, you can connect to your container using App Service Advanced Tools (Kudu). Pour faciliter la connexion à votre conteneur via SSH, Azure Functions fournit une image de base pour laquelle SSH est déjà activé.To make it easy to connect to your container using SSH, Azure Functions provides a base image that has SSH already enabled. Vous devez seulement modifier votre Dockerfile, puis regénérer et redéployer l’image.You need only edit your Dockerfile, then rebuild and redeploy the image. Vous pouvez ensuite vous connecter au conteneur via les outils avancés (Kudu).You can then connect to the container through the Advanced Tools (Kudu)

  1. Dans votre Dockerfile, ajoutez la chaîne -appservice à l’image de base dans votre instruction FROM :In your Dockerfile, append the string -appservice to the base image in your FROM instruction:

    FROM microsoft/dotnet:2.2-sdk-appservice AS installer-env
    
    FROM mcr.microsoft.com/azure-functions/node:2.0-appservice
    
    FROM mcr.microsoft.com/azure-functions/powershell:2.0-appservice
    
    FROM mcr.microsoft.com/azure-functions/python:2.0-python3.7-appservice
    
    FROM mcr.microsoft.com/azure-functions/node:2.0-appservice
    

    Les différences entre les images de base sont décrites dans le tutoriel App Services - Images Docker personnalisées.The differences between the base images are described in the App Services - Custom docker images tutorial.

  2. Regénérez l’image avec la commande docker build, en remplaçant <docker_id> par votre ID Docker :Rebuild the image by using the docker build command again, replacing <docker_id> with your Docker ID:

    docker build --tag <docker_id>/azurefunctionsimage:v1.0.0 .
    
  3. Envoyez l’image mise à jour sur Docker Hub, ce qui doit prendre beaucoup moins de temps que lors du premier envoi : seuls les segments mis à jour de l’image doivent être chargés.Push the updated image to Docker Hub, which should take considerably less time than the first push only the updated segments of the image need to be uploaded.

    docker push <docker_id>/azurefunctionsimage:v1.0.0
    
  4. Azure Functions redéploie automatiquement l’image sur votre application de fonctions ; le processus prend moins d’une minute.Azure Functions automatically redeploys the image to your functions app; the process takes place in less than a minute.

  5. Dans un navigateur, ouvrez https://<app_name>.scm.azurewebsites.net/ (remplacez <app_name> par votre nom unique).In a browser, open https://<app_name>.scm.azurewebsites.net/, replacing <app_name> with your unique name. Cette URL est le point de terminaison des outils avancés (Kudu) pour votre conteneur d’application de fonction.This URL is the Advanced Tools (Kudu) endpoint for your function app container.

  6. Connectez-vous à votre compte Azure, puis sélectionnez SSH pour établir une connexion avec votre conteneur.Sign in to your Azure account, and then select the SSH to establish a connection with the container. La connexion peut prendre quelques instants si Azure est toujours en train de mettre à jour l’image conteneur.Connecting may take a few moments if Azure is still in the process of updating the container image.

  7. Une fois la connexion établie avec votre conteneur, exécutez la commande top pour voir les processus en cours d’exécution.After a connection is established with your container, run the top command to view the currently running processes.

    Commande top Linux s’exécutant dans une session SSH

Écrire dans une file d’attente Stockage AzureWrite to an Azure Storage queue

Azure Functions vous permet de connecter vos fonctions à d’autres services et ressources Azure sans devoir écrire votre propre code d’intégration.Azure Functions lets you connect your functions to other Azure services and resources having to write your own integration code. Ces liaisons, qui représentent l’entrée et la sortie, sont déclarées dans la définition de la fonction.These bindings, which represent both input and output, are declared within the function definition. Les données issues des liaisons sont fournies à la fonction en tant que paramètres.Data from bindings is provided to the function as parameters. Un déclencheur est un type spécial de liaison d’entrée.A trigger is a special type of input binding. Si une fonction ne peut avoir qu’un seul déclencheur, elle peut avoir plusieurs liaisons d’entrée et de sortie.Although a function has only one trigger, it can have multiple input and output bindings. Pour en savoir plus, consultez Concepts des déclencheurs et liaisons Azure Functions.To learn more, see Azure Functions triggers and bindings concepts.

Cette section vous montre comment intégrer votre fonction à une file d’attente de stockage Azure.This section shows you how to integrate your function with an Azure Storage queue. La liaison de sortie que vous ajoutez à cette fonction écrit des données d’une requête HTTP dans un message en file d’attente.The output binding that you add to this function writes data from an HTTP request to a message in the queue.

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.

Ajoutez une liaison de sortie à function.jsonAdd an output binding to function.json

Dans Azure Functions, chaque type de liaison nécessite la définition d’une direction, d’un type et d’un name unique dans le fichier function.json.In Azure Functions, each type of binding requires a direction, type, and a unique name to be defined in the function.json file. Votre function.json contient déjà une liaison d’entrée pour le type « httpTrigger » et une liaison de sortie pour la réponse HTTP.Your function.json already includes an input binding for the "httpTrigger" type and an output binding for the HTTP response. Pour ajouter une liaison à une file d’attente de stockage, modifiez le fichier comme suit, ce qui ajoute une liaison de sortie pour le type « queue » (file d’attente), où la file d’attente apparaît dans le code sous la forme d’un argument d’entrée nommé msg.To add a binding to a storage queue, modify the file as follows, which adds an output binding for the "queue" type, where the queue appears in the code as an input argument named msg. La liaison de file d’attente nécessite également le nom de la file d’attente à utiliser, dans le cas présent outqueue, et le nom du paramètre qui contient la chaîne de connexion, dans le cas présent AzureWebJobStorage.The queue binding also requires the name of the queue to use, in this case outqueue, and the name of the settings that holds the connection string, in this case AzureWebJobStorage.

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 est ensuite généré automatiquement en fonction de ces attributs.The function.json file is then autogenerated based on these attributes.

  1. Pour la liaison de file d’attente, exécutez la commande dotnet add package suivante pour ajouter le package d’extension de Stockage à votre projet.For the queue binding, run the following dotnet add package command to add the Storage extension package to your project.

    dotnet add package Microsoft.Azure.WebJobs.Extensions.Storage --version 3.0.4
    
  2. Ouvrez le fichier HttpTrigger.cs et ajoutez l’instruction using suivante :Open the HttpTrigger.cs file and add the following using statement:

    using Microsoft.Azure.WebJobs.Extensions.Storage;
    
  3. Ajoutez le paramètre suivant à la définition de la méthode Run :Add the following parameter to the Run method definition:

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

    La définition de la méthode Run doit maintenant correspondre au code suivant :The Run method definition should now match the following code:

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

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're already using the default storage account.

Mettez à jour function.json comme ceci en ajoutant la liaison de file d’attente après la liaison HTTP :Update function.json to match the following by adding the queue binding after the HTTP binding:

{
  "bindings": [
    {
      "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"
    }
  ]
}

Mettez à jour function.json comme ceci en ajoutant la liaison de file d’attente après la liaison HTTP :Update function.json to match the following by adding the queue binding after the HTTP binding:

{
  "bindings": [
    {
      "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"
    }
  ]
}

Mettez à jour function.json comme ceci en ajoutant la liaison de file d’attente après la liaison HTTP :Update function.json to match the following by adding the queue binding after the HTTP binding:

{
  "scriptFile": "__init__.py",
  "bindings": [
    {
      "authLevel": "function",
      "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"
    }
  ]
}

Mettez à jour function.json comme ceci en ajoutant la liaison de file d’attente après la liaison HTTP :Update function.json to match the following by adding the queue binding after the HTTP binding:

{
  "bindings": [
    {
      "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"
    }
  ]
}

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

Une fois la liaison définie, le nom de la liaison, dans le cas présent msg, apparaît dans le code de la fonction en tant qu’argument (ou dans l’objet context en JavaScript et en TypeScript).After the binding is defined, the name of the binding, in this case msg, appears in the function code as an argument (or in the context object in JavaScript and TypeScript). Vous pouvez ensuite utiliser cette variable pour écrire des messages dans la file d’attente.You can then use that variable to write messages to the queue. Vous ne devez écrire aucun code pour l’authentification, pour obtenir une référence à une file d’attente ou pour écrire des données.You 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.

[FunctionName("HttpTrigger")]
public static async Task<IActionResult> Run(
    [HttpTrigger(AuthorizationLevel.Function, "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");
}
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.
        context.bindings.msg = "Name passed to the function: " +
            (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"
        };
    }
};
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) {
    $outputMsg = "Name passed to the function: $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
})
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
        )
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.
        context.bindings.msg = "Name passed to the function: " +
            (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"
        };
    }
};

export default httpTrigger;

Mettre à jour l’image dans le registreUpdate the image in the registry

  1. Dans le dossier racine, réexécutez la commande docker build et mettez cette fois à jour la version dans l’étiquette vers v1.0.1.In the root folder, run docker build again, and this time update the version in the tag to v1.0.1. Comme précédemment, remplacez <docker_id> par votre ID de compte Docker Hub :As before, replace <docker_id> with your Docker Hub account ID:

    docker build --tag <docker_id>/azurefunctionsimage:v1.0.1
    
  2. Envoyez l’image mise à jour dans le référentiel avec docker push :Push the updated image back to the repository with docker push:

    docker push <docker_id>/azurefunctionsimage:v1.0.1
    
  3. Comme vous avez configuré la livraison continue, la mise à jour de l’image dans le registre met à jour automatiquement votre application de fonction dans Azure.Because you configured continuous delivery, updating the image in the registry again automatically updates your function app in Azure.

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

Dans un navigateur, utilisez la même URL qu’auparavant pour appeler votre fonction.In a browser, use the same URL as before to invoke your function. Le navigateur doit afficher la même réponse qu’auparavant, car vous n’avez pas modifié cette partie du code de la fonction.The browser should display the same response as before, because you didn't modify that part of the function code. Le code ajouté a cependant écrit un message en utilisant le paramètre d’URL name dans la file d’attente de stockage outqueue.The added code, however, wrote a message using the name URL parameter to the outqueue 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, comme indiqué dans 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 <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 <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.)

    AZURE_STORAGE_CONNECTION_STRING="<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 peek pour voir les messages de cette file d’attente, laquelle doit correspondre au premier nom que vous avez utilisé quand vous avez testé la fonction.Use the az storage message peek command to view the messages in this queue, which should be the first name you used when testing the function earlier. La commande récupère le premier message de la file d’attente au format d’encodage base64. Vous devez donc également décoder le message pour le voir sous forme de texte.The command retrieves the first message in the queue in base64 encoding, so you must also decode the message to view as text.

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

Nettoyer les ressourcesClean up resources

Si vous voulez continuer à utiliser Azure Functions en utilisant les ressources que vous avez créées dans ce tutoriel, vous pouvez conserver toutes ces ressources en place.If you want to continue working with Azure Function using the resources you created in this tutorial, you can leave all those resources in place. Comme vous avez créé un plan Premium pour Azure Functions, un ou deux dollars US vous seront facturés quotidiennement.Because you created a Premium Plan for Azure Functions, you'll incur one or two USD per day in ongoing costs.

Pour éviter ces frais récurrents, supprimez le groupe de ressources AzureFunctionsContainer-rg pour supprimer toutes les ressources de ce groupe :To avoid ongoing costs, delete the AzureFunctionsContainer-rg resource group to clean up all the resources in that group:

az group delete --name AzureFunctionsContainer-rg

Étapes suivantesNext steps