Tutorial: Collegare un'app web Django a Database di Azure per PostgreSQL usando Service Connector

Questa esercitazione illustra come distribuire un'app Web Django basata sui dati Python in Servizio app di Azure e usare Service Connector per connetterla ad altri servizi Azure. L'app Web di esempio archivia i ristoranti e esamina le informazioni in un database Database di Azure per PostgreSQL e archivia le foto in un contenitore Archiviazione di Azure.

Usare interfaccia della riga di comando di Azure per completare le attività seguenti:

Prerequisiti

• Una sottoscrizione di Azure con autorizzazioni di scrittura e assegnazione di ruolo per le risorse dell'esercitazione, in un'area di Azure che supporta il connettore di servizio e che dispone di quota e supporto del servizio app.

• Azure Cloud Shell per eseguire i passaggi dell'esercitazione o se si preferisce eseguire localmente:

  1. Installa interfaccia della riga di comando di Azure 2.87.0 o versione successiva. Per controllare la versione, eseguire az version. Per eseguire l'aggiornamento, eseguire az upgrade.
  2. Installare Python 3.
  3. Installare Git.
  4. Accedere a Azure usando az login e seguendo le istruzioni.

Configurazione dell'ambiente

1. Registra i Microsoft.ServiceLinker fornitori di Microsoft.DBforPostgreSQL risorse per il tuo abbonamento.

   az provider register --namespace Microsoft.ServiceLinker
   az provider register --namespace Microsoft.DBforPostgreSQL
   

2. Installa l'ultima versione dell'estensione senza password Service Connector. Il --upgrade parametro aggiorna l'estensione se è già installata:

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

Clonare l'app di esempio

1. Clona il repository dell'app di esempio.

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

   In alternativa, puoi scaricare l'app dal repository serviceconnector-webapp-postgresql-django-passwordless e scomprimerla in una cartella chiamata serviceconnector-webapp-postgresql-django-passwordless.

2. Modificare le directory nella cartella del repository usando cd serviceconnector-webapp-postgresql-django-passwordless ed eseguire tutti i comandi rimanenti da tale cartella.

Nell'app di esempio, le impostazioni di produzione dell'app web sono nel file azureproject/production.py . Le impostazioni di sviluppo sono su Azureproject/settings.py. Le impostazioni di produzione configurano Django per l'esecuzione in qualsiasi ambiente di produzione e non sono specifiche del servizio app.

L'app usa le impostazioni di produzione quando viene impostata la WEBSITE_HOSTNAME variabile di ambiente. App Service imposta questa variabile al nome host dell'app, come msdocs-django.azurewebsites.net.

Per altre informazioni, vedere l'elenco di controllo per la distribuzione di Django. Vedere anche le impostazioni di Production per Django in Azure.

Definire le variabili di ambiente iniziali

Il codice seguente definisce le variabili di ambiente necessarie per questa esercitazione.

• LOCATION deve essere un'area di Azure in cui la tua sottoscrizione ha una quota sufficiente per creare le risorse e che non impone restrizioni per Database di Azure per PostgreSQL nella tua sottoscrizione.
• La password dell'amministratore di PostgreSQL deve contenere da 8 a 128 caratteri provenienti da almeno tre di queste categorie: lettere maiuscole, minuscole, numeri e caratteri non alfanumerici. Non usare $ nella password per questo tutorial.

1. Imposta le seguenti variabili di ambiente, sostituendole <region> con un valore valido:

   LOCATION="<region>"
   RAND_ID=$RANDOM$RANDOM
   RESOURCE_GROUP_NAME="msdocs-mi-web-app-$RAND_ID"
   APP_SERVICE_NAME="msdocs-mi-web-$RAND_ID"
   APP_SERVICE_PLAN_NAME="$APP_SERVICE_NAME-plan"
   DB_SERVER_NAME="msdocs-mi-postgres-$RAND_ID"
   DATABASE_NAME="restaurant"
   STORAGE_ACCOUNT_NAME="account$RAND_ID"
   ADMIN_USER="demoadmin"
   

2. Leggi la password dell'amministratore di PostgreSQL senza mostrarla o aggiungerla alla cronologia della tua shell:

   read -s -p "PostgreSQL administrator password: " ADMIN_PW && echo
   

3. Creare un gruppo di risorse per contenere tutte le risorse del progetto. 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
   

Distribuire il codice dell'app su App Service

Crea l'host dell'app in App Service, abilita l'automazione delle build e distribuisci il codice di esempio dell'app. Il piano App Service Basic (B1) utilizzato in questo tutorial comporta un costo nel tuo abbonamento Azure. Per i prezzi attuali, vedi prezzi dei servizi di app.

