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

  • Artykuł

Z tego samouczka dowiesz się, jak tworzyć aplikacje z wieloma kontenerami. Ten samouczek opiera się na samouczkach wprowadzających, rozpoczynaniu pracy z platformą Docker i programem Visual Studio Code. W tym zaawansowanym samouczku zaktualizujesz aplikację tak, aby działała zgodnie z opisem na tym diagramie i dowiesz się, jak wykonywać następujące działania:

  • Uruchom program MySQL.
  • Uruchom aplikację za pomocą programu MySQL.
  • Utwórz plik redagowania.
  • Uruchom stos aplikacji.

Diagram shows two containers labeled Todo App and MySQL connected with a line.

Korzystanie z wielu kontenerów umożliwia dedykować kontenery dla wyspecjalizowanych zadań. Każdy kontener powinien zrobić jedną rzecz i zrobić to dobrze.

Oto kilka powodów, dla których warto używać aplikacji wielokontenerowych:

  • Oddzielaj kontenery, aby zarządzać interfejsami API i frontonami inaczej niż bazy danych.
  • Kontenery umożliwiają przechowywanie wersji i aktualizowanie wersji w izolacji.
  • Chociaż możesz użyć kontenera dla bazy danych lokalnie, możesz użyć usługi zarządzanej dla bazy danych w środowisku produkcyjnym.
  • Uruchamianie wielu procesów wymaga menedżera procesów, co zwiększa złożoność uruchamiania/zamykania kontenera.

Wymagania wstępne

Ten samouczek kontynuuje serię samouczków, począwszy od sekcji Tworzenie aplikacji kontenera. Zacznij od tego, który zawiera wymagania wstępne. Następnie wykonaj samouczek Utrwalanie danych w aplikacji.

Potrzebne są również następujące elementy:

  • Docker Compose.

    Program Docker Desktop dla systemu Windows lub Mac zawiera narzędzie Docker Compose. Uruchom to polecenie, aby sprawdzić:

    docker-compose version

    Jeśli używasz systemu operacyjnego Linux, zainstaluj program Docker Compose.

Podobnie jak w przypadku poprzednich samouczków, większość zadań można wykonać z widoku EKSPLORATORa programu VS Code lub widoku platformy DOCKER. Możesz wybrać pozycję Terminal>Nowy terminal, aby otworzyć okno wiersza polecenia w programie VS Code. Polecenia można również uruchamiać w oknie powłoki Bash. O ile nie określono, każde polecenie oznaczone jako powłoka Bash może być uruchamiane w oknie powłoki Bash lub w terminalu programu VS Code.

Uruchamianie bazy danych MySQL

Kontenery, domyślnie, działają w izolacji. Nie wiedzą nic o innych procesach ani kontenerach na tym samym komputerze. Aby zezwolić jednemu kontenerowi na rozmowę z innym, użyj sieci.

Jeśli dwa kontenery znajdują się w tej samej sieci, mogą komunikować się ze sobą. Jeśli tak nie jest, nie mogą.

Istnieją dwa sposoby umieszczania kontenera w sieci: przypisywanie go na początku lub łączenie istniejącego kontenera. W tym przykładzie najpierw utworzysz sieć i dołączysz kontener MySQL podczas uruchamiania.

  1. Utwórz sieć przy użyciu tego polecenia.

    docker network create todo-app

  2. Uruchom kontener MySQL i dołącz go do sieci.

    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:5.7

    To polecenie definiuje również zmienne środowiskowe. Aby uzyskać więcej informacji, zobacz Artykuł MySQL Docker Hub listing (Lista usługi Docker Hub w usłudze MySQL).

    Polecenie określa alias sieciowy, mysql.

  3. Pobierz identyfikator kontenera docker ps przy użyciu polecenia .

  4. Aby potwierdzić, że baza danych jest uruchomiona, połącz się z bazą danych.

    docker exec -it <mysql-container-id> mysql -p

    Wprowadź hasło użyte powyżej po wyświetleniu monitu.

  5. W powłoce MySQL wyświetl listę baz danych i sprawdź, czy baza danych jest widoczna 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)

  6. Wprowadź exit , gdy wszystko będzie gotowe do powrotu do wiersza polecenia terminalu.

Uruchamianie aplikacji za pomocą programu MySQL

Aplikacja do wykonania obsługuje ustawienie zmiennych środowiskowych w celu określenia ustawień połączenia z programem MySQL.

  • MYSQL_HOST Nazwa hosta serwera MySQL.
  • MYSQL_USER Nazwa użytkownika do użycia na potrzeby połączenia.
  • MYSQL_PASSWORD Hasło do użycia dla połączenia.
  • MYSQL_DB Baza danych do użycia po nawiązaniu połączenia.

