Esercitazione: Uso di Connettore di servizi per creare un'app Django con Postgres nel Servizio app di Azure

Questa esercitazione illustra come distribuire un'app Web Python Django basata sui dati nel Servizio app di Azure e connetterla a un database del server flessibile di Database di Azure per PostgreSQL.

In questa esercitazione verrà usata l'interfaccia della riga di comando di Azure per completare le attività seguenti:

Configurare l'ambiente iniziale

az extension add --name serviceconnector-passwordless --upgrade

az extension add --name serviceconnector-passwordless --upgrade

Clonare o scaricare l'app di esempio

git clone https://github.com/Azure-Samples/serviceconnector-webapp-postgresql-django-passwordless.git

cd serviceconnector-webapp-postgresql-django-passwordless

In questa esercitazione si distribuisce un'app Web Django nel Servizio app di Azure. L'app Web usa un'identità gestita assegnata dal sistema (connessioni senza password) con controllo degli accessi in base al ruolo di Azure per accedere alle risorse Archiviazione di Azure e Database di Azure per PostgreSQL - Server flessibile. Il codice usa la classe DefaultAzureCredential della libreria client di Identità di Azure per Python. La classe DefaultAzureCredential rileva automaticamente che esiste un'identità gestita per il servizio app e la usa per accedere ad altre risorse di Azure.

• Le impostazioni di produzione si trovano nel file azuresite/production.py. Le impostazioni di sviluppo si trovano in azuresite/settings.py.
• L'app usa le impostazioni di produzione quando la variabile di ambiente WEBSITE_HOSTNAME è impostata. Il Servizio app di Azure imposta automaticamente questa variabile sull'URL dell'app Web, come msdocs-django.azurewebsites.net.

Le impostazioni di produzione sono specifiche per la configurazione di Django per l'esecuzione in qualsiasi ambiente di produzione e non sono peculiari del Servizio app. Per altre informazioni, vedere l'elenco di controllo per la distribuzione di Django. Vedere anche Impostazioni di produzione per le app Django per informazioni dettagliate su alcune delle modifiche.

Problemi? Segnalarli.

Creare un database Postgres in Azure

1. Configurare le variabili di ambiente necessarie per l'esercitazione.

   LOCATION="eastus"
   RAND_ID=$RANDOM
   RESOURCE_GROUP_NAME="msdocs-mi-web-app"
   APP_SERVICE_NAME="msdocs-mi-web-$RAND_ID"
   DB_SERVER_NAME="msdocs-mi-postgres-$RAND_ID"
   ADMIN_USER="demoadmin"
   ADMIN_PW="{your database password}"
   

   Importante

   ADMIN_PW deve contenere da 8 a 128 caratteri di tre delle categorie seguenti: lettere maiuscole, lettere minuscole, numeri e caratteri non alfanumerici. Quando si creano nomi utente o password non usare il carattere $. Successivamente, si creano variabili di ambiente con questi valori, in cui il carattere $ ha un significato specifico all'interno del contenitore Linux usato per eseguire le app Python.

2. Creare un gruppo di risorse (è possibile modificare il nome, se necessario). Il nome del gruppo di risorse viene memorizzato nella cache e applicato automaticamente ai comandi successivi.

   az group create --name $RESOURCE_GROUP_NAME --location $LOCATION
   

3. Creare il server di database. Se viene richiesto di abilitare l'accesso all'indirizzo IP client corrente, digitare y per sì. Questo processo richiede alcuni minuti:

   az postgres flexible-server create \
     --resource-group $RESOURCE_GROUP_NAME \
     --name $DB_SERVER_NAME \
     --location $LOCATION \
     --admin-user $ADMIN_USER \
     --admin-password $ADMIN_PW \
     --sku-name Standard_D2ds_v4
     --active-directory-auth Enabled
   

   Se il comando az non viene riconosciuto, verificare di aver installato l'interfaccia della riga di comando di Azure come descritto in Configurare l'ambiente iniziale.

   Il comando az postgres flexible-server create esegue le azioni seguenti, che richiedono alcuni minuti:

   • Creare un gruppo di risorse predefinito se non è già presente un nome memorizzato nella cache.
   • Creare un server flessibile PostgreSQL:
     • Con il nome del server specificato con il parametro --name. Il nome deve essere univoco in Azure.
     • Con lo SKU specificato con il parametro --sku-name.
   • Creare un account amministratore con un nome utente e una password specificati con i parametri --admin-user e --admin-password.
   • Creare un database con il nome specificato con il parametro --database-name.