1. Il file requirements.txt del campione archiviato non dichiara il server Gunicorn usato da start.sh. Aggiungilo alla tua copia locale se non è già presente:

   grep -qiE "^gunicorn([=<>~ ]|$)" requirements.txt || echo "gunicorn" >> requirements.txt
   

2. Crea un piano di App Service Linux nel piano tariffario Basic (B1) e quindi crea l'app Web con il comando di avvio dell'esempio:

   az appservice plan create \
     --resource-group $RESOURCE_GROUP_NAME \
     --name $APP_SERVICE_PLAN_NAME \
     --location $LOCATION \
     --sku B1 \
     --is-linux
   
   az webapp create \
     --resource-group $RESOURCE_GROUP_NAME \
     --name $APP_SERVICE_NAME \
     --plan $APP_SERVICE_PLAN_NAME \
     --runtime "PYTHON:3.14" \
     --startup-file "start.sh"
   

3. Abilita l'automazione della build dei servizi App in modo che la distribuzione installi i pacchetti in requirements.txt:

   az webapp config appsettings set \
     --resource-group $RESOURCE_GROUP_NAME \
     --name $APP_SERVICE_NAME \
     --settings SCM_DO_BUILD_DURING_DEPLOYMENT=true
   

4. Dalla radice del repository, crea un file ZIP dell'app di esempio e distribuiscilo usando az-webapp deploy:

   rm -f app.zip
   python -m zipfile -c app.zip *
   
   az webapp deploy \
     --resource-group $RESOURCE_GROUP_NAME \
     --name $APP_SERVICE_NAME \
     --src-path app.zip \
     --type zip \
     --track-status false
   
   rm app.zip
   

   Il comando di distribuzione ha successo quando App Service accetta il file ZIP. La build continua su App Service e può richiedere diversi minuti.

Crea il database PostgreSQL in Azure

Crea un server e un database flessibili Database di Azure per PostgreSQL per memorizzare i dati dell'app.

1. Creare il server di Database di Azure per PostgreSQL:

   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 \
     --microsoft-entra-auth Enabled
   

   Il comando ha successo quando lo stato di provisioning del server flessibile PostgreSQL è Succeeded.

2. Rimuovi la password amministratore dalla shell corrente dopo la creazione del server:

   unset ADMIN_PW
   

3. Crea il database usando az postgres flexible-server db create:

   az postgres flexible-server db create \
     --resource-group $RESOURCE_GROUP_NAME \
     --server-name $DB_SERVER_NAME \
     --name $DATABASE_NAME
   

Creare una connessione al servizio senza password

Usa az-webapp connection create postgres-flexible per aggiungere un connettore di servizio che collega l'app web Azure al database PostgreSQL usando l'autenticazione di identità gestita senza password. Il comando seguente configura il database di Azure per PostgreSQL per usare l'identità gestita e il controllo degli accessi in base al ruolo di Azure. L'output del comando elenca le azioni eseguite da Service Connector.

Il comando crea un'impostazione dell'app chiamata AZURE_POSTGRESQL_CONNECTIONSTRING che contiene le informazioni sulla connessione al database. L'esempio legge questa impostazione in azureproject/production.py. Per altre informazioni, vedere Accedere alle variabili di ambiente.

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 $DATABASE_NAME \
  --client-type python \
  --system-identity \
  --yes

La connessione è pronta quando il comando segnala la connessione del server flessibile PostgreSQL e crea l'impostazione dell'app AZURE_POSTGRESQL_CONNECTIONSTRING .

Collega l'app web Django ad Archiviazione di Azure con Service Connector

Crea un account di storage Azure e poi usa az-webapp connection create storage-blob per collegarlo all'app web. Il comando di connessione esegue le seguenti azioni:

• Abilita l'identità gestita assegnata dal sistema nell'app Web.
• Aggiunge l'app web con il ruolo Storage Blob Data Contributor all'account di archiviazione.
• Configura la rete dell'account di archiviazione per accettare l'accesso dall'app Web.
• Crea una variabile di ambiente denominata AZURE_STORAGEBLOB_RESOURCEENDPOINT per l'account Archiviazione di Azure.

Creare un account di archiviazione di Azure

Crea un account di archiviazione v2 generico con spazio di archiviazione localmente ridondante:

az storage account create \
  --resource-group $RESOURCE_GROUP_NAME \
  --name $STORAGE_ACCOUNT_NAME \
  --location $LOCATION \
  --sku Standard_LRS \
  --kind StorageV2

Crea una connessione di archiviazione senza password

Crea la connessione senza password all'account di archiviazione:

az webapp connection create storage-blob \
  --resource-group $RESOURCE_GROUP_NAME \
  --name $APP_SERVICE_NAME \
  --target-resource-group $RESOURCE_GROUP_NAME \
  --account $STORAGE_ACCOUNT_NAME \
  --client-type python \
  --system-identity

