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

In questa esercitazione si distribuisce un'app Web Python guidata dai dati nel servizio app di Azure con il servizio di database relazionale di Database di Azure per PostgreSQL . Servizio app di Azure supporta Python in un ambiente server Linux. Questo articolo usa un'app Flask . Le opzioni includono Django o FastAPI tutorial.

In questa esercitazione verranno illustrate le procedure per:

• Creare un'architettura di servizio App, PostgreSQL e cache Redis sicura per impostazione predefinita.
• Proteggere i segreti di connessione usando un'identità gestita e riferimenti a Key Vault.
• Distribuire un'app Python di esempio nel servizio app da un repository GitHub.
• Accedere alle stringhe di connessione del Servizio app nel codice dell'applicazione.
• Apportare aggiornamenti e ridistribuire il codice dell'applicazione.
• Generare lo schema del database eseguendo le migrazioni del database.
• Eseguire lo streaming dei log di diagnostica in Azure.
• Gestire l'app nel portale di Azure.
• Effettuare il provisioning della stessa architettura ed effettuare l'implementazione usando Azure Developer CLI.
• Ottimizzare il flusso di lavoro di sviluppo con GitHub Codespaces e GitHub Copilot.

Prerequisiti

• Un account Azure con una sottoscrizione attiva. Se non si ha un account Azure, è possibile crearne uno gratuitamente.
• Un account GitHub. È anche possibile ottenerne uno gratuitamente.
• Conoscenza di Python con esperienza di sviluppo Flask.
• (Facoltativo) Per provare GitHub Copilot, un account GitHub Copilot. È disponibile una versione di valutazione gratuita di 30 giorni.

• Un account Azure con una sottoscrizione attiva. Se non si ha un account Azure, è possibile crearne uno gratuitamente.
• Un account GitHub. È anche possibile ottenerne uno gratuitamente.
• Azure Developer CLI 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 esperienza di sviluppo Flask.
• (Facoltativo) Per provare GitHub Copilot, un account GitHub Copilot. È disponibile una versione di valutazione gratuita di 30 giorni.

Passare alla fine

Se si vuole visualizzare l'app di esempio in questa esercitazione in esecuzione in Azure, eseguire i comandi seguenti in Azure Cloud Shell e seguire il prompt:

mkdir msdocs-flask-postgresql-sample-app
cd msdocs-flask-postgresql-sample-app
azd init --template msdocs-flask-postgresql-sample-app
azd up

Esegui l'esempio

Come punto di partenza, configurare un'app guidata dai dati di esempio. Per tua comodità, il repository di esempio include una configurazione del contenitore di sviluppo. Il contenitore di sviluppo ha tutto il necessario per sviluppare un'applicazione. Include il database, la cache e tutte le variabili di ambiente necessarie per l'applicazione di esempio. Il contenitore di sviluppo può essere eseguito in uno spazio di codice GitHub, in modo da poter eseguire l'esempio in qualsiasi computer con un Web browser.

Note

** Se stai seguendo questa esercitazione con la tua app, controlla la descrizione del file requirements.txt in README.md per vedere quali pacchetti sono necessari.

Passaggio 1: In una nuova finestra del browser:

1. Accedi all'account GitHub.
2. Accedere a https://github.com/Azure-Samples/msdocs-flask-postgresql-sample-app/fork.
3. Deselezionare Copia solo il ramo principale. Si desiderano tutti i rami.
4. Selezionare Crea fork.

Passaggio 2: Nel fork di GitHub:

1. Selezionare main>starter-no-infra per il ramo starter. Questo ramo contiene solo il progetto di esempio senza file o configurazione correlati ad Azure.
2. Seleziona Codice. Nella scheda Codespaces (Spazi di codice ) selezionare Create codespace on starter-no-infra (Crea spazio di codice nello starter-no-infra). La configurazione del codespace richiede alcuni minuti. L'operazione viene eseguita pip install -r requirements.txt per il repository.

Passaggio 3: Nel terminale codespace:

1. Eseguire le migrazioni del database con flask db upgrade.
2. Eseguire l'app con flask run.
3. Quando viene visualizzata la notifica Your application running on port 5000 is available., selezionare Apri nel browser. L'applicazione di esempio dovrebbe essere visualizzata in una nuova scheda del browser. Per arrestare l'applicazione, digitare Ctrl+C.

Suggerimento

È possibile chiedere a GitHub Copilotinformazioni su questo repository. Ad esempio:

• @workspace Cosa fa questo progetto?
• @workspace Cosa fa la cartella .devcontainer?

Problemi? Controllare la sezione Risoluzione dei problemi.

Creare App Service e PostgreSQL

In questa sezione vengono create le risorse di Azure. Questa esercitazione crea un set di risorse sicure per impostazione standard che includono App Service e Database di Azure per PostgreSQL. Per il processo di creazione, :è necessario specificare:

• Nome dell'app Web. Viene usato come parte del nome DNS per l'app.
• La regione in cui eseguire fisicamente l'app nel mondo. Fa anche parte del nome DNS per l'app.
• Lo stack di runtime per l'app. Versione di Python da usare per l'app.
• Piano di hosting per l'app. Piano tariffario che include il set di funzionalità e capacità di scalabilità per l'app.
• Gruppo di risorse per l'app. Un gruppo di risorse consente di raggruppare le risorse di Azure per l'applicazione in un contenitore logico.

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

Passaggio 1: Nel portale di Azure:

1. Nella parte superiore del portale di Azure immettere il database dell'app Web nella barra di ricerca.
2. Nell'intestazione Marketplace selezionare l'elemento con etichetta App Web e database. È anche possibile passare direttamente a Crea app Web .

Passaggio 2: Nella pagina Crea app Web e database compilare il modulo come indicato di seguito.

1. Gruppo di risorse: selezionare Crea nuovo e usare un nome msdocs-flask-postgres-tutorial.
2. Area: qualsiasi area di Azure nelle vicinanze.
3. Nome: msdocs-python-postgres-XYZ.
4. Stack di runtime: Python 3.14.
5. Database: PostgreSQL - Server flessibile è selezionato per impostazione predefinita come motore di database. Per impostazione predefinita, il nome del server e il nome del database vengono impostati sui valori appropriati.
6. Aggiungere Azure Cache per Redis?: No.
7. Piano di hosting: Basic. Quando si è pronti, è possibile aumentare a un piano tariffario di produzione.
8. Selezionare Rivedi e crea.
9. Al termine della convalida, selezionare Crea.

Passaggio 3: La distribuzione richiede alcuni minuti. Al completamento della distribuzione, selezionare Vai alla risorsa. La distribuzione crea 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. La distribuzione crea un piano Linux nel livello Basic .
• App Service: rappresenta la tua app e viene eseguita nel piano App Service.
• Rete virtuale: integrata con l'app del servizio app, isola il traffico di rete back-end.
• Interfacce di rete: rappresenta gli indirizzi IP privati, uno per ognuno degli endpoint privati.
• 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.
• Zone DNS private: Abilita la risoluzione DNS dell'archivio chiavi e del server di database nella rete virtuale.

Proteggere i segreti di connessione

Il processo di distribuzione genera le variabili di connettività per l'utente come impostazioni dell'app. La procedura consigliata per la sicurezza consiste nel mantenere i segreti completamente fuori da App Service. Spostare i segreti in un Key Vault e modificare la configurazione dell'applicazione con Riferimenti a Key Vault con l'aiuto di Service Connectors.

Passaggio 1: Recuperare la stringa di connessione esistente:

1. Nel menu a sinistra della pagina Servizio app selezionare Impostazioni Variabili>di ambiente.
2. Selezionare AZURE_POSTGRESQL_CONNECTIONSTRING.
3. Nel campo Valoredell'impostazione Aggiungi/Modifica applicazione trovare password= alla fine della stringa.
4. Copiare la stringa della password dopo password= per usarla in un secondo momento. Questa impostazione dell'app consente di connettersi al database Postgres protetto dietro un endpoint privato. Il segreto viene salvato direttamente nell'app del servizio app, procedura non consigliata. Successivamente, si modifica questa configurazione.

Passaggio 2. Creare un insieme di credenziali delle chiavi per la gestione sicura dei segreti:

1. Nella barra di ricerca superiore digitare "Key Vault", quindi selezionare Marketplace>Key Vault.
2. In Gruppo di risorse selezionare msdocs-python-postgres-tutorial.
3. In Nome insieme di credenziali delle chiavi digitare un nome costituito solo da lettere e numeri.
4. In Area impostarlo sulla stessa posizione del gruppo di risorse.

Passaggio 3: Proteggere il vault delle chiavi con un endpoint privato:

1. Selezionare Rete.
2. Deselezionare Abilita l'accesso pubblico.
3. Selezionare Crea un endpoint privato.
4. In Gruppo di risorse selezionare msdocs-python-postgres-tutorial.
5. Nella finestra di dialogo, in Posizione, selezionare la stessa posizione dell'app del servizio App Service.
6. In Nome, digitare msdocs-python-postgres-XYZVaultEndpoint.
7. In Rete virtuale selezionare msdocs-python-postgres-XYZVnet.
8. In Subnet selezionare msdocs-python-postgres-XYZSubnet.
9. Selezionare OK.
10. Selezionare Rivedi e crea e quindi crea. Attendere il completamento della distribuzione dell'insieme di credenziali delle chiavi. Si noterà che la distribuzione è stata completata.

Passaggio 4: Configurare il connettore PostgreSQL:

1. Nella barra di ricerca superiore digitare msdocs-python-postgres, quindi selezionare la risorsa del servizio app denominata msdocs-python-postgres-XYZ.
2. Nel menu a sinistra della pagina Servizio app selezionare Impostazioni>Service Connector. Esiste già un connettore, creato automaticamente dal processo di distribuzione.
3. Selezionare la casella di controllo accanto al connettore PostgreSQL e quindi selezionare Modifica.
4. In Tipo di client selezionare Django. Anche se si dispone di un'app Flask, il tipo di client Django nel connettore del servizio PostgreSQL offre variabili di database in impostazioni separate anziché una stringa di connessione. Le variabili separate sono più facili da usare nel codice dell'applicazione, che usa SQLAlchemy per connettersi al database.
5. Selezionare Autenticazione.
6. In Password incollare la password copiata in precedenza.
7. Selezionare Archiviare Segreto in Key Vault.
8. In Connessione a Key Vault selezionare Crea nuovo. Viene visualizzata una finestra di dialogo Crea connessione nella parte superiore della finestra di dialogo di modifica.

Passaggio 5: Stabilire la connessione di Key Vault:

1. Nella finestra di dialogo Crea connessione per la connessione a Key Vault, nel Key Vault selezionare il key vault che hai creato in precedenza.
2. Selezionare Verifica e crea.
3. Al termine della convalida, selezionare Crea.

Passaggio 6: Finalizzare le impostazioni del connettore PostgreSQL:

1. Si torna alla finestra di dialogo di modifica per defaultConnector. Nella scheda Autenticazione attendere la creazione del connettore dell'insieme di credenziali delle chiavi. Al termine della creazione, l'elenco a discesa Connessione di Key Vault lo seleziona automaticamente.
2. Selezionare Avanti: Rete.
3. Selezionare Salva. Attendere che venga visualizzata la notifica Aggiornamento riuscito.

Passaggio 7: Verificare l'integrazione di Key Vault

1. Nel menu a sinistra selezionare di nuovo Impostazioni Variabili>di ambiente .
2. Accanto a AZURE_POSTGRESQL_PASSWORD selezionare Mostra valore. Il valore deve essere @Microsoft.KeyVault(...), il che significa che si tratta di un riferimento al Key Vault. Il segreto è ora gestito nell'insieme di credenziali delle chiavi.

Per riepilogare, il processo di protezione dei segreti di connessione implica:

• Recupero dei segreti di connessione dalle variabili di ambiente dell'app del servizio app.
• Creazione di un insieme di credenziali delle chiavi.
• Creazione di una connessione di Key Vault con l'identità gestita assegnata dal sistema.
• Aggiornamento dei connettori di servizi per archiviare i segreti nell'insieme di credenziali delle chiavi.

Problemi? Controllare la sezione Risoluzione dei problemi.

