Distribuire un'app Web Python (Django o Flask) con PostgreSQL in Azure

Articolo
08/08/2024

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

Flask
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

Con Azure Developer CLI installata, è possibile passare alla fine dell'esercitazione eseguendo i comandi seguenti in una directory di lavoro vuota:

azd auth login
azd init --template msdocs-django-postgresql-sample-app
azd up

Applicazione di esempio

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.

Flask
Django

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>

git clone -b starter-no-infra https://github.com/Azure-Samples/msdocs-django-postgresql-sample-app
cd msdocs-django-postgresql-sample-app

DBNAME=<database name>
DBHOST=<database-hostname>
DBUSER=<db-user-name>
DBPASS=<db-password>

Creare un valore SECRET_KEY per l'app eseguendo il comando seguente al prompt del terminale: python -c 'import secrets; print(secrets.token_hex())'.

Impostare il valore restituito come valore di SECRET_KEY nel file con estensione env.

SECRET_KEY=<secret-key>

Creare un ambiente virtuale per l’app:

Windows
macOS/Linux

py -m venv .venv
.venv\scripts\activate

python3 -m venv .venv
source .venv/bin/activate

Installare le dipendenze:

pip install -r requirements.txt

Per eseguire l'applicazione di esempio, usare i comandi seguenti:

Flask
Django

# Run database migration
flask db upgrade
# Run the app at http://127.0.0.1:5000
flask run

# Run database migration
python manage.py migrate
# Run the app at http://127.0.0.1:8000
python manage.py runserver

git clone https://github.com/Azure-Samples/msdocs-flask-postgresql-sample-app.git

git clone https://github.com/Azure-Samples/msdocs-django-postgresql-sample-app.git

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.

Flask
Django

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.

2. Verificare le impostazioni di connessione

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.

Flask
Django

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.

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 e AZURE_REDIS_CONNECTIONSTRING siano presenti. Verranno inseriti nell'ambiente di runtime come variabile di ambiente.

Passaggio 4: Tornare alla pagina Configurazione , selezionare Nuova impostazione dell'applicazione. Assegnare il nome SECRET_KEY all'impostazione. Incollare il valore del valore precedente. Seleziona OK.

Passaggio 5: Selezionare Salva.

3. Distribuire il codice di esempio

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.

Flask
Django

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.

Passaggio 1: in una nuova finestra del browser:

Accedi all'account GitHub.
Accedere a https://github.com/Azure-Samples/msdocs-django-postgresql-sample-app.
Seleziona Fork.
Selezionare Crea fork.

Passaggio 2: nella pagina GitHub aprire Visual Studio Code nel browser premendo il tasto ..

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-django-postgresql-sample-app.
Per Ramo selezionare principale.
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.

Problemi? Consultare la Guida alla risoluzione dei problemi.

4. Generare lo schema del database

Flask
Django

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.

Con il database PostgreSQL protetto dalla rete virtuale, il modo più semplice per eseguire le migrazioni del database Django è 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 python manage.py migrate. 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.

Suggerimento

In una sessione SSH, per Django è anche possibile creare utenti con il python manage.py createsuperuser comando come si farebbe con una tipica app Django. Per altre informazioni, vedere la documentazione per django django-admin e manage.py. Usare l'account con privilegi avanzati per accedere alla /admin parte del sito Web. Per Flask, usare un'estensione come Flask-admin per fornire la stessa funzionalità.

5. Passare all'app

Flask
Django

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.

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.

La home page mostra che il nome dell'ultimo ristorante visitato e i dati vengono salvati e recuperati dalla cache di Azure. Tenere presente che l'app di esempio usa il stringa di connessione AZURE_REDIS_CONNECTIONSTRING, creato automaticamente dalla procedura guidata.

6. Eseguire lo streaming dei log di diagnostica

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.

Flask
Django

@app.route('/', methods=['GET'])
def index():
    print('Request for index page received')
    restaurants = Restaurant.query.all()
    return render_template('index.html', restaurants=restaurants)

def index(request):
    print('Request for index page received')
    restaurants = Restaurant.objects.annotate(avg_rating=Avg('review__rating')).annotate(review_count=Count('review'))
    lastViewedRestaurant = request.session.get("lastViewedRestaurant", False)

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.

7. Pulire le risorse

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.

1. Creare risorse di Azure e distribuire un'app di esempio

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.

Flask
Django

git clone -b starter-no-infra https://github.com/Azure-Samples/msdocs-flask-postgresql-sample-app
cd msdocs-flask-postgresql-sample-app

git clone -b starter-no-infra https://github.com/Azure-Samples/msdocs-django-postgresql-sample-app
cd msdocs-django-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 comando azd 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:
- Flask
- Django
- 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.
- 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.
- cache di Azure per Redis → Accessibile solo dall'interno della rete virtuale.
- 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.

