Oktatóanyag: Többtárolós alkalmazások létrehozása a MySQL és a Docker Compose használatával

Ez a cikk azt ismerteti, hogyan hozhat létre többtárolós alkalmazásokat MySQL- és Docker Compose. A több tárolóval rendelkező alkalmazások lehetővé teszik a tárolók speciális feladatokra való felosztását, így minden tároló egyetlen tevékenységre összpontosíthat. A többtárolós alkalmazások használatának számos előnye van:

A különálló tárolók lehetővé teszik, hogy az API-kat és az előtérbeli erőforrásokat az adatbázisoktól eltérő módon kezelje.
Több tárolóval elkülönítve végezhet verziózást és frissítést.
A helyi adatbázisokat fenntarthatjuk tárolókban, továbbá az éles környezetben lévő adatbázisokhoz felügyelt szolgáltatásokat használhatunk.
A többtárolós alkalmazások hatékonyabbak, mint több folyamat futtatása egy folyamatkezelővel, ami összetettebbé teszi a tárolóindítást/leállítást.

Ebben az oktatóanyagban ön:

A MySQL indítása
Többtárolós alkalmazás futtatása a MySQL-lel
Docker Compose-fájl létrehozása az alkalmazáshoz
Az alkalmazásverem futtatása a Docker Compose használatával

Előfeltételek

Ez a cikk egy oktatóanyag-sorozat része. Az eljárások egy bevált példán alapulnak, amely megköveteli Docker Desktop Linux-tárolókhoz.

Az ajánlott módszer az első oktatóanyag elvégzése, tárolóalkalmazás létrehozása, beleértve az előfeltételek teljesítését, valamint az adatok megőrzése az alkalmazásban című oktatóanyagot. Az oktatóanyagok elvégzése után folytassa a cikkben ismertetett eljárásokkal.
A cikkben szereplő példa Docker Composehasznál.
- Windows
- Linux
A WindowsHoz készült Docker Desktop tartalmazza a Docker Compose-t.

Futtassa a következő parancsot a Docker telepítésének ellenőrzéséhez:
```
docker-compose version
```
Linux esetén kövesse az utasításokat a Docker Compose telepítéséhez.

Visual Studio Code

Ez az oktatóanyag-sorozat a Visual Studio Code (VS Code) eljárásait ismerteti. Tekintse át a következő szempontokat a környezetben való munkavégzéshez:

A bal oldali menüben válthat a CONTAINER EXPLORER vagy az EXPLORER (fájl és mappa) nézet között:
Nyisson meg egy parancssori ablakot a VS Code-ban a Terminál>Új terminálkiválasztásával. Használhatja a Ctrl+Shift+` (visszajel) billentyűparancsot is.
Ha másként nincs megadva, futtassa a parancsokat egy Bash-ablakban. A Bash címkével ellátott parancsok többsége Bash-ablakban vagy a VS Code parancssori ablakában fut.

MySQL-adatbázis-kezelő rendszer indítása

Alapértelmezés szerint a tárolók elszigetelten futnak. A tárolók nem tudnak más folyamatokról vagy más tárolókról ugyanazon a számítógépen.

A tárolók közötti kommunikáció engedélyezéséhez ugyanahhoz a hálózathoz kell csatlakozniuk. Ugyanazon a hálózaton több tároló is megoszthat adatokat és feldolgozhatja az adatokat egymással.

A tárolók hálózati csatlakoztatásának két módja van. A létrehozás során tárolót csatolhat egy hálózathoz, vagy később egy meglévő tárolót is csatolhat egy hálózathoz.

Ebben a példában a hálózatot hozza létre, és indításkor csatolja a MySQL-tárolót.

Hozzon létre egy todo-appnevű hálózatot:
```
docker network create todo-app
```
Indítsa el a todo-mysql-data nevű MySQL-tárolót, és csatolja azt a todo-app hálózathoz. A parancs létrehoz egy hálózati aliast mysql a MySQL-adatbázishoz todos.

A parancs futtatásakor adja meg a MySQL-gyökérjelszót a <your-password> helyőrzőhöz.
```
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
```
Ez a parancs a MYSQL_ROOT_PASSWORD és MYSQL_DATABASE környezeti változókat is meghatározza. További információért lásd a MySQL Docker Hub jegyzéket.

Figyelmeztetés

Ez az oktatóanyag bemutatja a jelszó hitelesítő adatait a MySQL-adatbázissal való hitelesítéshez, amely nem a legbiztonságosabb módszer. A biztonságosabb hitelesítési módszerekről a MySQL dokumentációjában tájékozódhat.
Kérje le a tárolóazonosítót a következő lépésben való használatra.
```
docker ps
```
Győződjön meg arról, hogy csatlakozhat a tárolóhoz a mysql hálózaton.

A parancs futtatásakor adja meg a konténerazonosítót a <mysql-container-id> helyőrzőhöz.
```
docker exec -it <mysql-container-id> mysql -p
```
A parancssorba írja be a todo-mysql-data tároló létrehozásakor megadott jelszót.

A MySQL-rendszerhéjban listázhatja az adatbázisokat, és ellenőrizheti, hogy megjelenik-e az todos adatbázis.

SHOW DATABASES;

A következő kimenetnek kell megjelennie:

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

A kapcsolat befejezéséhez és a parancssorhoz való visszatéréshez írja be a kilépésparancsot.

Az alkalmazás futtatása a MySQL-lel

A todo alkalmazás támogatja bizonyos környezeti változók beállítását a MySQL-kapcsolat beállításainak megadásához. Az alábbi táblázat a támogatott változókat és az ebben a szakaszban bemutatott példában használt értékeket sorolja fel.

Változó neve	Példaérték	Leírás
`MYSQL_HOST`	`mysql`	A MySQL-kiszolgáló állomásneve.
`MYSQL_USER`	`root`	A kapcsolathoz használandó felhasználónév.
`MYSQL_PASSWORD`	`<your-password>`	A kapcsolathoz használandó jelszó. Ebben a példában cserélje le a `<your-password>` helyőrzőt a gyökérjelszóra.
`MYSQL_DATABASE`	`todos`	A kapcsolat létrejötte után használni kívánt adatbázis neve.

Figyelmeztetés

A környezeti változók használata a kapcsolati beállítások beállításához elfogadható a fejlesztéshez, de ez a gyakorlat nem ajánlott az alkalmazások éles környezetben való futtatásához. További információ: Miért nem érdemes környezeti változókat használni a titkos adatokhoz.

Biztonságosabb mechanizmus a tárolóvezénylési keretrendszer által biztosított titkos támogatás használata. A legtöbb esetben ezek a titkos kódok fájlokként vannak csatlakoztatva a futó tárolóban.

Az alábbi példában elindítja az alkalmazást, és csatlakoztatja az alkalmazástárolót a MySQL-tárolóhoz.

Futtassa a következő docker parancsot. Figyelje meg, hogy a parancs hogyan határozza meg a korábban ismertetett környezeti változókat.

A parancs futtatásakor ne felejtse el beírni a MySQL-gyökérjelszót a <your-password> helyőrzőhöz.
```
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"
```
A VS Code-szerkesztőben nyissa meg a Container Explorert, kattintson a jobb gombbal az alkalmazástárolóra, és válassza a Naplók megtekintése lehetőséget.

A naplókat a parancssorból is megtekintheti a docker logs paranccsal.

Tekintse át a napló kimenetét. Figyelje meg azt a sort, amely azt jelzi, hogy az alkalmazás csatlakozik a MySQL-adatbázishoz: 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

Az internetböngészőben nyissa meg a futó alkalmazást: http://localhost:3000.
A futó alkalmazásban adjon hozzá néhány elemet a teendőlistához.
Csatlakozzon a MySQL-tárolóadatbázishoz a mysql hálózaton, hogy ellenőrizze az adatbázist.

A parancs futtatásakor adja meg a konténerazonosítót a <mysql-container-id> helyőrzőhöz.
```
docker exec -ti <mysql-container-id> mysql -p todos
```
A parancssorba írja be a todo-mysql-data tároló létrehozásakor megadott jelszót.

A MySQL shellben ellenőrizze, hogy a hozzáadott todo_items a todos adatbázisba lettek-e írva.

use todos;
select * from todo_items;

A következő példához hasonló kimenetnek kell megjelennie:

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

Most már rendelkezik egy olyan alkalmazással, amely egy külön tárolóban futó külső adatbázisban tárolja az adatokat. Ez az eljárás bemutatja, hogyan engedélyezheti a tárolók közötti kommunikációt hálózatkezeléssel.

Docker Compose-fájl létrehozása

A Docker Compose segít a többtárolós alkalmazások definiálásában és megosztásában. A Docker Compose-fájlok az összes szükséges szolgáltatást megadják, így egyetlen paranccsal indíthatja el vagy fejezheti be az összes kapcsolódó folyamatot. Az alkalmazásverem definiálható egy Docker Compose-fájlban a projekt adattárának gyökerénél, és a konfigurációt a verziókövetés alatt tarthatja fenn. Ez a megközelítés lehetővé teszi, hogy mások is hozzájáruljanak a projekthez, amikor klónozzák az adattárat.

Az alábbi példában egy Docker Compose-fájlt konfigurál a többtárolós alkalmazáshoz todo.

A todo alkalmazásprojekt gyökerében hozzon létre egy Docker Compose fájlt docker-compose.ymlnéven.

Jegyzet

Alapértelmezés szerint a YAML-séma verziója a legújabb verzióra van állítva. Az alkalmazás futtatásakor, ha a séma verziója elavult, figyelmeztető üzenetet kap. Az aktuális sémaverziók és a kompatibilitási mátrix áttekintéséhez tekintse át Áttekintés (Compose-fájl).
A docker-compose.yml fájlban adja hozzá a következő elemeket. Adja meg az alkalmazásához name-t, és kezdje meg a futtatni kívánt services (vagy tárolók) listájának az alkalmazáshoz való hozzáadását.
```
name: todo

