Distribuire un'app Web Python (Django o Flask) con PostgreSQL in Azure
In questa esercitazione si distribuirà un'app Web Python guidata dai dati (Django o Flask) nel servizio app Azure con il servizio di database relazionale Database di Azure per PostgreSQL. Il Servizio app di Azure supporta Python in un ambiente server Linux.
Per completare questa esercitazione, sono necessari gli elementi seguenti:
- Un account Azure con una sottoscrizione attiva. Se non si ha un account Azure, è possibile crearne uno gratuitamente.
- Conoscenza di Python con sviluppo Flask o Python con sviluppo Django
- Un account Azure con una sottoscrizione attiva. Se non si ha un account Azure, è possibile crearne uno gratuitamente.
- Azure Developer CLI installata. È possibile seguire la procedura con Azure Cloud Shell perché è già installata Azure Developer CLI.
- Conoscenza di Python con sviluppo Flask o Python con sviluppo Django
Con l'interfaccia della riga di comando per sviluppatori di Azure installata, è possibile distribuire un'app di esempio completamente configurata illustrata in questa esercitazione e visualizzarla in esecuzione in Azure. È sufficiente eseguire i comandi seguenti in una directory di lavoro vuota:
azd auth login
azd init --template msdocs-flask-postgresql-sample-app
azd up
Sono disponibili applicazioni Python di esempio che usano il framework Flask e Django per seguire questa esercitazione. Per distribuirli senza eseguirli in locale, ignorare questa parte.
Per eseguire l'applicazione in locale, assicurarsi di avere Python 3.7 o versione successiva e PostgreSQL installato in locale. Clonare quindi il ramo del repository starter-no-infra
di esempio e passare alla radice del repository.
git clone -b starter-no-infra https://github.com/Azure-Samples/msdocs-flask-postgresql-sample-app
cd msdocs-flask-postgresql-sample-app
Creare un file con estensione .env come illustrato di seguito usando il file .env.sample come riferimento. Impostare il valore di DBNAME
sul nome di un database esistente nell'istanza locale di PostgreSQL. Impostare i valori di DBHOST
, DBUSER
e DBPASS
in base alle esigenze dell'istanza di PostgreSQL locale.
DBNAME=<database name>
DBHOST=<database-hostname>
DBUSER=<db-user-name>
DBPASS=<db-password>
Creare un ambiente virtuale per l’app:
py -m venv .venv
.venv\scripts\activate
Installare le dipendenze:
pip install -r requirements.txt
Per eseguire l'applicazione di esempio, usare i comandi seguenti:
# Run database migration
flask db upgrade
# Run the app at http://127.0.0.1:5000
flask run
In questo passaggio si creano le risorse di Azure. Per impostazione predefinita la procedura usata in questa esercitazione crea un set di risorse sicure che include Servizio app e Database di Azure per PostgreSQL. Per il processo di creazione, specificare:
- Nome dell'app Web. È il nome usato come parte del nome DNS per l'app Web sotto forma di
https://<app-name>.azurewebsites.net
. - Area in cui eseguire l'app fisicamente nel mondo.
- Stack di runtime per l'app. È qui che si seleziona la versione di Python da usare per l'app.
- Piano di hosting per l'app. Si tratta del piano tariffario che include il set di funzionalità e la capacità di ridimensionamento per l'app.
- Gruppo di risorse per l'app. Un gruppo di risorse consente di raggruppare (in un contenitore logico) tutte le risorse di Azure necessarie per l'applicazione.
Per creare risorse del Servizio app di Azure, accedere al portale di Azure e seguire questa procedura.
Passaggio 1: nel portale di Azure:
- Immettere "database dell'app Web" nella barra di ricerca nella parte superiore del portale di Azure.
- Selezionare l'elemento con etichetta App Web e database sotto l'intestazione Marketplace. È anche possibile passare direttamente alla creazione guidata.
Passaggio 2: nella pagina Crea app Web e database compilare il modulo come indicato di seguito.
- Gruppo di risorse:selezionare Crea nuovo e usare il nome msdocs-python-postgres-tutorial.
- Area → Qualunque area di Azure nelle vicinanze.
- Nome: msdocs-python-postgres-XYZ dove XYZ possono essere tre caratteri qualsiasi scelti casualmente. Il nome deve essere univoco in Azure
- Stack di runtime → Python 3.10.
- Database: per impostazione predefinita, PostgreSQL - Server flessibile è l’opzione selezionata come motore di database. Per impostazione predefinita, il nome del server e il nome del database vengono impostati sui valori appropriati.
- Piano di hosting: Basic. Quando si è pronti, è possibile passare a un piano tariffario di produzione in un secondo momento.
- Selezionare Rivedi e crea.
- Al termine della convalida selezionare Crea.
Passaggio 3: il completamento della distribuzione richiede alcuni minuti. Al termine della distribuzione, selezionare il pulsante Vai alla risorsa. Si accede direttamente all'app del servizio app, ma vengono create le risorse seguenti:
- Gruppo di risorse: contenitore per tutte le risorse create.
- Piano di servizio app: definisce le risorse di calcolo per il Servizio app. Viene creato un piano Linux nel livello Basic.
- Servizio app: rappresenta l'app ed è in esecuzione nel piano di Servizio app.
- Rete virtuale: è integrata con l'app del Servizio app e isola il traffico di rete back-end.
- Server flessibile di Database di Azure per PostgreSQL: accessibile solo dall'interno della rete virtuale. Vengono automaticamente creati un database e un utente nel server.
- Zona DNS privato: abilita la risoluzione DNS del server PostgreSQL nella rete virtuale.
La procedura guidata di creazione ha già generato le variabili di connettività cosiccome le impostazioni dell'app. Le impostazioni dell'app sono un modo per mantenere i segreti di connessione all'esterno del repository di codice. Quando si è pronti a spostare i segreti in una posizione più sicura, ecco un articolo sull'archiviazione in Azure Key Vault.
Passaggio 1: Nel menu a sinistra della pagina Servizio app selezionare Configurazione.
Passaggio 2: nella scheda Impostazioni applicazione della pagina Configurazione verificare che AZURE_POSTGRESQL_CONNECTIONSTRING
sia presente. Che verrà inserito nell'ambiente di runtime come variabile di ambiente.
Passaggio 3: In un terminale o un prompt dei comandi eseguire lo script Python seguente per generare un segreto univoco: python -c 'import secrets; print(secrets.token_hex())'
. Copiare il valore di output da usare nel passaggio successivo.
In questo passaggio si configurerà la distribuzione di GitHub usando GitHub Actions. È solo uno dei molti modi per eseguire la distribuzione nel servizio app, ma anche un ottimo modo per avere l'integrazione continua nel processo di distribuzione. Per impostazione predefinita, ogni git push
al repository GitHub avvia l'azione di compilazione e distribuzione.
Passaggio 1: in una nuova finestra del browser:
- Accedi all'account GitHub.
- Accedere a https://github.com/Azure-Samples/msdocs-flask-postgresql-sample-app.
- Seleziona Fork.
- Selezionare Crea fork.
Passaggio 2: nella pagina GitHub aprire Visual Studio Code nel browser premendo il tasto .
.
Passaggio 3: In Visual Studio Code nel browser aprire azureproject/production.py in Esplora risorse. Vedere le variabili di ambiente usate nell'ambiente di produzione, incluse le impostazioni dell'app visualizzate nella pagina di configurazione.
Passaggio 4: Tornare alla pagina servizio app, nel menu a sinistra selezionare Centro distribuzione.
Passaggio 5: nella pagina Centro distribuzione:
- In Origine, selezionare GitHub. Per impostazione predefinita, GitHub Actions è selezionato come provider di compilazione.
- Accedere all'account GitHub e seguire la richiesta di autorizzare Azure.
- In Organizzazione, selezionare l'account.
- In Repository selezionare msdocs-flask-postgresql-sample-app.
- Per Ramo selezionare principale.
- Mantenere l'opzione predefinita impostata su Aggiungi un flusso di lavoro.
- Per Tipo di autenticazione selezionare Identità assegnata dall'utente.
- Nel menu in alto, selezionare Salva. Il servizio app esegue il commit di un file del flusso di lavoro nel repository GitHub scelto, nella directory
.github/workflows
.
Passaggio 6: nella pagina Centro distribuzione:
- Selezionare Log. È già stata avviata l’esecuzione di una distribuzione.
- Nell’elemento di log per l'esecuzione della distribuzione selezionare Compila/Distribuisci log.
Passaggio 7: si verrà reindrizzati al repository GitHub dove è possibile notare che l'azione GitHub è in esecuzione. Il file del flusso di lavoro definisce due fasi separate, compilare e distribuire. Attendere che l'esecuzione di GitHub visualizzi lo stato Operazione completata. Ci vogliono circa 5 minuti.
Problemi? Consultare la Guida alla risoluzione dei problemi.
Con il database PostgreSQL protetto dalla rete virtuale, il modo più semplice per eseguire le migrazioni del database Flask è in una sessione SSH con il contenitore servizio app.
Passaggio 1: tornare alla pagina Servizio app nel menu a sinistra,
- Selezionare SSH (22).
- Selezionare Vai.
Passaggio 2: nel terminale SSH, eseguire flask db upgrade
. Se ha esito positivo, il Servizio app si connette correttamente al database.
Solo le modifiche apportate ai file in /home
possono essere mantenute dopo i riavvii dell'app. Le modifiche al di fuori di /home
non sono persistenti.
Passaggio 1: nella pagina Servizio app:
- Nel menu a sinistra selezionare Panoramica.
- Selezionare l'URL dell'app. È anche possibile passare direttamente a
https://<app-name>.azurewebsites.net
.
Passaggio 2: aggiungere alcuni ristoranti all'elenco. A questo punto un'app Web è in esecuzione nel servizio app di Azure, con connettività sicura a Database di Azure per PostgreSQL.
Il Servizio app di Azure acquisisce tutto l'output dei messaggi nella console per facilitare la diagnosi dei problemi con l'applicazione. L'app di esempio include print()
istruzioni per illustrare questa funzionalità, come illustrato di seguito.
@app.route('/', methods=['GET'])
def index():
print('Request for index page received')
restaurants = Restaurant.query.all()
return render_template('index.html', restaurants=restaurants)
Passaggio 1: Nella pagina Servizio app:
- Nel menu a sinistra selezionare Log di servizio app.
- In Application Logging, selezionare File System.
- Nel menu in alto, selezionare Salva.
Passaggio 2: dal menu a sinistra selezionare Flusso di log. Vengono visualizzati i log per l'app, inclusi i log e i log della piattaforma dall'interno del contenitore.
Per altre informazioni sulla registrazione nelle app Python, vedere la serie sulla configurazione di Monitoraggio di Azure per l'applicazione Python.
Al termine, è possibile eliminare tutte le risorse dalla sottoscrizione di Azure eliminando il gruppo di risorse.
Passaggio 1: nella barra di ricerca nella parte superiore del portale di Azure:
- Immettere il nome del gruppo di risorse.
- Selezionare il gruppo di risorse.
Passaggio 2: nella pagina del gruppo di risorse selezionare Elimina gruppo di risorse.
Passaggio 3:
- Immettere il nome del gruppo di risorse per confermare l'eliminazione.
- Selezionare Elimina.
In questo passaggio si creano le risorse di Azure e si distribuisce un'app di esempio nel servizio app in Linux. Per impostazione predefinita la procedura usata in questa esercitazione crea un set di risorse sicure che include Servizio app e Database di Azure per PostgreSQL.
Se questa operazione non è ancora stata eseguita, clonare il ramo del repository di
starter-no-infra
esempio in un terminale locale.git clone -b starter-no-infra https://github.com/Azure-Samples/msdocs-flask-postgresql-sample-app cd msdocs-flask-postgresql-sample-app
Questo ramo clonato è il punto di partenza. Contiene una semplice applicazione Flask per unità dati.
Dalla radice del repository eseguire
azd init
.azd init --template python-app-service-postgresql-infra
Quando richiesto, fornire le risposte seguenti:
Domanda Risposta La directory corrente non è vuota. Inizializzare un progetto qui in "<your-directory>"? Y Cosa vuoi fare con questi file? Mantenere invariati i file esistenti Immettere un nuovo nome di ambiente Digitare un nome univoco. Il modello AZD usa questo nome come parte del nome DNS dell'app Web in Azure ( <app-name>.azurewebsites.net
). Sono consentiti caratteri alfanumerici e trattini.Eseguire il comando
azd up
per effettuare il provisioning delle risorse di Azure necessarie e distribuire il codice dell'app. Se non si è già connessi ad Azure, verrà avviato il browser e verrà chiesto di eseguire l'accesso. Il comandoazd up
richiederà anche di selezionare la sottoscrizione e il percorso desiderati in cui effettuare la distribuzione.azd up
Il completamento del comando
azd up
potrebbe richiedere alcuni minuti. Compila e distribuisce anche il codice dell'applicazione, ma il codice verrà modificato in un secondo momento per funzionare con il servizio app. Durante l'esecuzione, il comando fornisce messaggi sul processo di provisioning e distribuzione, incluso un collegamento alla distribuzione in Azure. Al termine, il comando visualizza anche un collegamento all'applicazione di distribuzione.Questo modello AZD contiene file (azure.yaml e la directory infra ) che generano un'architettura sicura per impostazione predefinita con le risorse di Azure seguenti:
- Gruppo di risorse: contenitore per tutte le risorse create.
- Piano di servizio app: definisce le risorse di calcolo per il Servizio app. Viene creato un piano Linux nel livello B1.
- Servizio app: rappresenta l'app ed è in esecuzione nel piano di Servizio app.
- Rete virtuale: è integrata con l'app del Servizio app e isola il traffico di rete back-end.
- Server flessibile di Database di Azure per PostgreSQL: accessibile solo dall'interno della rete virtuale. Vengono automaticamente creati un database e un utente nel server.
- Zona DNS privato: abilita la risoluzione DNS del server PostgreSQL nella rete virtuale.
- Area di lavoro Log Analytics: funge da contenitore di destinazione per l'app che spedisce i log e permette anche di eseguire query sui log.
Il modello azd usato ha generato le variabili di connettività già come impostazioni dell'app e li restituisce al terminale per praticità. Le impostazioni dell'app sono un modo per mantenere i segreti di connessione all'esterno del repository di codice.
Nell'output azd trovare le impostazioni dell'app e trovare le impostazioni
AZURE_POSTGRESQL_CONNECTIONSTRING
eAZURE_REDIS_CONNECTIONSTRING
. Per proteggere i segreti, vengono visualizzati solo i nomi delle impostazioni. L'aspetto è simile al seguente nell'output azd:App Service app has the following settings: - AZURE_POSTGRESQL_CONNECTIONSTRING - AZURE_REDIS_CONNECTIONSTRING - FLASK_DEBUG - SCM_DO_BUILD_DURING_DEPLOYMENT - SECRET_KEY
AZURE_POSTGRESQL_CONNECTIONSTRING
contiene il stringa di connessione al database Postgres in Azure eAZURE_REDIS_CONNECTIONSTRING
contiene il stringa di connessione nella cache Redis in Azure. È necessario usarli per connettersi al codice. Aprire azureproject/production.py, rimuovere il commento dalle righe seguenti e salvare il file:conn_str = os.environ['AZURE_POSTGRESQL_CONNECTIONSTRING'] conn_str_params = {pair.split('=')[0]: pair.split('=')[1] for pair in conn_str.split(' ')} DATABASE_URI = 'postgresql+psycopg2://{dbuser}:{dbpass}@{dbhost}/{dbname}'.format( dbuser=conn_str_params['user'], dbpass=conn_str_params['password'], dbhost=conn_str_params['host'], dbname=conn_str_params['dbname'] )
Il codice dell'applicazione è ora configurato per connettersi al database PostgreSQL in Azure. Se si vuole, aprire
app.py
e vedere come viene usata laDATABASE_URI
variabile di ambiente.Nel terminale eseguire
azd deploy
.azd deploy
Con il database PostgreSQL protetto dalla rete virtuale, il modo più semplice per eseguire le migrazioni del database Flask è in una sessione SSH con il contenitore servizio app.
Nell'output azd trovare l'URL per la sessione SSH e passarvi nel browser. L'output è simile al seguente:
Open SSH session to App Service container at: https://<app-name>.scm.azurewebsites.net/webssh/host
Nel terminale SSH eseguire
flask db upgrade
. Se ha esito positivo, il Servizio app si connette correttamente al database.Nota
Solo le modifiche apportate ai file in
/home
possono essere mantenute dopo i riavvii dell'app. Le modifiche al di fuori di/home
non sono persistenti.
Nell'output AZD trovare l'URL dell'app e passarvi nel browser. L'URL è simile al seguente nell'output AZD:
Deploying services (azd deploy) (✓) Done: Deploying service web - Endpoint: https://<app-name>.azurewebsites.net/
Aggiungere alcuni ristoranti all'elenco.
A questo punto un'app Web è in esecuzione nel servizio app di Azure, con connettività sicura a Database di Azure per PostgreSQL.
Il servizio app di Azure può acquisire i log della console per diagnosticare i problemi relativi all'applicazione. Per praticità, il modello azd ha già abilitato la registrazione nel file system locale e li ha spediti a un'area di lavoro Log Analitica.
L'app di esempio include print()
istruzioni per illustrare questa funzionalità, come illustrato nel frammento di codice seguente.
@app.route('/', methods=['GET'])
def index():
print('Request for index page received')
restaurants = Restaurant.query.all()
return render_template('index.html', restaurants=restaurants)
Nell'output azd trovare il collegamento per trasmettere servizio app log e passare a esso nel browser. Il collegamento è simile al seguente nell'output azd:
Stream App Service logs at: https://portal.azure.com/#@/resource/subscriptions/<subscription-guid>/resourceGroups/<group-name>/providers/Microsoft.Web/sites/<app-name>/logStream
Per altre informazioni sulla registrazione nelle app Python, vedere la serie sulla configurazione di Monitoraggio di Azure per l'applicazione Python.
Per eliminare tutte le risorse di Azure nell'ambiente di distribuzione corrente, eseguire azd down
.
azd down
Di seguito sono elencati i problemi che possono verificarsi durante il tentativo di eseguire questa esercitazione e i passaggi per risolvere tali problemi.
Se non è possibile connettersi alla sessione SSH, significa che l'avvio dell'app stessa non è riuscito. Controllare i log di diagnostica per informazioni dettagliate. Ad esempio, se viene visualizzato un errore simile a KeyError: 'AZURE_POSTGRESQL_CONNECTIONSTRING'
, è possibile la variabile di ambiente non sia presente (potrebbe essere stata rimossa l'impostazione dell'app).
Se si verificano errori relativi alla connessione al database, verificare se le impostazioni dell'app (AZURE_POSTGRESQL_CONNECTIONSTRING
) sono state modificate. Senza tale stringa di connessione, il comando di migrazione non può comunicare con il database.
- Quanto costa questa configurazione?
- In che modo è possibile connettersi al server PostgreSQL protetto dietro la rete virtuale con altri strumenti?
- Come funziona lo sviluppo di app locali con GitHub Actions?
- Come viene configurato l'esempio Django per l'esecuzione nel servizio app Azure?
I prezzi per le risorse create sono i seguenti:
- Il piano di servizio app viene creato nel livello Basic e può essere ridimensionato verso l'alto o verso il basso. Vedere Prezzi del servizio app.
- Il server flessibile PostgreSQL viene creato nel livello con possibilità di burst più bassa Standard_B1ms, con dimensioni di archiviazione minime, che possono essere ridimensionate, ossia aumentate o ridotte. Vedere i piani tariffari di Database di Azure per PostgreSQL.
- La rete virtuale non comporta alcun addebito a meno che non si configurino funzionalità aggiuntive, ad esempio il peering. Vedere Prezzi della rete virtuale di Azure.
- La zona DNS privata comporta un piccolo addebito. Vedere Prezzi di DNS di Azure.
In che modo è possibile connettersi al server PostgreSQL protetto dietro la rete virtuale con altri strumenti?
- Per l'accesso di base da uno strumento da riga di comando, è possibile eseguire
psql
dal terminale SSH dell'app. - Per connettersi da uno strumento desktop, il computer deve trovarsi all'interno della rete virtuale. Ad esempio, potrebbe trattarsi di una macchina virtuale di Azure connessa a una delle subnet o di un computer in una rete locale con una connessione VPN da sito a sito con la rete virtuale di Azure.
- È anche possibile integrare Azure Cloud Shell con la rete virtuale.
Quando si usa il file del flusso di lavoro generato automaticamente dal Servizio app come esempio, ogni git push
avvia una nuova esecuzione della compilazione e della distribuzione. Da un clone locale del repository GitHub si effettua il push degli aggiornamenti desiderati in GitHub. Ad esempio:
git add .
git commit -m "<some-message>"
git push origin main
Nota
Se si segue questa esercitazione con la propria app, esaminare la descrizione del file di requirements.txt nel file README.md di ogni progetto (Flask, Django) per vedere i pacchetti necessari.
L'applicazione di esempio Django configura le impostazioni nel file azureproject/production.py in modo che possa essere eseguito nel servizio app Azure. Queste modifiche sono comuni alla distribuzione di Django nell'ambiente di produzione e non specifiche di servizio app.
Django convalida l'intestazione HTTP_HOST nelle richieste in ingresso. Il codice di esempio usa la
WEBSITE_HOSTNAME
variabile di ambiente in servizio app per aggiungere il nome di dominio dell'app all'impostazione ALLOWED_HOSTS di Django.# Configure the domain name using the environment variable # that Azure automatically creates for us. ALLOWED_HOSTS = [os.environ['WEBSITE_HOSTNAME']] if 'WEBSITE_HOSTNAME' in os.environ else []
Django non supporta la gestione dei file statici nell'ambiente di produzione. Per questa esercitazione, si userà WhiteNoise per abilitare la gestione dei file. Il pacchetto WhiteNoise è già stato installato con requirements.txt e il relativo middleware viene aggiunto all'elenco.
# WhiteNoise configuration MIDDLEWARE = [ 'django.middleware.security.SecurityMiddleware', # Add whitenoise middleware after the security middleware 'whitenoise.middleware.WhiteNoiseMiddleware',
Le impostazioni dei file statici vengono quindi configurate in base alla documentazione di Django.
SESSION_ENGINE = "django.contrib.sessions.backends.cache" STATICFILES_STORAGE = 'whitenoise.storage.CompressedManifestStaticFilesStorage'
Per altre informazioni, vedere Impostazioni di produzione per le app Django.
Passare all'esercitazione successiva per informazioni su come proteggere l'app con un dominio e un certificato personalizzati.
Proteggere con dominio personalizzato e certificato di protezione
Vedere le informazioni sul modo in cui il Servizio app esegue un'app Python: