Condividi tramite

Distribuire un'app Web Python Django con PostgreSQL in Azure

  • Articolo

In questa esercitazione si distribuirà un'app Web Python guidata dai dati (Django) 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. Se si vuole, vedere l'esercitazionesu Flask o l'esercitazione fastAPI.

Diagramma dell'architettura che mostra un Servizio app con un database PostgreSQL in Azure.

In questa esercitazione apprenderai a:

  • Creare un'architettura di cache servizio app sicura per impostazione predefinita, PostgreSQL e Redis.
  • Proteggere i segreti di connessione usando un'identità gestita e riferimenti a Key Vault.
  • Distribuire un'app Python di esempio in servizio app da un repository GitHub.
  • Accedere alle servizio app stringa di connessione e alle impostazioni dell'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

Passare alla fine

Se si vuole solo 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-django-postgresql-sample-app
cd msdocs-django-postgresql-sample-app
azd init --template msdocs-django-postgresql-sample-app
azd up

1. Eseguire l'esempio

Prima di tutto, configurare un'app guidata dai dati di esempio come punto di partenza. Per praticità, il repository di esempio include una configurazione del contenitore di sviluppo. Il contenitore di sviluppo include tutti gli elementi necessari per sviluppare un'applicazione, tra cui il database, la cache e tutte le variabili di ambiente necessarie per l'applicazione di esempio. Il contenitore di sviluppo può essere eseguito in un codespace GitHub, il che significa che è possibile eseguire l'esempio in qualsiasi computer con un Web browser.

Nota

Se si segue questa esercitazione con la propria app, esaminare la descrizione del file requirements.txt in README.md per vedere quali pacchetti saranno necessari.

Passaggio 1: in una nuova finestra del browser:

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

Screenshot che mostra come creare un fork del repository GitHub di esempio.

Passaggio 2: Nel fork di GitHub:

  1. Selezionare main>starter-no-infra per il ramo starter. Questo ramo contiene solo il progetto di esempio e nessun file o configurazione correlati ad Azure.
  2. Selezionare Codice>Creare codespace in starter-no-infra. La configurazione dello spazio di codice richiede alcuni minuti e viene eseguita pip install -r requirements.txt per il repository alla fine. Inoltre, il file con estensione env fornito contiene già una variabile fittizia SECRET_KEY che Django deve eseguire in locale.

Screenshot che mostra come creare un codespace in GitHub.

Passaggio 3: nel terminale codespace:

  1. Eseguire le migrazioni del database con python manage.py migrate.
  2. Eseguire l'app con python manage.py runserver.
  3. Quando viene visualizzata la notifica Your application running on port 8000 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.

Screenshot che mostra come eseguire l'applicazione di esempio all'interno del codespace GitHub.

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.

2. Creare servizio app, database e cache

In questo passaggio si creano le risorse di Azure. I passaggi usati in questa esercitazione creano un set di risorse sicure per impostazione predefinita che includono servizio app, Database di Azure per PostgreSQL e Cache di Azure. Per il processo di creazione, :è necessario specificare:

  • Nome dell'app Web. Viene usato come parte del nome DNS per l'app sotto forma di https://<app-name>-<hash>.<region>.azurewebsites.net.
  • Area in cui eseguire l'app fisicamente nel mondo. Viene usato anche come parte del nome DNS per l'app.
  • Stack di runtime per l'app. È qui che si seleziona la versione di Python da usare per l'app.
  • Piano di hosting per l'app. Si tratta del piano tariffario che include il set di funzionalità e la capacità di ridimensionamento per l'app.
  • Gruppo di risorse per l'app. Un gruppo di risorse consente di raggruppare (in un contenitore logico) tutte le risorse di Azure necessarie per l'applicazione.

Per creare risorse del Servizio app di Azure, accedere al portale di Azure e seguire questa procedura.

Passaggio 1: nel portale di Azure:

  1. Immettere "database dell'app Web" nella barra di ricerca nella parte superiore del portale di Azure.
  2. Selezionare l'elemento con etichetta App Web e database sotto l'intestazione Marketplace. È anche possibile passare direttamente alla creazione guidata.