La connessione è pronta quando il comando segnala la connessione all'account di archiviazione e crea l'impostazione dell'app AZURE_STORAGEBLOB_RESOURCEENDPOINT .

Configura il contenitore della foto campione

1. Aggiorna l'account Archiviazione di Azure per consentire l'accesso pubblico in lettura ai blob per questa app di esempio archiviato.

   Nota

   Questo campione archiviato utilizza URL blob diretti per mostrare le foto, quindi il tutorial consente l'accesso anonimo alla lettura del photos container. Questa impostazione è specifica per il campione e non è richiesta dal Service Connector. Per le app di produzione, mantenere i container privati e utilizzare un metodo di consegna controllato, come un endpoint applicativo autenticato.

   az storage account update \
     --resource-group $RESOURCE_GROUP_NAME \
     --name $STORAGE_ACCOUNT_NAME \
     --allow-blob-public-access true
   

2. Assegna il permesso di utente con accesso per creare il container utilizzando l'autenticazione Microsoft Entra:

   SIGNED_IN_USER_ID=$(az ad signed-in-user show --query id --output tsv)
   STORAGE_ACCOUNT_ID=$(az storage account show \
     --resource-group $RESOURCE_GROUP_NAME \
     --name $STORAGE_ACCOUNT_NAME \
     --query id \
     --output tsv)
   
   MSYS_NO_PATHCONV=1 az role assignment create \
     --assignee-object-id $SIGNED_IN_USER_ID \
     --assignee-principal-type User \
     --role "Storage Blob Data Contributor" \
     --scope $STORAGE_ACCOUNT_ID
   

   L'impostazione di MSYS_NO_PATHCONV per questo comando impedisce a Git Bash su Windows di convertire l'ID della risorsa Azure in un percorso di Windows. Non ha effetto in Azure Cloud Shell o in altri ambienti Bash. Le assegnazioni dei ruoli possono richiedere alcuni minuti per diventare efficaci.

3. Usa az storage container create per creare un container chiamato photos e permettere l'accesso anonimo alla lettura dei blob in quel container:

   BLOB_ENDPOINT=$(az storage account show \
     --resource-group $RESOURCE_GROUP_NAME \
     --name $STORAGE_ACCOUNT_NAME \
     --query primaryEndpoints.blob \
     --output tsv)
   
   az storage container create \
     --account-name $STORAGE_ACCOUNT_NAME \
     --name photos \
     --public-access blob \
     --auth-mode login \
     --blob-endpoint $BLOB_ENDPOINT
   

   Il contenitore è pronto quando la risposta mostra "created": true per il contenitore photos.

Testare l'app Web Python in Azure

Aprire e testare l'app Web Azure Restaurant Review. L'app usa il pacchetto azure.identity e la relativa DefaultAzureCredential classe. Quando l'app è in esecuzione in Azure, il DefaultAzureCredential rileva automaticamente quando esiste un'identità gestita per il servizio app e la usa per accedere alle risorse Archiviazione di Azure e Database di Azure per PostgreSQL. L'app non deve fornire chiavi di archiviazione, certificati o credenziali per accedere a queste risorse.

• Per un'installazione interfaccia della riga di comando di Azure locale, è possibile usare az webapp browse per aprire l'app nel browser predefinito:

  az webapp browse --name $APP_SERVICE_NAME --resource-group $RESOURCE_GROUP_NAME
  

• Azure Cloud Shell non è possibile aprire un browser locale, quindi non supporta il comando az webapp browse. Da Cloud Shell, seleziona il link Dominio predefinito nell'angolo in alto a destra della pagina del portale Azure dell'app.

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

Testare la funzionalità dell'app di esempio aggiungendo un ristorante e alcune recensioni con le foto. L'app dovrebbe essere simile allo screenshot seguente:

Pulire le risorse

Per evitare addebiti in corso, è possibile eliminare le risorse create per questa esercitazione eliminando il gruppo di risorse che li contiene. Assicurarsi di non avere più bisogno dell'app o delle risorse prima di eseguire il comando.

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

Il comando ritorna immediatamente mentre Azure cancella le risorse.

Risoluzione dei problemi

Se l'app non si avvia o non si connette alle sue risorse, controlla i log di distribuzione dell'App Service, conferma che esistono le impostazioni dell'AZURE_POSTGRESQL_CONNECTIONSTRINGapp e AZURE_STORAGEBLOB_RESOURCEENDPOINT lascia qualche minuto affinché le assegnazioni dei ruoli su Azure entrino in atto. Per problemi di avvio di app Python, vedi il seguente articolo:

• Risolvere i problemi delle app Linux Python per il Servizio app di Azure

Contenuti correlati

• Quickstart: Connettere Servizio app di Azure a database e servizi con Service Connector
• Creare connessioni al servizio usando gli strumenti IaC
• Distribuire un'app Web Django Python con PostgreSQL in Azure