Exemple : Utiliser les bibliothèques Azure pour créer et déployer une application web

  • Article

Cet exemple montre comment utiliser les bibliothèques de gestion du Kit de développement logiciel (SDK) Azure dans un script Python pour créer et déployer une application web sur Azure App Service. Le code de l’application est déployé à partir d’un dépôt GitHub.

Avec les bibliothèques de gestion (espaces de noms commençant par azure-mgmt, par exemple, azure-mgmt-web), vous pouvez écrire des programmes de configuration et de déploiement pour effectuer les mêmes tâches que celles que vous pouvez effectuer via le portail Azure, l’interface de ligne de commande Azure, ou d'autres outils de gestion des ressources. Pour obtenir des exemples, consultez Démarrage rapide : Déployer une application web Python (Django ou Flask) sur Azure App Service. (Les commandes Azure CLI équivalentes sont fournies plus loin dans cet article.)

Sauf indication contraire, toutes les commandes de cet article fonctionnent de la même façon dans les interpréteurs de commandes Windows et bash Linux/macOS.

1 : Configurer votre environnement de développement local

Si ce n’est déjà fait, configurez un environnement dans lequel vous pouvez exécuter ce code. Voici quelques options possibles :

2 : Installer les packages de bibliothèque Azure requis

Créez un fichier nommé requirements.txt avec le contenu suivant :

azure-mgmt-resource
azure-mgmt-web
azure-identity

Dans un terminal ou une invite de commandes avec l’environnement virtuel activé, installez les éléments requis :

pip install -r requirements.txt

3 : Fourchez l’exemple de référentiel

Rendez-vous sur https://github.com/Azure-Samples/python-docs-hello-world et dupliquer (fork) le référentiel dans votre propre compte GitHub. Vous utiliserez une duplication pour vous assurer que vous disposez des autorisations nécessaires pour déployer le référentiel sur Azure.

Forking the sample repository on GitHub

Créez ensuite une variable d’environnement nommée REPO_URL avec l’URL de votre fourche. L’exemple de code de la section suivante dépend de cette variable d’environnement :

set REPO_URL=<url_of_your_fork>
set AZURE_SUBSCRIPTION_ID=<subscription_id>

4 : Écrire du code pour créer et déployer une application web

Créez un fichier Python nommé provision_deploy_web_app.py avec le code suivant. Les commentaires expliquent les détails du code. Veillez à définir les variables d’environnement et AZURE_SUBSCRIPTION_ID les REPO_URL variables d’environnement avant d’exécuter le script.

import random, os
from azure.identity import AzureCliCredential
from azure.mgmt.resource import ResourceManagementClient
from azure.mgmt.web import WebSiteManagementClient

# Acquire a credential object using CLI-based authentication.
credential = AzureCliCredential()

# Retrieve subscription ID from environment variable
subscription_id = os.environ["AZURE_SUBSCRIPTION_ID"]

# Constants we need in multiple places: the resource group name and the region
# in which we provision resources. You can change these values however you want.
RESOURCE_GROUP_NAME = 'PythonAzureExample-WebApp-rg'
LOCATION = "centralus"

# Step 1: Provision the resource group.
resource_client = ResourceManagementClient(credential, subscription_id)

rg_result = resource_client.resource_groups.create_or_update(RESOURCE_GROUP_NAME,
    { "location": LOCATION })

print(f"Provisioned resource group {rg_result.name}")

# For details on the previous code, see Example: Provision a resource group
# at https://docs.microsoft.com/azure/developer/python/azure-sdk-example-resource-group


#Step 2: Provision the App Service plan, which defines the underlying VM for the web app.

# Names for the App Service plan and App Service. We use a random number with the
# latter to create a reasonably unique name. If you've already provisioned a
# web app and need to re-run the script, set the WEB_APP_NAME environment 
# variable to that name instead.
SERVICE_PLAN_NAME = 'PythonAzureExample-WebApp-plan'
WEB_APP_NAME = os.environ.get("WEB_APP_NAME", f"PythonAzureExample-WebApp-{random.randint(1,100000):05}")