Screenshot che mostra come usare la casella di ricerca nella barra degli strumenti superiore per trovare la creazione guidata app Web e database (Django).

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-django-postgres-tutorial.
  2. Area: qualunque area di Azure nelle vicinanze.
  3. Nome: msdocs-python-postgres-XYZ.
  4. Stack di runtime: Python 3.12.
  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 cache di Azure per Redis: Sì.
  7. Piano di hosting: Basic. Quando si è pronti, è possibile passare a un piano tariffario di produzione.
  8. Selezionare Rivedi e crea.
  9. Al termine della convalida selezionare Crea.

Screenshot che mostra come configurare una nuova app e un nuovo database nella procedura guidata App Web + Database (Django).

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.
  • Endpoint privato: endpoint di accesso per 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 dall'interno della rete virtuale. Un database e un utente vengono creati automaticamente nel server.
  • cache di Azure per Redis: accessibile solo da dietro la rete privata.
  • DNS privato zone: abilita la risoluzione DNS del server di database nella cache Redis nella rete virtuale.

Screenshot che mostra il processo di distribuzione completato (Django).

3. Proteggere i segreti di connessione e aggiungere SECRET_KEY

La procedura guidata di creazione ha già generato le variabili di connettività cosiccome le impostazioni dell'app. Tuttavia, le procedure consigliate in materia di sicurezza prevedono di tenere i segreti completamente al di fuori del Servizio app. Si sposteranno i segreti in un insieme di credenziali delle chiavi e si cambierà l'impostazione dell'app in riferimenti Key Vault con l'aiuto dei Connettori di servizi.

Passaggio 1: Recuperare il stringa di connessione esistente

  1. Nel menu a sinistra della pagina servizio app selezionare Impostazioni Variabili >di ambiente.
  2. Selezionare AZURE_POSTGRESQL_CONNECTIONSTRING.
  3. IN Aggiungi/Modifica impostazione applicazione, nel campo Valore, trovare la sezione password= alla fine della stringa.
  4. Copiare la stringa della password dopo password= per usarla in un secondo momento. Queste impostazioni dell'app consentono di connettersi al database Postgres e alla cache Redis protetta dietro gli endpoint privati. Tuttavia, i segreti vengono salvati direttamente nell'app servizio app, che non è la soluzione migliore. Questa operazione verrà modificata. Inoltre, si aggiungerà un'impostazione SECRET_KEY , richiesta dall'app Django.

Screenshot che mostra come visualizzare il valore di un'impostazione dell'app.

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

  1. Nella barra di ricerca superiore digitare "insieme di credenziali delle chiavi", 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.

Screenshot che mostra come creare un insieme di credenziali delle chiavi.

Passaggio 3: Proteggere l'insieme di credenziali delle chiavi con un endpoint privato

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

Screenshot che mostra come proteggere un insieme di credenziali delle chiavi con un endpoint privato.

Passaggio 4: Configurare il connettore PostgreSQL

  1. Nella barra di ricerca superiore digitare msdocs-python-postgres, quindi selezionare la risorsa servizio app denominata msdocs-python-postgres-XYZ.
  2. Nel menu a sinistra della pagina Servizio app selezionare Impostazioni > Connettore di servizi. Esistono già due connettori, creati automaticamente dalla creazione guidata dell'app.
  3. Selezionare la casella di controllo accanto al connettore PostgreSQL e quindi selezionare Modifica.
  4. In Tipo di client selezionare Django. 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 nelle impostazioni del database di Django.
  5. Seleziona la scheda Autenticazione.
  6. In Password, incollare la password copiata in precedenza.
  7. Selezionare Archivia segreto in Key Vault.
  8. In Connessione a Key Vault selezionare Crea nuovo. Viene aperta una finestra di dialogo Crea connessione nella parte superiore della finestra di dialogo di modifica.

Screenshot che mostra come modificare un connettore di servizi con una connessione dell'insieme di credenziali delle chiavi.

