Dela via

Distribuera en Python FastAPI-webbapp med PostgreSQL i Azure

I den här självstudien distribuerar du en datadriven Python-webbapp (FastAPI ) till Azure App Service med relationsdatabastjänsten Azure Database for PostgreSQL . Azure App Service stöder Python i en Linux-servermiljö. Om du vill kan du se Flask-självstudien eller Django-självstudien i stället.

Ett arkitekturdiagram som visar en App Service med en PostgreSQL-databas i Azure.

För att slutföra den här självstudien behöver du:

  • Ett Azure-konto med en aktiv prenumeration. Om du inte har ett Azure-konto, kan du skapa ett gratis.
  • Kunskap om Python med FastAPI-utveckling

Hoppa till slutet

Med Azure Developer CLI installerat kan du gå vidare till slutet av självstudien genom att köra följande kommandon i en tom arbetskatalog:

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

Exempelprogram

Ett Python-exempelprogram med FastAPI-ramverk tillhandahålls som hjälper dig att följa med i den här självstudien. Om du vill distribuera den utan att köra den lokalt hoppar du över den här delen.

Om du vill köra programmet lokalt kontrollerar du att Du har Python 3.8 eller senare och PostgreSQL installerat lokalt. Klona istället exempellagringsplatsens starter-no-infra-gren och gå till lagringsplatsens rot.

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

Skapa en .env-fil enligt nedan med hjälp av .env.sample-filen som en guide. Ange värdet DBNAME för till namnet på en befintlig databas i din lokala PostgreSQL-instans. Ange värdena DBHOSTför , DBUSERoch DBPASS efter behov för din lokala PostgreSQL-instans.

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

Skapa en virtuell miljö för appen:

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

Installera beroendena:

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

Installera appen som ett redigerbart paket:

python3 -m pip install -e src

Kör exempelprogrammet med följande kommandon:

# 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. Skapa App Service och PostgreSQL

I det här steget skapar du Azure-resurserna. Stegen som används i den här handledningen skapar en uppsättning standardmässigt säkra resurser som inkluderar App Service och Azure Database for PostgreSQL. För skapandeprocessen anger du:

  • Webbappens namn . Det är namnet som används som en del av DNS-namnet för din webbapp.
  • Regionen som ska köra appen fysiskt i världen.
  • Runtime-stacken för appen. Det är där du väljer vilken version av Python som ska användas för din app.
  • Hosting-planen för appen. Det är prisnivån som innehåller uppsättningen funktioner och skalningskapacitet för din app.
  • Resursgruppen för appen. Med en resursgrupp kan du gruppera (i en logisk container) alla Azure-resurser som behövs för programmet.

Logga in på Azure Portal och följ dessa steg för att skapa dina Azure App Service-resurser.

Steg 1: I Azure-portalen:

  1. Skriv in "webbappdatabas" i sökfältet högst upp på Azure-portalen.
  2. Välj objektet webapp + databas under rubriken Marketplace . Du kan också navigera till skaparguiden direkt.

En skärmbild som visar hur du använder sökrutan i det övre verktygsfältet för att hitta guiden Skapa webbapp + databas (FastAPI).

Steg 2: På sidan Skapa webbapp + databas, fyll i formuläret enligt följande.

  1. Resursgrupp → Välj Skapa ny och använd namnet msdocs-python-postgres-tutorial.
  2. Region → Valfri Azure-region nära dig.
  3. Namn → msdocs-python-postgres-XYZ där XYZ är tre slumpmässiga tecken. Användarnamnet måste vara unikt inom Azure.
  4. Körningsstacken → Python 3.12.
  5. Databas → PostgreSQL – Flexibel server väljs som standard som databasmotor. Servernamnet och databasnamnet anges också som standard till lämpliga värden.
  6. Värdplan → Basic. När du är klar kan du skala upp till en produktionsprisnivå senare.
  7. Välj Förhandsgranska + skapa.
  8. När valideringen är klar väljer du Skapa.

En skärmbild som visar hur du konfigurerar en ny app och databas i guiden Webbapp + Databas (FastAPI).

Steg 3: Installationen tar några minuter att slutföra. När distributionen är klar väljer du knappen Gå till resurs . Du tas direkt till App Service-appen, men följande resurser skapas:

  • Resursgrupp → Behållaren för alla de skapade resurserna.
  • App Service plan → Definierar beräkningsresurserna för App Service. En Linux-plan i Basic-nivån skapas.
  • App Service → Representerar din app och körs i App Service-planen.
  • Virtuellt nätverk → Integreras med App Service-appen och isolerar nätverkstrafik på backend.
  • Azure Database for PostgreSQL – flexibel server → Endast tillgänglig inifrån det virtuella nätverket. En databas och en användare skapas åt dig på servern.
  • Privat DNS-zon → Aktiverar DNS-matchning för PostgreSQL-servern i det virtuella nätverket.

En skärmbild som visar hur distributionsprocessen har slutförts (FastAPI).

Steg 4: För FastAPI-appar måste du ange ett startkommando så att App Service kan starta din app. På sidan App Service:

  1. I den vänstra menyn går du till Inställningar och väljer Konfiguration.
  2. På fliken Allmänna inställningar på sidan Konfiguration anger du src/entrypoint.sh i fältet Startkommando under Stack-inställningar.
  3. Välj Spara. När du uppmanas till det väljer du Fortsätt. Mer information om appkonfiguration och start i App Service finns i Konfigurera en Linux Python-app för Azure App Service.

En skärmbild som visar hur du lägger till ett startkommando (FastAPI).

2. Kontrollera anslutningsinställningarna

Skapelseguiden har redan genererat anslutningsvariablerna åt dig i formen av appinställningar. Inställningar för appar är ett sätt att hålla anslutningshemligheter utanför din koddatabas. När du är redo att flytta dina hemligheter till en säkrare plats, här är en artikel om lagring i Azure Key Vault.

Steg 1: På sidan App Service går du till den vänstra menyn och väljer Miljövariabler.

En skärmbild som visar hur du öppnar konfigurationssidan i App Service (FastAPI).

Steg 2: På fliken Appinställningar på sidan Miljövariabler kontrollerar du att det AZURE_POSTGRESQL_CONNECTIONSTRING finns. Anslutningssträngen matas in i körningsmiljön som en miljövariabel.

En skärmbild som visar hur du ser den autogenererade anslutningssträngen (FastAPI).

3. Distribuera exempelkod

I det här steget konfigurerar du GitHub-distributionen med hjälp av GitHub Actions. Det är bara ett av många sätt att distribuera till App Service, men också ett utmärkt sätt att ha kontinuerlig integration i din distributionsprocess. Som standard startar varje git push till din GitHub-lagringsplats bygg- och distributionsåtgärden.

Steg 1: I ett nytt webbläsarfönster:

  1. Logga in på ditt GitHub-konto.
  2. Gå till https://github.com/Azure-Samples/msdocs-fastapi-postgresql-sample-app.
  3. Välj Fork.
  4. Välj Skapa förgrening.

En skärmbild som visar hur du skapar en förgrening av GitHub-exempellagringsplatsen (FastAPI).

Steg 2: På GitHub-sidan öppnar du Visual Studio Code i webbläsaren genom att trycka på . nyckeln.

En skärmbild som visar hur du öppnar Visual Studio Code-webbläsarupplevelsen i GitHub (FastAPI).

Steg 3: I Visual Studio Code i webbläsaren öppnar du src/fastapi/models.py i utforskaren. Se de miljövariabler som används i produktionsmiljön, inklusive appinställningarna som du såg på konfigurationssidan.

En skärmbild som visar Visual Studio Code i webbläsaren och en öppen fil (FastAPI).

Steg 4: På sidan App Service går du till den vänstra menyn under Distribution och väljer Distributionscenter.

En skärmbild som visar hur du öppnar distributionscentret i App Service (FastAPI).

Steg 5: På sidan Distributionscenter:

  1. I Källa väljer du GitHub. Som standard är GitHub Actions vald som byggleverantör.
  2. Logga in på ditt GitHub-konto och följ anvisningarna för att auktorisera Azure.
  3. I Organisation väljer du ditt konto.
  4. I Lagringsplats väljer du msdocs-fastapi-postgresql-sample-app.
  5. Välj Branch och sedan main.
  6. Behåll standardalternativet valt för Att lägga till ett arbetsflöde.
  7. Under Autentiseringstyp väljer du Användartilldelad identitet.
  8. I toppmenyn, välj Spara. App Service lägger in en arbetsflödesfil i det valda GitHub-förvaret i .github/workflows-katalogen.