---

Distribuire il codice di esempio

In questa sezione viene configurata la distribuzione di GitHub usando GitHub Actions. È uno dei molti modi per eseguire la distribuzione su servizio App. È un ottimo modo per avere l'integrazione continua nel processo di distribuzione. Per impostazione predefinita, ogni git push nel repository GitHub avvia l'azione di compilazione e distribuzione.

Passaggio 1: Nel menu a sinistra selezionare Centro distribuzione>.

Passaggio 2: Nella pagina Centro distribuzione :

1. In Origine selezionare GitHub. Per impostazione predefinita, GitHub Actions è selezionato come provider di compilazione.
2. Accedere all'account GitHub e seguire la richiesta di autorizzare Azure.
3. In Organizzazione selezionare l'account.
4. In Repository selezionare msdocs-flask-postgresql-sample-app.
5. In Ramo, selezionare starter-no-infra. Questo ramo è lo stesso usato con l'app di esempio, senza file o configurazione correlati ad Azure.
6. Per Tipo di autenticazione selezionare Identità assegnata dall'utente.
7. Nel menu in alto selezionare Salva. Il servizio app esegue il commit di un file del flusso di lavoro nel repository GitHub scelto, nella .github/workflows directory . Per impostazione predefinita, il centro distribuzione crea un'identità assegnata dall'utente per l'autenticazione tramite Microsoft Entra (autenticazione OIDC). Per altre opzioni di autenticazione, consultare Distribuire su App Service usando GitHub Actions.

Passaggio 3: Tornare allo spazio di codice GitHub del fork di esempio, eseguire git pull origin starter-no-infra. Questo comando importa il file del flusso di lavoro appena confermato nel tuo codespace.

Passaggio 4 (opzione 1: con GitHub Copilot):

1. Avviare una nuova sessione di chat selezionando la visualizzazione Chat , quindi selezionare +.
2. Chiedere @workspace Come si connette l'app al database? Copilot potrebbe fornire una spiegazione su SQLAlchemy, ad esempio la configurazione dell'URI di connessione in azureproject/development.py e azureproject/production.py.
3. Chiedi a @workspace in modalità produzione, la mia app è in esecuzione in un'app Web di App Service, che usa Azure Service Connector per connettersi a un server flessibile PostgreSQL utilizzando il tipo di client Django. Quali sono i nomi delle variabili di ambiente che devo usare? Copilot potrebbe fornire un suggerimento di codice simile a quello nei passaggi di Opzione 2: senza GitHub Copilot e persino guidarti a fare cambiamenti nel file azureproject/production.py.
4. Apri azureproject/production.py nell'esploratore e aggiungi il suggerimento del codice. GitHub Copilot non offre la stessa risposta ogni volta. Le risposte non sono sempre corrette. Potrebbe essere necessario porre altre domande per ottimizzare la risposta. Per suggerimenti, vedere Cosa è possibile fare con GitHub Copilot nello spazio di codice?

Passaggio 4 (opzione 2: senza GitHub Copilot):

1. Apri azureproject/production.py nell'esploratore.
2. Trovare il codice commentato (righe 3-8) e rimuovere il commento. Questa modifica crea una stringa di connessione per SQLAlchemy usando AZURE_POSTGRESQL_USER, AZURE_POSTGRESQL_PASSWORDAZURE_POSTGRESQL_HOST, e AZURE_POSTGRESQL_NAME.

Passaggio 5:

1. Selezionare l'estensione Controllo del codice sorgente .
2. Nella casella di testo digitare un messaggio di commit come Configure Azure database connection. In alternativa, selezionare e lasciare che GitHub Copilot generi automaticamente un messaggio di commit.
3. Selezionare Commit e quindi confermare con Sì.
4. Selezionare Sincronizza modifiche 1, quindi confermare con OK.

Passaggio 6: Tornare alla pagina Centro distribuzione nel portale di Azure:

1. Selezionare Log e quindi Aggiorna per visualizzare la nuova esecuzione della distribuzione.
2. Nell'elemento di log per l'esecuzione della distribuzione selezionare la voce Build/Deploy Logs con il timestamp più recente.