2. Utilizzare il database stringa di connessione

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 e AZURE_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_CONNECTIONSTRINGcontiene il stringa di connessione al database Postgres in Azure e AZURE_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:

Flask
Django

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 la DATABASE_URI variabile di ambiente.

conn_str = os.environ['AZURE_POSTGRESQL_CONNECTIONSTRING']
conn_str_params = {pair.split('=')[0]: pair.split('=')[1] for pair in conn_str.split(' ')}    
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql',
        'NAME': conn_str_params['dbname'],
        'HOST': conn_str_params['host'],
        'USER': conn_str_params['user'],
        'PASSWORD': conn_str_params['password'],
    }
}

CACHES = {
        "default": {  
            "BACKEND": "django_redis.cache.RedisCache",
            "LOCATION": os.environ.get('AZURE_REDIS_CONNECTIONSTRING'),
            "OPTIONS": {
                "CLIENT_CLASS": "django_redis.client.DefaultClient",
                "COMPRESSOR": "django_redis.compressors.zlib.ZlibCompressor",
        },
    }
}

Il codice dell'applicazione è ora configurato per connettersi al database PostgreSQL e alla cache Redis in Azure.

Nel terminale eseguire azd deploy.
```
azd deploy
```

4. Generare lo schema del database

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.

Flask
Django

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 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 python manage.py migrate. 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.

5. Passare all'app

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.
- Flask
- Django
A questo punto un'app Web è in esecuzione nel servizio app di Azure, con connettività sicura a Database di Azure per PostgreSQL.

6. Eseguire lo streaming dei log di diagnostica

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.

Flask
Django

@app.route('/', methods=['GET'])
def index():
    print('Request for index page received')
    restaurants = Restaurant.query.all()
    return render_template('index.html', restaurants=restaurants)

def index(request):
    print('Request for index page received')
    restaurants = Restaurant.objects.annotate(avg_rating=Avg('review__rating')).annotate(review_count=Count('review'))
    lastViewedRestaurant = request.session.get("lastViewedRestaurant", False)

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.

7. Pulire le risorse

Per eliminare tutte le risorse di Azure nell'ambiente di distribuzione corrente, eseguire azd down.

azd down

Risoluzione dei problemi

Di seguito sono elencati i problemi che possono verificarsi durante il tentativo di eseguire questa esercitazione e i passaggi per risolvere tali problemi.

Non è possibile connettersi alla sessione SSH

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

Viene visualizzato un errore durante l'esecuzione di migrazioni del database

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.

Domande frequenti

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?

Quanto costa questa configurazione?

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.

Come funziona lo sviluppo di app locali con GitHub Actions?

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

Come viene configurato l'esempio Django per l'esecuzione nel servizio app Azure?

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.

Passaggi successivi

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:

Configurare un'app Python

Condividi tramite

Distribuire un'app Web Python (Django o Flask) con PostgreSQL in Azure

Applicazione di esempio

1. Creare il Servizio app e PostgreSQL

2. Verificare le impostazioni di connessione

3. Distribuire il codice di esempio

4. Generare lo schema del database

5. Passare all'app

6. Eseguire lo streaming dei log di diagnostica

7. Pulire le risorse

1. Creare risorse di Azure e distribuire un'app di esempio

2. Utilizzare il database stringa di connessione

4. Generare lo schema del database

5. Passare all'app

6. Eseguire lo streaming dei log di diagnostica

7. Pulire le risorse

Risoluzione dei problemi

Non è possibile connettersi alla sessione SSH

Viene visualizzato un errore durante l'esecuzione di migrazioni del database

Domande frequenti

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?

Passaggi successivi

Commenti e suggerimenti

Risorse aggiuntive

Condividi tramite

Distribuire un'app Web Python (Django o Flask) con PostgreSQL in Azure

Passare alla fine

Applicazione di esempio

1. Creare il Servizio app e PostgreSQL

2. Verificare le impostazioni di connessione

3. Distribuire il codice di esempio

4. Generare lo schema del database

5. Passare all'app

6. Eseguire lo streaming dei log di diagnostica

7. Pulire le risorse

1. Creare risorse di Azure e distribuire un'app di esempio

2. Utilizzare il database stringa di connessione

4. Generare lo schema del database

5. Passare all'app

6. Eseguire lo streaming dei log di diagnostica

7. Pulire le risorse

Risoluzione dei problemi

Non è possibile connettersi alla sessione SSH

Viene visualizzato un errore durante l'esecuzione di migrazioni del database

Domande frequenti

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?

Passaggi successivi

Commenti e suggerimenti

Risorse aggiuntive