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

Articolo
12/09/2023

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. supporto del servizio app AzurePython in un ambiente server Linux.

Per completare questa esercitazione, è necessario:

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.
Interfaccia della riga di comando per sviluppatori di Azure installata. È possibile seguire la procedura con Azure Cloud Shell perché è già installata l'interfaccia della riga di comando per sviluppatori di Azure.
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 l'interfaccia della riga di comando per sviluppatori di Azure 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 di starter-no-infra 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 guida. Impostare il valore di DBNAME sul nome di un database esistente nell'istanza locale di PostgreSQL. Impostare i valori di DBHOST, DBUSERe 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 edizione StandardCRET_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

Eseguire l'applicazione di esempio con 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. I passaggi usati in questa esercitazione creano un set di risorse protette per impostazione predefinita che includono 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.

Accedere al portale di Azure e seguire questa procedura per creare le risorse del servizio app Azure.

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 un nome msdocs-python-postgres-tutorial.
Area → Qualsiasi area di Azure nelle vicinanze.
Nome → msdocs-python-postgres-XYZ dove XYZ è costituito da tre caratteri casuali. Il nome deve essere univoco in Azure
Stack di runtime → Python 3.10.
Database → PostgreSQL - Server flessibile è selezionato per impostazione predefinita come motore di database. Anche il nome del server e il nome del database vengono impostati per impostazione predefinita 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 servizio app, ma vengono create le risorse seguenti:

Gruppo di risorse → Contenitore per tutte le risorse create.
servizio app piano → Definisce le risorse di calcolo per 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 servizio app e isola il traffico di rete back-end.
Database di Azure per PostgreSQL server flessibile → Accessibile solo dall'interno della rete virtuale. Nel server vengono creati un database e un utente.
DNS privato zona → Abilita la risoluzione DNS del server PostgreSQL nella rete virtuale.

2. Verificare le impostazioni di connessione

La creazione guidata ha generato le variabili di connettività già come 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: nella pagina servizio app selezionare Configurazione nel menu a sinistra.

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: nella pagina servizio app selezionare Configurazione nel menu a sinistra.

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. Denominare l'impostazione SECRET_KEY. Incollare il valore del valore precedente. Selezionare 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 in servizio app, ma anche un ottimo modo per avere l'integrazione continua nel processo di distribuzione. Per impostazione predefinita, ogni git push 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 nell'elenco delle cartelle. 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.
In Ramo selezionare main.
Mantenere selezionata l'opzione predefinita per Aggiungere un flusso di lavoro.
In Tipo di autenticazione selezionare Identità assegnata dall'utente.
Nel menu in alto selezionare Salva. servizio app esegue il commit di un file del flusso di lavoro nel repository GitHub scelto, nella .github/workflows directory .

Passaggio 6: Nella pagina Centro distribuzione:

Selezionare Log. È già stata avviata un'esecuzione di distribuzione.
Nell'elemento di log per l'esecuzione della distribuzione selezionare Compila/Distribuisci log.

Passaggio 7: Si è eseguiti nel repository GitHub e si noterà 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 mostri lo stato Completato. 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.
In Ramo selezionare main.
Nel menu in alto selezionare Salva. servizio app esegue il commit di un file del flusso di lavoro nel repository GitHub scelto, nella .github/workflows directory .

Passaggio 6: Nella pagina Centro distribuzione:

Selezionare Log. È già stata avviata un'esecuzione di 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.
Selezionare Vai.

Passaggio 2: Nel terminale SSH eseguire flask db upgrade. Se ha esito positivo, servizio app si connette correttamente al database. Solo le modifiche apportate ai file in /home possono essere mantenute oltre 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.
Selezionare Vai.

Passaggio 2: Nel terminale SSH eseguire python manage.py migrate. Se ha esito positivo, servizio app si connette correttamente al database. Solo le modifiche apportate ai file in /home possono essere mantenute oltre 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. Si sta eseguendo un'app Web nel servizio app 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. Si sta eseguendo un'app Web nel servizio app 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. Trasmettere i log di diagnostica

app Azure Servizio acquisisce tutti i messaggi di output nella console per diagnosticare i problemi relativi all'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 servizio app log.
In Registrazione applicazioni 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.