Passaggio 7: Si viene visualizzati nel repository GitHub. 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 Operazione riuscita. Ci vogliono circa 5 minuti.

Problemi? Consultare la guida alla risoluzione dei problemi.

Generare 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 Linux nel servizio app.

Passaggio 1: Tornare alla pagina Servizio app nel menu a sinistra

1. Selezionare Strumenti di> sviluppoSSH.
2. Selezionare Vai.

Passaggio 2: Nella sessione SSH eseguire flask db upgrade. Se ha esito positivo, il servizio app si connette correttamente al database.

Suggerimento

Nella sessione SSH 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.

Problemi? Controllare la sezione Risoluzione dei problemi.

Passare all'app

Passaggio 1: Nella pagina Servizio app :

1. Nel menu a sinistra selezionare Panoramica.
2. Selezionare l'URL dell'app.

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.

Trasmettere i log di diagnostica

Azure App Service acquisisce tutti i log della console per aiutare a diagnosticare i problemi relativi alla tua 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 :

1. Nel menu a sinistra selezionare Monitoraggio>Log di servizio app.
2. In Registrazione applicazioni selezionare File System.
3. Nel menu in alto selezionare Salva.

Passaggio 2: Nel 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 Configurare Monitoraggio di Azure per l'applicazione Python.

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:

1. Immettere il nome del gruppo di risorse.
2. Selezionare il gruppo di risorse.

Passaggio 2: Nella pagina del gruppo di risorse selezionare Elimina gruppo di risorse.

Passaggio 3:

1. Per confermare l'eliminazione, immettere il nome del gruppo di risorse.
2. Selezionare Elimina.
3. Confermare nuovamente con Elimina.

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.

Il container di sviluppo ha già l'Azure Developer CLI (AZD).

1. Dalla radice del repository eseguire azd init.

   azd init --template python-app-service-postgresql-infra
   

2. Quando richiesto, fornire le risposte seguenti:

   Domanda	Risposta
   La directory corrente non è vuota. Inizializzare un progetto qui in "<your-directory>"?	S
   Cosa si vuole 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>-<hash>.azurewebsites.net). Sono consentiti caratteri alfanumerici e trattini.

3. Accedere ad Azure eseguendo il comando azd auth login e seguendo il prompt:

   azd auth login
   

4. Creare le risorse di Azure necessarie con il comando azd provision. Seguire la richiesta di selezionare la sottoscrizione e il percorso desiderati per le risorse di Azure.

   azd provision
   

   Il completamento del azd provision comando richiede circa 15 minuti. La cache Redis richiede più tempo. Successivamente, modificare il codice per usare il servizio app e distribuire le modifiche con azd deploy. Durante l'esecuzione, il comando fornisce messaggi sul processo di provisioning e distribuzione, incluso un collegamento alla distribuzione in Azure.

   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. Crea un piano Linux nel livello Basic .
   • App Service: rappresenta la tua app e viene eseguita nel piano App Service.
   • Rete virtuale: integrata con l'app del servizio app, isola il traffico di rete back-end.
   • Endpoint privati: accedere agli endpoint per l’insieme di credenziali delle chiavi e la cache Redis nella rete virtuale.
   • Interfacce di rete: rappresenta gli indirizzi IP privati, uno per ognuno degli endpoint privati.
   • Server flessibile di Database di Azure per PostgreSQL: accessibile solo da nella 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 per la spedizione dei log, in cui è anche possibile eseguire query sui log.
   • Cache di Azure per Redis: accessibile solo da dietro l'endpoint privato.
   • Insieme di credenziali delle chiavi: accessibile solo da dietro l'endpoint privato. Usato per gestire i segreti per l'app del Servizio app.

   Al termine della creazione delle risorse e della distribuzione del codice dell'applicazione, al primo tentativo, l'app di esempio implementata non funziona ancora. È necessario apportare piccole modifiche per connettersi al database in Azure.

Problemi? Controllare la sezione Risoluzione dei problemi.

Usare la stringa di connessione del database

Il modello AZD che utilizzi ha già generato per te le variabili di connettività come impostazioni dell'app. Li restituisce al terminale. Le impostazioni dell'app sono un modo per mantenere i segreti di connessione all'esterno del repository di codice.

