Distribuire un'app Web FastAPI Python con PostgreSQL in Azure

2025-04-30

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

Per completare questa esercitazione, è necessario:

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

Un account Azure con una sottoscrizione attiva. Se non si ha un account Azure, è possibile crearne uno gratuitamente.
CLI di Azure per sviluppatori 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 FastAPI

Con l'interfaccia della riga di comando per sviluppatori di Azure installata, è possibile passare alla fine dell'esercitazione eseguendo i comandi seguenti in una directory di lavoro vuota:

azd auth login
azd init --template msdocs-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 sia installato in locale e PostgreSQL . 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 guida. 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:

Finestre
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.
Regione in cui eseguire l'app a livello fisico nel mondo.
Stack di runtime per l'app. È qui che si seleziona la versione di Python da usare per l'app.
Piano di hosting per l'app. Si tratta del piano tariffario che include il set di funzionalità e la capacità di ridimensionamento per l'app.
Gruppo di risorse per l'app. Un gruppo di risorse consente di raggruppare (in un contenitore logico) tutte le risorse di Azure necessarie per l'applicazione.

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

Passaggio 1: Nel portale di Azure:

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

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

Gruppo di risorse → Selezionare Crea nuovo e usare un nome msdocs-python-postgres-tutorial.
Area → Qualsiasi area di Azure nelle vicinanze.
Nome → msdocs-python-postgres-XYZ dove XYZ è costituito da tre caratteri casuali. Il nome deve essere univoco in Azure
Stack di runtime → Python 3.12.
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.
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 → Il 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 .
App Service → Rappresenta la tua app ed è in esecuzione nel piano di App Service.
La rete virtuale → Integrata con l'app del Servizio App e isola il traffico di rete back-end.
Il 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 privata → 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 a sinistra, in Impostazioni, selezionare Configurazione.
Nella scheda Impostazioni generali della pagina Configurazione immettere src/entrypoint.sh nel campo Comando di avvio in Impostazioni stack.
Selezionare 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 creazione guidata ha generato le variabili di connettività già come impostazioni dell'app. Le impostazioni dell'app sono un modo per mantenere i segreti di connessione all'esterno del repository di codice. Quando si è pronti a spostare i segreti in una posizione più sicura, ecco un articolo sull'archiviazione in Azure Key Vault.

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

Passaggio 2: Nella scheda Impostazioni app della pagina Variabili di ambiente verificare che AZURE_POSTGRESQL_CONNECTIONSTRING sia presente. 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.
Selezionare Fork.
Selezionare Crea fork.

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

Passaggio 3: In Visual Studio Code sul browser, apri src/fastapi/models.py nella barra laterale dell'esploratore. Vedere le variabili di ambiente usate nell'ambiente di produzione, incluse le impostazioni dell'app visualizzate nella pagina di configurazione.

Passaggio 4: Tornare alla pagina Servizio app, nel menu a sinistra, in Distribuzione selezionare Centro distribuzione.

Passaggio 5: Nella pagina Centro distribuzione:

In Origine selezionare GitHub. Per impostazione predefinita, GitHub Actions è selezionato come provider di compilazione.
Accedere all'account GitHub e seguire la richiesta di autorizzare Azure.
In Organizzazione selezionare l'account.
In Repository, selezionare msdocs-fastapi-postgresql-sample-app.
In Ramo, selezionare main.
Mantenere selezionata l'opzione predefinita per Aggiungere un flusso di lavoro.
In Tipo di autenticazione selezionare Identità assegnata dall'utente.
Nel menu in alto selezionare Salva. 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 Registri. È già stata avviata l’esecuzione di una distribuzione.
Nell'elemento di log per l'esecuzione della distribuzione selezionare Compila/Distribuisci log.

Passaggio 7: Si viene visualizzati nel repository GitHub e si noterà che l'azione GitHub è in esecuzione. Il file del flusso di lavoro definisce due fasi separate, compilare e distribuire. Attendere che l'esecuzione di GitHub mostri lo stato Completato. Ci vogliono circa 5 minuti.

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

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 Monitoraggio, selezionare Log dei servizi App.
In Registrazione applicazioni selezionare File System.
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.

La visualizzazione degli eventi nei log di diagnostica può richiedere alcuni minuti. Scopri di più sulla registrazione nelle app Python nella serie sulla configurazione di Monitoraggio di Azure per l'applicazione Python.

7. Pulire le risorse

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

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

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

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

Passaggio 3:

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

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

In questo passaggio si creano le risorse di Azure e si distribuisce un'app di esempio 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 secure-by-default con le risorse di Azure seguenti:
- Gruppo di risorse → Il contenitore per tutte le risorse create.
- Piano di servizio app → Definisce le risorse di calcolo per il servizio app. Viene specificato un piano Linux nel livello B1 .
- App Service → Rappresenta la tua app ed è in esecuzione nel piano di App Service.
- La rete virtuale → Integrata con l'app del Servizio App e isola il traffico di rete back-end.
- Il 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 privata → Abilita la risoluzione DNS del server PostgreSQL nella rete virtuale.
- L'area di lavoro Log Analytics → funge da contenitore di destinazione per l'app per la spedizione dei log, in cui è anche possibile eseguire query sui log.

Al termine del azd up comando, annotare i 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.

Usa il valore del App Service che hai annotato precedentemente nell'output azd per costruire l'URL per la sessione SSH e navigare all'URL nel browser.
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: <URL>
 
```
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à abilitato la registrazione 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)
    )

Per accedere al flusso di log, aprire l'app nel portale di Azure. Selezionare Monitoraggio>flusso di log.

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

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 il listino prezzi di Azure Database 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 e certificato personalizzati

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

Configurare l'app Python

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