Självstudie: Distribuera en grupp med flera containrar med Docker Compose

I den här självstudien använder du Docker Compose för att definiera och köra ett program med flera containrar lokalt och sedan distribuera det som en containergrupp i Azure Container Instances.

Kör containrar Azure Container Instances på begäran när du utvecklar molnbaserade appar med Docker och vill växla sömlöst från lokal utveckling till molndistribution. Den här funktionen aktiveras genom integrering mellan Docker och Azure. Du kan använda interna Docker-kommandon för att köra antingen en enskild containerinstans eller en grupp med flera containrar i Azure.

Den här artikeln innehåller följande avsnitt:

Förutsättningar

• Azure CLI – Du måste ha Azure CLI installerat på den lokala datorn. Version 2.10.1 eller senare rekommenderas. Kör az --version för att hitta versionen. Om du behöver installera eller uppgradera kan du läsa informationen i Installera Azure CLI.

• Docker Desktop – Du måste använda Docker Desktop version 2.3.0.5 eller senare, som är tillgänglig för Windows eller macOS. Eller installera Docker ACI Integration CLI för Linux.

Skapa Azure Container Registry

Innan du skapar containerregistret måste du ha en resursgrupp att distribuera den till. En resursgrupp är en logisk samling där alla Azure-resurser distribueras och hanteras.

Skapa en resursgrupp med kommandot az group create. I följande exempel skapas en resursgrupp med namnet myResourceGroup i regionen eastus:

az group create --name myResourceGroup --location eastus

När du har skapat resursgruppen skapar du ett Azure-containerregister med kommandot az acr create. Namnet på containerregistret måste vara unikt i Azure och innehålla 5–50 alfanumeriska tecken. Ersätt <acrName> med ett unikt namn för ditt register:

az acr create --resource-group myResourceGroup --name <acrName> --sku Basic

Här är partiella utdata för ett nytt Azure-containerregister med namnet mycontainerregistry082:

{
  "creationDate": "2020-07-16T21:54:47.297875+00:00",
  "id": "/subscriptions/<Subscription ID>/resourceGroups/myResourceGroup/providers/Microsoft.ContainerRegistry/registries/mycontainerregistry082",
  "location": "eastus",
  "loginServer": "mycontainerregistry082.azurecr.io",
  "name": "mycontainerregistry082",
  "provisioningState": "Succeeded",
  "resourceGroup": "myResourceGroup",
  "sku": {
    "name": "Basic",
    "tier": "Basic"
  },
  "status": null,
  "storageAccount": null,
  "tags": {},
  "type": "Microsoft.ContainerRegistry/registries"
}

I resten av den här självstudien använder vi <acrName> som platshållare för det containerregisternamn du väljer i det här steget.

Logga in till containerregistret

Du måste logga in på din Azure Container Registry-instans innan du push-överför avbildningar till den. Använd kommandot az acr login till att slutföra åtgärden. Du måste ange det unika namn du valde för containerregistret när du skapade det.

az acr login --name <acrName>

Exempel:

az acr login --name mycontainerregistry082

Kommandot returnerar Login Succeeded när det har slutförts:

Login Succeeded

Hämta programkod

Exempelprogrammet som används i den här självstudien är en enkel röstningsapp. Programmet består av en webbkomponent på klientsidan och en Redis-instans på serversidan. Webbkomponenten paketeras i en anpassad containeravbildning. Redis-instansen använder en oförändrad avbildning från Docker Hub.

Använd git för att klona exempelprogrammet till utvecklingsmiljön:

git clone https://github.com/Azure-Samples/azure-voting-app-redis.git

Ändra till den klonade katalogen.

cd azure-voting-app-redis

I katalogen finns programmets källkod och en förskapad Docker Compose-fil, docker-compose.yaml.

Ändra Docker Compose-fil

Öppna docker-compose.yaml i en textredigerare. Filen konfigurerar azure-vote-back tjänsterna azure-vote-front och .

version: '3'
services:
  azure-vote-back:
    image: mcr.microsoft.com/oss/bitnami/redis:6.0.8
    container_name: azure-vote-back
    environment:
      ALLOW_EMPTY_PASSWORD: "yes"
    ports:
        - "6379:6379"

  azure-vote-front:
    build: ./azure-vote
    image: mcr.microsoft.com/azuredocs/azure-vote-front:v1
    container_name: azure-vote-front
    environment:
      REDIS: azure-vote-back
    ports:
        - "8080:80"

Gör azure-vote-front följande två ändringar i konfigurationen:

1. Uppdatera image egenskapen i azure-vote-front tjänsten. Prefixet avbildningsnamnet med inloggningsservernamnet för ditt <acrName> Azure-containerregister, .azurecr.io. Om registret till exempel heter myregistry är inloggningsserverns namn myregistry.azurecr.io (endast gemener) och avbildningsegenskapen är då myregistry.azurecr.io/azure-vote-front .
2. Ändra ports mappningen till 80:80 . Spara filen.

Den uppdaterade filen bör se ut ungefär så här:

version: '3'
services:
  azure-vote-back:
    image: mcr.microsoft.com/oss/bitnami/redis:6.0.8
    container_name: azure-vote-back
    environment:
      ALLOW_EMPTY_PASSWORD: "yes"
    ports:
        - "6379:6379"

  azure-vote-front:
    build: ./azure-vote
    image: myregistry.azurecr.io/azure-vote-front
    container_name: azure-vote-front
    environment:
      REDIS: azure-vote-back
    ports:
        - "80:80"

Genom att göra dessa ersättningar taggas avbildningen som du skapar i nästa steg för ditt Azure-containerregister och avbildningen kan hämtas för att köras azure-vote-front i Azure Container Instances.

Köra program med flera containrar lokalt

