Tutorial: Membuat aplikasi multi-kontainer dengan MySQL dan Docker Compose

2025-01-26

Artikel ini menjelaskan cara membuat aplikasi multi-kontainer dengan MySQL dan Docker Compose. Aplikasi dengan beberapa kontainer memungkinkan Anda mendedikasikan kontainer untuk tugas khusus, sehingga setiap kontainer dapat berfokus pada satu tugas. Ada banyak keuntungan menggunakan aplikasi multi-kontainer:

Kontainer terpisah memungkinkan Anda mengelola API dan sumber daya front-end secara berbeda dari database.
Beberapa kontainer memungkinkan Anda membuat versi dan memperbarui versi dalam isolasi.
Database lokal dapat dipertahankan dalam kontainer, dan layanan terkelola digunakan untuk basis data dalam produksi.
Aplikasi multi-kontainer lebih efisien daripada menjalankan beberapa proses dengan manajer proses, yang menambah kompleksitas dalam menyalakan/mematikan kontainer.

Dalam tutorial ini, Anda:

Mulai MySQL
Jalankan aplikasi multi-kontainer Anda dengan MySQL
Membuat file Docker Compose untuk aplikasi Anda
Jalankan tumpukan aplikasi dengan Docker Compose

Prasyarat

Artikel ini adalah bagian dari seri tutorial. Prosedur ini dibangun berdasarkan contoh yang sudah ada yang memerlukan Docker Desktop untuk kontainer Linux.

Pendekatan yang direkomendasikan adalah menyelesaikan tutorial pertama, Membuat aplikasi kontainer, termasuk memenuhi prasyarat, dan juga tutorial, Mempertahankan data di aplikasi Anda. Setelah Anda bekerja melalui tutorial ini, lanjutkan dengan prosedur yang dijelaskan dalam artikel ini.
Contoh dalam artikel ini menggunakan Docker Compose.
- Windows
- Linux
Docker Desktop untuk Windows menyertakan Docker Compose.

Jalankan perintah berikut untuk memverifikasi penginstalan Docker Anda:
```
docker-compose version
```
Untuk Linux, ikuti instruksi untuk menginstal Docker Compose.

Visual Studio Code

Seri tutorial ini menjelaskan prosedur untuk Visual Studio Code (VISUAL Code). Tinjau pertimbangan berikut untuk bekerja di lingkungan ini:

Gunakan menu sebelah kiri untuk beralih antara tampilan CONTAINER EXPLORER atau EXPLORER (file dan folder):
Buka jendela baris perintah di Visual Studio Code dengan memilih Terminal >Terminal Baru. Anda juga dapat menggunakan pintasan keyboard Ctrl+Shift+` (tanda centang belakang).
Kecuali ditentukan lain, jalankan perintah di jendela Bash. Sebagian besar perintah berlabel untuk Bash dijalankan di jendela Bash atau di jendela baris perintah Visual Studio Code.

Mulai sistem manajemen database MySQL

Secara default, kontainer berjalan dalam isolasi. Kontainer tidak mengetahui proses lain atau kontainer lain di komputer yang sama.

Untuk mengaktifkan komunikasi antar kontainer, mereka perlu terhubung ke jaringan yang sama. Beberapa kontainer pada jaringan yang sama dapat berbagi data dan memproses informasi satu sama lain.

Ada dua cara untuk melampirkan kontainer ke jaringan. Anda dapat melampirkan kontainer ke jaringan selama pembuatan, atau melampirkan kontainer yang ada ke jaringan di lain waktu.

Dalam contoh ini, Anda membuat jaringan dan melampirkan kontainer MySQL saat startup.

Buat jaringan bernama todo-app:
```
docker network create todo-app
```
Mulai kontainer MySQL bernama todo-mysql-data dan lampirkan ke jaringan todo-app. Perintah membuat alias jaringan mysql untuk database MySQL todos.

Saat Anda menjalankan perintah, masukkan password root MySQL Anda untuk tempat penampung <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
```
Perintah ini juga menentukan variabel lingkungan MYSQL_ROOT_PASSWORD dan MYSQL_DATABASE. Untuk informasi selengkapnya, lihat daftar MySQL Docker Hub.

Peringatan

Tutorial ini mengilustrasikan kredensial kata sandi untuk mengautentikasi dengan database MySQL, yang bukan metode yang paling aman. Lihat dokumentasi MySQL untuk mempelajari tentang metode autentikasi yang lebih aman.
Dapatkan ID kontainer Anda untuk digunakan di langkah berikutnya.
```
docker ps
```
Konfirmasikan bahwa Anda dapat tersambung ke kontainer di jaringan mysql.

Saat Anda menjalankan perintah, masukkan ID kontainer Anda pada placeholder <mysql-container-id>.
```
docker exec -it <mysql-container-id> mysql -p
```
Pada perintah, masukkan kata sandi yang Anda berikan saat membuat kontainer todo-mysql-data.

Di shell MySQL, cantumkan database dan verifikasi bahwa Anda melihat database todos.

SHOW DATABASES;

Anda akan melihat output berikut:

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

Untuk mengakhiri koneksi dan kembali ke prompt baris perintah, masukkan keluar.

Menjalankan aplikasi Anda dengan MySQL

Aplikasi todo mendukung pengaturan variabel lingkungan tertentu untuk menentukan pengaturan koneksi MySQL Anda. Tabel berikut mencantumkan variabel yang didukung, dan nilai yang digunakan dalam contoh yang disajikan di bagian ini.

Nama variabel	Contoh nilai	Deskripsi
`MYSQL_HOST`	`mysql`	Nama host untuk server MySQL.
`MYSQL_USER`	`root`	Nama pengguna yang digunakan untuk koneksi.
`MYSQL_PASSWORD`	`<your-password>`	Kata sandi yang digunakan untuk koneksi. Dalam contoh ini, ganti kata sandi root Anda dengan penampung `<your-password>`.
`MYSQL_DATABASE`	`todos`	Nama database yang akan digunakan setelah koneksi dibuat.

Peringatan

Menggunakan variabel lingkungan untuk mengatur pengaturan koneksi dapat diterima untuk pengembangan, tetapi praktik ini tidak disarankan untuk menjalankan aplikasi dalam produksi. Untuk informasi selengkapnya, lihat Mengapa Anda tidak boleh menggunakan variabel lingkungan untuk data rahasia.

Mekanisme yang lebih aman adalah menggunakan dukungan rahasia yang disediakan oleh kerangka kerja orkestrasi kontainer Anda. Dalam kebanyakan kasus, rahasia ini dipasang sebagai file dalam kontainer yang sedang berjalan.

Dalam contoh berikut, Anda memulai aplikasi dan menyambungkan kontainer aplikasi ke kontainer MySQL Anda.

Jalankan perintah docker berikut. Perhatikan bagaimana perintah menentukan variabel lingkungan yang dijelaskan sebelumnya.

Saat Anda menjalankan perintah, ingatlah untuk memasukkan kata sandi root MySQL Anda untuk placeholder <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"
```
Di editor Visual Studio Code, buka Penjelajah Kontainer, klik kanan kontainer aplikasi Anda, dan pilih Tampilkan Log.

Anda juga dapat melihat log dari baris perintah dengan menggunakan perintah docker logs.

Tinjau keluaran log. Perhatikan baris yang menunjukkan aplikasi tersambung ke database 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

Di browser internet Anda, buka aplikasi yang sedang berjalan: http://localhost:3000.
Di aplikasi anda yang sedang berjalan, tambahkan beberapa item ke daftar todo Anda.
Sambungkan ke database kontainer MySQL di jaringan mysql sehingga Anda dapat memeriksa database.

Saat Anda menjalankan perintah, masukkan ID kontainer Anda pada placeholder <mysql-container-id>.
```
docker exec -ti <mysql-container-id> mysql -p todos
```
Pada perintah, masukkan kata sandi yang Anda berikan saat membuat kontainer todo-mysql-data.

Di shell MySQL, verifikasi bahwa todo_items yang Anda tambahkan ditulis ke database todos.

use todos;
select * from todo_items;

Anda akan melihat output yang mirip dengan contoh berikut:

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

Anda sekarang memiliki aplikasi yang menyimpan data dalam database eksternal yang berjalan dalam kontainer terpisah. Prosedur ini menunjukkan bagaimana Anda dapat mengaktifkan komunikasi antar kontainer dengan menggunakan jaringan.

Membuat file Docker Compose

Docker Compose membantu Anda menentukan dan berbagi aplikasi multi-kontainer. File Docker Compose dapat menentukan semua layanan yang diperlukan, sehingga Anda dapat memulai atau mengakhiri semua proses terkait dengan satu perintah. Anda dapat menentukan tumpukan aplikasi Anda dalam file Docker Compose di akar repositori proyek Anda, dan mempertahankan konfigurasi Anda di bawah kontrol versi. Pendekatan ini memungkinkan orang lain untuk berkontribusi pada proyek Anda ketika mereka mengkloning repositori Anda.

Dalam contoh berikut, Anda mengonfigurasi file Docker Compose untuk aplikasi multi-kontainer Anda todo.

Di akar proyek aplikasi todo Anda, buat file Docker Compose bernama docker-compose.yml.

Nota

Secara default, versi skema YAML diatur ke versi terbaru. Saat menjalankan aplikasi, jika versi skema Anda usang, Anda akan menerima pesan peringatan. Untuk meninjau versi skema saat ini dan matriks kompatibilitas, lihat Ikhtisar (Compose file).
Dalam file docker-compose.yml, tambahkan elemen berikut. Tentukan name aplikasi Anda dan mulai daftar services (atau kontainer) yang ingin Anda jalankan sebagai bagian dari aplikasi Anda.
```
name: todo

services:
```
Daftar layanan unik untuk aplikasi Anda. Contohnya termasuk app, web, db, proxy, dan sebagainya. Anda memperluas definisi untuk elemen services di langkah selanjutnya.

Petunjuk

Indentasi penting dalam file .yml. Jika Anda mengedit di Visual Studio Code, Intellisense menunjukkan kesalahan dalam format atau sintaks.
Kembali ke definisi services dalam file docker-compose.yml. Perluas definisi dengan menambahkan entri untuk menentukan elemen layanan app, yang mencakup gambar untuk kontainer.
```
services:
  app:
    image: node:lts-alpine
```
Anda dapat memilih nama apa pun untuk layanan ini. Nama secara otomatis menjadi alias jaringan, yang berguna saat Anda menentukan layanan MySQL.

Perluas definisi elemen app untuk menentukan command yang akan dijalankan.

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

Tentukan ports untuk digunakan dengan layanan app. Perhatikan port ini sesuai dengan argumen -p 3000:3000 untuk perintah yang digunakan untuk menjalankan aplikasi dengan MySQL.
```
  app:
    image: node:lts-alpine
    command: sh -c "yarn install && yarn run dev"
    ports:
      - 3000:3000
```
Identifikasi direktori kerja working_dir untuk layanan app dan juga volumesyang telah dipetakan.
```
  app:
    image: node:lts-alpine
    command: sh -c "yarn install && yarn run dev"
    ports:
      - 3000:3000
    working_dir: /app
    volumes:
      - ./:/app
```
Saat menentukan volume Docker Compose, Anda dapat menggunakan jalur relatif berdasarkan direktori saat ini.

Tentukan definisi variabel environment yang akan digunakan saat Anda menjalankan perintah untuk layanan 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

Ingatlah untuk memasukkan kata sandi pengguna root MySQL Anda untuk tempat penampung <your-password>.

Tambahkan definisi untuk layanan MySQL mysql setelah definisi layanan app. Tentukan nama dan nilai elemen seperti yang ditunjukkan dan dengan indentasi yang sama.
```
services:
  app:
    ...
  mysql:
    image: mysql:lts
```
Definisi layanan mysql sesuai dengan perintah yang Anda gunakan sebelumnya untuk memulai MySQL. Saat Anda menentukan layanan, layanan secara otomatis menerima alias jaringan.

Identifikasi pemetaan volumes untuk layanan mysql.

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

Tentukan definisi variabel environment yang akan digunakan saat Anda menjalankan perintah untuk layanan mysql.
```
services:
  app:
    ...
  mysql:
    image: mysql:lts
    volumes:
      - todo-mysql-data:/var/lib/mysql
    environment: 
      MYSQL_ROOT_PASSWORD: <your-password>
      MYSQL_DATABASE: todos
```
Ingatlah untuk memasukkan kata sandi pengguna root MySQL Anda untuk tempat penampung <your-password>.
Tentukan pemetaan volume untuk seluruh aplikasi. Tambahkan bagian volumes: setelah bagian services: dan dengan indentasi yang sama.
```
services:
   ...

