Självstudie: Skapa appar med flera containrar med MySQL och Docker Compose

Den här artikeln beskriver hur du skapar appar med flera containrar med MySQL- och Docker Compose. Med en app med flera containrar kan du dedikera containrar för specialiserade uppgifter, så att varje container kan fokusera på en enda uppgift. Det finns många fördelar med att använda appar med flera containrar:

Med separata containrar kan du hantera API:er och klientdelsresurser på ett annat sätt än databaser.
Flera containrar låter dig hantera och uppdatera versioner i isolering.
Lokala databaser kan underhållas i containrar, och använda hanterade tjänster för databaser i produktion.
Appar med flera containrar är effektivare än att köra flera processer med en processhanterare, vilket ökar komplexiteten för start/avstängning av containrar.

I den här handledningen:

Starta MySQL
Kör din app för flera containrar med MySQL
Skapa en Docker Compose-fil för din app
Kör programstacken med Docker Compose

Förutsättningar

Den här artikeln är en del av en självstudieserie. Procedurerna bygger på ett etablerat exempel som kräver Docker Desktop för Linux-containrar.

Det rekommenderade tillvägagångssättet är att slutföra den första guiden, Skapa en containerapp, vilket inkluderar att uppfylla alla förutsättningar, samt guiden Spara data i din app. När du har jobbat igenom de här handledningarna fortsätter du med de steg som tas upp i den här artikeln.
Exemplet i den här artikeln använder Docker Compose.
- Windows
- Linux
Docker Desktop för Windows innehåller Docker Compose.

Kör följande kommando för att verifiera Docker-installationen:
```
docker-compose version
```
För Linux följer du anvisningarna för att installera Docker Compose.

Visual Studio Code

Den här självstudieserien beskriver procedurer för Visual Studio Code (VS Code). Granska följande överväganden för att arbeta i den här miljön:

Använd den vänstra menyn för att växla mellan CONTAINER EXPLORER - eller EXPLORER-vyn (fil och mapp):
Öppna ett kommandoradsfönster i VS Code genom att välja Terminal>New Terminal. Du kan också använda kortkommandot Ctrl+Skift+` (bakåt tick).
Om inget annat anges kör du kommandon i ett Bash-fönster. De flesta kommandon som är märkta för Bash köras i ett Bash-fönster eller i kommandoradsfönstret i VS Code.

Starta MySQL-databashanteringssystemet

Som standard körs containrar isolerat. En container känner inte till andra processer eller andra containrar på samma dator.

För att möjliggöra kommunikation mellan containrar måste de ansluta till samma nätverk. Flera containrar i samma nätverk kan dela data och bearbeta information med varandra.

Det finns två sätt att ansluta en container till ett nätverk. Du kan ansluta en container till ett nätverk när du skapar den eller koppla en befintlig container till ett nätverk vid ett senare tillfälle.

I det här exemplet skapar du nätverket och kopplar MySQL-containern vid start.

Skapa ett nätverk med namnet todo-app:
```
docker network create todo-app
```
Starta en MySQL-container med namnet todo-mysql-data och koppla den till todo-app nätverket. Kommandot skapar ett nätverksalias mysql för MySQL-databasen todos.

När du kör kommandot anger du mySQL-rotlösenordet för platshållaren <your-password>.
```
docker run -d --network todo-app --network-alias mysql -v todo-mysql-data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=<your-password> -e MYSQL_DATABASE=todos mysql:lts
```
Det här kommandot definierar även miljövariablerna MYSQL_ROOT_PASSWORD och MYSQL_DATABASE. Mer information finns i MySQL Docker Hub-lista.

Varning

Den här självstudien illustrerar lösenordsuppgifter för autentisering med en MySQL-databas, vilket inte är det säkraste sättet. Mer information om säkrare autentiseringsmetoder finns i MySQL-dokumentationen.
Hämta ditt container-ID för användning i nästa steg.
```
docker ps
```
Bekräfta att du kan ansluta till containern i mysql nätverket.

När du kör kommandot anger du ditt container-ID för platshållaren <mysql-container-id>.
```
docker exec -it <mysql-container-id> mysql -p
```
Ange det lösenord som du angav när du skapade todo-mysql-data containern i prompten.

I MySQL-gränssnittet listar du databaserna och kontrollerar att du ser todos-databasen.

SHOW DATABASES;

Du bör se följande utdata:

+--------------------+
| Database           |
+--------------------+
| information_schema |
| mysql              |
| performance_schema |
| sys                |
| todos              |
+--------------------+
5 rows in set (0.00 sec)

Om du vill avsluta anslutningen och återgå till kommandotolken anger du exit.

Kör din app med MySQL

todo-appen stöder inställning av vissa miljövariabler för att ange dina MySQL-anslutningsinställningar. I följande tabell visas de variabler som stöds och de värden som används i exemplet som visas i det här avsnittet.

Variabelnamn	Exempelvärde	Beskrivning
`MYSQL_HOST`	`mysql`	Värdnamnet för MySQL-servern.
`MYSQL_USER`	`root`	Användarnamnet som ska användas för anslutningen.
`MYSQL_PASSWORD`	`<your-password>`	Lösenordet som ska användas för anslutningen. I det här exemplet ersätter du rotlösenordet med platshållaren `<your-password>`.
`MYSQL_DATABASE`	`todos`	Namnet på databasen som ska användas när anslutningen har upprättats.

Varning

Användning av miljövariabler för att ange anslutningsinställningar är acceptabelt för utveckling, men den här metoden rekommenderas inte för att köra program i produktion. Mer information finns i Varför du inte bör använda miljövariabler för hemliga data.

En säkrare mekanism är att använda det hemliga stöd som tillhandahålls av ditt ramverk för containerorkestrering. I de flesta fall monteras dessa hemligheter som filer i den körande containern.

I följande exempel startar du appen och ansluter din appcontainer till MySQL-containern.

Kör följande docker kommando. Observera hur kommandot anger de miljövariabler som beskrevs tidigare.

När du kör kommandot måste du komma ihåg att ange ditt MySQL-rotlösenord för platshållaren <your-password>.
```
docker run -dp 3000:3000 -w /app -v ${PWD}:/app --network todo-app -e MYSQL_HOST=mysql -e MYSQL_USER=root -e MYSQL_PASSWORD=<your-password> -e MYSQL_DB=todos node:lts-alpine sh -c "yarn install && yarn run dev"
```
I VS Code-redigeraren öppnar du Container Explorer, högerklickar på din appcontainer och väljer Visa loggar.

Du kan också visa loggarna från kommandoraden med hjälp av kommandot docker logs.

Granska loggutdata. Observera raden som anger att appen är ansluten till MySQL-databasen: Connected to mysql db at host mysql.

# Previous log messages omitted
$ nodemon src/index.js
[nodemon] 1.19.2
[nodemon] to restart at any time, enter `rs`
[nodemon] watching dir(s): *.*
[nodemon] starting `node src/index.js`
Connected to mysql db at host mysql
Listening on port 3000

I webbläsaren går du till ditt program som körs: http://localhost:3000.
Lägg till några objekt i din att göra-lista i ditt program som körs.
Anslut till MySQL-containerdatabasen i mysql nätverket så att du kan kontrollera databasen.

När du kör kommandot anger du ditt container-ID för platshållaren <mysql-container-id>.
```
docker exec -ti <mysql-container-id> mysql -p todos
```
Ange det lösenord som du angav när du skapade todo-mysql-data containern i prompten.

I MySQL-gränssnittet kontrollerar du att todo_items du har lagt till skrivs till todos-databasen.

use todos;
select * from todo_items;

Du bör se utdata som liknar följande exempel:

+--------------------------------------+--------------------+-----------+
| id                                   | name               | completed |
+--------------------------------------+--------------------+-----------+
| c906ff08-60e6-44e6-8f49-ed56a0853e85 | Do amazing things! |         0 |
| 2912a79e-8486-4bc3-a4c5-460793a575ab | Be awesome!        |         0 |
+--------------------------------------+--------------------+-----------+

Nu har du ett program som lagrar data i en extern databas som körs i en separat container. Den här proceduren visar hur du kan aktivera kommunikation mellan containrar med hjälp av nätverk.

Skapa Docker Compose-fil

Docker Compose hjälper dig att definiera och dela program med flera containrar. En Docker Compose-fil kan ange alla nödvändiga tjänster, så att du kan starta eller avsluta alla relaterade processer med ett enda kommando. Du kan definiera programstacken i en Docker Compose-fil i roten på projektrepoen och underhålla konfigurationen under versionskontrollen. Med den här metoden kan andra bidra till projektet när de klonar lagringsplatsen.

I följande exempel konfigurerar du en Docker Compose-fil för ditt program med flera containrar todo.

I roten för ditt todo-appprojekt skapar du en Docker Compose-fil med namnet docker-compose.yml.

Not

Som standard är YAML-schemaversionen inställd på den senaste versionen. Om din schemaversion är föråldrad får du ett varningsmeddelande när du kör appen. För att granska aktuella schemaversioner och en kompatibilitetsmatris, se Översikt (Compose-fil).
Lägg till följande element i filen docker-compose.yml. Ange din app name och starta listan över services (eller containrar) som du vill köra som en del av ditt program.
```
name: todo

services:
```
Listan över tjänster är unik för din app. Exempel är app, web, db, proxyoch så vidare. Du utökar definitionen för services-elementet i ett senare steg.

Tips

Indrag är viktigt i .yml filer. Om du redigerar i VS Code anger Intellisense eventuella fel i formatet eller syntaxen.
Gå tillbaka till definitionen services i filen docker-compose.yml. Utöka definitionen genom att lägga till en post för att definiera app-tjänstelementet, som innehåller avbildningen för containern.
```
services:
  app:
    image: node:lts-alpine
```
Du kan välja valfritt namn för tjänsten. Namnet blir automatiskt ett nätverksalias, vilket är användbart när du definierar MySQL-tjänsten.

Utöka app-elementdefinitionen för att ange en command som ska köras.

  app:
    image: node:lts-alpine
    command: sh -c "yarn install && yarn run dev"

Definiera ports som ska användas med app-tjänsten. Observera att dessa portar motsvarar argumentet -p 3000:3000 för kommandot som används för att köra appen med MySQL.
```
  app:
    image: node:lts-alpine
    command: sh -c "yarn install && yarn run dev"
    ports:
      - 3000:3000
```
Identifiera arbetskatalogen working_dir för app-tjänsten och även den mappade volumes.
```
  app:
    image: node:lts-alpine
    command: sh -c "yarn install && yarn run dev"
    ports:
      - 3000:3000
    working_dir: /app
    volumes:
      - ./:/app
```
När du definierar Docker Compose-volymer kan du använda relativa sökvägar baserat på den aktuella katalogen.

Ange environment variabeldefinitioner som ska användas när du kör kommandon för app-tjänsten.

  app:
    image: node:lts-alpine
    command: sh -c "yarn install && yarn run dev"
    ports:
      - 3000:3000
    working_dir: /app
    volumes:
      - ./:/app
    environment:
      MYSQL_HOST: mysql
      MYSQL_USER: root
      MYSQL_PASSWORD: <your-password>
      MYSQL_DB: todos

Kom ihåg att ange ditt MySQL-rotlösenord för platshållaren <your-password>.

Lägg till definitionen för MySQL-tjänsten mysql efter app-tjänstdefinitionen. Ange elementnamn och värden enligt exemplet och med samma indrag.
```
services:
  app:
    ...
  mysql:
    image: mysql:lts
```
mysql-tjänstdefinitionen motsvarar det kommando som du använde tidigare för att starta MySQL-. När du definierar tjänsten tar den automatiskt emot nätverksaliaset.

Identifiera den mappade volumes för mysql-tjänsten.

services:
  app:
    ...
  mysql:
    image: mysql:lts
    volumes:
      - todo-mysql-data:/var/lib/mysql

Ange environment variabeldefinitioner som ska användas när du kör kommandon för mysql-tjänsten.

services:
  app:
    ...
  mysql:
    image: mysql:lts
    volumes:
      - todo-mysql-data:/var/lib/mysql
    environment: 
      MYSQL_ROOT_PASSWORD: <your-password>
      MYSQL_DATABASE: todos

Kom ihåg att ange ditt MySQL-rotlösenord för platshållaren <your-password>.

Definiera volymmappning för hela appen. Lägg till ett volumes: avsnitt efter avsnittet services: och med samma indrag.
```
services:
   ...

volumes:
  todo-mysql-data:
```

Bekräfta att den slutförda docker-compose.yml filen ser ut som i följande exempel. Du bör se ditt MySQL root-lösenord för platshållaren <your-password>.

name: todo

services:
  app:
    image: node:lts-alpine
    command: sh -c "yarn install && yarn run dev"
    ports:
      - 3000:3000
    working_dir: /app
    volumes:
      - ./:/app
    environment:
      MYSQL_HOST: mysql
      MYSQL_USER: root
      MYSQL_PASSWORD: <your-password>
      MYSQL_DB: todos

  mysql:
    image: mysql:lts
    volumes:
      - todo-mysql-data:/var/lib/mysql
    environment: 
      MYSQL_ROOT_PASSWORD: <your-password>
      MYSQL_DATABASE: todos

volumes:
  todo-mysql-data:

Kör programstacken med Docker Compose

Nu kan du prova att köra filen docker-compose.yml.

Stoppa alla aktiva instanser av din applikation och databas.
- Visual Studio Code
- Kommandorad
Följ dessa steg i VS Code:
1. Öppna CONTAINER EXPLORER (Container Tools-tillägget).
2. Högerklicka på varje container som körs och välj Ta bort.
Kör följande kommandon i ett kommandoradsfönster eller en terminal:
1. Hämta listan över körande containrar och deras identifierare <container-id>:
```
docker ps
```
2. Stoppa och ta bort varje körande container:
```
docker stop <container-id>
docker rm <container-id>
```
Starta din app för flera containrar och alla tjänster.
- Visual Studio Code
- Kommandorad
Följ dessa steg i VS Code:
1. Öppna vyn EXPLORER (fil och mapp).
2. Högerklicka på filen docker-compose.yml och välj Compose Up.
Kör följande kommando med argumentet -d, som kör kommandot som en bakgrundsprocess:
```
docker-compose up -d
```
Du bör se utdata som liknar följande exempel:
```
[+] Building 0.0s (0/0)
[+] Running 2/2
✔ Container app-app-1    Started  0.9s 
✔ Container app-mysql-1  Running
```
Den här åtgärden skapar den mappade volymen för appen och nätverket. Som standard skapar Docker Compose ett nätverk som är specifikt för programstacken.
Granska loggarna för den container som körs.
- Visual Studio Code
- Kommandorad
Följ dessa steg i VS Code:
1. Öppna CONTAINER EXPLORER (Container Tools-tillägget).
2. Högerklicka på appcontainern och välj Visa loggar.
Kör följande kommando:
```
docker logs
```
Du kan visa loggar för en specifik tjänst genom att lägga till tjänstnamnet, till exempel app i slutet av kommandot logs:
```
docker logs <service-name>
```
Du bör se utdata som liknar följande exempel:
```
mysql_1  | 2019-10-03T03:07:16.083639Z 0 [Note] mysqld: ready for connections.
mysql_1  | Version: '5.7.27'  socket: '/var/run/mysqld/mysqld.sock'  port: 3306  MySQL Community Server (GPL)
app_1    | Connected to mysql db at host mysql
app_1    | Listening on port 3000
```
Loggarna visar tjänstnamnet och instansnumret, till exempel app_1 i början av varje rad. Det här formatet hjälper dig att skilja meddelanden efter tjänst och instans. Loggarna från varje tjänst interfolieras till en enda ström. Med den här metoden kan du hålla utkik efter tidsrelaterade problem.
Nu kan du gå till ditt program som körs i webbläsaren: http://localhost:3000.

Stoppa Docker Compose och de körande containrarna

När du är klar med appen och containrarna kan du ta bort dem.

Visual Studio Code
Kommandorad

Följ dessa steg i VS Code:

Öppna vyn EXPLORER (fil och mapp).
Högerklicka på filen docker-compose.yml och välj Skriv ned.

Kör följande kommando för att stoppa appen och containrarna som körs:

docker-compose down

Den här åtgärden stoppar alla aktiva containrar och tar bort nätverket.

Som standard tas inte namngivna volymer i din compose-fil bort. Om du vill ta bort dessa volymer kan du använda kommandot docker-compose down --volumes.

Rensa resurser

Om du har tillämpat Krav komponenter i den här självstudieserien på din installation kan du återanvända konfigurationen för framtida Docker-utveckling. Det är inte nödvändigt att ta bort eller avinstallera någon komponent.

Feedback

Var den här sidan till hjälp?

Last updated on 2025-05-14