services:
```
A szolgáltatások listája egyedi az alkalmazás számára. Ilyenek például a app, web, db, proxystb. Egy későbbi lépésben kiterjesztheti a services elem definícióját.

Borravaló

A behúzás jelentős a .yml fájlokban. Ha a VS Code-ban szerkeszt, az Intellisense a formátum vagy a szintaxis esetleges hibáit jelzi.
Térjen vissza a services fájlban található definícióhoz. Bővítse a definíciót úgy, hogy hozzáad egy bejegyzést a app szolgáltatáselem meghatározásához, amely tartalmazza a tároló rendszerképét.
```
services:
  app:
    image: node:lts-alpine
```
A szolgáltatás tetszőleges nevét kiválaszthatja. A név automatikusan hálózati aliassá válik, ami a MySQL-szolgáltatás definiálásakor hasznos.

A app elem-definíciót bővítse ki, hogy megadjon egy végrehajtandó command-et.

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

Határozza meg a ports-t, hogy a app szolgáltatással használhassa. Figyelje meg, hogy ezek a portok megfelelnek az alkalmazás MySQL-lel való futtatásához használt parancs -p 3000:3000 argumentumának.
```
  app:
    image: node:lts-alpine
    command: sh -c "yarn install && yarn run dev"
    ports:
      - 3000:3000
```
Azonosítsa a working_dir munkakönyvtárat a app szolgáltatás számára, és a megfeleltetett volumes-t is.
```
  app:
    image: node:lts-alpine
    command: sh -c "yarn install && yarn run dev"
    ports:
      - 3000:3000
    working_dir: /app
    volumes:
      - ./:/app
```
Docker Compose-kötetek definiálásakor az aktuális könyvtár alapján használhatunk relatív elérési utakat.

Adja meg environmentapp szolgáltatás parancsainak végrehajtásakor használandó változódefiníciókat.

  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

Ne felejtse el megadni a MySQL-gyökérjelszót a <your-password> helyőrzőhöz.

Adja hozzá a MySQL-szolgáltatás mysql definícióját a app szolgáltatásdefiníció után. Adja meg az elemneveket és az értékeket az ábrán látható módon és ugyanazzal a behúzással.
```
services:
  app:
    ...
  mysql:
    image: mysql:lts
```
A mysql szolgáltatásdefiníció összhangban van azzal a paranccsal, amit korábban a MySQL elindításához használt. A szolgáltatás definiálásakor a rendszer automatikusan megkapja a hálózati aliast.

Azonosítsa a volumes szolgáltatáshoz hozzárendelt mysql.

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

Adja meg environmentmysql szolgáltatás parancsainak végrehajtásakor használandó változódefiníciókat.

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

Ne felejtse el megadni a MySQL-gyökérjelszót a <your-password> helyőrzőhöz.

A teljes alkalmazás kötetleképezésének definiálása. Adjon hozzá egy volumes: szakaszt a services: szakasz után, ugyanazzal a behúzással.
```
services:
   ...

volumes:
  todo-mysql-data:
```

Győződjön meg arról, hogy a kész docker-compose.yml fájl az alábbi példához hasonlóan néz ki. Meg kell jelennie a MySQL-gyökérjelszónak a <your-password> helyőrzőhöz.

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:

Az alkalmazásverem futtatása a Docker Compose használatával

Most kipróbálhatja a docker-compose.yml fájl futtatását.

Állítsa le az alkalmazás és az adatbázis futó példányait.
- Visual Studio Code
- parancssor
Kövesse az alábbi lépéseket a VS Code-ban:
1. Nyissa meg a CONTAINER EXPLORERt (Container Tools bővítmény).
2. Minden futó tárolóhoz kattintson a jobb gombbal a tárolóra, és válassza eltávolítása lehetőséget.
Futtassa a következő parancsokat egy parancssori ablakban vagy terminálban:
1. A futó tárolók és azonosítóik listájának lekérése <container-id>:
```
docker ps
```
2. Minden futó konténer leállítása és eltávolítása:
```
docker stop <container-id>
docker rm <container-id>
```
Indítsa el a többtárolós alkalmazást és az összes szolgáltatást.
- Visual Studio Code
- parancssor
Kövesse az alábbi lépéseket a VS Code-ban:
1. Nyissa meg a EXPLORER (fájl és mappa) nézetet.
2. Kattintson a jobb gombbal a docker-compose.yml fájlra, és válassza a Felíráslehetőséget.
Futtassa a következő parancsot a -d argumentummal, amely háttérfolyamatként hajtja végre a parancsot:
```
docker-compose up -d
```
A következő példához hasonló kimenetnek kell megjelennie:
```
[+] Building 0.0s (0/0)
[+] Running 2/2
✔ Container app-app-1    Started  0.9s 
✔ Container app-mysql-1  Running
```
Ez a művelet létrehozza az alkalmazás és a hálózat leképezett kötetét. A Docker Compose alapértelmezés szerint kifejezetten az alkalmazásverem számára hoz létre hálózatot.
Tekintse át a futó konténer naplóit.
- Visual Studio Code
- parancssor
Kövesse az alábbi lépéseket a VS Code-ban:
1. Nyissa meg a CONTAINER EXPLORERt (Container Tools bővítmény).
2. Kattintson a jobb gombbal az alkalmazástárolóra, és válassza Naplók megtekintéselehetőséget.
Futtassa a következő parancsot:
```
docker logs
```
Egy adott szolgáltatás naplóit úgy tekintheti meg, hogy hozzáadja a szolgáltatás nevét, például app a logs parancs végéhez:
```
docker logs <service-name>
```
A következő példához hasonló kimenetnek kell megjelennie:
```
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
```
A naplók a szolgáltatás nevét és példányszámát jelenítik meg, például app_1 az egyes sorok elején. Ez a formátum segít az üzenetek szolgáltatás és példány szerinti megkülönböztetésében. Az egyes szolgáltatások naplói egyetlen streambe vannak beágyazva. Ezzel a módszerrel figyelheti az időzítéssel kapcsolatos problémákat.
Ekkor megnyithatja a futó alkalmazást az internetböngészőben: http://localhost:3000.

A Docker Compose és a futó tárolók leállítása

Ha végzett az alkalmazással és a tárolókkal, eltávolíthatja őket.

Visual Studio Code
parancssor

Kövesse az alábbi lépéseket a VS Code-ban:

Nyissa meg a EXPLORER (fájl és mappa) nézetet.
Kattintson a jobb gombbal a docker-compose.yml fájlra, és válassza a Írás lefelélehetőséget.

Futtassa a következő parancsot a futó alkalmazás és tárolók leállításához:

docker-compose down

Ez a művelet leállítja az összes futó tárolót, és eltávolítja a hálózatot.

Alapértelmezés szerint a compose fájlban lévő névvel ellátott kötetek nincsenek eltávolítva. Ha el szeretné távolítani ezeket a köteteket, használhatja a docker-compose down --volumes parancsot.

Erőforrások törlése

Ha az oktatóanyag-sorozatban szereplő előfeltételek összetevőket alkalmazta a telepítésre, újra felhasználhatja a konfigurációt a Későbbi Docker-fejlesztéshez. Nem feltétlenül szükséges semmilyen összetevőt törölni vagy eltávolítani.

Visszajelzés

Hasznosnak találta ezt az oldalt?

Last updated on 2025-05-14