Kurz: Vytváření vícekontejnerových aplikací pomocí MySQL a Docker Compose

Tento článek popisuje, jak vytvářet vícekontejnerové aplikace pomocí MySQL a Docker Compose. Aplikace s více kontejnery umožňuje vyhradit kontejnery pro specializované úlohy, aby se každý kontejner mohl soustředit na jeden úkol. Použití vícekontenerových aplikací má mnoho výhod:

Samostatné kontejnery umožňují spravovat rozhraní API a front-endové prostředky jinak než databáze.
Více kontejnerů umožňuje verzovat a aktualizovat verze odděleně.
Místní databáze je možné udržovat v kontejnerech a spravovaných službách používaných pro databáze v produkčním prostředí.
Vícekontenerové aplikace jsou efektivnější než spouštění více procesů pomocí správce procesů, což zvyšuje složitost spouštění a vypínání kontejneru.

V tomto kurzu:

Spustit MySQL
Spuštění vícekontejnerové aplikace pomocí MySQL
Vytvoření souboru Docker Compose pro vaši aplikaci
Spuštění zásobníku aplikací pomocí Docker Compose

Požadavky

Tento článek je součástí série kurzů. Postupy vycházejí ze zavedeného příkladu, který vyžaduje Docker Desktop pro Linuxové kontejnery.

Doporučeným přístupem je dokončení prvního kurzu, vytvoření aplikace typu kontejner, včetně splnění požadavků, a také kurzu Zachování dat v aplikaci. Až si projdete tyto kurzy, pokračujte postupy popsanými v tomto článku.
Příklad v tomto článku používá Docker Compose.
- Windows
- Operační systém Linux
Docker Desktop pro Windows zahrnuje Docker Compose.

Spuštěním následujícího příkazu ověřte instalaci Dockeru:
```
docker-compose version
```
V případě Linuxu postupujte podle pokynů k instalaciDocker Compose .

Visual Studio Code

Tato série kurzů popisuje postupy pro Visual Studio Code (VS Code). Projděte si následující aspekty práce v tomto prostředí:

Pomocí levé nabídky můžete přepínat mezi zobrazením CONTAINER EXPLORER nebo EXPLORER (soubor a složka):
V editoru VS Code otevřete okno příkazového řádku tak, že vyberete Terminál>Nový terminál. Můžete také použít klávesovou zkratku Ctrl+Shift+` (zpět).
Pokud není uvedeno jinak, spusťte příkazy v okně Bash. Většina příkazů označených pro Bash běží v okně Bash nebo v okně příkazového řádku VS Code.

Spuštění systému pro správu databází MySQL

Kontejnery se ve výchozím nastavení spouštějí izolovaně. Kontejner nezná jiné procesy ani jiné kontejnery ve stejném počítači.

Aby bylo možné povolit komunikaci mezi kontejnery, musí se připojit ke stejné síti. Několik kontejnerů ve stejné síti může sdílet data a zpracovávat informace mezi sebou.

Kontejner můžete připojit k síti dvěma způsoby. Kontejner můžete připojit k síti během vytváření nebo později připojit existující kontejner k síti.

V tomto příkladu vytvoříte síť a připojíte kontejner MySQL při spuštění.

Vytvořte síť s názvem todo-app:
```
docker network create todo-app
```
Spusťte kontejner MySQL s názvem todo-mysql-data a připojte ho k síti todo-app. Příkaz vytvoří síťový alias mysql pro todosdatabáze MySQL .

Po spuštění příkazu zadejte kořenové heslo MySQL pro zástupný symbol <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
```
Tento příkaz také definuje proměnné prostředí MYSQL_ROOT_PASSWORD a MYSQL_DATABASE. Pro více informací se podívejte do seznamu MySQL Docker Hub.

Varování