Altre informazioni sulla registrazione nelle app Python nella 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 in servizio app in Linux. I passaggi usati in questa esercitazione creano un set di risorse protette per impostazione predefinita che includono servizio app e Database di Azure per PostgreSQL.

Se non è già stato fatto, 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 per effettuare il azd up 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 azd up comando richiederà anche di selezionare la sottoscrizione e il percorso desiderati in cui eseguire la distribuzione.
```
azd up
```
Il completamento del azd up comando potrebbe richiedere alcuni minuti. Compila e distribuisce anche il codice dell'applicazione, ma il codice verrà modificato in un secondo momento per lavorare con 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 secure-by-default con le risorse di Azure seguenti:
- Flask
- Django
- Gruppo di risorse → Contenitore per tutte le risorse create.
- servizio app piano → Definisce le risorse di calcolo per servizio app. Viene specificato 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 servizio app e isola il traffico di rete back-end.
- Database di Azure per PostgreSQL server flessibile → Accessibile solo dall'interno della rete virtuale. Nel server vengono creati un database e un utente.
- DNS privato zona → Abilita la risoluzione DNS del server PostgreSQL nella rete virtuale.
- L'area di lavoro Log Analytics → funge da contenitore di destinazione per l'app per la spedizione dei log, in cui è anche possibile eseguire query sui log.
- Gruppo di risorse → Contenitore per tutte le risorse create.
- servizio app piano → Definisce le risorse di calcolo per servizio app. Viene specificato 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 servizio app e isola il traffico di rete back-end.
- Database di Azure per PostgreSQL server flessibile → Accessibile solo dall'interno della rete virtuale. Nel server vengono creati un database e un utente.
- cache di Azure per Redis → Accessibile solo dall'interno della rete virtuale.
- DNS privato zona → Abilita la risoluzione DNS del server PostgreSQL nella rete virtuale.
- L'area di lavoro Log Analytics → funge da contenitore di destinazione per l'app per la spedizione dei log, in cui è anche possibile 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, servizio app si connette correttamente al database.

Nota

Solo le modifiche apportate ai file in /home possono essere mantenute oltre 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, servizio app si connette correttamente al database.

Nota

Solo le modifiche apportate ai file in /home possono essere mantenute oltre 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
Si sta eseguendo un'app Web nel servizio app Azure, con connettività sicura a Database di Azure per PostgreSQL.

6. Trasmettere i log di diagnostica

app Azure Servizio 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 Analytics.

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

Altre informazioni sulla registrazione nelle app Python nella 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 risolverli.

Non è possibile connettersi alla sessione SSH

Se non è possibile connettersi alla sessione SSH, l'app stessa non è stata avviata. Controllare i log di diagnostica per informazioni dettagliate. Ad esempio, se viene visualizzato un errore simile KeyError: 'AZURE_POSTGRESQL_CONNECTIONSTRING'a , potrebbe significare che la variabile di ambiente è mancante (potrebbe essere stata rimossa l'impostazione dell'app).

Viene visualizzato un errore durante l'esecuzione di migrazioni di 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 migrate non può comunicare con il database.

Domande frequenti

Quanto costa questa configurazione?
Ricerca per categorie 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 o ridotto. Vedere Prezzi del servizio app.
Il server flessibile PostgreSQL viene creato nel livello con burst più basso Standard_B1ms, con le dimensioni di archiviazione minime, che possono essere ridimensionate verso l'alto o verso il basso. 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 di Azure Rete virtuale.
La zona DNS privata comporta un piccolo addebito. Vedere Prezzi di DNS di Azure.

Ricerca per categorie 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, la macchina 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?

Usando il file del flusso di lavoro generato automaticamente da servizio app come esempio, viene avviata git push una nuova esecuzione di compilazione e distribuzione. Da un clone locale del repository GitHub si apportano gli aggiornamenti desiderati e si esegue il push 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 requirements.txt nel file README.md di ogni progetto (Flask, Django) per visualizzare 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 e certificato personalizzati

Vedere le informazioni sul modo in cui il Servizio app esegue un'app Python:

Configurare un'app Python

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

Vai alla fine

Applicazione di esempio

1. Creare 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. Trasmettere i 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. Trasmettere i 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 di database

Domande frequenti

Quanto costa questa configurazione?

Ricerca per categorie 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

Risorse aggiuntive