En skärmbild som visar hur du konfigurerar CI/CD med GitHub Actions (FastAPI).

Steg 6: På sidan för Distribueringscenter:

  1. Välj Loggfiler. En deployering är redan påbörjad.
  2. I loggobjektet för distributionskörningen väljer du Skapa/distribuera loggar.

En skärmbild som visar hur du öppnar distributionsloggar i distributionscentret (FastAPI).

Steg 7: Du tas till din GitHub-lagringsplats och ser att GitHub-åtgärden körs. Arbetsflödesfilen definierar två separata steg: bygga och distribuera. Vänta tills GitHub-körningen visar statusen Slutförd. Det tar ungefär 5 minuter.

En skärmdump som visar en pågående GitHub-körning (FastAPI).

Har du problem? Kontrollera felsökningsguiden.

4. Generera databasschema

I föregående avsnitt lade du till src/entrypoint.sh som startkommando för din app. entrypoint.sh innehåller följande rad: python3 src/fastapi_app/seed_data.py. Det här kommandot migrerar databasen. I exempelappen ser den bara till att rätt tabeller skapas i databasen. De här tabellerna fylls inte i med några data.

I det här avsnittet kör du det här kommandot manuellt i demonstrationssyfte. Med PostgreSQL-databasen skyddad av det virtuella nätverket är det enklaste sättet att köra kommandot i en SSH-session med App Service-containern.

Steg 1: Tillbaka i App Service-sidan, i den vänstra menyn,

  1. Välj SSH.
  2. Välj Gå.

En skärmbild som visar hur du öppnar SSH-gränssnittet för din app från Azure-portalen (FastAPI).

Steg 2: Kör i SSH-terminalen python3 src/fastapi_app/seed_data.py. Om det lyckas ansluter App Service till databasen. Endast ändringar i filer i /home kan bevaras utöver omstarter av appar. Ändringar utanför /home sparas inte.

En skärmbild som visar kommandona som ska köras i SSH-gränssnittet och deras utdata (FastAPI).

5. Gå till appen

Steg 1: På App Service-sidan:

  1. Välj Översikt på den vänstra menyn.
  2. Välj URL:en för din app.

En skärmbild som visar hur du startar en App Service från Azure-portalen (FastAPI).

Steg 2: Lägg till några restauranger i listan. Grattis, du kör en webbapp i Azure App Service med säker anslutning till Azure Database for PostgreSQL.

En skärmbild av FastAPI-webbappen med PostgreSQL som körs i Azure och som visar restauranger och restaurangrecensioner (FastAPI).

6. Strömma diagnostikloggar

Exempelappen använder loggningsmodulen för Python Standard Library för att hjälpa dig att diagnostisera problem med ditt program. Exempelappen innehåller anrop till loggaren enligt följande kod.

@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)
    )

Steg 1: På App Service-sidan:

  1. Välj App Service-loggar under Övervakning på den vänstra menyn.
  2. Under Programloggning väljer du Filsystem.
  3. I toppmenyn, välj Spara.

En skärmdump som visar hur man aktiverar inbyggda loggar i App Service i Azure-portalen.

Steg 2: Välj Loggström på den vänstra menyn. Du ser loggarna för din app, inklusive plattformsloggar och loggar från insidan av containern.

En skärmdump som visar hur man tittar på loggströmmen i Azure-portalen.

Det kan ta flera minuter att visa händelser i diagnostikloggarna. Läs mer om att logga in Python-appar i serien när du konfigurerar Azure Monitor för ditt Python-program.

7. Rensa resurser

När du är klar kan du ta bort alla resurser från din Azure-prenumeration genom att ta bort resursgruppen.

Steg 1: I sökfältet överst i Azure-portalen:

  1. Ange namnet på resursgruppen.
  2. Välj resursgruppen.

En skärmbild som visar hur du söker efter och navigerar till en resursgrupp i Azure-portalen.

Steg 2: På resursgruppssidan väljer du Ta bort resursgrupp.

En skärmbild som visar platsen för knappen Ta bort resursgrupp i Azure-portalen.

Steg 3:

  1. Ange namnet på resursgruppen för att bekräfta din radering.
  2. Välj Ta bort.

En skärmbild av bekräftelsedialogrutan för att ta bort en resursgrupp i Azure Portal.

1. Skapa Azure-resurser och distribuera en exempelapp

I detta steg skapar du Azure-resurser och distribuerar en exempelapplikation till App Service på Linux. Stegen som används i den här handledningen skapar en uppsättning standardmässigt säkra resurser som inkluderar App Service och Azure Database for PostgreSQL.

  1. Om du inte redan har gjort det klonar du exempellagringsplatsens starter-no-infra gren i en lokal terminal.

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

    Den här klonade grenen är din startpunkt. Den innehåller en enkel datadriven FastAPI-applikation.

  2. Från lagringsroten kör du azd init.

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

  3. När du uppmanas, ge följande svar:

    Fråga Svar
    Den aktuella katalogen är inte tom. Vill du initiera ett projekt här i '<your-directory>'? Y
    Vad vill du göra med de här filerna? Behåll mina befintliga filer oförändrade
    Ange ett nytt miljönamn Skriv ett unikt namn. Azd-mallen använder det här namnet som en del av DNS-namnet på din webbapp i Azure (<app-name>.azurewebsites.net). Alfanumeriska tecken och bindestreck är tillåtna.

  4. azd up Kör kommandot för att etablera nödvändiga Azure-resurser och distribuera appkoden. Om du inte redan är inloggad i Azure startas webbläsaren och du uppmanas att logga in. Kommandot azd up uppmanar dig också att välja önskad prenumeration och plats att distribuera till.

    azd up

    Kommandot azd up kan ta flera minuter att slutföra. Den kompilerar och distribuerar även programkoden. När den körs, ger kommandot meddelanden om provisionerings- och distributionsprocessen, inklusive en länk till distributionen i Azure. När det är klart visar kommandot även en länk till distributionsprogrammet.

    Den här azd-mallen innehåller filer (azure.yaml och infra-katalogen ) som genererar en säker arkitektur som standard med följande Azure-resurser:

    • Resursgrupp → Behållaren för alla de skapade resurserna.
    • App Service plan → Definierar beräkningsresurserna för App Service. En Linux-plan på B1-nivån har angetts.
    • App Service → Representerar din app och körs i App Service-planen.
    • Virtuellt nätverk → Integreras med App Service-appen och isolerar nätverkstrafik på backend.
    • Azure Database for PostgreSQL – flexibel server → Endast tillgänglig inifrån det virtuella nätverket. En databas och en användare skapas åt dig på servern.
    • Privat DNS-zon → Aktiverar DNS-matchning för PostgreSQL-servern i det virtuella nätverket.
    • Log Analytics-arbetsytan → Fungerar som målcontainer för din app där loggarna kan överföras, och där du också kan utföra frågor på loggarna.

  5. azd up När kommandot har slutförts noterar du värdena för prenumerations-ID (Guid), App Service och resursgruppen i utdata. Du använder dem i följande avsnitt. Dina utdata ser ut ungefär som följande (partiella) utdata:

    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. Granska databasanslutningssträngen

Azd-mallen genererar anslutningsvariablerna åt dig som appinställningar. Inställningar för appar är ett sätt att hålla anslutningshemligheter utanför din koddatabas.

  1. infra/resources.bicep Leta upp appinställningarna i filen och leta reda på inställningen för 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'
  }
}

  2. AZURE_POSTGRESQL_CONNECTIONSTRING innehåller anslutningssträngen till Postgres-databasen i Azure. Du behöver använda det i din kod för att ansluta till det. Du hittar koden som använder den här miljövariabeln i 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. Granska startkommandot

Azure App Service kräver ett startkommando för att köra din FastAPI-app. Azd-mallen anger det här kommandot åt dig i Din App Service-instans.

  1. infra/resources.bicep Leta upp deklarationen för webbplatsen i filen och leta sedan upp inställningen för appCommandLine. Det här är inställningen för startkommandot.

    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'
  }

  2. Startkommandot kör filen src/entrypoint.sh. Granska koden i filen för att förstå de kommandon som App Service kör för att starta appen:

    #!/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

Mer information om appkonfiguration och start i App Service finns i Konfigurera en Linux Python-app för Azure App Service.

4. Generera databasschema

Du kanske har märkt i föregående avsnitt att entrypoint.sh innehåller följande rad: python3 src/fastapi_app/seed_data.py. Det här kommandot migrerar databasen. I exempelappen ser den bara till att rätt tabeller skapas i databasen. De här tabellerna fylls inte i med några data.

I det här avsnittet kör du det här kommandot manuellt i demonstrationssyfte. Med PostgreSQL-databasen skyddad av det virtuella nätverket är det enklaste sättet att köra kommandot i en SSH-session med App Service-containern.

  1. Använd värdet för apptjänsten som du antecknade tidigare i azd-utdata för att konstruera URL:en för SSH-sessionen och navigera till den i webbläsaren:

  2. Kör python3 src/fastapi_app/seed_data.py i SSH-terminalen. Om det lyckas ansluter App Service till databasen.

    En skärmbild som visar kommandona som ska köras i SSH-gränssnittet och deras utdata (FastAPI).

    Anmärkning

    Endast ändringar i filer i /home kan bevaras utöver omstarter av appar. Ändringar utanför /home sparas inte.

5. Gå till appen

  1. I azd-utdata letar du reda på url:en för din app och navigerar till den i webbläsaren. URL:en ser ut så här i AZD-utdata:

     Deploying services (azd deploy)

   (✓) Done: Deploying service web
   - Endpoint: <URL>

  2. Lägg till några restauranger i listan.

    En skärmbild av FastAPI-webbappen med PostgreSQL som körs i Azure och som visar restauranger och restaurangrecensioner (FastAPI).

    Grattis, du kör en webbapp i Azure App Service med säker anslutning till Azure Database for PostgreSQL.

6. Strömma diagnostikloggar

Azure App Service kan samla in loggar som hjälper dig att diagnostisera problem med ditt program. För enkelhetens skull har azd-mallen redan aktiverat loggning till det lokala filsystemet.

Exempelappen använder loggningsmodulen i Python Standard Library för att generera loggar. Exempelappen innehåller anrop till loggaren enligt nedan.

@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)
    )

Öppna din app i Azure-portalen för att komma åt loggströmmen. Välj Övervakning>Loggström.

Det kan ta flera minuter att visa händelser i diagnostikloggarna. Läs mer om att logga in Python-appar i serien när du konfigurerar Azure Monitor för ditt Python-program.

7. Rensa resurser

Om du vill ta bort alla Azure-resurser i den aktuella distributionsmiljön kör du azd down.

azd down

Felsökning

Nedan visas problem som kan uppstå när du försöker gå igenom den här självstudien och steg för att lösa dem.

Jag kan inte ansluta till SSH-sessionen

Om du inte kan ansluta till SSH-sessionen har själva appen inte startats. Mer information finns i diagnostikloggarna . Om du till exempel ser ett fel som KeyError: 'AZURE_POSTGRESQL_CONNECTIONSTRING'kan det innebära att miljövariabeln saknas (du kan ha tagit bort appinställningen).

Jag får ett fel när jag kör databasmigreringar

Om du stöter på fel som rör anslutning till databasen kontrollerar du om appinställningarna (AZURE_POSTGRESQL_CONNECTIONSTRING) har ändrats. Utan den anslutningssträng kan migreringskommandot inte kommunicera med databasen.

Vanliga frågor

Hur mycket kostar den här installationen?

Prissättningen för de skapade resurserna är som följer:

Hur gör jag för att ansluta till PostgreSQL-servern som skyddas bakom det virtuella nätverket med andra verktyg?

  • För grundläggande åtkomst från ett kommandoradsverktyg kan du köra psql från appens SSH-terminal.
  • Om du vill ansluta från ett skrivbordsverktyg måste datorn finnas i det virtuella nätverket. Det kan till exempel vara en virtuell Azure-dator som är ansluten till ett av undernäten, eller en dator i ett lokalt nätverk som har en plats-till-plats-VPN-anslutning med det virtuella Azure-nätverket.
  • Du kan också integrera Azure Cloud Shell med det virtuella nätverket.

Hur fungerar utveckling av lokala appar med GitHub Actions?

Med hjälp av den automatiskt genererade arbetsflödesfilen från App Service som exempel startar varje git push en ny bygg- och distributionskörning. Från en lokal klon av GitHub-lagringsplatsen gör du önskade uppdateringar och push-överför till GitHub. Till exempel:

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

Nästa steg

Gå vidare till nästa handledning för att lära dig hur du säkrar din app med en anpassad domän och certifikat.

  Säkra med anpassad domän och certifikat

Lär dig hur App Service kör en Python-app:

Konfigurera Python-app