1. Nell'output AZD trovare le impostazioni AZURE_POSTGRESQL_USER, AZURE_POSTGRESQL_PASSWORD, AZURE_POSTGRESQL_HOSTe AZURE_POSTGRESQL_NAME. Per proteggere i segreti, vengono visualizzati solo i nomi delle impostazioni. L'output AZD è simile al seguente:

   App Service app has the following connection settings:
           - AZURE_POSTGRESQL_NAME
           - AZURE_POSTGRESQL_HOST
           - AZURE_POSTGRESQL_USER
           - AZURE_POSTGRESQL_PASSWORD
           - AZURE_REDIS_CONNECTIONSTRING
           - AZURE_KEYVAULT_RESOURCEENDPOINT
           - AZURE_KEYVAULT_SCOPE
   

2. Per praticità, il modello AZD mostra il collegamento diretto alla pagina delle impostazioni dell'app. Trovare il collegamento e aprirlo in una nuova scheda del browser.

Problemi? Controllare la sezione Risoluzione dei problemi.

Modificare il codice di esempio e ridistribuire

Con GitHub Copilot

1. Nello spazio di codice GitHub avviare una nuova sessione di chat selezionando la visualizzazione Chat e quindi selezionare +.

2. Chiedere @workspace Come si connette l'app al database? Copilot potrebbe fornire una spiegazione su SQLAlchemy, ad esempio la configurazione dell'URI di connessione in azureproject/development.py e azureproject/production.py.

3. Chiedi a @workspace: in modalità di produzione, la mia app viene eseguita in un'app Web del servizio App, che utilizza Azure Service Connector per connettersi a un server flessibile PostgreSQL utilizzando il client Django. Quali sono i nomi delle variabili di ambiente che devo usare? Copilot potrebbe fornire un suggerimento di codice simile a quello specificato in Opzione 2: senza GitHub Copilot e persino suggerirti di apportare la modifica nel file azureproject/production.py.

4. Apri azureproject/production.py nell'esploratore e aggiungi il suggerimento del codice.

   GitHub Copilot non offre la stessa risposta ogni volta. Le risposte non sono sempre corrette. Potrebbe essere necessario porre altre domande per ottimizzare la risposta. Per suggerimenti, vedere Cosa posso fare con GitHub Copilot nel mio spazio di codice?.

5. Nel terminale eseguire azd deploy.

   azd deploy
   

Senza GitHub Copilot

1. È necessario usare le quattro impostazioni dell'app per la connettività nel servizio app. Aprire azureproject/production.py, rimuovere il commento dalle righe seguenti (righe 3-8) e salvare il file:

   DATABASE_URI = 'postgresql+psycopg2://{dbuser}:{dbpass}@{dbhost}/{dbname}'.format(
       dbuser=os.getenv('AZURE_POSTGRESQL_USER'),
       dbpass=os.getenv('AZURE_POSTGRESQL_PASSWORD'),
       dbhost=os.getenv('AZURE_POSTGRESQL_HOST'),
       dbname=os.getenv('AZURE_POSTGRESQL_NAME')
   )
   

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

2. Nel terminale eseguire azd deploy.

   azd deploy
   

Note

Se si esegue azd up, si combinano azd package, azd provision e azd deploy. Il motivo per cui non è stato eseguito questo comando all'inizio è dovuto al fatto che non sono state ancora disponibili le impostazioni di connessione PostgreSQL per modificare il codice. Se si esegue il azd up comando, la fase di distribuzione si blocca perché il server Gunicorn non sarà in grado di avviare l'app senza impostazioni di connessione valide.

Problemi? Controllare la sezione Risoluzione dei problemi.

Generare 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 Linux nel servizio app.

1. 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: <URL>
   

2. Nella sessione SSH eseguire flask db upgrade. Se ha esito positivo, il servizio app si connette correttamente al database.

   

   Note

   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.

Problemi? Controllare la sezione Risoluzione dei problemi.

Passare all'app

1. 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: <URL>
   

