Distribuire un'app Web FastAPI Python con PostgreSQL in Azure

Articolo
08/08/2024

In questa esercitazione viene distribuita un’app Web Python basata sui dati (FastAPI ) nel Servizio app di 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 su Django.

Per completare questa esercitazione, sono necessari gli elementi seguenti:

Un account Azure con una sottoscrizione attiva. Se non si ha un account Azure, è possibile crearne uno gratuitamente.
Conoscenza di Python con esperienza di sviluppo FastAPI

Un account Azure con una sottoscrizione attiva. Se non si ha un account Azure, è possibile crearne uno gratuitamente.
Azure Developer CLI installata. È possibile seguire la procedura con Azure Cloud Shell perché è già installata Azure Developer CLI.
Conoscenza di Python con esperienza di sviluppo FastAPI

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

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

Applicazione di esempio

Viene fornita un'applicazione Python di esempio che usa il framework FastAPI per seguire questa esercitazione. Per distribuirla senza eseguirla in locale, ignorare questa parte.

Per eseguire l'applicazione in locale, assicurarsi che Python 3.8 o versione successiva e PostgreSQL siano installati in locale. Clonare quindi il ramo del repository starter-no-infra di esempio e passare alla radice del repository.

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

Creare un file con estensione .env come illustrato di seguito usando il file .env.sample come riferimento. Impostare il valore di DBNAME sul nome di un database esistente nell'istanza locale di PostgreSQL. Impostare i valori di DBHOST, DBUSER e DBPASS in base alle esigenze dell'istanza di PostgreSQL locale.

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

Creare un ambiente virtuale per l’app:

Windows
macOS/Linux

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

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

Installare le dipendenze:

python3 -m pip install -r src/requirements.txt

Installare l'app come pacchetto modificabile:

python3 -m pip install -e src

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

# Run database migration
python3 src/fastapi_app/seed_data.py
# Run the app at http://127.0.0.1:8000
python3 -m uvicorn fastapi_app:app --reload --port=8000

1. Creare il Servizio app e PostgreSQL

In questo passaggio si creano le risorse di Azure. Per impostazione predefinita la procedura usata in questa esercitazione crea un set di risorse sicure che include Servizio app e Database di Azure per PostgreSQL. Per il processo di creazione, :è necessario specificare:

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

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

Passaggio 1: nel portale di Azure:

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

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

Gruppo di risorse:selezionare Crea nuovo e usare il nome msdocs-python-postgres-tutorial.
Area → Qualunque area di Azure nelle vicinanze.
Nome: msdocs-python-postgres-XYZ dove XYZ possono essere tre caratteri qualsiasi scelti casualmente. Il nome deve essere univoco in Azure
Stack di runtime: Python 3.12.
Database: per impostazione predefinita, PostgreSQL - Server flessibile è l’opzione selezionata come motore di database. Per impostazione predefinita, il nome del server e il nome del database vengono impostati sui valori appropriati.
Piano di hosting: Basic. Quando si è pronti, è possibile passare a un piano tariffario di produzione in un secondo momento.
Selezionare Rivedi e crea.
Al termine della convalida selezionare Crea.

Passaggio 3: il completamento della distribuzione richiede alcuni minuti. Al termine della distribuzione, selezionare il pulsante Vai alla risorsa. Si accede direttamente all'app del servizio app, ma vengono create le risorse seguenti:

Gruppo di risorse: contenitore per tutte le risorse create.
Piano di servizio app: definisce le risorse di calcolo per il Servizio app. Viene creato un piano Linux nel livello Basic.
Servizio app: rappresenta l'app ed è in esecuzione nel piano di Servizio app.
Rete virtuale: è integrata con l'app del Servizio app e isola il traffico di rete back-end.
Server flessibile di Database di Azure per PostgreSQL: accessibile solo dall'interno della rete virtuale. Vengono automaticamente creati un database e un utente nel server.
Zona DNS privato: abilita la risoluzione DNS del server PostgreSQL nella rete virtuale.

Passaggio 4: per le app FastAPI, è necessario immettere un comando di avvio in modo che il Servizio app possa avviare l'app. Nella pagina Servizio app:

Nel menu di sinistra, in Impostazioni, selezionare Configurazione.
Nella scheda Impostazioni generali della pagina Configurazione immettere src/entrypoint.sh nel campo Comando di avvio in Impostazioni stack.
Seleziona Salva. Quando richiesto, selezionare Continua. Per altre informazioni sulla configurazione e l'avvio delle app nel Servizio app, vedere Configurare un'app Python Linux per il Servizio app di Azure.

2. Verificare le impostazioni di connessione

La procedura guidata di creazione ha già generato le variabili di connettività cosiccome le impostazioni dell'app. Le impostazioni dell'app sono un modo per mantenere i segreti di connessione all'esterno del repository di codice. Quando si è pronti a spostare i segreti in una posizione più sicura, ecco un articolo sull'archiviazione in Azure Key Vault.

Passaggio 1: nel menu a sinistra della pagina Servizio app selezionare Variabili di ambiente.

Passaggio 2: nella scheda Impostazioni dell'app della pagina Variabili di ambiente verificare che sia presente AZURE_POSTGRESQL_CONNECTIONSTRING. La stringa di connessione verrà inserita nell'ambiente di runtime come variabile di ambiente.

3. 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 al repository GitHub avvia l'azione di compilazione e distribuzione.

Passaggio 1: in una nuova finestra del browser:

Accedi all'account GitHub.
Accedere a https://github.com/Azure-Samples/msdocs-fastapi-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, selezionare il browser e aprire src/fastapi/models.py in Esplora risorse. Vedere le variabili di ambiente usate nell'ambiente di produzione, incluse le impostazioni dell'app visualizzate nella pagina di configurazione.

Passaggio 4: tornare alla pagina del Servizio app e nel menu a sinistra selezionare Distribuzione e quindi scegliere 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-fastapi-postgresql-sample-app.
Per Ramo selezionare principale.
Mantenere l'opzione predefinita impostata su Aggiungi un flusso di lavoro.
Per Tipo di autenticazione selezionare Identità assegnata dall'utente.
Nel menu in alto, selezionare Salva. Il servizio app esegue il commit di un file del flusso di lavoro nel repository GitHub scelto, nella directory .github/workflows.

Passaggio 6: nella pagina Centro distribuzione:

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

Passaggio 7: si verrà reindrizzati al repository GitHub dove è possibile notare che l'azione GitHub è in esecuzione. Il file del flusso di lavoro definisce due fasi separate, compilare e distribuire. Attendere che l'esecuzione di GitHub visualizzi lo stato Operazione completata. Ci vogliono circa 5 minuti.

Problemi? Consultare la Guida alla risoluzione dei problemi.

4. Generare lo schema del database

Nella sezione precedente è stato aggiunto src/entrypoint.sh come comando di avvio per l'app. entrypoint.sh contiene la riga seguente: python3 src/fastapi_app/seed_data.py. Questo comando esegue la migrazione del database. Nell'app di esempio, garantisce solo che vengano create le tabelle corrette nel database. Non popola queste tabelle con dati.

In questa sezione si eseguirà manualmente tale comando a scopo dimostrativo. Con il database SQL protetto dalla rete virtuale, il modo più semplice per eseguire il comando è in una sessione SSH con il contenitore del Servizio app.

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

Selezionare SSH (22).
Selezionare Vai.

Passaggio 2: nel terminale SSH, eseguire python3 src/fastapi_app/seed_data.py. Se ha esito positivo, il Servizio app si connette correttamente al database. Solo le modifiche apportate ai file in /home possono essere mantenute dopo i riavvii dell'app. Le modifiche al di fuori di /home non sono persistenti.

5. Passare all'app

Passaggio 1: nella pagina Servizio app:

Nel menu a sinistra selezionare Panoramica.
Selezionare l'URL dell'app. È anche possibile passare direttamente a https://<app-name>.azurewebsites.net.

Passaggio 2: aggiungere alcuni ristoranti all'elenco. A questo punto un'app Web è in esecuzione nel servizio app di Azure, con connettività sicura a Database di Azure per PostgreSQL.

6. Eseguire lo streaming dei log di diagnostica

L'app di esempio usa il modulo di registrazione della libreria standard Python per facilitare la diagnosi dei problemi con l'applicazione. L'app di esempio include chiamate al logger, come illustrato nel codice seguente.

@app.get("/", response_class=HTMLResponse)
async def index(request: Request, session: Session = Depends(get_db_session)):
    logger.info("root called")
    statement = (
        select(Restaurant, func.avg(Review.rating).label("avg_rating"), func.count(Review.id).label("review_count"))
        .outerjoin(Review, Review.restaurant == Restaurant.id)
        .group_by(Restaurant.id)
    )