Passaggio 5: Stabilire la connessione a Key Vault

  1. Nella finestra di dialogo Crea connessione per la connessione a Key Vault, in Key Vault selezionare l'insieme di credenziali delle chiavi creato in precedenza.
  2. Selezionare Rivedi e crea.
  3. Al termine della convalida selezionare Crea.

Screenshot che mostra come configurare un connettore di servizi dell'insieme di credenziali delle chiavi.

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, l'elenco a discesa Connessione a Key Vault lo seleziona automaticamente.
  2. Selezionare Avanti: Rete.
  3. Seleziona Salva. Attendere che venga visualizzata la notifica Aggiornamento completato.

Screenshot che mostra la connessione dell'insieme di credenziali delle chiavi selezionata in defaultConnector.

Passaggio 7: Configurare il connettore Redis per l'uso dei segreti di Key Vault

  1. Nella pagina Service Connectors (Connettori di servizio) selezionare la casella di controllo accanto al connettore Cache for Redis e quindi selezionare Modifica.
  2. Seleziona la scheda Autenticazione.
  3. Selezionare Archivia segreto in Key Vault.
  4. In Connessione a Key Vault selezionare l'insieme di credenziali delle chiavi creato.
  5. Selezionare Avanti: Rete.
  6. Selezionare Configura regole del firewall per abilitare l'accesso al servizio di destinazione. La creazione guidata dell'app ha già protetto il database SQL con un endpoint privato.
  7. Seleziona Salva. Attendere che venga visualizzata la notifica Aggiornamento completato.

Screenshot che mostra come modificare un connettore di servizi Cache per Redis con una connessione dell'insieme di credenziali delle chiavi.

Passaggio 8: 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 all'insieme di credenziali delle chiavi perché il segreto è ora gestito nell'insieme di credenziali delle chiavi.
  3. Per verificare la stringa di connessione Redis, selezionare Mostra valore accanto a AZURE_REDIS_CONNECTIONSTRING.

Screenshot che mostra come visualizzare il valore della password PostgreSQL in Azure.

Passaggio 9: L'applicazione di esempio legge la variabile di ambiente SECRET_KEY per impostare l'impostazione SECRET_KEY richiesta. La si crea come impostazione dell'app in questo passaggio.

  1. Nella scheda Impostazioni app selezionare Aggiungi.
  2. Impostare Nome su SECRET_KEY.
  3. Impostare Value su una stringa casuale lunga.
  4. Fare clic su Applica, quindi su Applica di nuovo, quindi su Conferma.

Screenshot che mostra la finestra di dialogo Aggiungi/Modifica impostazione applicazione.

Per riepilogare, il processo per proteggere i segreti di connessione coinvolti:

  • Recupero dei segreti di connessione dalle variabili di ambiente dell'app 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 servizio per archiviare i segreti nell'insieme di credenziali delle chiavi.

Nota

Idealmente, l'impostazione dell'app SECRET_KEY deve essere configurata anche come riferimento all'insieme di credenziali delle chiavi, che è un processo in più passaggi. Per altre informazioni, vedere Ricerca per categorie modificare l'impostazione dell'app SECRET_KEY in un riferimento a Key Vault?

Problemi? Controllare la sezione Risoluzione dei problemi.

4. Distribuire il codice di esempio

In questo passaggio viene configurata 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 nel repository GitHub avvia l'azione di compilazione e distribuzione.

Passaggio 1: nel menu a sinistra selezionare Distribuzione>Centro di distribuzione.

Screenshot che mostra come aprire il Centro distribuzione nel servizio app.

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-django-postgresql-sample-app.
  5. In Ramo, selezionare starter-no-infra. Si tratta dello stesso ramo 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 directory .github/workflows. Per impostazione predefinita, il centro distribuzione crea un'identità assegnata dall'utente per l'autenticazione tramite Microsoft Entra (autenticazione OIDC). Per le opzioni di autenticazione alternative, vedere Distribuire nel servizio app usando GitHub Actions.

Screenshot che mostra come configurare CI/CD usando GitHub Actions (Django).

Passaggio 3: tornare nel codespace GitHub del fork di esempio, eseguire git pull origin starter-no-infra. In questo modo viene eseguito il pull del file del flusso di lavoro appena eseguito nel codespace.