# Obtain the client object
app_service_client = WebSiteManagementClient(credential, subscription_id)

# Provision the plan; Linux is the default
poller = app_service_client.app_service_plans.begin_create_or_update(RESOURCE_GROUP_NAME,
    SERVICE_PLAN_NAME,
    {
        "location": LOCATION,
        "reserved": True,
        "sku" : {"name" : "B1"}
    }
)

plan_result = poller.result()

print(f"Provisioned App Service plan {plan_result.name}")


# Step 3: With the plan in place, provision the web app itself, which is the process that can host
# whatever code we want to deploy to it.

poller = app_service_client.web_apps.begin_create_or_update(RESOURCE_GROUP_NAME,
    WEB_APP_NAME,
    {
        "location": LOCATION,
        "server_farm_id": plan_result.id,
        "site_config": {
            "linux_fx_version": "python|3.8"
        }
    }
)

web_app_result = poller.result()

print(f"Provisioned web app {web_app_result.name} at {web_app_result.default_host_name}")

# Step 4: deploy code from a GitHub repository. For Python code, App Service on Linux runs
# the code inside a container that makes certain assumptions about the structure of the code.
# For more information, see How to configure Python apps,
# https://docs.microsoft.com/azure/app-service/containers/how-to-configure-python.
#
# The create_or_update_source_control method doesn't provision a web app. It only sets the
# source control configuration for the app. In this case we're simply pointing to
# a GitHub repository.
#
# You can call this method again to change the repo.

REPO_URL = os.environ["REPO_URL"]

poller = app_service_client.web_apps.begin_create_or_update_source_control(RESOURCE_GROUP_NAME,
    WEB_APP_NAME, 
    { 
        "location": "GitHub",
        "repo_url": REPO_URL,
        "branch": "master",
        "is_manual_integration": True
    }
)

sc_result = poller.result()

print(f"Set source control on web app to {sc_result.branch} branch of {sc_result.repo_url}")

# Step 5: Deploy the code using the repository and branch configured in the previous step.
#
# If you push subsequent code changes to the repo and branch, you must call this method again
# or use another Azure tool like the Azure CLI or Azure portal to redeploy. 
# Note: By default, the method returns None.

app_service_client.web_apps.sync_repository(RESOURCE_GROUP_NAME, WEB_APP_NAME)

print(f"Deploy code")

Ce code utilise l’authentification basée sur CLI (en utilisant AzureCliCredential), car il montre les actions que vous pourriez autrement faire directement à l’aide d’Azure CLI. Dans les deux cas, vous utilisez la même identité pour l’authentification. Selon votre environnement, vous devrez peut-être exécuter az login en premier pour vous authentifier.

Pour utiliser ce type de code dans un script de production (par exemple, pour automatiser la gestion des machines virtuelles), utilisez DefaultAzureCredential (recommandé) avec une méthode basée sur un principal de service, comme décrit dans Comment authentifier des applications Python avec des services Azure.

5 : Exécuter le script

python provision_deploy_web_app.py

6 : Vérifier le déploiement de l’application web

Rendez-vous sur le site web déployé en exécutant la commande suivante :

az webapp browse --name PythonAzureExample-WebApp-12345 --resource-group PythonAzureExample-WebApp-rg

Remplacez le nom de l’application web (--name option) et le nom du groupe de ressources (--resource-group option) par les valeurs que vous avez utilisées dans le script. Vous devriez voir « Hello, World ! » dans le navigateur.

Si vous ne voyez pas la sortie attendue, patientez quelques minutes et réessayez.

