Zelfstudie: Apps met meerdere containers maken met MySQL en Docker Compose

2025-06-09

In dit artikel wordt beschreven hoe u apps met meerdere containers maakt met MySQL- en Docker Compose-. Met een app met meerdere containers kunt u containers toewijzen voor gespecialiseerde taken, zodat elke container zich kan richten op één taak. Er zijn veel voordelen voor het gebruik van apps met meerdere containers:

Met afzonderlijke containers kunt u API's en front-endbronnen anders beheren dan databases.
Met meerdere containers kunt u versies onafhankelijk beheren en bijwerken.
Lokale databases kunnen worden onderhouden in containers en gebruik maken van beheerde services voor databases in de productieomgeving.
Apps met meerdere containers zijn efficiënter dan het uitvoeren van meerdere processen met een procesbeheer, waardoor het opstarten/afsluiten van containers complexer wordt.

In deze zelfstudie gaat u het volgende doen:

MySQL starten
Uw app met meerdere containers uitvoeren met MySQL
Een Docker Compose-bestand maken voor uw app
De toepassingsstack uitvoeren met Docker Compose

Voorwaarden

Dit artikel maakt deel uit van een reeks zelfstudies. De procedures zijn gebaseerd op een vastgesteld voorbeeld waarvoor Docker Desktop- voor Linux-containers is vereist.

De aanbevolen aanpak is om de eerste zelfstudie te voltooien, een container-app maken, inclusief voldoen aan de vereisten en ook de zelfstudie: Gegevens in uw app behouden. Nadat u deze zelfstudies hebt doorlopen, gaat u verder met de procedures die in dit artikel worden beschreven.
In het voorbeeld in dit artikel wordt Docker Compose-gebruikt.
- Ramen
- Linux
Docker Desktop voor Windows bevat Docker Compose.

Voer de volgende opdracht uit om uw Docker-installatie te controleren:
```
docker-compose version
```
Volg voor Linux de instructies om Docker Compose teinstalleren.

Visual Studio Code

In deze reeks zelfstudies worden procedures beschreven voor Visual Studio Code (VS Code). Bekijk de volgende overwegingen voor het werken in deze omgeving:

Gebruik het linkermenu om te schakelen tussen de CONTAINER EXPLORER en de EXPLORER (bestand en map) weergave.
Open een opdrachtregelvenster in VS Code door Terminal>New Terminalte selecteren. U kunt ook de sneltoets Ctrl+Shift+` (back tick) gebruiken.
Voer opdrachten uit in een Bash-venster, tenzij anders opgegeven. De meeste opdrachten die zijn gelabeld voor Bash worden uitgevoerd in een Bash-venster of in het opdrachtregelvenster van VS Code.

MySQL-databasebeheersysteem starten

Containers worden standaard geïsoleerd uitgevoerd. Een container is niet op de hoogte van andere processen of andere containers op dezelfde computer.

Om communicatie tussen containers mogelijk te maken, moeten ze verbinding maken met hetzelfde netwerk. Meerdere containers in hetzelfde netwerk kunnen gegevens delen en informatie met elkaar verwerken.

Er zijn twee manieren om een container aan een netwerk te koppelen. U kunt een container aan een netwerk koppelen tijdens het maken of een bestaande container op een later tijdstip aan een netwerk koppelen.

In dit voorbeeld maakt u het netwerk en koppelt u de MySQL-container bij het opstarten.

Maak een netwerk met de naam todo-app:
```
docker network create todo-app
```
Start een MySQL-container met de naam todo-mysql-data en koppel deze aan het todo-app netwerk. Met de opdracht maakt u een netwerkalias mysql voor de MySQL-database todos.

Wanneer u de opdracht uitvoert, voert u uw MySQL-hoofdwachtwoord in voor de tijdelijke aanduiding <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
```
Met deze opdracht worden ook de omgevingsvariabelen MYSQL_ROOT_PASSWORD en MYSQL_DATABASE gedefinieerd. Zie MySQL Docker Hubvoor meer informatie.

Waarschuwing

Deze handleiding illustreert het gebruik van een wachtwoord voor authenticatie met een MySQL-database, wat niet de meest veilige methode is. Raadpleeg de MySQL-documentatie voor meer informatie over veiligere verificatiemethoden.
Haal uw container-id op voor gebruik in de volgende stap.
```
docker ps
```
Controleer of u verbinding kunt maken met de container in het mysql-netwerk.

Wanneer u de opdracht uitvoert, voert u de container-id in voor de tijdelijke aanduiding <mysql-container-id>.
```
docker exec -it <mysql-container-id> mysql -p
```
Voer bij de prompt het wachtwoord in dat u hebt opgegeven bij het maken van de todo-mysql-data-container.

Vermeld in de MySQL-shell de databases en controleer of u de todos-database ziet.

SHOW DATABASES;

U ziet nu de volgende uitvoer:

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

Als u de verbinding wilt beëindigen en wilt terugkeren naar de opdrachtregelprompt, voert u afsluitenin.

Uw app uitvoeren met MySQL

De todo-app ondersteunt het instellen van bepaalde omgevingsvariabelen om uw MySQL-verbindingsinstellingen op te geven. De volgende tabel bevat de ondersteunde variabelen en de waarden die worden gebruikt in het voorbeeld dat in deze sectie wordt weergegeven.

Variabelenaam	Voorbeeldwaarde	Beschrijving
`MYSQL_HOST`	`mysql`	De hostnaam voor de MySQL-server.
`MYSQL_USER`	`root`	De gebruikersnaam die moet worden gebruikt voor de verbinding.
`MYSQL_PASSWORD`	`<your-password>`	Het wachtwoord dat moet worden gebruikt voor de verbinding. In dit voorbeeld vervangt u uw hoofdwachtwoord door de tijdelijke aanduiding `<your-password>`.
`MYSQL_DATABASE`	`todos`	De naam van de database die moet worden gebruikt nadat de verbinding tot stand is gebracht.

Waarschuwing

Het gebruik van omgevingsvariabelen voor het instellen van verbindingsinstellingen is acceptabel voor ontwikkeling, maar deze procedure wordt niet aanbevolen voor het uitvoeren van toepassingen in productie. Zie Waarom u geen omgevingsvariabelen moet gebruiken voor geheime gegevensvoor meer informatie.

Een veiliger mechanisme is gebruikmaken van de geheime ondersteuning die wordt geboden door uw container-orkestratieplatform. In de meeste gevallen worden deze geheimen als bestanden in de draaiende container gekoppeld.

In het volgende voorbeeld start u uw app en verbindt u uw app-container met uw MySQL-container.

Voer de volgende docker opdracht uit. U ziet hoe met de opdracht de omgevingsvariabelen worden opgegeven die eerder zijn beschreven.

Wanneer u de opdracht uitvoert, moet u uw MySQL-hoofdwachtwoord invoeren voor de tijdelijke aanduiding <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"
```
Open de Container Explorer in de VS Code-editor, klik met de rechtermuisknop op de app-container en selecteer Logboeken weergeven.

U kunt de logboeken ook vanaf de opdrachtregel bekijken met behulp van de opdracht docker logs.

Controleer de logboekuitvoer. Let op de regel die aangeeft dat de app is verbonden met de MySQL-database: 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

Ga in uw internetbrowser naar uw actieve toepassing: http://localhost:3000.
Voeg in de actieve toepassing enkele items toe aan uw takenlijst.
Maak verbinding met de MySQL-containerdatabase in het mysql-netwerk, zodat u de database kunt controleren.

Wanneer u de opdracht uitvoert, voert u de container-id in voor de tijdelijke aanduiding <mysql-container-id>.
```
docker exec -ti <mysql-container-id> mysql -p todos
```
Voer bij de prompt het wachtwoord in dat u hebt opgegeven bij het maken van de todo-mysql-data-container.

Controleer in de MySQL-shell of de todo_items die u hebt toegevoegd, naar de todos-database zijn geschreven.

use todos;
select * from todo_items;

U zou uitvoer moeten zien die lijkt op het volgende voorbeeld:

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

U hebt nu een toepassing waarin gegevens worden opgeslagen in een externe database die wordt uitgevoerd in een afzonderlijke container. Deze procedure laat zien hoe u communicatie tussen containers kunt inschakelen met behulp van netwerken.

Docker Compose-bestand maken

Docker Compose helpt u bij het definiëren en delen van toepassingen met meerdere containers. Een Docker Compose-bestand kan al uw vereiste services opgeven, zodat u alle gerelateerde processen met één opdracht kunt starten of beëindigen. U kunt uw toepassingsstack definiëren in een Docker Compose-bestand in de hoofdmap van uw projectopslagplaats en uw configuratie onderhouden onder versiebeheer. Met deze methode kunnen anderen bijdragen aan uw project wanneer ze uw opslagplaats klonen.

In het volgende voorbeeld configureert u een Docker Compose-bestand voor uw toepassing met meerdere containers todo.

Maak in de hoofdmap van uw todo-app-project een Docker Compose-bestand met de naam docker-compose.yml.

Notitie

Standaard is de YAML-schemaversie ingesteld op de meest recente versie. Wanneer u uw app uitvoert en uw schemaversie verouderd is, ontvangt u een waarschuwingsbericht. Zie Overview (Compose file)als u de huidige schemaversies en een compatibiliteitsmatrix wilt bekijken.
Voeg in het bestand docker-compose.yml de volgende elementen toe. Geef uw toepassing name op en start de lijst met services (of containers) die u als onderdeel van uw applicatie wilt uitvoeren.
```
name: todo

services:
```
De lijst met services is uniek voor uw app. Voorbeelden hiervan zijn app, web, db, proxyenzovoort. In een latere stap breidt u de definitie voor het services-element uit.

Aanbeveling

Inspringing is belangrijk in .yml bestanden. Als u in VS Code bewerkt, geeft IntelliSense eventuele fouten in de indeling of syntaxis aan.
Ga terug naar de definitie van services in het docker-compose.yml-bestand. Breid de definitie uit door een item toe te voegen dat het app-service-element definieert, dat de image voor de container bevat.
```
services:
  app:
    image: node:lts-alpine
```
U kunt elke naam voor de service kiezen. De naam wordt automatisch een netwerkalias, wat handig is wanneer u de MySQL-service definieert.
Breid de definitie van het app-element uit om een command op te geven die moet worden uitgevoerd.
```
  app:
    image: node:lts-alpine
    command: sh -c "yarn install && yarn run dev"
```
Definieer de ports die u wilt gebruiken met de app-service. Let op: deze poorten komen overeen met het argument -p 3000:3000 voor de opdracht die wordt gebruikt om de app uit te voeren met MySQL.
```
  app:
    image: node:lts-alpine
    command: sh -c "yarn install && yarn run dev"
    ports:
      - 3000:3000
```
Identificeer de werkmap working_dir voor de app-service en de toegewezen volumes.
```
  app:
    image: node:lts-alpine
    command: sh -c "yarn install && yarn run dev"
    ports:
      - 3000:3000
    working_dir: /app
    volumes:
      - ./:/app
```
Wanneer u Docker Compose-volumes definieert, kunt u relatieve paden gebruiken op basis van de huidige map.

Geef environment variabelendefinities op die moeten worden gebruikt wanneer u opdrachten uitvoert voor de app-service.

  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

Vergeet niet om uw MySQL-hoofdwachtwoord in te voeren voor de tijdelijke aanduiding <your-password>.

Voeg de definitie voor de MySQL-service toe mysql na de app-servicedefinitie. Geef de elementnamen en -waarden op zoals weergegeven en met dezelfde inspringing.
```
services:
  app:
    ...
  mysql:
    image: mysql:lts
```
De mysql-servicedefinitie komt overeen met de opdracht die u eerder hebt gebruikt om MySQL testarten. Wanneer u de service definieert, ontvangt deze automatisch de netwerkalias.

Identificeer de toegewezen volumes voor de mysql-service.

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

Geef environment variabelendefinities op die moeten worden gebruikt wanneer u opdrachten uitvoert voor de mysql-service.
```
services:
  app:
    ...
  mysql:
    image: mysql:lts
    volumes:
      - todo-mysql-data:/var/lib/mysql
    environment: 
      MYSQL_ROOT_PASSWORD: <your-password>
      MYSQL_DATABASE: todos
```
Vergeet niet om uw MySQL-hoofdwachtwoord in te voeren voor de tijdelijke aanduiding <your-password>.
Volumemapping definiëren voor de hele app. Voeg een volumes: sectie aan na de services: sectie, met dezelfde inspringing.
```
services:
   ...

volumes:
  todo-mysql-data:
```

Controleer of het voltooide docker-compose.yml bestand eruitziet zoals in het volgende voorbeeld. U zou uw MySQL root-wachtwoord voor de <your-password>-placeholder moeten zien.

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:

De toepassingsstack uitvoeren met Docker Compose

U kunt nu proberen uw docker-compose.yml-bestand uit te voeren.

Stop alle actieve exemplaren van uw toepassing en database.
- Visual Studio Code
- opdrachtregel
Volg deze stappen in VS Code:
1. Open de CONTAINER EXPLORER (Container Tools-extensie).
2. Klik voor elke actieve container met de rechtermuisknop op de container en selecteer verwijderen.
Voer de volgende opdrachten uit in een opdrachtregelvenster of terminal:
1. Haal de lijst met actieve containers en hun identificaties op <container-id>:
```
docker ps
```
2. Stop en verwijder elke actieve container:
```
docker stop <container-id>
docker rm <container-id>
```
Start uw app met meerdere containers en alle services.
- Visual Studio Code
- opdrachtregel
Volg deze stappen in VS Code:
1. Open de weergave EXPLORER (bestand en map).
2. Klik met de rechtermuisknop op het bestand docker-compose.yml en selecteer Compose Up.
Voer de volgende opdracht uit met het argument -d, waarmee de opdracht wordt uitgevoerd als achtergrondproces:
```
docker-compose up -d
```
U zou uitvoer moeten zien die lijkt op het volgende voorbeeld:
```
[+] Building 0.0s (0/0)
[+] Running 2/2
✔ Container app-app-1    Started  0.9s 
✔ Container app-mysql-1  Running
```
Met deze bewerking maakt u het toegewezen volume voor de app en het netwerk. Docker Compose maakt standaard een netwerk speciaal voor de toepassingsstack.
Bekijk de logboeken voor de actieve container.
- Visual Studio Code
- opdrachtregel
Volg deze stappen in VS Code:
1. Open de CONTAINER EXPLORER (Container Tools-extensie).
2. Klik met de rechtermuisknop op de app-container en selecteer Logboeken weergeven.
Voer de volgende opdracht uit:
```
docker logs
```
U kunt logboeken voor een specifieke service bekijken door de servicenaam toe te voegen, zoals app aan het einde van de opdracht logs:
```
docker logs <service-name>
```
U zou uitvoer moeten zien die lijkt op het volgende voorbeeld:
```
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
```
In de logboeken worden de servicenaam en het exemplaarnummer weergegeven, zoals app_1 aan het begin van elke regel. Met deze indeling kunt u berichten onderscheiden per service en instantie. De logboeken van elke service worden in één stream samengevoegd. Met deze aanpak kunt u observeren op tijdgerelateerde problemen.
U kunt nu naar uw actieve toepassing gaan in uw internetbrowser: http://localhost:3000.

Docker Compose stoppen en containers uitvoeren

Wanneer u klaar bent met de app en containers, kunt u ze verwijderen.

Visual Studio Code
opdrachtregel

Volg deze stappen in VS Code:

Open de weergave EXPLORER (bestand en map).
Klik met de rechtermuisknop op het docker-compose.yml-bestand en selecteer Compositie beëindigen.

Voer de volgende opdracht uit om de actieve app en containers te stoppen:

docker-compose down

Met deze bewerking worden alle actieve containers gestopt en wordt het netwerk verwijderd.

In het compose-bestand worden benoemde volumes standaard niet verwijderd. Als u deze volumes wilt verwijderen, kunt u de opdracht docker-compose down --volumes gebruiken.

Resources opschonen

Als u de Vereisten onderdelen in deze reeks zelfstudies hebt toegepast op uw installatie, kunt u de configuratie opnieuw gebruiken voor toekomstige Docker-ontwikkeling. Het is niet noodzakelijk om een onderdeel te verwijderen of te deïnstalleren.

Delen via