Ostrzeżenie

Ustawienie ustawień połączenia przy użyciu zmiennych środowiskowych jest akceptowalne w przypadku programowania. Zalecamy stosowanie tej praktyki 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 wpisów tajnych udostępnianych przez platformę orkiestracji kontenerów. W większości przypadków te wpisy tajne są instalowane jako pliki w uruchomionym kontenerze.

Ta procedura uruchamia aplikację i łączy ten kontener z kontenerem MySQL.

  1. Użyj następującego polecenia docker run. Określa zmienne środowiskowe powyżej.

    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:20-alpine 
  sh -c "yarn install && yarn run dev"

  2. W programie VS Code w widoku platformy Docker kliknij prawym przyciskiem myszy kontener aplikacji i wybierz pozycję Wyświetl dzienniki. Aby wyświetlić dzienniki z wiersza polecenia, użyj docker logs polecenia .

    Wynik zawiera wiersz wskazujący, że aplikacja jest połączona z bazą danych 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

  3. Wprowadź http://localhost:3000 wartość w przeglądarce. Dodaj niektóre elementy do listy zadań do wykonania.

  4. Połączenie do bazy danych MySQL, tak jak w poprzedniej sekcji. Uruchom to polecenie, aby sprawdzić, czy elementy są zapisywane w bazie danych.

    docker exec -ti <mysql-container-id> mysql -p todos

    W powłoce MySQL uruchom następujące polecenia.

    use todos;
select * from todo_items;

    Wynik będzie wyglądać podobnie do poniższych danych wyjściowych.

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

W tym momencie masz aplikację, która przechowuje dane w zewnętrznej bazie danych. Ta baza danych działa w osobnym kontenerze. Wiesz już o sieci kontenerów.

Tworzenie pliku docker Compose

Aplikacja Docker Compose ułatwia definiowanie i udostępnianie aplikacji z wieloma kontenerami. Za pomocą narzędzia Docker Compose można utworzyć plik w celu zdefiniowania usług. Za pomocą jednego polecenia można ściągnąć wszystko lub rozerwać wszystko.

Możesz zdefiniować stos aplikacji w pliku i zachować ten plik w katalogu głównym repozytorium projektu pod kontrolą wersji. Takie podejście umożliwia innym osobom współtworzenie projektu. Wystarczyłoby sklonować repozytorium.

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

  2. W pliku redagowania rozpocznij od zdefiniowania wersji schematu.

    version: "3.7"

    W większości przypadków najlepiej użyć najnowszej obsługiwanej wersji. Aby uzyskać informacje o bieżących wersjach schematów i macierzy zgodności, zobacz Compose file (Redaguj plik).

  3. Zdefiniuj usługi lub kontenery, które mają być uruchamiane w ramach aplikacji.

    version: "3.7"

services:

    Napiwek

    Wcięcie jest istotne w plikach yml . W przypadku edytowania w programie VS Code funkcja IntelliSense wskazuje błędy.

  4. Oto polecenie użyte do kontenera aplikacji. Te informacje zostaną dodane do pliku yml .

    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:20-alpine 
  sh -c "yarn install && yarn run dev"

    Zdefiniuj wpis usługi i obraz kontenera.

    version: "3.7"

services:
  app:
    image: node:20-alpine

    Możesz wybrać dowolną nazwę usługi. Nazwa automatycznie staje się aliasem sieci, który jest przydatny podczas definiowania usługi MySQL.

  5. Dodaj polecenie .

    version: "3.7"

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

  6. Określ porty dla usługi, które odpowiadają -p 3000:3000 w poleceniu powyżej.

    version: "3.7"

services:
  app:
    image: node:20-alpine
    command: sh -c "yarn install && yarn run dev"
    ports:
      - 3000:3000

  7. Określanie katalogu roboczego i mapowania woluminu

    version: "3.7"

services:
  app:
    image: node:20-alpine
    command: sh -c "yarn install && yarn run dev"
    ports:
      - 3000:3000
    working_dir: /app
    volumes:
      - ./:/app

    W definicjach woluminów narzędzia Docker Compose można użyć ścieżek względnych z bieżącego katalogu.

  8. Określ definicje zmiennych środowiskowych.

    version: "3.7"