Tento kurz ukazuje přihlašovací údaje pro heslo pro ověření v databázi MySQL, což není nejbezpečnější metoda. Další informace o bezpečnějších metodách ověřování najdete v dokumentaci k MySQL.
Získejte ID kontejneru pro použití v dalším kroku.
```
docker ps
```
Ověřte, že se můžete připojit ke kontejneru v síti mysql.

Po spuštění příkazu zadejte ID kontejneru pro zástupný symbol <mysql-container-id>.
```
docker exec -it <mysql-container-id> mysql -p
```
Na příkazovém řádku zadejte heslo, které jste zadali při vytváření kontejneru todo-mysql-data.

V prostředí MySQL zobrazte seznam databází a ověřte, že se zobrazí databáze todos.

SHOW DATABASES;

Měl by se zobrazit následující výstup:

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

Chcete-li ukončit připojení a vrátit se do příkazového řádku, zadejte exit.

Spuštění aplikace pomocí MySQL

Aplikace todo podporuje nastavení určitých proměnných prostředí pro zadání nastavení připojení MySQL. Následující tabulka uvádí podporované proměnné a hodnoty použité v příkladu uvedené v této části.

Název proměnné	Příklad hodnoty	Popis
`MYSQL_HOST`	`mysql`	Název hostitele pro server MySQL.
`MYSQL_USER`	`root`	Uživatelské jméno, které se má použít pro připojení.
`MYSQL_PASSWORD`	`<your-password>`	Heslo, které se má použít pro připojení. V tomto příkladu nahraďte zástupný symbol `<your-password>` kořenovým heslem.
`MYSQL_DATABASE`	`todos`	Název databáze, která se má použít po navázání připojení.

Varování

Použití proměnných prostředí k nastavení připojení je přijatelné pro vývoj, ale tento postup se nedoporučuje pro spouštění aplikací v produkčním prostředí. Další informace najdete v tématu Proč byste neměli používat proměnné prostředí pro tajné data.

Bezpečnějším mechanismem je použití podpory tajných kódů poskytovaných architekturou orchestrace kontejnerů. Ve většině případů se tyto tajné kódy připojují jako soubory ve spuštěném kontejneru.

V následujícím příkladu spustíte aplikaci a připojíte kontejner aplikace k kontejneru MySQL.

Spusťte následující příkaz docker. Všimněte si, jak příkaz určuje proměnné prostředí popsané výše.

Při spuštění příkazu nezapomeňte zadat kořenové heslo MySQL pro zástupný symbol <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"
```
V editoru VS Code otevřete Průzkumníka kontejnerů, klikněte pravým tlačítkem na kontejner aplikace a vyberte Zobrazit protokoly.

Protokoly můžete zobrazit také z příkazového řádku pomocí příkazu docker logs.

Zkontrolujte výstup protokolu. Všimněte si řádku, který označuje, že je aplikace připojená k databázi 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

V internetovém prohlížeči přejděte do spuštěné aplikace: http://localhost:3000.
Ve spuštěné aplikaci přidejte do seznamu úkolů některé položky.
Připojte se k databázi kontejneru MySQL v síti mysql, abyste mohli databázi zkontrolovat.

Po spuštění příkazu zadejte ID kontejneru pro zástupný symbol <mysql-container-id>.
```
docker exec -ti <mysql-container-id> mysql -p todos
```
Na příkazovém řádku zadejte heslo, které jste zadali při vytváření kontejneru todo-mysql-data.

V prostředí MySQL ověřte, že todo_items, které jste přidali, jsou zapsány do databáze todos.

use todos;
select * from todo_items;

Měl by se zobrazit výstup podobný následujícímu příkladu:

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

Teď máte aplikaci, která ukládá data do externí databáze spuštěné v samostatném kontejneru. Tento postup ukazuje, jak můžete povolit komunikaci mezi kontejnery pomocí sítí.

Vytvoření souboru Docker Compose

Docker Compose vám pomůže definovat a sdílet vícekontenerové aplikace. Soubor Docker Compose může zadat všechny požadované služby, takže můžete zahájit nebo ukončit všechny související procesy jediným příkazem. Zásobník aplikací můžete definovat v souboru Docker Compose v kořenovém adresáři úložiště projektu a spravovat konfiguraci v rámci správy verzí. Tento přístup umožňuje ostatním přispívat do projektu při klonování úložiště.

V následujícím příkladu nakonfigurujete soubor Docker Compose pro aplikaci s více kontejnery todo.

V kořenovém adresáři projektu aplikace todo vytvořte soubor Docker Compose s názvem docker-compose.yml.

Poznámka

Ve výchozím nastavení je verze schématu YAML nastavená na nejnovější verzi. Pokud je vaše verze schématu zastaralá, při spuštění aplikace se zobrazí zpráva s upozorněním. Pokud chcete zkontrolovat aktuální verze schématu a matici kompatibility, přečtěte si Přehled (soubor Compose).
Do souboru docker-compose.yml přidejte následující prvky. Zadejte name aplikace a spusťte seznam services (nebo kontejnerů), které chcete spustit jako součást aplikace.
```
name: todo

