Esercitazione: Uso di Service Connector per creare un'app Django con PostgreSQL in Azure App Service

Questa esercitazione illustra come distribuire un'app Web Python basata sui dati con Django in Azure App Service e connetterla a un database Azure Database for PostgreSQL Flexible Server.

In questa esercitazione si userà il Azure CLI 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 questo tutorial, pubblichi un'app Web Django su Azure App Service. L'app Web usa un'identità gestita assegnata dal sistema (connessioni senza password) con il controllo degli accessi basato sui ruoli di Azure per accedere alle risorse Azure Storage e Azure Database for PostgreSQL - Server flessibile. Il codice usa la classe DefaultAzureCredential della libreria client Azure Identity per Python. La classe DefaultAzureCredential rileva automaticamente che esiste un'identità gestita per il servizio app e la usa per accedere ad altre risorse 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 viene impostata la WEBSITE_HOSTNAME variabile di ambiente. Azure App Service imposta automaticamente questa variabile sull'URL dell'app Web, ad esempio 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 Django in Azure per informazioni dettagliate su alcune delle modifiche.

Problemi? Fateci sapere.

Creare un database PostgreSQL in Microsoft 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 da 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 Python app.

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 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, assicurarsi di aver installato il Azure CLI come descritto in Impostare 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 --name parametro . Il nome deve essere univoco in tutte le Azure.
     • Con lo sku specificato dal parametro --sku-name.
   • Creare un account amministratore con un nome utente e una password specificati con i --admin-user parametri e --admin-password .
   • Creare un database con il nome specificato con il --database-name parametro .

4. Configurare una regola del firewall sul 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
   

   Utilizzare qualsiasi strumento o sito Web che mostri l'indirizzo IP per sostituire <your IP> nel comando. Ad esempio, puoi utilizzare 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 in Azure App Service

In questa sezione si crea un ambiente di hosting nel servizio app di Azure, si connette questa app al database Postgres e quindi si pubblica 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 seguente az webapp up 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 Azure. Per un elenco completo dei piani di servizio app, vedere la pagina dei 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 precedente az group create (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 utilizzare i valori predefiniti.
   • Creare l'app del servizio App Service.
   • 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 utilizzare il 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 prevede di trovare informazioni sul database in una variabile di ambiente denominata AZURE_POSTGRESQL_CONNECTIONSTRING per il server flessibile PostgreSQL e una variabile di ambiente denominata AZURE_STORAGEBLOB_RESOURCEENDPOINT per Azure Storage account.

I comandi di Service Connector configurano le risorse di Azure Storage e Azure Database for PostgreSQL per l'uso dell'identità gestita e del controllo degli accessi basato sui ruoli 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.

Aggiungere un connettore di servizio 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 si accede 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, altrimenti, fatecelo sapere.

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 servizio che esegue le configurazioni seguenti:

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

• Aggiunge l'app Web con il ruolo Collaboratore dati 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 ristoranti 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 nuovo contenitore 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 di esempio Python 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 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. Accedere all'applicazione distribuita all'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. Il ristorante e le informazioni di revisione vengono archiviate in Azure Database for PostgreSQL e le foto vengono archiviate in Azure Storage. Ecco uno screenshot di esempio:

   

Pulire le risorse

Se vuoi mantenere l'app o continuare con altre esercitazioni, vai 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? Fateci sapere.

Passaggio successivo