Passaggio 1: nella pagina Servizio app:

Nel menu a sinistra, in Monitoraggioselezionare Log del Servizio app.
In Registrazione applicazione 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.

La visualizzazione degli eventi nei log di diagnostica può richiedere alcuni minuti. Per altre informazioni sulla registrazione nelle app Python, vedere la serie sulla configurazione di Monitoraggio di Azure per l'applicazione Python.

7. Pulire le risorse

Al termine, è possibile eliminare tutte le risorse dalla sottoscrizione di Azure eliminando il gruppo di risorse.

Passaggio 1: nella barra di ricerca nella parte superiore del portale di Azure:

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

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

Passaggio 3:

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

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

In questo passaggio si creano le risorse di Azure e si distribuisce un'app di esempio nel servizio app in Linux. Per impostazione predefinita la procedura usata in questa esercitazione crea un set di risorse sicure che include Servizio app e Database di Azure per PostgreSQL.

Se questa operazione non è ancora stata eseguita, clonare il ramo del repository di starter-no-infra esempio in un terminale locale.
```
git clone -b starter-no-infra https://github.com/Azure-Samples/msdocs-fastapi-postgresql-sample-app
cd msdocs-fastapi-postgresql-sample-app
```
Questo ramo clonato è il punto di partenza. Contiene una semplice applicazione FastAPI basata sui dati.

Dalla radice del repository eseguire azd init.

azd init --template msdocs-fastapi-postgresql-sample-app

Quando richiesto, fornire le risposte seguenti:

Domanda	Risposta
La directory corrente non è vuota. Inizializzare un progetto qui in "<your-directory>"?	Y
Cosa vuoi fare con questi file?	Mantenere invariati i file esistenti
Immettere un nuovo nome di ambiente	Digitare un nome univoco. Il modello AZD usa questo nome come parte del nome DNS dell'app Web in Azure (`<app-name>.azurewebsites.net`). Sono consentiti caratteri alfanumerici e trattini.

Eseguire il comando azd up per effettuare il provisioning delle risorse di Azure necessarie e distribuire il codice dell'app. Se non è già stato eseguito l'accesso ad Azure, il browser si avvierà e chiederà di eseguire l'accesso. Il comando azd up richiederà anche di selezionare la sottoscrizione e il percorso desiderati in cui effettuare la distribuzione.
```
azd up
```
Il completamento del comando azd up può richiedere alcuni minuti. Compila e distribuisce anche il codice dell'applicazione. Durante l'esecuzione, il comando fornisce messaggi sul processo di provisioning e distribuzione, incluso un collegamento alla distribuzione in Azure. Al termine, il comando visualizza anche un collegamento all'applicazione di distribuzione.

Questo modello AZD contiene file (azure.yaml e la directory infra ) che generano un'architettura sicura per impostazione predefinita con le risorse di Azure seguenti:
- Gruppo di risorse: contenitore per tutte le risorse create.
- Piano di servizio app: definisce le risorse di calcolo per il Servizio app. Viene creato un piano Linux nel livello B1.
- Servizio app: rappresenta l'app ed è in esecuzione nel piano di Servizio app.
- Rete virtuale: è integrata con l'app del Servizio app e isola il traffico di rete back-end.
- Server flessibile di Database di Azure per PostgreSQL: accessibile solo dall'interno della rete virtuale. Vengono automaticamente creati un database e un utente nel server.
- Zona DNS privato: abilita la risoluzione DNS del server PostgreSQL nella rete virtuale.
- Area di lavoro Log Analytics: funge da contenitore di destinazione per l'app che spedisce i log e permette anche di eseguire query sui log.

Al termine del comandoazd up, prendere nota dei valori per l'ID sottoscrizione (GUID), il Servizio app e il gruppo di risorse nell'output. Tali valori vengono usati nelle sezioni seguenti. L'output sarà simile a quello (parziale) di esempio seguente:

Subscription: Your subscription name (1111111-1111-1111-1111-111111111111)
Location: East US

  You can view detailed progress in the Azure Portal:
  https://portal.azure.com/#view/HubsExtension/DeploymentDetailsBlade/~/overview/id/%2Fsubscriptions%2F1111111-1111-1111-1111-111111111111%2Fproviders%2FMicrosoft.Resources%2Fdeployments%2Fyourenv-1721867673

  (✓) Done: Resource group: yourenv-rg
  (✓) Done: Virtual Network: yourenv-e2najjk4vewf2-vnet
  (✓) Done: App Service plan: yourenv-e2najjk4vewf2-service-plan
  (✓) Done: Log Analytics workspace: yourenv-e2najjk4vewf2-workspace
  (✓) Done: Application Insights: yourenv-e2najjk4vewf2-appinsights
  (✓) Done: Portal dashboard: yourenv-e2najjk4vewf2-dashboard
  (✓) Done: App Service: yourenv-e2najjk4vewf2-app-service
  (✓) Done: Azure Database for PostgreSQL flexible server: yourenv-e2najjk4vewf2-postgres-server
  (✓) Done: Cache for Redis: yourenv-e2najjk4vewf2-redisCache
  (✓) Done: Private Endpoint: cache-privateEndpoint

SUCCESS: Your application was provisioned in Azure in 32 minutes.
You can view the resources created under the resource group yourenv-rg in Azure Portal:
https://portal.azure.com/#@/resource/subscriptions/1111111-1111-1111-1111-111111111111/resourceGroups/yourenv-rg/overview

Deploying services (azd deploy)

  (✓) Done: Deploying service web
  - Endpoint: https://yourenv-e2najjk4vewf2-app-service.azurewebsites.net/

2. Esaminare la stringa di connessione del database

Il modello AZD genera automaticamente le variabili di connettività come impostazioni dell'app. Le impostazioni dell'app sono un modo per mantenere i segreti di connessione all'esterno del repository di codice.

Nel file infra/resources.biceptrovare le impostazioni dell'app e trovare l'impostazione per AZURE_POSTGRESQL_CONNECTIONSTRING.

resource appSettings 'config' = {
  name: 'appsettings'
  properties: {
    SCM_DO_BUILD_DURING_DEPLOYMENT: 'true'
    AZURE_POSTGRESQL_CONNECTIONSTRING: 'dbname=${pythonAppDatabase.name} host=${postgresServer.name}.postgres.database.azure.com port=5432 sslmode=require user=${postgresServer.properties.administratorLogin} password=${databasePassword}'
    SECRET_KEY: secretKey
    AZURE_REDIS_CONNECTIONSTRING: 'rediss://:${redisCache.listKeys().primaryKey}@${redisCache.name}.redis.cache.windows.net:6380/0'
  }
}

AZURE_POSTGRESQL_CONNECTIONSTRING contiene la stringa di connessione a Database di Azure per PostgreSQL. È necessario usarla nel codice per connettersi. È possibile trovare il codice che usa questa variabile di ambiente in src/fastapi/models.py:

sql_url = ""
if os.getenv("WEBSITE_HOSTNAME"):
    logger.info("Connecting to Azure PostgreSQL Flexible server based on AZURE_POSTGRESQL_CONNECTIONSTRING...")
    env_connection_string = os.getenv("AZURE_POSTGRESQL_CONNECTIONSTRING")
    if env_connection_string is None:
        logger.info("Missing environment variable AZURE_POSTGRESQL_CONNECTIONSTRING")
    else:
        # Parse the connection string
        details = dict(item.split('=') for item in env_connection_string.split())

        # Properly format the URL for SQLAlchemy
        sql_url = (
            f"postgresql://{quote_plus(details['user'])}:{quote_plus(details['password'])}"
            f"@{details['host']}:{details['port']}/{details['dbname']}?sslmode={details['sslmode']}"
        )

else:
    logger.info("Connecting to local PostgreSQL server based on .env file...")
    load_dotenv()
    POSTGRES_USERNAME = os.environ.get("DBUSER")
    POSTGRES_PASSWORD = os.environ.get("DBPASS")
    POSTGRES_HOST = os.environ.get("DBHOST")
    POSTGRES_DATABASE = os.environ.get("DBNAME")
    POSTGRES_PORT = os.environ.get("DBPORT", 5432)

    sql_url = f"postgresql://{POSTGRES_USERNAME}:{POSTGRES_PASSWORD}@{POSTGRES_HOST}:{POSTGRES_PORT}/{POSTGRES_DATABASE}"

engine = create_engine(sql_url)

3. Esaminare il comando di avvio

Il Servizio app di Azure richiede un comando di avvio per eseguire l'app FastAPI. Il modello AZD imposta automaticamente questo comando nell'istanza del Servizio app.

Nel file infra/resources.bicep trovare la dichiarazione per il sito Web e quindi trovare l'impostazione per appCommandLine. Questa è l'impostazione per il comando di avvio.

resource web 'Microsoft.Web/sites@2022-03-01' = {
  name: '${prefix}-app-service'
  location: location
  tags: union(tags, { 'azd-service-name': 'web' })
  kind: 'app,linux'
  properties: {
    serverFarmId: appServicePlan.id
    siteConfig: {
      alwaysOn: true
      linuxFxVersion: 'PYTHON|3.11'
      ftpsState: 'Disabled'
      appCommandLine: 'src/entrypoint.sh'
      minTlsVersion: '1.2'
    }
    httpsOnly: true
  }
  identity: {
    type: 'SystemAssigned'
  }

Il comando di avvio esegue il file src/entrypoint.sh. Esaminare il codice in tale file per comprendere i comandi eseguiti dal Servizio app per avviare l'app:

#!/bin/bash
set -e
python3 -m pip install --upgrade pip
python3 -m pip install -e src
python3 src/fastapi_app/seed_data.py
python3 -m gunicorn fastapi_app:app -c src/gunicorn.conf.py

Per altre informazioni sulla configurazione e l'avvio delle app nel Servizio app, vedere Configurare un'app Python Linux per il Servizio app di Azure.

4. Generare lo schema del database

È possibile che si sia notato nella sezione precedente che entrypoint.sh contiene la riga seguente: python3 src/fastapi_app/seed_data.py. Questo comando esegue la migrazione del database. Nell'app di esempio, garantisce solo che vengano create le tabelle corrette nel database. Non popola queste tabelle con dati.

Usare il valore del Servizio app di cui si è preso nota in precedenza nell'output AZD e il modello illustrato di seguito per costruire l'URL per la sessione SSH e passarvi nel browser:
```
https://<app-name>.scm.azurewebsites.net/webssh/host
```
Nel terminale SSH eseguire python3 src/fastapi_app/seed_data.py. Se ha esito positivo, il Servizio app si connette correttamente al database.

Nota

Solo le modifiche apportate ai file in /home possono essere mantenute dopo i riavvii dell'app. Le modifiche al di fuori di /home non sono persistenti.

5. Passare all'app

Nell'output AZD trovare l'URL dell'app e passarvi nel browser. L'URL è simile al seguente nell'output AZD:

 Deploying services (azd deploy)

   (✓) Done: Deploying service web
   - Endpoint: https://<app-name>.azurewebsites.net/

Aggiungere alcuni ristoranti all'elenco.

A questo punto un'app Web è in esecuzione nel servizio app di Azure, con connettività sicura a Database di Azure per PostgreSQL.

6. Eseguire lo streaming dei log di diagnostica

Il servizio app di Azure può acquisire i log della console per diagnosticare i problemi relativi all'applicazione. Per praticità, il modello AZD ha già la registrazione abilitata nel file system locale.

L'app di esempio usa il modulo di registrazione della libreria standard Python per restituire i log di output. L'app di esempio include chiamate al logger, come illustrato di seguito.

@app.get("/", response_class=HTMLResponse)
async def index(request: Request, session: Session = Depends(get_db_session)):
    logger.info("root called")
    statement = (
        select(Restaurant, func.avg(Review.rating).label("avg_rating"), func.count(Review.id).label("review_count"))
        .outerjoin(Review, Review.restaurant == Restaurant.id)
        .group_by(Restaurant.id)
    )

Usare i valori di ID sottoscrizione (Guid), Gruppo risorse e Servizio app ci cui si è preso nota in precedenza nell’output AZD e nel modello illustrato di seguito per costruire l’URL per lo streaming dei log del Servizio app e per passarvi nel browser.

https://portal.azure.com/#@/resource/subscriptions/<subscription-guid>/resourceGroups/<group-name>/providers/Microsoft.Web/sites/<app-name>/logStream

7. Pulire le risorse

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

azd down

Risoluzione dei problemi

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

Non è possibile connettersi alla sessione SSH

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

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

Se si verificano errori relativi alla connessione al database, verificare se le impostazioni dell'app (AZURE_POSTGRESQL_CONNECTIONSTRING) sono state modificate. Senza tale stringa di connessione, il comando di migrazione non può comunicare con il database.

Domande frequenti

Quanto costa questa configurazione?
In che modo è possibile connettersi al server PostgreSQL protetto dietro la rete virtuale con altri strumenti?
Come funziona lo sviluppo di app locali con GitHub Actions?

Quanto costa questa configurazione?

I prezzi per le risorse create sono i seguenti:

Il piano di servizio app viene creato nel livello Basic e può essere ridimensionato verso l'alto o verso il basso. Vedere Prezzi del servizio app.
Il server flessibile PostgreSQL viene creato nel livello con possibilità di burst più bassa Standard_B1ms, con dimensioni di archiviazione minime, che possono essere ridimensionate, ossia aumentate o ridotte. Vedere i piani tariffari di Database di Azure per PostgreSQL.
La rete virtuale non comporta alcun addebito a meno che non si configurino funzionalità aggiuntive, ad esempio il peering. Vedere Prezzi della rete virtuale di Azure.
La zona DNS privata comporta un piccolo addebito. Vedere Prezzi di DNS di Azure.

In che modo è possibile connettersi al server PostgreSQL protetto dietro la rete virtuale con altri strumenti?

Per l'accesso di base da uno strumento da riga di comando, è possibile eseguire psql dal terminale SSH dell'app.
Per connettersi da uno strumento desktop, il computer deve trovarsi all'interno della rete virtuale. Ad esempio, potrebbe trattarsi di una macchina virtuale di Azure connessa a una delle subnet o di un computer in una rete locale con una connessione VPN da sito a sito con la rete virtuale di Azure.
È anche possibile integrare Azure Cloud Shell con la rete virtuale.

Come funziona lo sviluppo di app locali con GitHub Actions?

Quando si usa il file del flusso di lavoro generato automaticamente dal Servizio app come esempio, ogni git push avvia una nuova esecuzione della compilazione e della distribuzione. Da un clone locale del repository GitHub si effettua il push degli aggiornamenti desiderati in GitHub. Ad esempio:

git add .
git commit -m "<some-message>"
git push origin main

Passaggi successivi

Passare all'esercitazione successiva per informazioni su come proteggere l'app con un dominio e un certificato personalizzati.

Proteggere con dominio personalizzato e certificato di protezione

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

Configurare un'app Python

Condividi tramite

Distribuire un'app Web FastAPI Python con PostgreSQL in Azure

Applicazione di esempio

1. Creare il Servizio app e PostgreSQL

2. Verificare le impostazioni di connessione

3. Distribuire il codice di esempio

4. Generare lo schema del database

5. Passare all'app

6. Eseguire lo streaming dei log di diagnostica

7. Pulire le risorse

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

2. Esaminare la stringa di connessione del database

3. Esaminare il comando di avvio

4. Generare lo schema del database

5. Passare all'app

6. Eseguire lo streaming dei log di diagnostica

7. Pulire le risorse

Risoluzione dei problemi

Non è possibile connettersi alla sessione SSH

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

Domande frequenti

Quanto costa questa configurazione?

In che modo è possibile connettersi al server PostgreSQL protetto dietro la rete virtuale con altri strumenti?

Come funziona lo sviluppo di app locali con GitHub Actions?

Passaggi successivi

Commenti e suggerimenti

Risorse aggiuntive

Condividi tramite

Distribuire un'app Web FastAPI Python con PostgreSQL in Azure

Passare alla fine

Applicazione di esempio

1. Creare il Servizio app e PostgreSQL

2. Verificare le impostazioni di connessione

3. Distribuire il codice di esempio

4. Generare lo schema del database

5. Passare all'app

6. Eseguire lo streaming dei log di diagnostica

7. Pulire le risorse

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

2. Esaminare la stringa di connessione del database

3. Esaminare il comando di avvio

4. Generare lo schema del database

5. Passare all'app

6. Eseguire lo streaming dei log di diagnostica

7. Pulire le risorse

Risoluzione dei problemi

Non è possibile connettersi alla sessione SSH

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

Domande frequenti

Quanto costa questa configurazione?

In che modo è possibile connettersi al server PostgreSQL protetto dietro la rete virtuale con altri strumenti?

Come funziona lo sviluppo di app locali con GitHub Actions?

Passaggi successivi

Commenti e suggerimenti

Risorse aggiuntive