Screenshot che mostra il pull git all'interno di un codespace GitHub.

Passaggio 4 (opzione 1: con GitHub Copilot):

  1. Avviare una nuova sessione di chat selezionando la visualizzazione Chat e quindi selezionando +.
  2. Chiedere " @workspace Come si connette l'app al database e redis?" Copilot potrebbe fornire una spiegazione su come vengono configurate le impostazioni in azureproject/development.py e azureproject/production.py.
  3. Chiedere: "@workspace In modalità di produzione, l'app è in esecuzione in un'app Web servizio app, che usa Il connettore di servizi di Azure per connettersi a un server flessibile PostgreSQL usando il tipo di client Django. Quali sono i nomi delle variabili di ambiente che è necessario usare?" Copilot potrebbe fornire un suggerimento di codice simile a quello dell'opzione 2: senza i passaggi di GitHub Copilot riportati di seguito e anche indicare di apportare la modifica nel file azureproject/production.py.
  4. Aprire azureproject/production.py in Esplora risorse e aggiungere il suggerimento del codice.
  5. Chiedere: "@workspace'app my servizio app usa anche Azure Service Connector per connettersi a una cache per Redis usando il tipo di client Django. Quali sono i nomi delle variabili di ambiente da usare?*" Copilot potrebbe fornire un suggerimento di codice simile a quello nell'opzione 2: senza i passaggi di GitHub Copilot seguenti e anche indicare di apportare la modifica nel file azureproject/production.py .
  6. Aggiungere il suggerimento per il codice. GitHub Copilot non fornisce la stessa risposta ogni volta e non è sempre corretta. Potrebbe essere necessario porre altre domande per ottimizzare la risposta. Per suggerimenti, vedere Cosa è possibile fare con GitHub Copilot nel codespace?.

Screenshot che mostra come porre una domanda in una nuova sessione di chat di GitHub Copilot.

Passaggio 4 (opzione 2: senza GitHub Copilot):

  1. Aprire Program.cs in Esplora risorse.
  2. Trovare il codice commentato (righe 29-48) e rimuovere il commento. In questo modo vengono create connessioni PostgreSQL e Redis usando AZURE_POSTGRESQL_USER, AZURE_POSTGRESQL_PASSWORDAZURE_POSTGRESQL_HOST, AZURE_POSTGRESQL_NAME, e AZURE_REDIS_CONNECTIONSTRING.

Screenshot che mostra uno spazio di codice GitHub e azureproject/production.py aperto.

Passaggio 5:

  1. Selezionare l'estensione Controllo del codice sorgente.
  2. Nella casella di testo digitare un messaggio di commit come Configure Azure database and cache connectons. 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.

Screenshot che mostra le modifiche di cui è stato eseguito il commit e il push in GitHub.

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

  1. Selezionare la scheda Log, quindi selezionare Aggiorna per visualizzare la nuova esecuzione della distribuzione.
  2. Nell'elemento di log per l'esecuzione della distribuzione selezionare la voce Compila/Distribuisci Log con il timestamp più recente.

Screenshot che mostra come aprire i log di distribuzione nel Centro distribuzione.

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

Screenshot che mostra un'esecuzione di GitHub in corso.

Problemi? Consultare la Guida alla risoluzione dei problemi.

5. Generare lo schema del database

Con il database PostgreSQL protetto dalla rete virtuale, il modo più semplice per eseguire le migrazioni di database Django è in una sessione SSH con il contenitore Linux in servizio app.

Passaggio 1: tornare alla pagina Servizio app nel menu a sinistra,

  1. Selezionare Strumenti di>sviluppo SSH.
  2. Selezionare Vai.

Screenshot che mostra come aprire la shell SSH per l'app dal portale di Azure (Django).

Passaggio 2: Nella sessione SSH eseguire python manage.py migrate. Se ha esito positivo, il Servizio app si connette correttamente al database.

Screenshot che mostra i comandi da eseguire nella shell SSH e il relativo output (Django).

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. La sessione SSH è utile per l'esecuzione di comandi comunipython manage.py, ad esempio la creazione dell'utente con .python manage.py createsuperuser 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.