volumes:
  todo-mysql-data:
```

Konfirmasikan file docker-compose.yml Anda yang telah selesai terlihat seperti contoh berikut. Anda akan melihat kata sandi root MySQL Anda untuk tempat penampung <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:

Jalankan tumpukan aplikasi dengan Docker Compose

Sekarang Anda dapat mencoba menjalankan file docker-compose.yml Anda.

Hentikan instans aplikasi dan database Anda yang sedang berjalan.
- Visual Studio Code
- Baris Perintah
Ikuti langkah-langkah ini di Visual Studio Code:
1. Buka PENJELAJAHAN KONTAINER (ekstensi untuk alat kontainer).
2. Untuk setiap kontainer yang sedang berjalan, klik kanan kontainer dan pilih Hapus.
Jalankan perintah berikut di jendela baris perintah atau terminal:
1. Dapatkan daftar kontainer yang sedang berjalan dan identifikatornya <container-id>:
```
docker ps
```
2. Hentikan dan hapus setiap kontainer yang sedang berjalan:
```
docker stop <container-id>
docker rm <container-id>
```
Mulai aplikasi multi-kontainer Anda beserta semua layanannya.
- Visual Studio Code
- Baris Perintah
Ikuti langkah-langkah ini di Visual Studio Code:
1. Buka tampilan EXPLORER (file dan folder).
2. Klik kanan file docker-compose.yml dan pilih Compose Up.
Jalankan perintah berikut dengan argumen -d, yang menjalankan perintah sebagai proses latar belakang:
```
docker-compose up -d
```
Anda akan melihat output yang mirip dengan contoh berikut:
```
[+] Building 0.0s (0/0)
[+] Running 2/2
✔ Container app-app-1    Started  0.9s 
✔ Container app-mysql-1  Running
```
Operasi ini membuat volume yang dipetakan untuk aplikasi dan jaringan. Secara default, Docker Compose membuat jaringan khusus untuk tumpukan aplikasi.
Tinjau log untuk kontainer yang sedang berjalan.
- Visual Studio Code
- Baris Perintah
Ikuti langkah-langkah ini di Visual Studio Code:
1. Buka PENJELAJAHAN KONTAINER (ekstensi untuk alat kontainer).
2. Klik kanan kontainer aplikasi dan pilih Tampilkan Log.
Jalankan perintah berikut:
```
docker logs
```
Anda dapat melihat log untuk layanan tertentu dengan menambahkan nama layanan, seperti app ke akhir perintah logs:
```
docker logs <service-name>
```
Anda akan melihat output yang mirip dengan contoh berikut:
```
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
```
Log menunjukkan nama layanan dan nomor instans, seperti app_1 di awal setiap baris. Format ini membantu Anda membedakan pesan berdasarkan layanan dan instans. Log dari setiap layanan digabungkan ke dalam satu aliran. Pendekatan ini memungkinkan Anda untuk mengawasi masalah terkait waktu.
Anda sekarang dapat membuka aplikasi yang sedang berjalan di browser internet Anda: http://localhost:3000.

Menghentikan Docker Compose dan menjalankan kontainer

Setelah selesai dengan aplikasi dan kontainer, Anda dapat menghapusnya.

Visual Studio Code
Baris Perintah

Ikuti langkah-langkah ini di Visual Studio Code:

Buka tampilan EXPLORER (file dan folder).
Klik kanan file docker-compose.yml dan pilih Compose Down.

Jalankan perintah berikut untuk menghentikan aplikasi dan kontainer yang sedang berjalan:

docker-compose down

Operasi ini menghentikan semua kontainer yang sedang berjalan dan menghapus jaringan.

Secara bawaan, volume yang diberi nama dalam file susun Anda tidak dihapus. Jika Anda ingin menghapus volume ini, Anda dapat menggunakan perintah docker-compose down --volumes.

Membersihkan sumber daya

Jika Anda menerapkan komponen Prasyarat dalam seri tutorial ini ke penginstalan Anda, Anda dapat menggunakan kembali konfigurasi untuk pengembangan Docker di masa mendatang. Tidak perlu menghapus atau mencopot komponen apa pun.

Bagikan melalui