4. Configurare una regola del firewall nel server con il comando az postgres flexible-server firewall-rule create. Questa regola consente all'ambiente locale di accedere al server. Se viene richiesto di abilitare l'accesso dall'indirizzo IP client nel passaggio precedente, è possibile ignorare questo passaggio.

   IP_ADDRESS=<your IP>
   az postgres flexible-server firewall-rule create \
      --resource-group $RESOURCE_GROUP_NAME \
      --name $DB_SERVER_NAME \
      --rule-name AllowMyIP \
      --start-ip-address $IP_ADDRESS \
      --end-ip-address $IP_ADDRESS
   

   Usare qualsiasi strumento o sito Web che mostri l'indirizzo IP per sostituire <your IP> nel comando. Ad esempio, è possibile usare il sito Web What's My IP Address?

5. Creare un database denominato restaurant usando il comando az postgres flexible-server execute.

   az postgres flexible-server execute \
     --name $DB_SERVER_NAME \
     --admin-user $ADMIN_USER \
     --admin-password $ADMIN_PW \
     --database-name postgres \
     --querytext 'create database restaurant;'
   

Distribuire il codice nel Servizio app di Azure

In questa sezione si crea l'host delle app nell'app del Servizio app, si connette questa app al database Postgres e quindi si distribuisce il codice in tale host.

Creare l'app del Servizio app

1. Nel terminale assicurarsi di essere nella cartella del repository serviceconnector-webapp-postgresql-django-passwordless che contiene il codice dell'app.

