Skapa och köra en containerbaserad Python-webbapp lokalt

I den här delen av självstudieserien får du lära dig hur du skapar och kör en containerbaserad Django eller en Flask Python-webbapp på din lokala dator. Om du vill lagra data för den här appen kan du använda antingen en lokal MongoDB-instans eller Azure Cosmos DB för MongoDB. Den här artikeln är del 2 i en självstudieserie i fem delar. Du bör slutföra del 1 innan du påbörjar den här artikeln.

Följande tjänstdiagram visar de lokala komponenter som beskrivs i den här artikeln. I den här artikeln lär du dig också hur du använder Azure Cosmos DB för MongoDB med en lokal Docker-avbildning i stället för en lokal instans av MongoDB.

Klona eller ladda ned Python-exempelappen

I det här avsnittet ska du klona eller ladda ned python-exempelappen som du använder för att skapa en Docker-avbildning. Du kan välja mellan en Django- eller Flask Python-webbapp. Om du har en egen Python-webbapp kan du välja att använda den i stället. Om du använder din egen Python-webbapp kontrollerar du att appen har en Dockerfile i rotmappen och kan ansluta till en MongoDB-databas.

Git-klon
Ladda ned

Klona antingen Django- eller Flask-lagringsplatsen till en lokal mapp med något av följande kommandon:

Django
Flaska

# Django
git clone https://github.com/Azure-Samples/msdocs-python-django-container-web-app.git

# Flask
git clone https://github.com/Azure-Samples/msdocs-python-flask-container-web-app.git

Gå till rotmappen för den klonade lagringsplatsen.

Django
Flaska

# Django
cd msdocs-python-django-container-web-app

# Flask
cd msdocs-python-flask-container-web-app

Skapa en Docker-avbildning

I det här avsnittet skapar du en Docker-avbildning för Python-webbappen med antingen Visual Studio Code eller Azure CLI. Docker-avbildningen innehåller Python-webbappen, dess beroenden och Python-körningen. Du skapar Docker-avbildningen från en Dockerfile som definierar avbildningens innehåll och beteende. Dockerfile finns i rotmappen för exempelappen som du klonade eller laddade ned (eller angav själv).

Tips/Råd

Om du inte har använt Azure CLI tidigare kan du läsa Komma igång med Azure CLI för att lära dig hur du laddar ned och installerar Azure CLI lokalt eller hur du kör Azure CLI-kommandon i Azure Cloud Shell.

Azure CLI
VS-kod

Om du vill skapa Docker-avbildningen med hjälp av Docker CLI behöver du Docker. När du har installerat Docker öppnar du ett terminalfönster och går till exempelmappen.

Anmärkning

Stegen i det här avsnittet kräver att Docker-daemon körs. I vissa installationer, till exempel på Windows, måste du öppna Docker Desktop som startar daemonen innan du kan fortsätta.

Bekräfta att Docker är tillgängligt genom att köra följande kommando i rotmappen för exempelappen.
```
docker
```
Om du efter att ha kört det här kommandot ser hjälpen för Docker CLI är Docker tillgänglig. Annars kontrollerar du att Docker är installerat och att ditt terminalfönster har åtkomst till Docker CLI.
Skapa Docker-avbildningen för Python-webbappen med hjälp av kommandot Docker build .

Kommandots allmänna form är docker build --rm --pull --file "<path-to-project-root>/Dockerfile" --label "com.microsoft.created-by=docker-cli" --tag "<container-name>:latest" "<path-to-project-root>".

Om du är i rotmappen för projektet använder du följande kommando för att skapa Docker-avbildningen. Punkten (".") i slutet av kommandot refererar till den aktuella katalogen där kommandot körs. Om du vill tvinga fram en ombyggnad lägger du till --no-cache.

Anmärkning

Exempellagringsplatsen använder Python 3.8. Om du skapar en egen Dockerfile använder du en Python version som stöds, till exempel 3.12 eller 3.13. Mer information om versioner som stöds finns i Python version.
- Bash
- PowerShell
```
#!/bin/bash
docker build --rm --pull \
  --file "Dockerfile" \
  --label "com.microsoft.created-by=docker-cli" \
  --tag "msdocspythoncontainerwebapp:latest" \
    .
```
```
# PowerShell syntax
docker build --rm --pull `
  --file "Dockerfile" `
  --label "com.microsoft.created-by=docker-cli" `
  --tag "msdocspythoncontainerwebapp:latest" `
    .
```
Bekräfta att avbildningen har skapats med kommandot Docker Images .
```
docker images
```
Kommandot returnerar en lista över avbildningar efter LAGRINGSPLATSnamn, TAGG och SKAPAT datum bland andra bildegenskaper.

Om du vill skapa Docker-avbildningen lokalt med hjälp av Visual Studio Code behöver du Visual Studio Code och tillägget Docker. Installera Visual Studio Code och Docker-tillägget innan du fortsätter. När du har installerat Visual Studio Code och Docker-tillägget går du till exempelmappen som du klonade eller laddade ned och öppnar VS Code med hjälp av kommandot code ..

Anmärkning

Stegen i det här avsnittet kräver att Docker-daemon körs. I vissa installationer, till exempel på Windows, måste du öppna Docker Desktop för att starta daemonen innan du fortsätter.

När du har installerat Visual Studio Code och Docker-tillägget går du till exempelmappen som du klonade eller laddade ned och öppnar VS Code med hjälp av kommandot code ..
Öppna Docker-tillägget i VS Code och välj sedan Docker-tillägget i aktivitetsfältet.

Om Docker-tillägget rapporterar felet "Det gick inte att ansluta" kontrollerar du att Docker är installerat och körs.
Om du vill skapa Docker-avbildningen högerklickar du på Dockerfile och väljer sedan Skapa avbildning....

Mer information om Dockerfile-syntax finns i Dockerfile-referensen.
Bekräfta att avbildningen har skapats genom att expandera avsnittet IMAGES i Docker-tillägget och leta efter den nyligen skapade avbildningen. Namnet på den här containeravbildningen är "msdocspythoncontainerwebapp" (det här värdet anges i filen .vscode/tasks.json ).

Nu har du en lokal Docker-avbildning med namnet "msdocspythoncontainerwebapp" med taggen "latest". Taggar hjälper dig att definiera versionsinformation, avsedd användning, stabilitet och annan relevant information. Mer information finns i Rekommendationer för taggning och versionshantering av containeravbildningar.

Anmärkning

Du kan också visa avbildningar som du skapar från VS Code eller med hjälp av Docker CLI direkt med hjälp av Docker Desktop-programmet .

Konfigurera MongoDB

Din Python webbapp kräver en MongoDB-databas och en samling, båda med namnet restaurants_reviews, för att lagra data. I den här självstudien använder du både en lokal installation av MongoDB och en Azure Cosmos DB för MongoDB-instans för att skapa och komma åt databasen och kollektionen.

Viktigt!

Använd inte en MongoDB-databas som du använder i produktion. I den här självstudien lagrar du MongoDB-anslutningssträngen till en av dessa MongoDB-instanser i en miljövariabel. Alla som kan inspektera din container – till exempel med hjälp av docker inspect – kan se den här anslutningssträngen.

Lokal MongoDB

Skapa en lokal instans av MongoDB med hjälp av Azure CLI.

Installera MongoDB om det inte redan är installerat.

Om du vill kontrollera om MongoDB är installerat använder du MongoDB Shell (mongosh). Om följande kommandon inte fungerar kan du behöva installera mongosh eller ansluta mongosh till MongoDB-servern.
- Använd följande kommando för att öppna MongoDB-gränssnittet och hämta versionen av både MongoDB-gränssnittet och MongoDB-servern:
```
mongosh
```
  Tips/Råd
  
  Om du bara vill returnera den version av MongoDB-servern som är installerad på systemet stänger du och öppnar MongoDB-gränssnittet igen och använder följande kommando: mongosh --quiet --exec 'db.version()'
  
  I vissa installationer kan du också direkt anropa Mongo-daemon i bash-gränssnittet.
```
mongod --version
```
Redigera filen mongod.cfg i \MongoDB\Server\8.0\bin mappen och lägg till datorns lokala IP-adress i bindIP nyckeln.

Anmärkning

Sökvägen till konfigurationsfilen varierar beroende på operativsystem och MongoDB-version. På macOS letar du efter /usr/local/etc/mongod.conf eller /opt/homebrew/etc/mongod.conf. I Linux kontrollerar du /etc/mongod.conf.

Nyckeln bindip i MongoD-konfigurationsfilen definierar de värdnamn och IP-adresser som MongoDB lyssnar efter klientanslutningar. Lägg till den aktuella IP-adressen för din lokala utvecklingsdator. Python-exempelwebbappen som körs lokalt i en Docker-container kommunicerar med värddatorn med den här adressen.