services:
```
Seznam služeb je pro vaši aplikaci jedinečný. Příklady zahrnují app, web, db, proxyatd. Definici elementu services rozšíříte v pozdějším kroku.

Spropitné

V .yml souborech je odsazení významné. Pokud upravujete v editoru VS Code, IntelliSense indikuje případné chyby ve formátu nebo syntaxi.
Vraťte se do definice services v souboru docker-compose.yml. Rozšiřte definici přidáním položky, která definuje prvek služby app, který obsahuje image kontejneru.
```
services:
  app:
    image: node:lts-alpine
```
Můžete vybrat libovolný název služby. Název se automaticky stane síťovým aliasem, což je užitečné při definování služby MySQL.

Rozšiřte definici elementu app a specifikujte command ke spuštění.

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

Definujte ports pro použití se službou app. Všimněte si, že tyto porty odpovídají argumentu -p 3000:3000 pro příkaz použitý ke spuštění aplikace s MySQL.
```
  app:
    image: node:lts-alpine
    command: sh -c "yarn install && yarn run dev"
    ports:
      - 3000:3000
```
Identifikujte pracovní adresář working_dir pro službu app a také mapované volumes.
```
  app:
    image: node:lts-alpine
    command: sh -c "yarn install && yarn run dev"
    ports:
      - 3000:3000
    working_dir: /app
    volumes:
      - ./:/app
```
Při definování svazků Docker Compose můžete použít relativní cesty na základě aktuálního adresáře.

Zadejte environment definice proměnných, které se mají použít při provádění příkazů pro službu 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

Nezapomeňte zadat kořenové heslo MySQL pro zástupný symbol <your-password>.

Za definici služby mysql přidejte definici služby MySQL app. Zadejte názvy a hodnoty prvků, jak je znázorněno a se stejným odsazením.
```
services:
  app:
    ...
  mysql:
    image: mysql:lts
```
Definice služby mysql odpovídá příkazu, který jste použili dříve k spuštěníMySQL . Když definujete službu, automaticky obdrží alias sítě.

Identifikujte mapované volumes pro službu mysql.

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

Zadejte environment definice proměnných, které se mají použít při provádění příkazů pro službu mysql.

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

Nezapomeňte zadat kořenové heslo MySQL pro zástupný symbol <your-password>.

Definujte mapování svazků pro celou aplikaci. Přidejte oddíl volumes: za oddíl services: se stejným odsazením.
```
services:
   ...

volumes:
  todo-mysql-data:
```

Ověřte, že dokončený docker-compose.yml soubor vypadá jako v následujícím příkladu. U zástupného symbolu <your-password> by se mělo zobrazit vaše kořenové heslo MySQL.

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:

Spuštění zásobníku aplikací pomocí Docker Compose

Teď můžete zkusit spustit soubor docker-compose.yml.

Zastavte všechny spuštěné instance vaší aplikace a databáze.
- Visual Studio Code
- Příkazový řádek
V nástroji VS Code postupujte takto:
1. Otevřete PRŮZKUMNÍKA KONTEJNERŮ (rozšíření Nástroje kontejneru).
2. U každého spuštěného kontejneru klikněte pravým tlačítkem na kontejner a vyberte Odebrat.
V okně příkazového řádku nebo terminálu spusťte následující příkazy:
1. Získejte seznam spuštěných kontejnerů a jejich identifikátorů <container-id>:
```
docker ps
```
2. Zastavte a odeberte každý spuštěný kontejner:
```
docker stop <container-id>
docker rm <container-id>
```
Spusťte aplikaci s více kontejnery a všechny služby.
- Visual Studio Code
- Příkazový řádek
V nástroji VS Code postupujte takto:
1. Otevřete zobrazení EXPLORER (souborů a složek).
2. Klikněte pravým tlačítkem myši na soubor docker-compose.yml a vyberte Vytvořit.
Spusťte následující příkaz s argumentem -d, který příkaz spustí jako proces na pozadí:
```
docker-compose up -d
```
Měl by se zobrazit výstup podobný následujícímu příkladu:
```
[+] Building 0.0s (0/0)
[+] Running 2/2
✔ Container app-app-1    Started  0.9s 
✔ Container app-mysql-1  Running
```
Tato operace vytvoří namapovaný svazek pro aplikaci a síť. Ve výchozím nastavení Vytvoří Docker Compose síť speciálně pro zásobník aplikací.
Zkontrolujte protokoly pro spuštěný kontejner.
- Visual Studio Code
- Příkazový řádek
V nástroji VS Code postupujte takto:
1. Otevřete PRŮZKUMNÍKA KONTEJNERŮ (rozšíření Nástroje kontejneru).
2. Klikněte pravým tlačítkem na kontejner aplikace a vyberte Zobrazit protokoly.
Spusťte následující příkaz:
```
docker logs
```
Protokoly pro konkrétní službu můžete zobrazit přidáním názvu služby, například app na konec příkazu logs:
```
docker logs <service-name>
```
Měl by se zobrazit výstup podobný následujícímu příkladu:
```
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
```
Protokoly zobrazují název služby a číslo instance, například app_1 na začátku každého řádku. Tento formát vám pomůže rozlišovat zprávy podle služby a instance. Protokoly z každé služby jsou prokládány do jediného datového proudu. Tento přístup umožňuje sledovat problémy související s časováním.
Nyní můžete přejít do spuštěné aplikace v internetovém prohlížeči: http://localhost:3000.

Zastavení docker Compose a spouštění kontejnerů

Až budete s aplikací a kontejnery hotovi, můžete je odebrat.

Visual Studio Code
Příkazový řádek

V nástroji VS Code postupujte takto:

Otevřete zobrazení EXPLORER (souborů a složek).
Klikněte pravým tlačítkem na soubor docker-compose.yml a vyberte Vytvořitdolů .

Spuštěním následujícího příkazu zastavte spuštěnou aplikaci a kontejnery:

docker-compose down

Tato operace zastaví všechny spuštěné kontejnery a odstraní síť.

Ve výchozím nastavení se pojmenované svazky v compose souboru neodstraňují. Pokud chcete tyto svazky odebrat, můžete použít příkaz docker-compose down --volumes.

Vyčištění prostředků

Pokud jste pro instalaci použili součásti Požadavky v této sérii kurzů, můžete konfiguraci znovu použít pro budoucí vývoj Dockeru. Není nezbytné odstranit ani odinstalovat žádnou komponentu.

integrace cloudu Dockeru
Příklady

Váš názor

Byla tato stránka užitečná?

Last updated on 2025-05-14