Docker Compose Pemula: Jalankan Aplikasi Multi-Layanan Mudah

Halo, gaes! Pernah ngerasain vibes ribetnya ngurus aplikasi yang punya banyak bagian, kayak web server, database, sama cache, tapi semuanya jalan di container Docker yang beda-beda? Manual docker run sana-sini, connect-in network, setting environment variable satu-satu, pusing banget, kan?

Nah, ini dia nih jagoannya yang bakal bikin hidup developer kamu jadi lebih santai: Docker Compose!

Apaan Sih Docker Compose Itu, Ngab?

Gini, bayangin kamu punya orkestra. Setiap musisi (baca: container) punya perannya masing-masing. Ada yang main biola (web server), ada yang main drum (database), ada yang main piano (cache). Kalo kamu harus satu-satu bilang "main!" ke tiap musisi, pasti ribet.

Docker Compose itu kayak konduktor ajaib yang bisa ngasih instruksi ke semua musisi sekaligus! Jadi, cukup satu file konfigurasi doang (biasanya namanya docker-compose.yml), kamu bisa deskripsiin semua layanan aplikasi kamu, gimana cara mereka saling terhubung, network apa yang dipakai, volume buat data persistensi, dan seabrek hal lainnya. Sekali perintah, boom! Semua layanan kamu langsung jalan barengan, auto-connected, anti pusing!

Kenapa Wajib Pake Docker Compose, Gaes?

1. Gampang Banget! Cukup satu file YAML, kamu bisa mendefinisikan seluruh tumpukan aplikasi kamu. Ini super duper memudahkan setup development environment.
2. Reproducible Abis! Mau di komputer A, komputer B, atau di laptop temen? Selama ada Docker, setup aplikasi kamu bakal sama persis. Goodbye "works on my machine"!
3. Lingkungan Dev yang Mirip Prod: Kamu bisa bikin lingkungan dev lokal yang sangat mirip sama lingkungan produksi kamu, jadi minim kejutan pas deploy.
4. Manajemen Efisien: Start, stop, restart, build, scaling, semua layanan kamu cuma butuh satu perintah dari terminal.

Skuy, Kita Bikin Aplikasi Multi-Layanan Sendiri Pake Docker Compose!

Kita bakal bikin contoh aplikasi web sederhana pake Node.js yang connect ke database PostgreSQL.

Prerequisites (Wajib Punya!)

• Docker Desktop terinstall di laptop kamu. Kalo belum, buruan install!

Struktur Proyek Kita

Bikin folder baru, misalnya my-compose-app. Di dalamnya, kita bakal punya:

my-compose-app/
├── app/
│   ├── app.js
│   ├── package.json
│   └── Dockerfile
├── .env
└── docker-compose.yml

Step 1: Bikin Aplikasi Node.js Sederhana (File di Folder app/)

app/package.json

{
  "name": "my-node-app",
  "version": "1.0.0",
  "description": "Simple Node.js app for Docker Compose tutorial",
  "main": "app.js",
  "scripts": {
    "start": "node app.js"
  },
  "dependencies": {
    "express": "^4.17.1",
    "pg": "^8.7.1"
  }
}

npm install jangan lupa di terminal di dalam folder app/ agar node_modules terbuat ya sebelum copy ke container. (Opsional, nanti di Dockerfile akan npm install juga).

app/app.js

const express = require('express');
const { Pool } = require('pg');

const app = express();
const port = 3000;

const pool = new Pool({
  user: process.env.POSTGRES_USER,
  host: process.env.POSTGRES_HOST, // Ini penting! Pakai nama service database kita di docker-compose.yml
  database: process.env.POSTGRES_DB,
  password: process.env.POSTGRES_PASSWORD,
  port: 5432,
});

app.get('/', async (req, res) => {
  try {
    const client = await pool.connect();
    const result = await client.query('SELECT NOW()');
    client.release();
    res.send(`Halo, gaes! Waktu di DB sekarang: ${result.rows[0].now}`);
  } catch (err) {
    console.error('Error connecting to DB', err);
    res.status(500).send('Duh, gagal konek ke database nih! ' + err.message);
  }
});

app.listen(port, () => {
  console.log(`App jalan di http://localhost:${port}, kuy cek!`);
});

Step 2: Bikin Dockerfile Buat Aplikasi Node.js Kita

app/Dockerfile

# Pake base image Node.js versi 16, yang 'alpine' biar enteng
FROM node:16-alpine

# Bikin direktori kerja di dalam container
WORKDIR /app

# Copy file package.json dan package-lock.json ke direktori kerja
COPY package*.json ./

# Install semua dependencies Node.js
RUN npm install

# Copy semua file aplikasi lainnya ke direktori kerja
COPY . .

# Expose port 3000, biar bisa diakses dari luar container
EXPOSE 3000

# Perintah buat jalanin aplikasi pas container start
CMD ["npm", "start"]

Step 3: Siapin File .env Buat Environment Variables

Ini biar credential database kita enggak hardcode di docker-compose.yml atau kode aplikasi, lebih aman dan fleksibel.

.env (di root folder my-compose-app)

POSTGRES_USER=userku
POSTGRES_PASSWORD=passwordrahasia
POSTGRES_DB=mydatabase

Step 4: Jantungnya: docker-compose.yml!

Ini dia yang paling seru! File YAML ini bakal jadi "blueprint" buat semua layanan kita.

docker-compose.yml (di root folder my-compose-app)

version: '3.8' # Versi Docker Compose yang kita pakai

services: # Di sini kita definisikan semua layanan/container kita
  web: # Nama layanan pertama kita: 'web' (aplikasi Node.js)
    build: ./app # Instruksi buat Docker Compose untuk build image dari Dockerfile di folder './app'
    ports: # Mapping port: "HOST_PORT:CONTAINER_PORT"
      - "3000:3000" # Port 3000 di laptop kita akan di-map ke port 3000 di container 'web'
    environment: # Variabel lingkungan yang akan diteruskan ke container 'web'
      POSTGRES_USER: ${POSTGRES_USER} # Ngambil dari file .env
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD} # Ngambil dari file .env
      POSTGRES_DB: ${POSTGRES_DB} # Ngambil dari file .env
      POSTGRES_HOST: db # PENTING! Ini nama layanan database kita, bukan localhost atau IP
    depends_on: # Menentukan urutan start. 'web' bergantung pada 'db'
      - db
    networks: # Menentukan network yang dipakai layanan ini
      - app-network

  db: # Nama layanan kedua kita: 'db' (database PostgreSQL)
    image: postgres:13-alpine # Kita pakai image PostgreSQL official versi 13 (alpine biar kecil)
    environment: # Variabel lingkungan untuk container PostgreSQL
      POSTGRES_USER: ${POSTGRES_USER}
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
      POSTGRES_DB: ${POSTGRES_DB}
    volumes: # Buat nyimpen data database biar gak ilang kalo container di-stop/dihapus
      - db-data:/var/lib/postgresql/data # 'db-data' adalah named volume yang kita definisikan di bawah
    networks: # Ikut network yang sama biar bisa saling komunikasi
      - app-network

volumes: # Definisi named volumes kita
  db-data: # Volume buat data PostgreSQL

networks: # Definisi custom network kita
  app-network:
    driver: bridge # Tipe network default Docker

Penjelasan Singkat Konfigurasi docker-compose.yml:

• version: Versi format docker-compose.yml yang digunakan. Selalu pakai versi terbaru yang stabil.
• services: Ini kumpulan semua container yang akan kamu jalankan. Setiap key di sini (misal web, db) adalah nama layanan.
• build: Menginstruksikan Docker Compose untuk membangun image dari Dockerfile di path yang ditentukan.
• image: Menginstruksikan Docker Compose untuk langsung menarik image dari Docker Hub (atau registry lain).
• ports: Memetakan port dari host ke container. 3000:3000 artinya port 3000 di mesin lokal kamu terhubung ke port 3000 di dalam container web.
• environment: Mengatur environment variables di dalam container. Kita bisa spill dari .env kita pake sintaks ${VARIABEL}.
• depends_on: Menentukan ketergantungan antar layanan. Misal, web butuh db jalan dulu baru dia bisa start.
• volumes: Buat nyimpen data biar persist. Kalo kamu delete container, datanya tetep aman di volume ini. db-data adalah named volume.
• networks: Cara container berkomunikasi satu sama lain. Kita bikin custom network app-network biar lebih rapi dan aman. Secara default, Docker Compose akan bikin network sendiri, tapi pake custom network itu best practice.

Step 5: Gas Pol! Jalankan Aplikasi Kita!

Setelah semua file siap, buka terminal di root folder my-compose-app dan ketik perintah ini:

docker compose up -d

• docker compose up: Perintah buat start semua layanan yang didefinisikan di docker-compose.yml.
• -d: (detached mode) Ini biar container jalan di background dan terminal kamu tetep bisa dipake buat ngoding atau main game. Kalo gak pake -d, log bakal langsung keluar di terminal kamu.

Kalo ini pertama kalinya kamu jalanin, Docker bakal download image postgres:13-alpine dan build image Node.js kamu. Sabar ya, gaes!

Step 6: Cek Aplikasi dan Log-nya

Setelah jalan, kamu bisa cek status container:

docker compose ps

Outputnya harusnya nunjukkin web dan db dengan status Up.

Terus, coba buka browser kamu dan akses: http://localhost:3000. Harusnya muncul pesan Halo, gaes! Waktu di DB sekarang: [tanggal & waktu dari PostgreSQL]. Kalo error, cek log-nya:

docker compose logs web # Buat liat log dari layanan 'web'
docker compose logs db  # Buat liat log dari layanan 'db'
docker compose logs     # Buat liat log dari semua layanan

Step 7: Beres-beres (Stop dan Hapus)

Kalo udah selesai atau mau bersih-bersih, kamu bisa stop semua layanan dan hapus semua container, network, dan volume yang dibuat Docker Compose:

docker compose down

• docker compose down: Memberhentikan dan menghapus container serta network yang dibuat oleh up.
• Kalo mau sekalian hapus named volume (db-data kita tadi), tambahin -v:

  docker compose down -v
  

  Hati-hati! Ini akan menghapus data yang ada di dalam volume db-data. Jadi, kalo datanya penting, jangan pake -v!

Tips Praktis dari Ngab Senior

• Pake .env File: Udah kita lakuin di atas. Ini best practice buat manajemen environment variable, terutama untuk sensitif data kayak password.
• depends_on itu Bukan Health Check: depends_on cuma memastikan urutan start. Jadi, web baru start setelah db container-nya jalan. Tapi, itu enggak ngecek apakah database di dalam container db itu udah siap menerima koneksi. Untuk itu, kamu bisa pake healthcheck di docker-compose.yml (buat next level ya, sekarang basic dulu!).
• Jaga Dockerfile Tetap Minimalis: Buat image Docker kamu sekecil mungkin biar cepat di-build dan di-deploy.
• Jangan Lupa docker compose build: Kalo kamu ada perubahan di Dockerfile atau di kode aplikasi di folder app/, jangan lupa docker compose build dulu sebelum docker compose up biar image-nya di-update. Atau bisa langsung docker compose up --build.
• Scaling Itu Gampang: Mau jalanin 3 instance web server? Gampang!

  docker compose up -d --scale web=3
  

Penutup

Gimana, gaes? Udah kebayang kan gimana Docker Compose bisa bikin workflow development kamu jadi jauh lebih gampang dan efisien? Dari yang awalnya manual satu-satu, sekarang cukup pake satu file YAML, semua aplikasi multi-layanan kamu bisa langsung jalan mulus kayak jalan tol!

Jadi, jangan ragu lagi buat spill ilmu ini ke temen-temen kamu, dan langsung praktikkin di proyek-proyek kamu. Dijamin bikin develop jadi auto-happy! Gas pol terus, jangan kasih kendor!