Kör docker-compose up, som använder exempelfilen för att skapa containeravbildningen, ladda ned docker-compose.yaml Redis-avbildningen och starta programmet:

docker-compose up --build -d

När kommandot har körts kan du använda kommandot docker images till att se de avbildningar som skapats. Tre avbildningar har hämtats eller skapats. azure-vote-frontAvbildningen innehåller frontend-programmet, som använder uwsgi-nginx-flask avbildningen som bas. redis-avbildningen används för att starta en Redis-instans.

$ docker images

REPOSITORY                                TAG        IMAGE ID            CREATED             SIZE
myregistry.azurecr.io/azure-vote-front    latest     9cc914e25834        40 seconds ago      944MB
mcr.microsoft.com/oss/bitnami/redis       6.0.8      3a54a920bb6c        4 weeks ago          103MB
tiangolo/uwsgi-nginx-flask                python3.6  788ca94b2313        9 months ago        9444MB

Kör kommandot docker ps för att visa de containrar som körs:

$ docker ps

CONTAINER ID        IMAGE                                      COMMAND                  CREATED             STATUS              PORTS                           NAMES
82411933e8f9        myregistry.azurecr.io/azure-vote-front     "/entrypoint.sh /sta…"   57 seconds ago      Up 30 seconds       443/tcp, 0.0.0.0:80->80/tcp   azure-vote-front
b62b47a7d313        mcr.microsoft.com/oss/bitnami/redis:6.0.8  "/opt/bitnami/script…"   57 seconds ago      Up 30 seconds       0.0.0.0:6379->6379/tcp          azure-vote-back

Om du vill visa programmet som körs anger du http://localhost:80 i en lokal webbläsare. Exempelprogrammet läses in, som du ser i följande exempel:

När du har provat det lokala programmet kör du docker-compose för att stoppa programmet och ta bort containrarna.

docker-compose down

Push-avbildning till containerregister

Om du vill distribuera programmet Azure Container Instances måste du push-installera azure-vote-front avbildningen till containerregistret. Kör docker-compose push för att push-skicka avbildningen:

docker-compose push

Det kan ta några minuter att push-skicka till registret.

Kontrollera att avbildningen lagras i registret genom att köra kommandot az acr repository show:

az acr repository show --name <acrName> --repository azure-vote-front

Skapa Azure-kontext

Om du vill använda Docker-kommandon för att köra behållare i Azure Container Instances loggar du först in på Azure:

docker login azure

När du uppmanas till det anger eller väljer du dina autentiseringsuppgifter för Azure.

Skapa en ACI-kontext genom att köra docker context create aci . Den här kontexten kopplar Docker med en Azure-prenumeration och resurs grupp så att du kan skapa och hantera behållar instanser. Till exempel för att skapa en kontext som heter myacicontext:

docker context create aci myacicontext

När du uppmanas väljer du ditt ID för Azure-prenumerationen och väljer sedan en befintlig resurs grupp eller skapar en ny resurs grupp. Om du väljer en ny resurs grupp skapas den med ett namn som skapats av systemet. Azure-containerinstanser måste, precis som alla Azure-resurser, distribueras i en resursgrupp. Resursgrupper gör det enkelt att organisera och hantera relaterade Azure-resurser.

Kör docker context ls för att bekräfta att du har lagt till ACI-kontexten till Docker-kontexterna:

docker context ls

Distribuera program till Azure Container Instances

Ändra sedan till ACI-kontexten. Efterföljande Docker-kommandon körs i den här kontexten.

docker context use myacicontext

Kör docker compose up för att starta programmet i Azure Container Instances. azure-vote-frontAvbildningen hämtas från containerregistret och containergruppen skapas i Azure Container Instances.

docker compose up

På kort tid distribueras containergruppen. Exempel på utdata:

[+] Running 3/3
 ⠿ Group azurevotingappredis  Created                          3.6s
 ⠿ azure-vote-back            Done                             10.6s
 ⠿ azure-vote-front           Done                             10.6s

Kör docker ps för att se de containrar som körs och IP-adressen som tilldelats till containergruppen.

docker ps

Exempel på utdata:

CONTAINER ID                           IMAGE                                         COMMAND             STATUS              PORTS
azurevotingappredis_azure-vote-back    mcr.microsoft.com/oss/bitnami/redis:6.0.8                         Running             52.179.23.131:6379->6379/tcp
azurevotingappredis_azure-vote-front   myregistry.azurecr.io/azure-vote-front                            Running             52.179.23.131:80->80/tcp

Om du vill se programmet som körs i molnet anger du IP-adressen som visas i en lokal webbläsare. I det här exemplet anger du 52.179.23.131 . Exempelprogrammet läses in, som du ser i följande exempel:

Om du vill se loggarna för frontend-containern kör du kommandot docker logs. Exempel:

docker logs azurevotingappredis_azure-vote-front

Du kan också använda Azure Portal eller andra Azure-verktyg för att se egenskaper och status för den containergrupp som du distribuerade.

När du har provat klart programmet stoppar du programmet och containrarna med docker compose down :

docker compose down

Det här kommandot tar bort containergruppen i Azure Container Instances.

Nästa steg

I den här självstudien har du använt Docker Compose för att växla från att köra ett program med flera containrar lokalt till att Azure Container Instances. Du har lärt dig att:

Du kan också använda Docker-tillägget för Visual Studio Code för en integrerad upplevelse för att utveckla, köra och hantera containrar, avbildningar och kontexter.

Om du vill dra nytta av fler funktioner i Azure Container Instances kan du använda Azure-verktyg för att ange en grupp med flera containrar. Se till exempel självstudierna för att distribuera en containergrupp med hjälp av Azure CLI med en YAML-fileller distribuera med hjälp av en Azure Resource Manager mall.