En del av konfigurationsfilen bör till exempel se ut så här:
```
net:
  port: 27017
  bindIp: 127.0.0.1,<local-ip-address>
```
Spara ändringarna i den här konfigurationsfilen.

Viktigt!

Du behöver administratörsbehörighet för att spara de ändringar du gör i den här konfigurationsfilen.
Starta om MongoDB för att hämta ändringar i konfigurationsfilen.
Öppna ett MongoDB-gränssnitt och kör följande kommando för att ange databasnamnet till "restaurants_reviews" och samlingsnamnet till "restaurants_reviews". Du kan också skapa en databas och samling med VS Code MongoDB-tillägget eller något annat MongoDB-medvetet verktyg.
```
> help
> use restaurants_reviews
> db.restaurants_reviews.insertOne({})
> show dbs
> exit
```

När du har slutfört föregående steg är den lokala MongoDB-anslutningssträngen "mongodb://127.0.0.1:27017/", databasnamnet är "restaurants_reviews" och samlingsnamnet är "restaurants_reviews".

Azure Cosmos DB för MongoDB

Skapa nu en Azure Cosmos DB för MongoDB-instansen med hjälp av Azure CLI.

Anmärkning

I del 4 i den här självstudieserien använder du Azure Cosmos DB for MongoDB-instansen för att köra webbappen i Azure App Service.

Innan du kör följande skript ersätter du platsen, resursgruppen och Azure Cosmos DB för MongoDB-kontonamnet med lämpliga värden (valfritt). Använd samma resursgrupp för alla Azure resurser som du skapar i den här självstudien för att göra dem enklare att ta bort när du är klar.

Det tar några minuter att köra skriptet.

Bash
PowerShell

#!/bin/bash
# LOCATION: The Azure region. Use the "az account list-locations -o table" command to find a region near you.
LOCATION='westus'
# RESOURCE_GROUP_NAME: The resource group name, which can contain underscores, hyphens, periods, parenthesis, letters, and numbers.
RESOURCE_GROUP_NAME='msdocs-web-app-rg'
# ACCOUNT_NAME: The Azure Cosmos DB for MongDB account name, which can contain lowercase letters, hyphens, and numbers.
ACCOUNT_NAME='msdocs-cosmos-db-account-name'

# Create a resource group
echo "Creating resource group $RESOURCE_GROUP_NAME in $LOCATION..."
az group create --name $RESOURCE_GROUP_NAME --location $LOCATION

# Create a Cosmos account for MongoDB API
echo "Creating $ACCOUNT_NAME. This command may take a while to complete."
az cosmosdb create --name $ACCOUNT_NAME --resource-group $RESOURCE_GROUP_NAME --kind MongoDB

# Create a MongoDB API database
echo "Creating database restaurants_reviews"
az cosmosdb mongodb database create --account-name $ACCOUNT_NAME --resource-group $RESOURCE_GROUP_NAME --name restaurants_reviews

# Create a MongoDB API collection
echo "Creating collection restaurants_reviews"
az cosmosdb mongodb collection create --account-name $ACCOUNT_NAME --resource-group $RESOURCE_GROUP_NAME --database-name restaurants_reviews --name restaurants_reviews

# Get the connection string for the MongoDB database
echo "Get the connection string for the MongoDB account"
az cosmosdb keys list --name $ACCOUNT_NAME --resource-group $RESOURCE_GROUP_NAME --type connection-strings

echo "Copy the Primary MongoDB Connection String from the list above"

# PowerShell syntax
# LOCATION: The Azure region. Use "az account list-locations -o table" to find a region near you.
# RESOURCE_GROUP_NAME: The resource group name, which can contain underscores, hyphens, periods, parenthesis, letters, and numbers.
# ACCOUNT_NAME: The Azure Cosmos DB for MongoDB account name, which can contain lowercase letters, hyphens, and numbers.

$LOCATION = "westus"
$RESOURCE_GROUP_NAME = "msdocs-web-app-rg"
$ACCOUNT_NAME = "msdocs-cosmos-db-account-name"

# Create a resource group
Write-Output "Creating resource group $RESOURCE_GROUP_NAME in $LOCATION..."
az group create --name $RESOURCE_GROUP_NAME --location $LOCATION

# Create a Cosmos account for MongoDB API
Write-Output "Creating $ACCOUNT_NAME. This command may take a while to complete."
az cosmosdb create --name $ACCOUNT_NAME --resource-group $RESOURCE_GROUP_NAME --kind MongoDB

# Create a MongoDB API database
Write-Output "Creating database restaurants_reviews"
az cosmosdb mongodb database create --account-name $ACCOUNT_NAME --resource-group $RESOURCE_GROUP_NAME --name "restaurants_reviews"

# Create a MongoDB API collection
Write-Output "Creating collection restaurants_reviews"
az cosmosdb mongodb collection create --account-name $ACCOUNT_NAME --resource-group $RESOURCE_GROUP_NAME --database-name "restaurants_reviews" --name "restaurants_reviews"

# Get the connection string for the MongoDB database
Write-Output "Getting the connection string for the MongoDB account..."
az cosmosdb keys list --name $ACCOUNT_NAME --resource-group $RESOURCE_GROUP_NAME --type connection-strings

Write-Output "Copy the Primary MongoDB Connection String from the list above."

När skriptet är klart kopierar du den primära MongoDB-anslutningssträngen från utdata från det senaste kommandot till Urklipp eller någon annan plats.

{
  "connectionStrings": [
    {
      "connectionString": ""mongodb://msdocs-cosmos-db:pnaMGVtGIRAZHUjsg4GJBCZMBJ0trV4eg2IcZf1TqV...5oONz0WX14Ph0Ha5IeYACDbuVrBPA==@msdocs-cosmos-db.mongo.cosmos.azure.com:10255/?ssl=true&replicaSet=globaldb&retrywrites=false&maxIdleTimeMS=120000&appName=@msdocs-cosmos-db@"",
      "description": "Primary MongoDB Connection String",
      "keyKind": "Primary",
      "type": "MongoDB"
    },

    ...
  ]
}

När du har slutfört föregående steg har du en Azure Cosmos DB för MongoDB-anslutningssträng i formuläret mongodb://<server-name>:<password>@<server-name>.mongo.cosmos.azure.com:10255/?ssl=true&<other-parameters>, en databas med namnet restaurants_reviewsoch en samling med namnet restaurants_reviews.

Mer information om hur du använder Azure CLI för att skapa ett Cosmos DB för MongoDB-konto och för att skapa databaser och samlingar finns i Skapa en databas och samling för MongoDB för Azure Cosmos DB med Azure CLI. Du kan också använda PowerShell, VS Code Azure Databases-tillägget och Azure-portalen.

Tips/Råd

I TILLÄGGET VS Code Azure Databases kan du högerklicka på MongoDB-servern och hämta anslutningssträngen.

Kör avbildningen lokalt i en container

Nu är du redo att köra Docker-containern lokalt med hjälp av antingen din lokala MongoDB-instans eller Cosmos DB för MongoDB-instansen. I det här avsnittet av självstudien lär du dig hur du använder antingen VS Code eller Azure CLI för att köra avbilden lokalt. Exempelappen förväntar sig att MongoDB-anslutningsinformationen skickas med hjälp av miljövariabler. Det finns flera metoder för att skicka miljövariabler till en container lokalt. Varje metod har fördelar och nackdelar när det gäller säkerhet. Undvik att checka in eller lämna känsliga uppgifter i kod som finns i containern.

Anmärkning

När du distribuerar webbappen till Azure hämtar webbappen anslutningsinformation från miljövärden som angetts som App Service-konfigurationsinställningar. Ingen av ändringarna för scenariot för den lokala utvecklingsmiljön gäller.

Azure CLI
VS-kod

MongoDB lokal

Använd följande kommandon med din lokala instans av MongoDB för att köra Docker-avbildningen lokalt.

Kör den senaste versionen av avbildningen.

Bash
PowerShell

#!/bin/bash

# Define variables
# Set the port number based on the framework being used:
# 8000 for Django, 5000 for Flask
export PORT=<port-number>  # Replace with actual port (e.g., 8000 or 5000)

# Set your computer''s IP address (replace with actual IP)
export YOUR_IP_ADDRESS=<your-computer-ip-address>  # Replace with actual IP address

# Run the Docker container with the required environment variables
docker run --rm -it \
  --publish "$PORT:$PORT" \
  --add-host "mongoservice:$YOUR_IP_ADDRESS" \
  --env CONNECTION_STRING=mongodb://mongoservice:27017 \
  --env DB_NAME=restaurants_reviews \
  --env COLLECTION_NAME=restaurants_reviews \
  --env SECRET_KEY="supersecretkeythatispassedtopythonapp" \
  msdocspythoncontainerwebapp:latest

# PowerShell syntax
# Define variables
# Set the port number based on the framework being used:
# 8000 for Django, 5000 for Flask
$PORT = "your_port_number"  # Replace with your actual port number
$YOUR_IP_ADDRESS = "your_ip_address"  # Replace with your actual IP address

# Run the Docker container with the required environment variables
docker run --rm -it `
    --publish "${PORT}:${PORT}" `
    --add-host "mongoservice:$YOUR_IP_ADDRESS" `
    --env CONNECTION_STRING="mongodb://mongoservice:27017" `
    --env DB_NAME="restaurants_reviews" `
    --env COLLECTION_NAME="restaurants_reviews" `
    --env SECRET_KEY="supersecretkeythatispassedtopythonapp" `
    msdocspythoncontainerwebapp:latest

Bekräfta att containern är igång. Kör kommandot docker container ls i ett annat konsolfönster.
```
docker container ls
```
Du ser behållaren msdocspythoncontainerwebapp:latest i listan. Observera kolumnen för NAMES utdata och PORTS kolumnen. Använd containernamnet för att stoppa containern.
Testa webbappen.

Gå till http://127.0.0.1:8000 för Django och http://127.0.0.1:5000/ för Flask.
Stäng av containern.
```
docker container stop <container-name>
```

Azure Cosmos DB för MongoDB

Använd följande kommandon med din Azure Cosmos DB for MongoDB-instans för att köra Docker-avbildningen i Azure.

Kör den senaste versionen av avbildningen.

Bash
PowerShell

#!/bin/bash
# PORT=8000 for Django and 5000 for Flask
export PORT=<port-number>
export CONNECTION_STRING="<connection-string>"

docker run --rm -it \
  --publish $PORT:$PORT/tcp \
  --env CONNECTION_STRING=$CONNECTION_STRING \
  --env DB_NAME=restaurants_reviews \
  --env COLLECTION_NAME=restaurants_reviews \
  --env SECRET_KEY=supersecretkeythatyougenerate \
  msdocspythoncontainerwebapp:latest

# PowerShell syntax
# PORT=8000 for Django and 5000 for Flask
$PORT=<port-number>
$CONNECTION_STRING="<connection-string>"

docker run --rm -it `
  --publish ${PORT}:${PORT}/tcp `
  --env CONNECTION_STRING=$CONNECTION_STRING `
  --env DB_NAME=restaurants_reviews `
  --env COLLECTION_NAME=restaurants_reviews `
  --env SECRET_KEY=supersecretkeythatyougenerate `
  msdocspythoncontainerwebapp:latest

I demonstrationssyfte visar det här exemplet att känslig information skickas. Du kan visa reťazec pripojenia information genom att inspektera containern med hjälp av kommandot docker container inspect. Ett annat sätt att hantera hemligheter är att använda BuildKit-funktionerna i Docker.

Öppna ett nytt konsolfönster och kör följande docker container ls-kommando för att bekräfta att containern körs.
```
docker container ls
```
Du ser behållaren msdocspythoncontainerwebapp:latest i listan. Observera kolumnen för NAMES utdata och PORTS kolumnen. Använd containernamnet för att stoppa containern.
Testa webbappen.

Gå till http://127.0.0.1:8000 för Django och http://127.0.0.1:5000/ för Flask.
Stäng av containern.
```
docker container stop <container-name>
```

I det här avsnittet av självstudien använder du Docker-tillägget i Visual Studio Code för att köra containern. Du kan använda antingen anslutningssträngen till din lokala MongoDB-instans eller Cosmos DB för MongoDB-instansen i VS Code.

I mappen .vscode i exempelappen definierar settings.json-filen vad som händer när du använder Docker-tillägget och väljer Kör eller Kör interaktivt på snabbmenyn för en tagg. Filen settings.json innehåller två mallar vardera för scenarierna (MongoDB local) och (MongoDB Azure) .

Om du använder en lokal MongoDB-databas:
- Ersätt båda instanserna av <YOUR_IP_ADDRESS> med din IP-adress.
- Ersätt båda instanserna av <CONNECTION_STRING> med anslutningssträngen för mongoDB-databasen.
- Lägg till följande miljövariabel i strängen med variabler som skickas till Docker-körningskommandot för de lokala MongoDB-mallarna för kodblocken "docker.commands.run" och "docker.commands.runInteractive":
```
-e 'SECRET_KEY=supersecretkeythatispassedtopythonapp'
```
Om du använder en Azure Cosmos DB för MongoDB-databas:
- Ersätt båda instanserna av <CONNECTION_STRING> med Azure Cosmos DB för MongoDB-anslutningssträngen.
- Lägg till följande miljövariabel i strängen med variabler som skickas till Docker-körningskommandot för Azure Cosmos DB för MongoDB-mallar för både kodblocken "docker.commands.run" och "docker.commands.runInteractive":
```
-e 'SECRET_KEY=supersecretkeythatispassedtopythonapp'
```
Ange konfigurationsinställningen docker.dockerPath som används av mallarna. Om du vill ange docker.dockerPathöppnar du VS Code-kommandopaletten (Ctrl+Skift+P), anger "Inställningar: Öppna arbetsyteinställningar" och anger sedan "docker.dockerPath" i rutan Sökinställningar . Ange "docker" (utan citattecken) som värde för inställningen.

Anmärkning

Både databasnamnet och samlingsnamnet antas vara restaurants_reviews.
Kör avbildningen.
1. I avsnittet BILDER i Docker-tillägget hittar du den skapade avbildningen.
2. Expandera bilden för att hitta den senaste taggen, högerklicka och välj Kör interaktiv.
3. Du uppmanas att välja den uppgift som är lämplig för ditt scenario, antingen "Interaktiv körningskonfiguration (Lokal MongoDB)" eller "Konfiguration av interaktiv körning (MongoDB Azure)".
Med en interaktiv session ser du utskriftsuttryck i koden, vilket kan vara användbart för felsökning. Du kan också välja Kör, som inte är interaktivt och inte håller standardindata öppna.

Viktigt!

Det här steget misslyckas om standardterminalprofilen är inställd på (Windows) kommandotolk. Om du vill ändra standardprofilen öppnar du VS Code-kommandopaletten (Ctrl+Skift+P), anger "Terminal: Välj standardprofil" och väljer sedan en annan profil från den nedrullningsbara menyn , till exempel Git Bash eller PowerShell.
Bekräfta att Docker-containern körs.
1. I avsnittet CONTAINRAR i Docker-tillägget letar du reda på containern.
2. Expandera noden Enskilda containrar och bekräfta att containern "msdocspythoncontainerwebapp" körs. Leta efter en grön triangelsymbol bredvid containernamnet.
Testa webbappen genom att högerklicka på containernamnet och välja Öppna i webbläsare.

Webbläsaren öppnas i din standardwebbläsare som "http://127.0.0.1:8000" för Django eller "http://127.0.0.1:5000/" för Flask.

Anmärkning

Om du stöter på ett timeoutfel, kontrollera att MongoDB-tjänsten körs. Annars stoppar du Docker-containern i VS Code och startar om MongoDB-tjänsten. Starta sedan Docker-containern igen och försök komma åt webbappen i webbläsaren.
Stoppa containern.
1. I avsnittet CONTAINRAR i Docker-tillägget letar du reda på containern som körs.
2. Högerklicka på containern och välj Stoppa.

Tips/Råd

Du kan också köra containern genom att välja en körnings- eller felsökningskonfiguration. När du kör eller felsöker anropas Docker-tilläggsuppgifterna i tasks.json . Vilken uppgift som anropas beror på vilken startkonfiguration du väljer. För uppgiften "Docker: Python (MongoDB local)" anger du <YOUR-IP-ADDRESS>. För uppgiften "Docker: Python (MongoDB Azure)" anger du <CONNECTION-STRING>.

Du kan också starta en container från en avbild och stoppa den genom att använda Docker Desktop-programmet.

Nästa steg

Skapa en containeravbildning i Azure

Feedback

Var den här sidan till hjälp?

Last updated on 2026-05-26

Skapa och köra en containerbaserad Python-webbapp lokalt

Klona eller ladda ned Python-exempelappen

Skapa en Docker-avbildning

Konfigurera MongoDB

Lokal MongoDB

Azure Cosmos DB för MongoDB

Kör avbildningen lokalt i en container

MongoDB lokal

Azure Cosmos DB för MongoDB

Nästa steg

Feedback

Ytterligare resurser