services:
  app:
    image: node:20-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

  9. Dodaj definicje dla usługi MySQL. Poniżej przedstawiono polecenie, którego użyto powyżej:

    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:5.7

    Zdefiniuj nową usługę i nadaj jej nazwę mysql. Dodaj tekst po app definicji na tym samym poziomie wcięcia.

    version: "3.7"

services:
  app:
    # The app service definition
  mysql:
    image: mysql:5.7

    Usługa automatycznie pobiera alias sieciowy. Określ obraz do użycia.

  10. Zdefiniuj mapowanie woluminu.

    Określ wolumin z sekcją volumes: na tym samym poziomie co services:. Określ mapowanie woluminów pod obrazem.

    version: "3.7"

services:
  app:
    # The app service definition
  mysql:
    image: mysql:5.7
    volumes:
      - todo-mysql-data:/var/lib/mysql

volumes:
  todo-mysql-data:

  11. Określ zmienne środowiskowe.

    version: "3.7"

services:
  app:
    # The app service definition
  mysql:
    image: mysql:5.7
    volumes:
      - todo-mysql-data:/var/lib/mysql
    environment: 
      MYSQL_ROOT_PASSWORD: <your-password>
      MYSQL_DATABASE: todos

volumes:
  todo-mysql-data:

W tym momencie ukończenie docker-compose.yml wygląda następująco:

version: "3.7"

services:
  app:
    image: node:20-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:5.7
    volumes:
      - todo-mysql-data:/var/lib/mysql
    environment: 
      MYSQL_ROOT_PASSWORD: <your-password>
      MYSQL_DATABASE: todos

volumes:
  todo-mysql-data:

Uruchamianie stosu aplikacji

Teraz, gdy masz docker-compose.yml plik, wypróbuj go.

  1. Upewnij się, że żadne inne kopie aplikacji i bazy danych nie są uruchomione. W rozszerzeniu platformy Docker kliknij prawym przyciskiem myszy dowolny uruchomiony kontener i wybierz polecenie Usuń. Możesz też użyć polecenia docker rm w wierszu polecenia, jak w poprzednich przykładach.

  2. W Eksploratorze programu VS Code kliknij prawym przyciskiem myszy plik docker-compose.yml i wybierz polecenie Utwórz. Możesz też użyć tego polecenia platformy Docker w wierszu polecenia.

    docker-compose up -d

    Parametr -d sprawia, że polecenie jest uruchamiane w tle.

    Powinny zostać wyświetlone dane wyjściowe podobne do poniższych wyników.

    [+] Building 0.0s (0/0)
[+] Running 2/2
✔ Container app-app-1    Started                                                                                                       0.9s 
✔ Container app-mysql-1  Running

    Wolumin został utworzony, a także sieć. Domyślnie narzędzie Docker Compose tworzy sieć specjalnie dla stosu aplikacji.

  3. W rozszerzeniu platformy Docker kliknij prawym przyciskiem myszy kontener aplikacji i wybierz pozycję Wyświetl dzienniki. Aby wyświetlić dzienniki z wiersza polecenia, użyj docker logs polecenia .

    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 z poszczególnych usług są przeplatane w jeden strumień. Dzięki temu zachowaniu można obserwować problemy związane z chronometrażem.

    Nazwa usługi jest wyświetlana na początku wiersza, aby ułatwić odróżnienie komunikatów. Aby wyświetlić dzienniki dla określonej usługi, dodaj nazwę usługi na końcu polecenia logs.

  4. Na tym etapie powinno być możliwe otwarcie aplikacji. Wprowadź http://localhost:3000 wartość w przeglądarce.

Gdy skończysz z tymi kontenerami, możesz je usunąć po prostu.

  • W Eksploratorze programu VS Code kliknij prawym przyciskiem myszy plik docker-compose.yml i wybierz polecenie Redaguj w dół.
  • W wierszu polecenia uruchom polecenie docker-compose down.

Kontenery zatrzymują się. Sieć zostanie usunięta.

Domyślnie nazwane woluminy w pliku redagowania nie są usuwane. Jeśli chcesz usunąć woluminy, uruchom polecenie docker-compose down --volumes.

Czyszczenie zasobów

Wymagania wstępne użyte w tej serii samouczków mogą służyć do tworzenia w przyszłości platformy Docker. Nie ma powodu, aby usunąć ani odinstalować niczego.

Następne kroki

W tym samouczku przedstawiono informacje o aplikacjach z wieloma kontenerami i narzędziu Docker Compose. Aplikacja Docker Compose znacznie upraszcza definiowanie i udostępnianie aplikacji obsługujących wiele usług.

Poniżej przedstawiono niektóre zasoby, które mogą być przydatne: