Samouczek: tworzenie aplikacji wielokontenerowych za pomocą programów MySQL i Docker Compose

2025-01-26

W tym artykule opisano sposób tworzenia aplikacji wielokontenerowych za pomocą MySQL i Docker Compose. Aplikacja z wieloma kontenerami umożliwia dedykacja kontenerów do wyspecjalizowanych zadań, dzięki czemu każdy kontener może skupić się na jednym zadaniu. Korzystanie z aplikacji wielokontenerowych ma wiele zalet:

Oddzielne kontenery umożliwiają zarządzanie interfejsami API i zasobami frontonu inaczej niż bazy danych.
Wiele kontenerów umożliwia wersjonowanie i aktualizowanie wersji w odizolowaniu.
Lokalne bazy danych można przechowywać w kontenerach i usługach zarządzanych używanych dla baz danych w środowisku produkcyjnym.
Aplikacje wielokontenerowe są wydajniejsze niż uruchamianie wielu procesów za pomocą menedżera procesów, co zwiększa złożoność uruchamiania/zamykania kontenera.

W tym samouczku wykonasz następujące elementy:

Uruchamianie programu MySQL
Uruchamianie aplikacji z wieloma kontenerami za pomocą programu MySQL
Tworzenie pliku docker Compose dla aplikacji
Uruchamianie stosu aplikacji za pomocą narzędzia Docker Compose

Warunki wstępne

Ten artykuł jest częścią serii samouczków. Procedury opierają się na ustalonym przykładzie, który wymaga Docker Desktop dla kontenerów Linuksa.

Zalecanym podejściem jest ukończenie pierwszego samouczka: Tworzenie aplikacji kontenera, w tym spełnienie wymagań wstępnych, a także samouczek Utrwalanie danych w aplikacji. Po wykonaniu tych samouczków przejdź do procedur opisanych w tym artykule.
W przykładzie w tym artykule użyto narzędzia Docker Compose.
- Windows
- Linux
Program Docker Desktop dla systemu Windows zawiera narzędzie Docker Compose.

Uruchom następujące polecenie, aby zweryfikować instalację platformy Docker:
```
docker-compose version
```
W przypadku systemu Linux postępuj zgodnie z instrukcjami, aby zainstalować program Docker Compose.

Visual Studio Code

W tej serii samouczków opisano procedury programu Visual Studio Code (VS Code). Zapoznaj się z następującymi zagadnieniami dotyczącymi pracy w tym środowisku:

Użyj menu po lewej stronie, aby przełączyć się między eksploratorem kontenerów lub widokiem EKSPLORATORa (plik i folder):
Otwórz okno wiersza polecenia w programie VS Code, wybierając pozycję Terminal>New Terminal. Możesz również użyć skrótu klawiaturowego Ctrl+Shift+` (znacznik wsteczny).
O ile nie określono inaczej, uruchamiaj polecenia w oknie Bash. Większość poleceń oznaczonych jako Bash jest uruchamiana w oknie powłoki Bash lub w oknie wiersza polecenia programu VS Code.

Uruchamianie systemu zarządzania bazami danych MySQL

Domyślnie kontenery działają w izolacji. Kontener nie zna innych procesów ani innych kontenerów na tym samym komputerze.

Aby umożliwić komunikację między kontenerami, muszą być dołączane do tej samej sieci. Wiele kontenerów w tej samej sieci może współużytkować dane i przetwarzać ze sobą informacje.

Istnieją dwa sposoby dołączania kontenera do sieci. Kontener można dołączyć do sieci podczas tworzenia lub dołączyć istniejący kontener do sieci w późniejszym czasie.

W tym przykładzie utworzysz sieć i dołączysz kontener MySQL podczas uruchamiania.

Utwórz sieć o nazwie todo-app:
```
docker network create todo-app
```
Uruchom kontener MySQL o nazwie todo-mysql-data i dołącz go do sieci todo-app. Polecenie tworzy alias sieciowy mysql dla bazy danych MySQL todos.

Po uruchomieniu polecenia wprowadź hasło użytkownika root MySQL dla symbolu zastępczego <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
```
To polecenie definiuje również zmienne środowiskowe MYSQL_ROOT_PASSWORD i MYSQL_DATABASE. Aby uzyskać więcej informacji, zobacz listę MySQL na Docker Hub .

Ostrzeżenie

W tym samouczku przedstawiono hasła używane do uwierzytelniania w bazie danych MySQL, co nie jest najbezpieczniejszą metodą. Zapoznaj się z dokumentacją MySQL, aby dowiedzieć się więcej o bezpieczniejszych metodach uwierzytelniania.
Pobierz identyfikator kontenera do użycia w następnym kroku.
```
docker ps
```
Upewnij się, że możesz nawiązać połączenie z kontenerem w sieci mysql.

Po uruchomieniu polecenia wprowadź identyfikator kontenera dla symbolu zastępczego <mysql-container-id>.
```
docker exec -it <mysql-container-id> mysql -p
```
Po wyświetleniu monitu wprowadź hasło podane podczas tworzenia kontenera todo-mysql-data.

W powłoce MySQL wyświetl listę baz danych i sprawdź, czy widzisz bazę danych todos.

SHOW DATABASES;

Powinny zostać wyświetlone następujące dane wyjściowe:

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

Aby zakończyć połączenie i wrócić do wiersza polecenia, wprowadź exit.

Uruchamianie aplikacji za pomocą programu MySQL

Aplikacja todo obsługuje ustawianie pewnych zmiennych środowiskowych w celu określenia ustawień połączenia MySQL. W poniższej tabeli wymieniono obsługiwane zmienne oraz wartości użyte w przykładzie przedstawionym w tej sekcji.

Nazwa zmiennej	Przykładowa wartość	Opis
`MYSQL_HOST`	`mysql`	Nazwa hosta serwera MySQL.
`MYSQL_USER`	`root`	Nazwa użytkownika do użycia na potrzeby połączenia.
`MYSQL_PASSWORD`	`<your-password>`	Hasło do użycia dla połączenia. W tym przykładzie zastąp hasło główne symbolem zastępczym `<your-password>`.
`MYSQL_DATABASE`	`todos`	Nazwa bazy danych do użycia po nawiązaniu połączenia.

Ostrzeżenie

Używanie zmiennych środowiskowych do ustawiania ustawień połączenia jest akceptowalne w przypadku programowania, ale ta praktyka nie jest zalecana w przypadku uruchamiania aplikacji w środowisku produkcyjnym. Aby uzyskać więcej informacji, zobacz Dlaczego nie należy używać zmiennych środowiskowych dla tajnych danych.

Bezpieczniejszym mechanizmem jest użycie obsługi sekretów udostępnianych przez platformę orkiestracji kontenerów. W większości przypadków te sekrety są montowane jako pliki w uruchomionym kontenerze.

W poniższym przykładzie uruchomisz aplikację i połączysz kontener aplikacji z kontenerem MySQL.

Uruchom następujące polecenie docker. Zwróć uwagę, że polecenie określa zmienne środowiskowe opisane wcześniej.

Po uruchomieniu polecenia pamiętaj, aby wprowadzić hasło root MySQL dla symbolu zastępczego <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"
```
W edytorze programu VS Code otwórz Eksploratora kontenerów, kliknij prawym przyciskiem myszy kontener aplikacji i wybierz pozycję Wyświetl dzienniki.

Dzienniki można również wyświetlić w wierszu polecenia przy użyciu polecenia docker logs.

Przejrzyj dane wyjściowe dziennika. Zwróć uwagę na wiersz wskazujący, że aplikacja jest połączona z bazą danych MySQL: 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

W przeglądarce internetowej przejdź do uruchomionej aplikacji: http://localhost:3000.
W uruchomionej aplikacji dodaj kilka elementów do listy zadań do wykonania.
Połącz się z bazą danych kontenerów MySQL w sieci mysql, aby można było sprawdzić bazę danych.

Po uruchomieniu polecenia wprowadź identyfikator kontenera dla symbolu zastępczego <mysql-container-id>.
```
docker exec -ti <mysql-container-id> mysql -p todos
```
Po wyświetleniu monitu wprowadź hasło podane podczas tworzenia kontenera todo-mysql-data.

W powłoce MySQL sprawdź, czy todo_items, które dodałeś, są zapisane w bazie danych todos.

use todos;
select * from todo_items;

Powinny zostać wyświetlone dane wyjściowe podobne do następującego przykładu:

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

Masz teraz aplikację, która przechowuje dane w zewnętrznej bazie danych uruchomionej w osobnym kontenerze. Ta procedura pokazuje, jak włączyć komunikację między kontenerami przy użyciu sieci.

Tworzenie pliku narzędzia Docker Compose

Aplikacja Docker Compose ułatwia definiowanie i udostępnianie aplikacji wielokontenerowych. Plik Docker Compose może określać wszystkie wymagane usługi, aby można było uruchomić lub zakończyć wszystkie powiązane procesy za pomocą jednego polecenia. Możesz zdefiniować stos swojej aplikacji w pliku Docker Compose znajdującym się w katalogu głównym repozytorium projektu oraz utrzymywać konfigurację pod kontrolą wersji. Takie podejście umożliwia innym osobom współtworzenie projektu podczas klonowania repozytorium.

W poniższym przykładzie skonfigurujesz plik Docker Compose dla aplikacji wielokontenerowej todo.

W katalogu głównym projektu aplikacji todo utwórz plik Docker Compose o nazwie docker-compose.yml.

Notatka

Domyślnie wersja schematu YAML jest ustawiona na najnowszą wersję. Po uruchomieniu aplikacji, jeśli wersja schematu jest przestarzała, zostanie wyświetlony komunikat ostrzegawczy. Aby przejrzeć bieżące wersje schematu i macierz zgodności, zobacz Overview (Compose file).
W pliku docker-compose.yml dodaj następujące elementy. Określ aplikację name i uruchom listę services (lub kontenerów), które mają być uruchamiane w ramach aplikacji.
```
name: todo

services:
```
Lista usług jest unikatowa dla twojej aplikacji. Przykłady obejmują app, web, db, proxyitd. Definicję elementu services można rozszerzyć w późniejszym kroku.

Napiwek

Wcięcie jest istotne w plikach .yml. W przypadku edytowania w programie VS Code funkcja IntelliSense wskazuje błędy w formacie lub składni.
Wróć do definicji services w pliku docker-compose.yml. Rozszerz definicję, dodając wpis w celu zdefiniowania elementu usługi app, który zawiera obraz kontenera.
```
services:
  app:
    image: node:lts-alpine
```
Możesz wybrać dowolną nazwę usługi. Nazwa automatycznie staje się aliasem sieci, który jest przydatny podczas definiowania usługi MySQL.

Rozszerz definicję elementu app, aby określić command do wykonania.

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

Zdefiniuj ports do użycia z usługą app. Zwróć uwagę, że te porty odpowiadają argumentowi -p 3000:3000 polecenia używanego do uruchamiania aplikacji za pomocą programu MySQL.
```
  app:
    image: node:lts-alpine
    command: sh -c "yarn install && yarn run dev"
    ports:
      - 3000:3000
```
Zidentyfikuj katalog roboczy working_dir dla usługi app oraz przypisany volumes.
```
  app:
    image: node:lts-alpine
    command: sh -c "yarn install && yarn run dev"
    ports:
      - 3000:3000
    working_dir: /app
    volumes:
      - ./:/app
```
Podczas definiowania woluminów Docker Compose można użyć ścieżek względnych w oparciu o bieżący katalog.

Określ definicje zmiennych environment do użycia podczas wykonywania poleceń dla usługi app.

  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

Pamiętaj, aby wprowadzić hasło główne MySQL dla symbolu zastępczego <your-password>.

Dodaj definicję usługi MySQL mysql po definicji usługi app. Określ nazwy i wartości elementów, jak pokazano i z tym samym wcięciem.
```
services:
  app:
    ...
  mysql:
    image: mysql:lts
```
Definicja usługi mysql odpowiada poleceniu użytemu wcześniej do uruchomienia programu MySQL. Podczas definiowania usługi automatycznie odbiera alias sieciowy.

Zidentyfikuj zamapowane volumes dla usługi mysql.

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

Określ definicje zmiennych environment do użycia podczas wykonywania poleceń dla usługi mysql.

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

Pamiętaj, aby wprowadzić hasło główne MySQL dla symbolu zastępczego <your-password>.

Zdefiniuj mapowanie woluminów dla całej aplikacji. Dodaj sekcję volumes: po sekcji services: i z tym samym wcięciem.
```
services:
   ...

volumes:
  todo-mysql-data:
```

Upewnij się, że ukończony plik docker-compose.yml wygląda jak w poniższym przykładzie. Powinno zostać wyświetlone hasło root MySQL dla zastępnika <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:

Uruchamianie stosu aplikacji za pomocą narzędzia Docker Compose

Teraz możesz spróbować uruchomić plik docker-compose.yml.

Zatrzymaj wszystkie uruchomione instancje Twojej aplikacji i bazy danych.
- programu Visual Studio Code
- wiersza polecenia
Wykonaj następujące kroki w programie VS Code:
1. Otwórz EKSPLORATOR KONTENERÓW (rozszerzenie Narzędzi Kontenerów).
2. Dla każdego uruchomionego kontenera kliknij prawym przyciskiem myszy kontener i wybierz pozycję Usuń.
Uruchom następujące polecenia w oknie wiersza polecenia lub terminalu:
1. Pobierz listę uruchomionych kontenerów i ich identyfikatorów <container-id>:
```
docker ps
```
2. Zatrzymaj i usuń każdy uruchomiony kontener:
```
docker stop <container-id>
docker rm <container-id>
```
Uruchom aplikację wielokontenerową i wszystkie usługi.
- programu Visual Studio Code
- wiersza polecenia
Wykonaj następujące kroki w programie VS Code:
1. Otwórz widok eksploratora (plik i folder).
2. Kliknij prawym przyciskiem myszy plik docker-compose.yml i wybierz Uruchom.
Uruchom następujące polecenie z argumentem -d, który wykonuje polecenie jako proces w tle:
```
docker-compose up -d
```
Powinny zostać wyświetlone dane wyjściowe podobne do następującego przykładu:
```
[+] Building 0.0s (0/0)
[+] Running 2/2
✔ Container app-app-1    Started  0.9s 
✔ Container app-mysql-1  Running
```
Ta operacja tworzy zamapowany wolumin dla aplikacji i sieci. Domyślnie narzędzie Docker Compose tworzy sieć specjalnie dla stosu aplikacji.
Przejrzyj dzienniki uruchomionego kontenera.
- programu Visual Studio Code
- wiersza polecenia
Wykonaj następujące kroki w programie VS Code:
1. Otwórz EKSPLORATOR KONTENERÓW (rozszerzenie Narzędzi Kontenerów).
2. Kliknij prawym przyciskiem myszy kontener aplikacji i wybierz pozycję Wyświetl dzienniki.
Uruchom następujące polecenie:
```
docker logs
```
Dzienniki dla określonej usługi można wyświetlić, dodając nazwę usługi, taką jak app na końcu polecenia logs:
```
docker logs <service-name>
```
Powinny zostać wyświetlone dane wyjściowe podobne do następującego przykładu:
```
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
```
Dzienniki zawierają nazwę usługi i numer wystąpienia, takie jak app_1 na początku każdego wiersza. Ten format ułatwia rozróżnianie komunikatów według usługi i wystąpienia. Dzienniki z każdej usługi są zintegrowane w jeden strumień. Takie podejście umożliwia obserwowanie problemów związanych z czasem.
Teraz możesz przejść do uruchomionej aplikacji w przeglądarce internetowej: http://localhost:3000.

Zatrzymywanie narzędzia Docker Compose i uruchamianie kontenerów

Gdy skończysz z aplikacją i kontenerami, możesz je usunąć.

programu Visual Studio Code
wiersza polecenia

Wykonaj następujące kroki w programie VS Code:

Otwórz widok eksploratora (plik i folder).
Kliknij prawym przyciskiem myszy plik docker-compose.yml i wybierz pozycję Redaguj w dół.

Uruchom następujące polecenie, aby zatrzymać uruchomioną aplikację i kontenery:

docker-compose down

Ta operacja zatrzymuje wszystkie uruchomione kontenery i usuwa sieć.

Domyślnie nazwane woluminy w pliku compose nie są usuwane. Jeśli chcesz usunąć te woluminy, możesz użyć polecenia docker-compose down --volumes.

Czyszczenie zasobów

Jeśli do instalacji zastosowano składniki Wymagania wstępne w tej serii samouczków, możesz ponownie użyć konfiguracji na potrzeby przyszłego programowania platformy Docker. Nie trzeba usuwać ani odinstalować żadnego składnika.

Udostępnij za pośrednictwem