2. Aggiungere alcuni ristoranti all'elenco.

   

   Congratulazioni! Stai eseguendo un'app Web nel Servizio App di Azure, con connettività sicura ad Azure Database per PostgreSQL.

Problemi? Controllare la sezione Risoluzione dei problemi.

Trasmettere i log di diagnostica

Il servizio app di Azure può acquisire i log della console per diagnosticare i problemi relativi all'applicazione. Il modello AZD consente già di accedere al file system locale e di inviare i log a un'area di lavoro Log Analytics.

L'applicazione di esempio include istruzioni print() 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 individuare il collegamento per trasmettere in streaming i log del servizio app e passarvi nel browser.

Scopri di più sul logging nelle applicazioni Python nella serie sulla configurazione di Monitoraggio di Azure per la tua applicazione Python.

Problemi? Controllare la sezione Risoluzione dei problemi.

Pulire le risorse

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

azd down

Risoluzione dei problemi

Ecco alcuni 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_HOST'a , potrebbe significare che la variabile di ambiente è mancante. Forse hai rimosso 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_USER, AZURE_POSTGRESQL_PASSWORD, AZURE_POSTGRESQL_HOSTe AZURE_POSTGRESQL_NAME) sono state modificate o eliminate. Senza tale stringa di connessione, il comando di migrazione non può comunicare con il database.

Domande frequenti

• Quanto costa questa configurazione?
• Come ci si connette al server PostgreSQL protetto dietro la rete virtuale con altri strumenti?
• Come funziona lo sviluppo di app locali con GitHub Actions?
• Come si esegue il debug degli errori durante la distribuzione di GitHub Actions?
• Non si dispone delle autorizzazioni per creare un'identità assegnata dall'utente
• Cosa è possibile fare con GitHub Copilot nello spazio di codice?

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 burst più basso Standard_B1ms, con le dimensioni minime di archiviazione, che possono essere ridimensionate verso l'alto o verso il basso. Consulta Database di Azure per PostgreSQL: prezzi.
• 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 dalla sessione SSH dell'app.
• Per connettersi da uno strumento desktop, il computer deve trovarsi nella rete virtuale. Ad esempio, potrebbe trattarsi di una macchina virtuale di Azure connessa a una delle subnet o a 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?

Per il file del flusso di lavoro generato automaticamente da App Service, ad esempio, ogni git push avvia una nuova esecuzione di compilazione e 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 si esegue il debug degli errori durante la distribuzione di GitHub Actions?

Se un passaggio non riesce nel file del flusso di lavoro GitHub generato automaticamente, provare a modificare il comando non riuscito per generare un output più dettagliato. Ad esempio, è possibile ottenere un output dettagliato dal comando python aggiungendo l'opzione -d. Eseguire il commit e il push delle modifiche per attivare un'altra distribuzione nel servizio app.

Non si dispone delle autorizzazioni per creare un'identità assegnata dall'utente

Vedere Configurare la distribuzione di GitHub Actions dal Centro distribuzione.

Cosa è possibile fare con GitHub Copilot nel codespace?

Potresti aver notato che la finestra di chat di GitHub Copilot era già presente quando hai creato il codespace. Per praticità, includiamo l'estensione di chat Di GitHub Copilot nella definizione del contenitore. Vedere .devcontainer/devcontainer.json. È necessario un account GitHub Copilot. È disponibile una versione di valutazione gratuita di 30 giorni.

Alcuni suggerimenti per l'utente quando si parla con GitHub Copilot:

• In una singola sessione di chat, le domande e le risposte si basano l'una sull'altra. È possibile modificare le domande per ottimizzare la risposta che si ottiene.
• Per impostazione predefinita, GitHub Copilot non ha accesso ad alcun file nel repository. Per porre domande su un file, aprire prima il file nell'editor.
• Per consentire a GitHub Copilot di accedere a tutti i file nel repository quando si preparano le risposte, iniziare la domanda con @workspace. Per altre informazioni, vedere Use the @workspace agent.
• Nella sessione di chat, GitHub Copilot può suggerire modifiche e, con @workspace, indicare anche dove effettuarle, ma non è consentito apportarle. È necessario aggiungere le modifiche suggerite e testarle.

Contenuti correlati

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 l'app Python