Condividi tramite

Esempio: usare le librerie di Azure per creare e distribuire un'app Web

Questo esempio illustra come usare le librerie di gestione di Azure SDK in uno script Python per creare e distribuire un'app Web nel servizio app di Azure, con il codice dell'app estratto da un repository GitHub.

Azure SDK per Python include librerie di gestione (spazi dei nomi che iniziano con azure-mgmt) che consentono di automatizzare la configurazione e la distribuzione delle risorse, in modo analogo alle operazioni che è possibile eseguire con il portale di Azure, l'interfaccia della riga di comando di Azure o i modelli di Resource Manager. Per esempi, vedere Avvio rapido: Distribuire un'app Web Python (Django o Flask) nel servizio app di Azure.

1: Configurare l'ambiente di sviluppo locale

Se non è già stato fatto, configurare un ambiente in cui è possibile eseguire questo codice. Ecco alcune opzioni:

  • Configurare un ambiente virtuale Python usando venv o lo strumento preferito. Per iniziare a usare l'ambiente virtuale, assicurarsi di attivarlo. Per installare Python, vedere Installare Python.

    #!/bin/bash
# Create a virtual environment
python -m venv .venv
# Activate the virtual environment
source .venv/Scripts/activate # only required for Windows (Git Bash)

  • Usa un ambiente conda . Per installare Conda, vedere Installare Miniconda.

  • Usare un contenitore di sviluppo in Visual Studio Code o GitHub Codespaces.

2: Installare i pacchetti di libreria di Azure necessari

Creare un file denominato requirements.txt con il contenuto seguente:

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

Nell'ambiente di sviluppo locale installare i requisiti usando il codice seguente:

pip install -r requirements.txt

3: Creare una copia tramite fork del repository di esempio

  1. Visitare https://github.com/Azure-Samples/python-docs-hello-world e creare un fork del repository nel proprio account GitHub. L'uso di un fork garantisce di avere le autorizzazioni necessarie per distribuire l'app in Azure.

    Fare il fork del repository di esempio su GitHub

  2. Creare quindi una variabile di ambiente denominata REPO_URL e impostarla sull'URL del repository copiato tramite fork. Questa variabile è richiesta dal codice di esempio nella sezione successiva.

export REPO_URL=<url_of_your_fork>
export AZURE_SUBSCRIPTION_ID=<subscription_id>

4: Scrivere codice per creare e distribuire un'app Web

Creare un file Python denominato provision_deploy_web_app.py e aggiungere il codice seguente. I commenti in linea illustrano le operazioni che ogni parte dello script esegue. Le REPO_URL variabili di ambiente e AZURE_SUBSCRIPTION_ID devono essere già impostate nel passaggio precedente.

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")

Questo codice usa l'autenticazione basata sull'interfaccia della riga di comando (usando AzureCliCredential) perché illustra le azioni che è possibile eseguire direttamente con l'interfaccia della riga di comando di Azure. In entrambi i casi si usa la stessa identità per l'autenticazione. A seconda dell'ambiente, potrebbe essere necessario eseguire az login prima di eseguire l'autenticazione.

Per usare questo codice in uno script di produzione (ad esempio, per automatizzare la gestione delle macchine virtuali), usare DefaultAzureCredential (scelta consigliata) con un metodo basato sull'entità servizio come descritto in Come autenticare le app Python con i servizi di Azure.

5: Eseguire lo script

python provision_deploy_web_app.py

6: Verificare la distribuzione dell'app Web

Per visualizzare il sito Web distribuito, eseguire il comando seguente:

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

Sostituire il nome dell'app Web (--name) con il valore generato dallo script. Non è necessario modificare il nome del gruppo di risorse (--resource-group) a meno che non sia stato modificato nello script. Quando si apre il sito, verrà visualizzato "Hello, World!" nel tuo browser.

Suggerimento

Se l'output previsto non viene visualizzato, attendere alcuni minuti e riprovare.

Se l'output previsto non viene ancora visualizzato:

  1. Vai al portale di Azure .
  2. Passare a Gruppi di risorse e individuare il gruppo di risorse creato.
  3. Selezionare il gruppo di risorse per visualizzarne le risorse. Assicurarsi che includa sia un piano di servizio app che un servizio app.
  4. Selezionare il servizio app e quindi passare a Centro distribuzione.
  5. Aprire la scheda Log per controllare i log di distribuzione per eventuali errori o aggiornamenti dello stato.

7: Ridistribuire il codice dell'app Web (facoltativo)

Lo script fornisce tutte le risorse necessarie per ospitare la tua applicazione web e configura l'origine di distribuzione in modo da usare il tuo repository derivato tramite integrazione manuale. Con l'integrazione manuale, è necessario attivare manualmente l'app Web per eseguire il pull degli aggiornamenti dal repository e dal ramo specificati.

Lo script usa il metodo WebSiteManagementClient.web_apps.sync_repository per attivare l'app Web per eseguire il pull del codice dal repository. Se si apportano altre modifiche al codice, è possibile ridistribuire chiamando nuovamente questa API o usando altri strumenti di Azure, ad esempio l'interfaccia della riga di comando di Azure o il portale di Azure.

È possibile ridistribuire il codice usando l'interfaccia della riga di comando di Azure eseguendo il comando az webapp deployment source sync :

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

Non è necessario modificare il nome del gruppo di risorse (--resource-group) a meno che non sia stato modificato nello script.

Per distribuire il codice dal portale di Azure:

  1. Vai al portale di Azure .
  2. Passare a Gruppi di risorse e individuare il gruppo di risorse creato.
  3. Selezionare il nome del gruppo di risorse per visualizzarne le risorse. Assicurarsi che includa sia un piano di servizio app che un servizio app.
  4. Selezionare il servizio app e quindi passare a Centro distribuzione.
  5. Nel menu in alto selezionare Sincronizza per attivare la distribuzione del codice.

8: Pulire le risorse

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

Non è necessario modificare il nome del gruppo di risorse (--resource-group opzione ) a meno che non sia stato modificato nello script.

Se il gruppo di risorse creato in questo esempio non è più necessario, è possibile eliminarlo eseguendo il comando az group delete . Anche se i gruppi di risorse non comportano addebiti in corso, è consigliabile pulire le risorse inutilizzate. Utilizzare l'argomento --no-wait per restituire immediatamente il controllo alla riga di comando senza attendere il completamento dell'eliminazione.

È anche possibile eliminare un gruppo di risorse a livello di codice usando il ResourceManagementClient.resource_groups.begin_delete metodo .

Vedere anche