Problemi? Controllare la sezione Risoluzione dei problemi.

6. Passare all'app

Passaggio 1: Nella pagina Servizio app:

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

Screenshot che mostra come avviare un servizio app dal portale di Azure (Django).

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.

Screenshot dell'app Web Django con PostgreSQL in esecuzione in Azure che mostra ristoranti e recensioni di ristoranti (Django).

7. Eseguire lo streaming dei log di diagnostica

app Azure Servizio acquisisce tutti i log della console per diagnosticare i problemi relativi all'applicazione. L'app di esempio include print() istruzioni per illustrare questa funzionalità, come illustrato di seguito.

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:

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

Screenshot che mostra come abilitare i log nativi nel servizio app nel portale di Azure.

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.

Screenshot che mostra come visualizzare il flusso di log nel portale di Azure.

Per altre informazioni sulla registrazione nelle app Python, vedere la serie sulla configurazione di Monitoraggio di Azure per l'applicazione Python.

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

Screenshot che illustra come cercare e passare a un gruppo di risorse nel portale di Azure.

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

Screenshot che mostra la posizione del pulsante Elimina gruppo di risorse nel portale di Azure.

Passaggio 3:

  1. Immettere il nome del gruppo di risorse per confermare l'eliminazione.
  2. Selezionare Elimina.

Screenshot della finestra di dialogo di conferma per l’eliminazione di un gruppo di risorse nel portale di Azure. :

2. 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. I passaggi usati in questa esercitazione creano un set di risorse sicure per impostazione predefinita che includono servizio app, Database di Azure per PostgreSQL e cache di Azure per Redis.

Il contenitore di sviluppo ha già l'interfaccia della 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>"? 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>-<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 azd provision comando . Seguire la richiesta di selezionare la sottoscrizione e il percorso desiderati per le risorse di Azure.

    azd provision

    Il completamento del comando azd provision richiede circa 15 minuti (la cache Redis richiede il tempo maggiore). Successivamente, si modificherà il codice in modo che funzioni con servizio app e distribuirà 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. 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.
    • 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 dall'interno della rete virtuale. Un database e un utente vengono creati automaticamente 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.
    • Cache Redis di Azure: 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.

    Una volta che il comando ha terminato di creare le risorse e di distribuire il codice dell'applicazione per la prima volta, l'app di esempio distribuita non funziona ancora perché è necessario apportare alcune piccole modifiche per effettuare la connessione al database in Azure.

Problemi? Controllare la sezione Risoluzione dei problemi.

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

  1. Nell'output AZD trovare le impostazioni AZURE_POSTGRESQL_USER, AZURE_POSTGRESQL_PASSWORD, AZURE_POSTGRESQL_HOST, AZURE_POSTGRESQL_NAMEe AZURE_REDIS_CONNECTIONSTRING. 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.

4. Modificare il codice di esempio e ridistribuire

  1. Nel codespace GitHub avviare una nuova sessione di chat selezionando la visualizzazione Chat e quindi selezionando +.

  2. Chiedere "@workspace Come si connette l'app al database?" Copilot potrebbe fornire una spiegazione su come vengono configurate le impostazioni di connessione in azureproject/development.py e azureproject/production.py.

  3. Chiedere: "@workspace In modalità di produzione, l'app è in esecuzione in un'app Web servizio app, che usa Il connettore di servizi di Azure per connettersi a un server flessibile PostgreSQL usando il tipo di client Django. Quali sono i nomi delle variabili di ambiente che è necessario usare?" Copilot potrebbe fornire un suggerimento di codice simile a quello dell'opzione 2: senza i passaggi di GitHub Copilot riportati di seguito e anche indicare di apportare la modifica nel file azureproject/production.py.

  4. Aprire azureproject/production.py in Esplora risorse e aggiungere il suggerimento del codice.

    GitHub Copilot non fornisce la stessa risposta ogni volta e non è sempre corretta. Potrebbe essere necessario porre altre domande per ottimizzare la risposta. Per suggerimenti, vedere Cosa è possibile fare con GitHub Copilot nel codespace?.

  5. Nel terminale eseguire azd deploy.

    azd deploy

