Översikt över Python Container Apps i Azure

Den här artikeln beskriver hur du tar ett Python-projekt, till exempel ett webbprogram, och distribuerar det som en Docker-container i Azure. Den omfattar det allmänna arbetsflödet för containerisering, Azure-distributionsalternativ för containrar och Python-specifika containerkonfigurationer i Azure. Att skapa och distribuera Docker-containrar i Azure följer en standardprocess mellan olika språk, med Python-specifika konfigurationer i Dockerfile, requirements.txtoch inställningar för webbramverk som Django, Flask och FastAPI.

Scenarier för containerarbetsflöde

För utveckling av Python-containrar beskrivs några vanliga arbetsflöden för att flytta från kod till container i följande tabell.

Slutmålet med dessa arbetsflöden är att ha en container som körs i en av De Azure-resurser som stöder Docker-containrar enligt listan i nästa avsnitt.

En utvecklingsmiljö kan vara:

• Din lokala arbetsstation med Visual Studio Code eller PyCharm
• Codespaces (en utvecklingsmiljö som är värd i molnet)
• Visual Studio Dev Containers (en container som en utvecklingsmiljö)

Alternativ för distributionscontainer i Azure

Python-containerappar stöds i följande tjänster.

En mer detaljerad jämförelse av dessa tjänster finns i Jämföra containerappar med andra Azure-containeralternativ.

Virtuella miljöer och containrar

Virtuella miljöer i Python isolerar projektberoenden från Python-installationer på systemnivå, vilket säkerställer konsekvens mellan utvecklingsmiljöer. En virtuell miljö innehåller en egen isolerad Python-tolk, tillsammans med de bibliotek och skript som behövs för att köra den specifika projektkoden i den miljön. Beroenden för Python-projekt hanteras via filenrequirements.txt . Genom att ange beroenden i en requirements.txt fil kan utvecklare återskapa den exakta miljö som behövs för deras projekt. Den här metoden underlättar smidigare övergångar till containerbaserade distributioner som Azure App Service, där miljökonsekvens är avgörande för tillförlitliga programprestanda.

Du kan betrakta Docker-containrar som funktioner som liknar virtuella Python-miljöer , men med bredare fördelar när det gäller reproducerbarhet, isolering och portabilitet. Till skillnad från virtuella miljöer kan Docker-containrar köras konsekvent i olika operativsystem och miljöer, så länge en containerkörning är tillgänglig.

En Docker-container innehåller din Python-projektkod tillsammans med allt som behövs för att köras, till exempel beroenden, miljöinställningar och systembibliotek. För att skapa en container skapar du först en Docker-avbildning från projektkoden och konfigurationen och startar sedan en container, som är en körbar instans av avbildningen.

För containerisering av Python-projekt beskrivs nyckelfilerna i följande tabell:

Containerinställningar för webbramverk

Webbramverk binder vanligtvis till standardportar (till exempel 5 000 för Flask, 8 000 för FastAPI). När du distribuerar containrar till Azure-tjänster, till exempel Azure Container Instances, Azure Kubernetes Service (AKS) eller App Service for Containers, är det viktigt att du uttryckligen exponerar och konfigurerar containerns lyssnarport för att säkerställa korrekt routning av inkommande trafik. Genom att konfigurera rätt port ser du till att Azures infrastruktur kan dirigera begäranden till rätt slutpunkt i containern.

I följande tabell visas hur du ställer in porten för olika Azure-containerlösningar.

Python Dockerfile

En Dockerfile är en textfil som innehåller instruktioner för att skapa en Docker-avbildning för ett Python-program. Den första instruktionen anger vanligtvis basavbildningen som ska startas från. Efterföljande instruktioner beskriver sedan åtgärder som att installera nödvändig programvara, kopiera programfiler och konfigurera miljön för att skapa en runnable-avbildning. Följande tabell innehåller Python-specifika exempel för vanliga Dockerfile-instruktioner.

Docker build-kommandot skapar Docker-avbildningar från en Dockerfile och en kontext. En byggkontext är den uppsättning filer som finns i den angivna sökvägen eller URL:en. Vanligtvis skapar du en avbildning från python-projektets rot och sökvägen till build-kommandot är "." som du ser i följande exempel.

docker build --rm --pull  --file "Dockerfile"  --tag "mywebapp:latest"  .

Byggprocessen kan referera till någon av filerna i kontexten. Ditt bygge kan till exempel använda en COPY-instruktion för att referera till en fil i kontexten. Här är ett exempel på en Dockerfile för ett Python-projekt med Flask-ramverket :

FROM python:3.9-slim

EXPOSE 5000

# Keeps Python from generating .pyc files in the container.
ENV PYTHONDONTWRITEBYTECODE=1

# Turns off buffering for easier container logging
ENV PYTHONUNBUFFERED=1

# Install pip requirements.
COPY requirements.txt .
RUN python -m pip install -r requirements.txt

WORKDIR /app
COPY . /app

# Creates a non-root user with an explicit UID and adds permission to access the /app folder.
RUN adduser -u 5678 --disabled-password --gecos "" appuser && chown -R appuser /app
USER appuser

# Provides defaults for an executing container; can be overridden with Docker CLI.
CMD ["gunicorn", "--bind", "0.0.0.0:5000", "wsgi:app"]

Du kan skapa en Dockerfile för hand eller skapa den automatiskt med VS Code och Docker-tillägget. Mer information finns i Generera Docker-filer.

Docker Build-kommandot är en del av Docker CLI. När du använder IDE:er som VS Code eller PyCharm anropar användargränssnittskommandona för att arbeta med Docker-avbildningar build-kommandot åt dig och automatiserar att ange alternativ.

Arbeta med Python Docker-avbildningar och containrar

VS Code och PyCharm

Integrerade utvecklingsmiljöer (IDE:er) som Visual Studio Code (VS Code) och PyCharm effektiviserar python-containerutvecklingen genom att integrera Docker-uppgifter i arbetsflödet. Med tillägg eller plugin-program gör dessa IDE:er det enklare att skapa Docker-avbildningar, köra containrar och distribuera till Azure-tjänster som App Service eller Container Instances. Här är några av de saker du kan göra med VS Code och PyCharm.

• Ladda ned och skapa Docker-avbildningar.

  • Skapa avbildningar i utvecklingsmiljön.
  • Skapa Docker-avbildningar i Azure utan Docker installerat i utvecklingsmiljön. (För PyCharm använder du Azure CLI för att skapa avbildningar i Azure.)

• Skapa och kör Docker-containrar från en befintlig avbildning, en hämtad avbildning eller direkt från en Dockerfile.

• Kör multicontainer-program med Docker Compose.

• Ansluta och arbeta med containerregister som Docker Hub, GitLab, JetBrains Space, Docker V2 och andra docker-register med egen värd.

• (endast VS Code) Lägg till en Dockerfile och Docker compose-filer som är skräddarsydda för ditt Python-projekt.

Använd följande steg för att konfigurera VS Code och PyCharm för att köra Docker-containrar i utvecklingsmiljön.

• VS-kod
• PyCharm

Om du inte redan har gjort det installerar du Azure Tools för VS Code.

Instruktion	Skärmbild
Steg 1: Använd SKIFT + ALT + A för att öppna Azure-tillägget och bekräfta att du är ansluten till Azure. Du kan också välja Azure-ikonen i VS Code-tilläggsfältet. Om du inte är inloggad väljer du Logga in på Azure och följer anvisningarna. Om du har problem med att komma åt din Azure-prenumeration kan det bero på att du är bakom en proxyserver. Information om hur du löser anslutningsproblem finns i Nätverksanslutningar i Visual Studio Code.
Steg 2: Använd CTRL + SKIFT + X för att öppna Tillägg, söka efter Docker-tillägget och installera tillägget. Du kan också välja tilläggsikonen i VS Code-tilläggsfältet.
Steg 3: Välj Docker-ikonen i tilläggsfältet, expandera avbildningar och högerklicka på en Docker-avbildning kör den som en container.
Steg 4: Övervaka Docker-körningens utdata i terminalfönstret .

Azure CLI och Docker CLI

Du kan också arbeta med Python Docker-avbildningar och containrar med hjälp av Azure CLI och Docker CLI. Både VS Code och PyCharm har terminaler där du kan köra dessa CLI:er.

Använd ett CLI när du vill ha bättre kontroll över bygg- och körningsargument och för automatisering. Följande kommando visar till exempel hur du använder Azure CLI az acr build för att ange Docker-avbildningsnamnet.

az acr build --registry <registry-name> \
  --resource-group <resource-group> \
  --target pythoncontainerwebapp:latest .

Som ett exempel till kan man överväga följande kommando som visar hur du använder Docker CLI run-kommando. Exemplet visar hur du kör en Docker-container som kommunicerar med en MongoDB-instans i utvecklingsmiljön utanför containern. De olika värdena för att slutföra kommandot är enklare att automatisera när de anges på en kommandorad.

docker run --rm -it \
  --publish <port>:<port> --publish 27017:27017 \
  --add-host mongoservice:<your-server-IP-address> \
  --env CONNECTION_STRING=mongodb://mongoservice:27017 \
  --env DB_NAME=<database-name> \
  --env COLLECTION_NAME=<collection-name> \
  containermongo:latest  

Mer information om det här scenariot finns i Skapa och testa en containerbaserad Python-webbapp lokalt.

Miljövariabler i containrar

Python-projekt använder ofta miljövariabler för att skicka konfigurationsdata till programkoden. Den här metoden ger större flexibilitet i olika miljöer. Information om databasanslutning kan till exempel lagras i miljövariabler, vilket gör det enkelt att växla mellan utvecklings-, testnings- och produktionsdatabaser utan att ändra koden. Den här separationen av konfigurationen från kod främjar renare distributioner och förbättrar säkerhet och underhåll.

Paket som python-dotenv används ofta för att läsa nyckel/värde-par från en .env-fil och ange dem som miljövariabler. En .env-fil är användbar när den körs i en virtuell miljö, men rekommenderas inte när du arbetar med containrar. Kopiera inte .env-filen till Docker-avbildningen, särskilt om den innehåller känslig information och containern kommer att offentliggöras. Använd .dockerignore-filen för att undanta filer från att kopieras till Docker-avbildningen. Mer information finns i avsnittet Virtuella miljöer och containrar i den här artikeln.

Du kan skicka miljövariabler till containrar på några sätt:

1. Definieras i Dockerfile som ENV-instruktioner .
2. Skickas som --build-arg argument med Kommandot Docker build .
3. Skickas som --secret argument med Docker Build-kommandot och BuildKit-backend.
4. Skickas som --env eller --env-file argument med Docker run-kommandot.

De två första alternativen har samma nackdel som med .env-filer , nämligen att du hårdkodar potentiellt känslig information till en Docker-avbildning. Du kan inspektera en Docker-avbildning och se miljövariablerna, till exempel med kommandot docker-avbildningen inspekterad.

Med det tredje alternativet med BuildKit kan du skicka hemlig information som ska användas i Dockerfile för att skapa Docker-avbildningar på ett säkert sätt som inte lagras i den slutliga avbildningen.

Det fjärde alternativet för att ange miljövariabler med docker-körningskommandot innebär att Docker-bilden inte innehåller variablerna. Variablerna är dock fortfarande synliga när man inspekterar containerinstansen (till exempel med docker container inspect). Det här alternativet kan vara acceptabelt när åtkomsten till containerinstansen styrs eller i test- eller utvecklingsscenarier.

Här är ett exempel på hur du skickar miljövariabler med kommandot Docker CLI-körning och använder --env argumentet .

# PORT=8000 for Django and 5000 for Flask
export PORT=<port-number>

docker run --rm -it \
  --publish $PORT:$PORT \
  --env CONNECTION_STRING=<connection-info> \
  --env DB_NAME=<database-name> \
  <dockerimagename:tag>

I VS Code (Docker-tillägg) eller PyCharm (Docker-plugin-program) förenklar UI-verktygen hanteringen av Docker-avbildningar och containrar genom att köra STANDARD-DOCKER CLI-kommandon (till exempel docker build, docker run) i bakgrunden.

Slutligen är det annorlunda att ange miljövariabler när du distribuerar en container i Azure än att använda miljövariabler i utvecklingsmiljön. Till exempel:

• För Web App for Containers konfigurerar du programinställningar under konfigurationen av App Service. De här inställningarna är tillgängliga för din appkod som miljövariabler och används med standardmönstret os.environ . Du kan ändra värden efter den första distributionen när det behövs. Mer information finns i Åtkomst till appinställningar som miljövariabler.

• För Azure Container Apps konfigurerar du miljövariabler under den inledande konfigurationen av containerappen. Efterföljande ändringar av miljövariabler skapar en revision av containern. Dessutom kan du med Azure Container Apps definiera hemligheter på programnivå och sedan referera till dem i miljövariabler. Mer information finns i Hantera hemligheter i Azure Container Apps.

Som ett annat alternativ kan du använda Service Connector för att hjälpa dig att ansluta Azure-beräkningstjänster till andra säkerhetskopieringstjänster. Den här tjänsten konfigurerar nätverksinställningar och anslutningsinformation (till exempel generera miljövariabler) mellan beräkningstjänster och målstödtjänster i hanteringsplanet.

Visa containerloggar

Visa containerinstansloggar för att se diagnostikmeddelanden som matas ut från kod och för att felsöka problem i containerns kod. Här är flera sätt att visa loggar när du kör en container i utvecklingsmiljön:

• När du kör en container med VS Code eller PyCharm, som du ser i avsnittet VS Code och PyCharm, kan du se loggar i terminalfönster som öppnas när Docker-körningen körs.

• Om du använder Docker CLI-kommandot run med den interaktiva flaggan -it, visas utdata följande kommandot.

• I Docker Desktop kan du också visa loggar för en container som körs.

När du distribuerar en container i Azure har du också åtkomst till containerloggar. Här är flera Azure-tjänster och hur du kommer åt containerloggar i Azure-portalen.

Här är Azure CLI-kommandona för att komma åt loggar för dessa tjänster.

Det finns också stöd för att visa loggar i VS Code. Du måste ha Azure Tools for VS Code installerat. Nedan visas ett exempel på hur du visar Loggar för Web Apps for Containers (App Service) i VS Code.

Nästa steg

• Containerbaserad Python-webbapp i Azure med MongoDB
• Distribuera en Python-webbapp i Azure Container Apps med PostgreSQL