Si vous ne voyez toujours pas la sortie attendue, alors :

  1. Accédez au portail Azure.
  2. Sélectionnez Groupes de ressources, puis recherchez le groupe de ressources que vous avez créé.
  3. Sélectionnez le nom du groupe de ressources pour afficher les ressources qu’il contient. Plus précisément, vérifiez qu’il existe un plan App Service et App Service.
  4. Sélectionnez App Service, puis sélectionnez Centre de déploiement.
  5. Sélectionnez l’onglet Journaux pour afficher les journaux de déploiement.

7 : Redéployer le code de l’application web (facultatif)

Le script configure les ressources nécessaires pour héberger votre application web et définit la source de déploiement sur votre fourche à l’aide de l’intégration manuelle. Avec l’intégration manuelle, vous devez déclencher l’application web pour extraire à partir du référentiel et de la branche configurés.

Le script appelle la méthode WebSiteManagementClient.web_apps.sync_repository pour déclencher une extraction à partir de l’application web. Si vous envoyez des modifications de code ultérieures à votre référentiel, vous pouvez redéployer votre code en appelant cette API ou en utilisant d’autres outils Azure tels qu’Azure CLI ou Portail Azure.

Vous pouvez déployer votre code avec Azure CLI en exécutant la commande az webapp deployment source sync :

az webapp deployment source sync --name PythonAzureExample-WebApp-12345 --resource-group PythonAzureExample-WebApp-rg

Remplacez le nom de l’application web (--name option) et le nom du groupe de ressources (--resource-group option) par les valeurs que vous avez utilisées dans le script.

Pour déployer votre code à partir de Portail Azure :

  1. Accédez au portail Azure.
  2. Sélectionnez Groupes de ressources, puis recherchez le groupe de ressources que vous avez créé.
  3. Sélectionnez le nom du groupe de ressources pour afficher les ressources qu’il contient. Plus précisément, vérifiez qu’il existe un plan App Service et App Service.
  4. Sélectionnez App Service, puis sélectionnez Centre de déploiement.
  5. Dans le menu supérieur, sélectionnez Synchroniser pour déployer votre code.

8 : Nettoyer les ressources

az group delete --name PythonAzureExample-WebApp-rg --no-wait

Exécutez la commande az group delete si vous n’avez pas besoin de conserver le groupe de ressources créé dans cet exemple. Les groupes de ressources n’entraînent pas de frais récurrents dans votre abonnement, mais il est conseillé de nettoyer tout groupe que vous n’utilisez pas activement. L’argument --no-wait permet à la commande de retourner immédiatement un résultat au lieu d’attendre que l’opération se termine.

Vous pouvez également utiliser la méthode ResourceManagementClient.resource_groups.begin_delete pour supprimer un groupe de ressources du code.

Pour référence : commandes Azure CLI équivalentes

Les commandes Azure CLI suivantes réalisent les mêmes étapes d’approvisionnement que le script Python :

rem Replace <your_github_user_name> with the account name of the fork.

set repoUrl=https://github.com/<your_github_user_name>/python-docs-hello-world
set appName=PythonAzureExample-WebApp-%random%

az group create -l centralus -n PythonAzureExample-WebApp-rg

az appservice plan create -n PythonAzureExample-WebApp-plan -g PythonAzureExample-WebApp-rg ^
     --is-linux --sku F1

echo Creating app: %appName%

az webapp create -g PythonAzureExample-WebApp-rg -n %appName% ^
    --plan PythonAzureExample-WebApp-plan --runtime "python|3.8"

rem You can use --deployment-source-url with the first create command. It is shown here
rem to match the sequence of the Python code.

az webapp create -n %appName% -g PythonAzureExample-WebApp-rg ^
    --plan PythonAzureExample-WebApp-plan --runtime "python|3.8" ^
    --deployment-source-url %repoUrl% 

rem The previous command sets up External Git deployment from the specified repository. This 
rem command triggers a pull from the repository.

az webapp deployment source sync --name %appName% --resource-group PythonAzureExample-WebApp-rg

Voir aussi