Problemi? Controllare la sezione Risoluzione dei problemi.

5. Generare lo schema del database

Con il database PostgreSQL protetto dalla rete virtuale, il modo più semplice per eseguire le migrazioni di database Django è in una sessione SSH con il contenitore Linux in 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: https://<app-name>.scm.azurewebsites.net/webssh/host

  2. Nella sessione SSH eseguire python manage.py migrate. Se ha esito positivo, il Servizio app si connette correttamente al database.

    Screenshot che mostra i comandi da eseguire nella shell SSH e il relativo output (Django).

    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.

Problemi? Controllare la sezione Risoluzione dei problemi.

6. 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: https://<app-name>.azurewebsites.net/

  2. Aggiungere alcuni ristoranti all'elenco.

    Screenshot dell'app Web Django con PostgreSQL in esecuzione in Azure che mostra ristoranti e recensioni di ristoranti (Django).

    Si esegue un'app Web nel servizio app di Azure, con connettività sicura a Database di Azure per PostgreSQL.

Problemi? Controllare la sezione Risoluzione dei problemi.

7. 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 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 print() istruzioni per illustrare questa funzionalità, come illustrato nel frammento di codice seguente.

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 i log del servizio app e passarvi 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.

Problemi? Controllare la sezione Risoluzione dei problemi.

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

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_HOST', è 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_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?

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 dalla sessione 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?

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.

Ricerca per categorie modificare l'impostazione dell'app SECRET_KEY in un riferimento a Key Vault?

Nei passaggi precedenti del portale è possibile passare SECRET_KEY a un riferimento a Key Vault eseguendo i comandi seguenti dell'interfaccia della riga di comando di Azure in Cloud Shell:

# Change the following variables to match your environment
SUBSCRIPTION_ID=<subscription-id>
RESOURCE_GROUP=<resource-group-name>
KEY_VAULT_NAME=<key-vault-name>
APP_SERVICE_NAME=<app-name>
SECRET_NAME=djangoSecretKey

# Set the subscription ID
az account set --subscription $SUBSCRIPTION_ID

# Assign 'Key Vault Secrets Officer' role to your user at the scope of the key vault
az role assignment create \
  --assignee $(az ad signed-in-user show --query id -o tsv) \
  --role $(az role definition list --name "Key Vault Secrets Officer" --query "[].id" -o tsv) \
  --scope $(az keyvault show --name $KEY_VAULT_NAME --resource-group $RESOURCE_GROUP --query id --output tsv)

# Add the secret to the key vault
az keyvault secret set \
  --vault-name $KEY_VAULT_NAME \
  --name $SECRET_NAME \
  --value $(python -c 'import secrets; print(secrets.token_hex())')

# Add Key Vault reference to the App Service configuration
az webapp config appsettings set \
  --resource-group $RESOURCE_GROUP \
  --name $APP_SERVICE_NAME \
  --settings "SECRET_KEY=@Microsoft.KeyVault(SecretUri=https://$KEY_VAULT_NAME.vault.azure.net/secrets/$SECRET_NAME)"

È anche possibile eseguire la stessa operazione nel portale. Per altre informazioni, vedi:

  1. Assegnazione di ruolo dell'ambito di Key Vault
  2. Aggiungere un segreto a Key Vault
  3. Recuperare un segreto da Key Vault
  4. Configurare le impostazioni dell'app

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 più output dal python comando 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?

Si potrebbe aver notato che la visualizzazione chat di GitHub Copilot era già presente quando è stato creato il codespace. Per praticità, includiamo l'estensione di chat di GitHub Copilot nella definizione del contenitore (vedere .devcontainer/devcontainer.json). Tuttavia, è 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 e puoi regolare le tue domande per ottimizzare la risposta che ottieni.
  • 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 ulteriori informazioni, vedere Use the @workspace agent.
  • Nella sessione di chat, GitHub Copilot può suggerire modifiche e (con @workspace) anche dove apportare le modifiche, ma non è consentito apportare le modifiche. È necessario aggiungere le modifiche suggerite e testarle.

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