Partager via

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

  • Article

Cet exemple démontre comment utiliser les bibliothèques Azure management 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é depuis un référentiel 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 des exemples, veuillez consulter la section Démarrage rapide : Déployez 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 : Configurez votre environnement de développement local

Si vous ne l’avez pas encore fait, configurez un environnement où vous pouvez exécuter ce code. Voici quelques options possibles :

2 : Installez les packages de bibliothèques 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 : Forkez le référentiel d’exemple

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 un fork pour vous assurer que vous avez les permissions de déployer le référentiel sur Azure.

Duplication (fork) de l’exemple de référentiel sur 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 : Écrivez le 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. Assurez-vous de définir les variables d’environnement REPO_URL et AZURE_SUBSCRIPTION_ID 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. En fonction de 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 VM), utilisez DefaultAzureCredential (recommandé) avec une méthode basée sur un principal du service comme décrit dans Comment authentifier les applications Python avec les services Azure.

5 : Exécutez le script.

python provision_deploy_web_app.py

6 : Vérifiez 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 (option --name) et le nom du groupe de ressources (option --resource-group) par les valeurs que vous avez utilisées dans le script. Vous devriez voir « Hello, World! » dans le navigateur.

Si vous ne voyez pas le résultat attendu, attendez quelques minutes et réessayez.

Si vous ne voyez toujours pas le résultat attendu, alors :

  1. Accédez au portail Azure.
  2. Sélectionnez Groupes de ressources, et trouvez le groupe de ressources que vous avez créé.
  3. Sélectionnez le nom du groupe de ressources pour afficher les ressources qu’il contient. Vérifiez spécifiquement qu’il y a un App Service Plan et l’App Service.
  4. Sélectionnez l’App Service, puis sélectionnez Centre de déploiement.
  5. Sélectionnez l’onglet logs pour afficher les journaux de déploiement.

7 : Redéployez le code de l’application web (optionnel)

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

Le script appelle la méthode WebSiteManagementClient.web_apps.sync_repository pour déclencher un tirage de l’application web. Si vous poussez des modifications de code ultérieures vers votre référentiel, vous pouvez redéployer votre code en invoquant cette API ou en utilisant d’autres outils Azure comme Azure CLI ou Azure portal.

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 (option --name) et le nom du groupe de ressources (option --resource-group) par les valeurs que vous avez utilisées dans le script.

Pour déployer votre code depuis Azure portal :

  1. Accédez au portail Azure.
  2. Sélectionnez Groupes de ressources, et trouvez le groupe de ressources que vous avez créé.
  3. Sélectionnez le nom du groupe de ressources pour afficher les ressources qu’il contient. Vérifiez spécifiquement qu’il y a un App Service Plan et l’App Service.
  4. Sélectionnez l’App Service, puis sélectionnez Centre de déploiement.
  5. Dans le menu supérieur, sélectionnez Sync pour déployer votre code.

8 : Nettoyez 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