2. Eseguire il comando az webapp up seguente per creare l'host del servizio app per l'app:

   az webapp up \
     --resource-group $RESOURCE_GROUP_NAME \
     --location $LOCATION \
     --name $APP_SERVICE_NAME \
     --runtime PYTHON:3.9 \
     --sku B1
   

   Lo SKU definisce le dimensioni (CPU, memoria) e il costo del piano di servizio app. Il piano di servizio B1 (Basic) comporta un costo ridotto nella sottoscrizione di Azure. Per un elenco completo dei piani del Servizio app, visualizzare la pagina Prezzi del Servizio app.

   Questo comando esegue le azioni seguenti, che possono richiedere alcuni minuti, usando il gruppo di risorse e la posizione memorizzati nella cache dal comando az group create precedente (il gruppo $RESOURCE_GROUP_NAME nell'area eastus in questo esempio).

   • Creare un piano di servizio app nel piano tariffario Basic (B1). È possibile omettere --sku per usare i valori predefiniti.
   • Creare l'app del servizio app.
   • Abilitare la registrazione predefinita per l'app.
   • Carica il repository usando la distribuzione ZIP con l'automazione della compilazione abilitata.

3. Configurare il servizio app per usare il file start.sh nel repository con il comando az webapp config set.

   az webapp config set \
     --resource-group $RESOURCE_GROUP_NAME \
     --name $APP_SERVICE_NAME \
     --startup-file "start.sh"
   

Creare un connettore senza password per il database Postgres

Con il codice ora distribuito nel Servizio app, il passaggio successivo consiste nel connettere l'app al database Postgres in Azure. Il codice dell'app si aspetta di trovare informazioni sul database in una variabile di ambiente denominata AZURE_POSTGRESQL_CONNECTIONSTRING per il server flessibile PostgresSQL e in una variabile di ambiente denominata AZURE_STORAGEBLOB_RESOURCEENDPOINT per l'account di Archiviazione di Azure.

I comandi del Connettore di servizi configurano le risorse Archiviazione di Azure e Database di Azure per PostgreSQL in modo che usino l'identità gestita e il controllo degli accessi in base al ruolo di Azure. I comandi creano le impostazioni dell'app nel servizio app che connettono l'app Web a queste risorse. L'output dei comandi elenca le azioni del connettore di servizi eseguite per abilitare la funzionalità senza password.

1. Aggiungere un connettore di servizi PostgreSQL con il comando az webapp connection create postgres-flexible. L'identità gestita assegnata dal sistema viene usata per autenticare l'app Web nella risorsa di destinazione, PostgreSQL in questo caso.

   az webapp connection create postgres-flexible \
     --resource-group $RESOURCE_GROUP_NAME \
     --name $APP_SERVICE_NAME \
     --target-resource-group $RESOURCE_GROUP_NAME \
     --server $DB_SERVER_NAME \
     --database restaurant \
     --client-type python \
     --system-identity
   

Nel codice Python è possibile accedere a queste impostazioni come variabili di ambiente con istruzioni come os.environ.get('AZURE_POSTGRESQL_HOST'). Per altre informazioni, vedere Accedere alle variabili di ambiente.

Problemi? Per prima cosa, vedere la guida alla risoluzione dei problemi. Se i problemi persistono, segnalarli.

Creare un account di archiviazione e connettersi

1. Usare il comando az webapp connection create storage-blob per creare un account di archiviazione e creare un connettore di servizi che esegue le configurazioni seguenti:

• Abilita l'identità gestita assegnata dal sistema nell'app Web

• Aggiunge l'app Web con ruolo Collaboratore ai dati dei BLOB di archiviazione all'account di archiviazione appena creato.

• Configura la rete dell'account di archiviazione per accettare l'accesso dall'app Web.

  STORAGE_ACCOUNT_URL=$(az webapp connection create storage-blob \
    --new true \
    --resource-group $RESOURCE_GROUP_NAME \
    --name $APP_SERVICE_NAME \
    --target-resource-group $RESOURCE_GROUP_NAME \
    --client-type python \
    --system-identity \
    --query configurations[].value \
    --output tsv)
  STORAGE_ACCOUNT_NAME=$(cut -d . -f1 <<< $(cut -d / -f3 <<< $STORAGE_ACCOUNT_URL))
  

1. Aggiornare l'account di archiviazione per consentire l'accesso pubblico ai BLOB agli utenti dell'app ristorante utenti per accedere alle immagini.

    az storage account update  \
      --name $STORAGE_ACCOUNT_NAME \
      --allow-blob-public-access 
   

2. Creare un contenitore denominato photos nell'account di archiviazione con il comando az storage container create. Consentire l'accesso in lettura anonimo (pubblico) ai BLOB nel contenitore appena creato.

   # Set the BLOB_ENDPOINT variable
   BLOB_ENDPOINT=$(az storage account show --name $STORAGE_ACCOUNT_NAME --query "primaryEndpoints.blob" | sed 's/"//g')
   echo $BLOB_ENDPOINT
   
   # Create the storage container using the BLOB_ENDPOINT variable
   az storage container create \
     --account-name $STORAGE_ACCOUNT_NAME \
     --name photos \
     --public-access blob \
     --auth-mode login \
     --blob-endpoint $BLOB_ENDPOINT
   

Testare l'app Web Python in Azure

L'app Python di esempio usa il pacchetto azure.identity e la relativa classe DefaultAzureCredential. Quando l'app è in esecuzione in Azure, DefaultAzureCredential rileva automaticamente se esiste un'identità gestita per il servizio app e, in tal caso, la usa per accedere ad altre risorse di Azure (archiviazione e PostgreSQL in questo caso). Non è necessario fornire chiavi di archiviazione, certificati o credenziali al servizio app per accedere a queste risorse.

1. Passare all'applicazione distribuita nell'URL http://$APP_SERVICE_NAME.azurewebsites.net.

   L'avvio dell'app può richiedere uno o due minuti. Se viene visualizzata una pagina dell'app predefinita che non è la pagina predefinita dell'app di esempio, attendere un minuto e aggiornare il browser.

2. Testare la funzionalità dell'app di esempio aggiungendo un ristorante e alcune recensioni con foto del ristorante. Le informazioni relative al ristorante e alle recensioni vengono archiviate in Database di Azure per PostgreSQL e le foto vengono archiviate in Archiviazione di Azure. Ecco uno screenshot di esempio:

   

Pulire le risorse

Se si vuole mantenere l'app o continuare con le altre esercitazioni, andare a Passaggi successivi. In caso contrario, per evitare di sostenere addebiti continui, eliminare il gruppo di risorse creato per questa esercitazione:

az group delete --name $RESOURCE_GROUP_NAME --no-wait

Eliminando il gruppo di risorse, vengono inoltre deallocate ed eliminate tutte le risorse in esso contenute. Prima di eseguire il comando assicurarsi che nessuna delle risorse del gruppo sia più necessaria.

L'eliminazione di tutte le risorse può richiedere tempo. Con l'argomento --no-wait, il comando restituisce immediatamente il risultato.

Problemi? Segnalarli.

Passaggio successivo