Cara Instalasi Docker & Docker Compose di Ubuntu 24.04 LTS

Docker adalah platform container yang membungkus aplikasi beserta seluruh dependency-nya jadi satu unit yang portable dan konsisten di berbagai environment. Panduan ini menjelaskan langkah instalasi Docker Engine dan Docker Compose di Ubuntu 24.04 LTS menggunakan paket qVM-4, mulai dari membersihkan package lawas, setup repository resmi, instalasi, konfigurasi user non-root, sampai studi kasus menjalankan aplikasi multi-container (Flask + Redis) menggunakan Docker Compose.

Pengenalan

Docker Compose sekarang bukan lagi binary terpisah bernama docker-compose (dengan tanda hubung) — sejak Compose v2, fungsinya sudah menyatu sebagai CLI plugin resmi Docker Engine, dipanggil menggunakan docker compose (dengan spasi). Banyak tutorial lama masih mengacu ke instalasi docker-compose versi lama yang sebenarnya sudah deprecated; panduan ini langsung memasang keduanya (Docker Engine + Compose plugin) dari repository resmi Docker dalam satu langkah, sehingga Anda tidak perlu instalasi terpisah.

Repository default Ubuntu 24.04 LTS sebenarnya menyediakan package docker.io, tapi versinya sering tertinggal beberapa rilis dibanding versi resmi dari Docker. Panduan ini menggunakan repository resmi download.docker.com supaya Anda mendapat Docker Engine versi terbaru yang didukung penuh oleh Docker Inc.

Ubuntu 24.04 LTS dipilih sebagai basis OS karena mendapat dukungan resmi (security update dan bug fix) sampai April 2029. Panduan ini ditujukan untuk qVM yang baru saja di-deploy (fresh install), belum ada konfigurasi tambahan apa pun.

Persyaratan

Sebelum mulai instalasi, pastikan hal-hal berikut sudah terpenuhi:

Software

• Ubuntu 24.04 LTS, kondisi fresh install
• Akses root atau user dengan hak sudo
• Koneksi internet untuk mengunduh package dari repository resmi Docker
• SSH client di sisi lokal untuk remote ke qVM

Hardware / Spesifikasi VPS qVM

Panduan ini menggunakan paket qVM-4, dengan spesifikasi:

• vCPU: 2
• RAM: 4 GB
• Storage: NVMe 60 GB
• 1 IP Publik

Docker Engine sendiri ringan (overhead beberapa puluh MB), paket qVM-4 dipilih supaya sisa RAM cukup untuk container aplikasi yang lebih berat, misalnya untuk keperluan menjalankan LLM lokal — sesuaikan dengan paket qVM yang lebih besar apabila kebutuhan Anda ke arah situ.

Tahapan

1. Update dan Upgrade OS Ubuntu 24.04 LTS

Lakukan update dan upgrade pada sistem operasi Ubuntu 24.04 LTS terlebih dahulu, sebelum memulai instalasi service lainnya.

apt update && sudo apt upgrade -y

2. Hapus Package Docker Lama (Jika Ada)

Pada qVM yang benar-benar fresh install, package ini secara default tidak tersedia, tetap jalankan sebagai langkah aman, supaya tidak ada konflik dengan Docker Engine yang akan diinstal dari repository resmi:

apt remove docker.io docker-doc docker-compose docker-compose-v2 podman-docker containerd runc -y

Error "package not found" pada perintah di atas aman diabaikan — artinya package tersebut memang belum pernah terpasang di qVM Anda.

3. Tambahkan Repository Resmi Docker

Instal dependency yang dibutuhkan:

apt install ca-certificates curl -y

Buat direktori untuk menyimpan GPG key, lalu unduh key resmi Docker:

install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc
chmod a+r /etc/apt/keyrings/docker.asc

Tambahkan repository resmi Docker — baris di bawah ini otomatis menyesuaikan dengan arsitektur CPU dan codename Ubuntu yang terpasang di qVM Anda:

echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/ubuntu \
  $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | \
  tee /etc/apt/sources.list.d/docker.list > /dev/null

Update package index:

apt update

4. Instalasi Docker Engine dan Docker Compose

apt install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin -y

Package docker-compose-plugin di atas yang menyediakan perintah docker compose. docker-buildx-plugin menambahkan dukungan build multi-platform yang dibutuhkan banyak image modern.

Aktifkan supaya berjalan otomatis setiap qVM reboot, lalu cek statusnya:

systemctl enable docker
systemctl status docker

Cek versi yang terpasang:

docker --version
docker compose version

5. Konfigurasi User Non-Root untuk Docker

Secara default, perintah docker cuma bisa dijalankan oleh root (atau menggunakan sudo) karena Docker daemon berkomunikasi melalui Unix socket yang dimiliki root. Menjalankan Docker terus-menerus dengan sudo merepotkan dan berisiko kalau lupa dalam script otomatis. Tambahkan user Anda ke group docker:

usermod -aG docker $USER

Perubahan group tidak langsung berlaku di sesi shell yang sedang aktif. Keluar dan login SSH ulang, atau jalankan:

newgrp docker

Group docker secara praktis setara dengan akses root — siapa pun di group ini bisa memasang volume host manapun ke dalam container dan membaca/menulis file sistem melalui situ. Jangan tambahkan user yang tidak Anda percaya ke group ini.

6. Uji Coba Docker

docker run hello-world

Perintah ini menarik image hello-world dari Docker Hub, menjalankannya sebagai container, mencetak pesan konfirmasi, lalu container otomatis berhenti. Kalau pesan "Hello from Docker!" muncul tanpa perlu sudo, instalasi dan konfigurasi user non-root Anda sudah berhasil.

Bersihkan container uji coba yang sudah selesai:

docker rm $(docker ps -aq --filter ancestor=hello-world)

7. Studi Kasus: Demo Multi-Container dengan Docker Compose

docker run hello-world pada tahap sebelumnya membuktikan Docker Engine berjalan, tetapi belum menunjukkan kekuatan Docker Compose sebenarnya — mengelola beberapa container sekaligus menggunakan satu file konfigurasi. Sebagai contoh nyata, Anda akan membangun aplikasi sederhana: web app Python (Flask) yang menghitung jumlah kunjungan, dengan angka hitungannya disimpan di Redis — dua service terpisah yang saling terhubung otomatis melalui network internal Compose.

Buat direktori project:

mkdir -p ~/demo-compose && cd ~/demo-compose

Buat file aplikasi Python:

vim app.py

import time
import redis
from flask import Flask

app = Flask(__name__)
cache = redis.Redis(host="redis", port=6379)

def get_hit_count():
    retries = 5
    while True:
        try:
            return cache.incr("hits")
        except redis.exceptions.ConnectionError as exc:
            if retries == 0:
                raise exc
            retries -= 1
            time.sleep(0.5)

@app.route("/")
def hello():
    count = get_hit_count()
    return f"Halo dari qVM! Halaman ini sudah dikunjungi {count} kali.\n"

Perhatikan baris redis.Redis(host="redis", ...) — kode Anda memanggil Redis cukup menggunakan nama redis, bukan IP address, itu yang dimaksud sebagai "networking otomatis" di Docker Compose: tiap service bisa saling memanggil menggunakan nama service-nya, karena Compose otomatis mendaftarkan semuanya di DNS internal satu network yang sama.

Buat file dependency Python:

vim requirements.txt

flask
redis

Buat Dockerfile untuk image web:

vim Dockerfile

FROM python:3.12-alpine
WORKDIR /code
ENV FLASK_APP=app.py
ENV FLASK_RUN_HOST=0.0.0.0
COPY requirements.txt requirements.txt
RUN pip install -r requirements.txt
COPY . .
EXPOSE 5000
CMD ["flask", "run"]

Terakhir, buat docker-compose.yml yang mendefinisikan kedua service ini:

vim docker-compose.yml

services:
  web:
    build: .
    ports:
      - "5000:5000"
    depends_on:
      - redis
  redis:
    image: redis:alpine

web di-build dari Dockerfile di direktori yang sama (build: .), sementara redis langsung menarik image resmi dari Docker Hub tanpa perlu Dockerfile sendiri.

Jalankan seluruh stack dengan satu perintah:

docker compose up -d

Compose akan membangun image web, menarik image redis, lalu menjalankan keduanya sekaligus dengan network yang sudah saling terhubung. Cek status kedua container:

docker compose ps

Uji aplikasinya:

curl http://localhost:5000

Jalankan curl di atas berkali-kali — angka hitungan kunjungan akan terus bertambah, membuktikan web benar-benar menyimpan datanya di redis, bukan di memory container itu sendiri. Coba restart container web saja, lalu curl lagi:

docker compose restart web
curl http://localhost:5000

Hitungannya tetap lanjut dari angka terakhir, bukan reset ke nol — karena datanya memang tersimpan di redis, bukan ikut hilang saat web di-restart.

Lihat log kedua service sekaligus:

docker compose logs -f

Port 5000 di atas ter-mapping ke seluruh interface qVM, termasuk IP Publik-nya — karena qVM tidak mengaktifkan firewall secara default, aplikasi demo tanpa autentikasi ini otomatis bisa diakses dari internet selama container-nya berjalan. Matikan stack begitu selesai menguji, atau ubah port mapping menjadi "127.0.0.1:5000:5000" kalau cuma ingin diakses dari qVM itu sendiri.

Hentikan dan bersihkan seluruh stack begitu selesai:

docker compose down

Kesimpulan

qVM-4 (2 vCPU, 4 GB RAM, 60 GB NVMe) Anda sekarang sudah punya Docker Engine dan Docker Compose plugin dari repository resmi, dengan user non-root yang bisa langsung menjalankan container tanpa sudo. Studi kasus Flask + Redis membuktikan Docker Compose bekerja: satu file docker-compose.yml membangun image custom, menjalankan dua container sekaligus, dan menghubungkan keduanya melalui network internal tanpa konfigurasi manual. Dari sini, Anda sudah bisa menjalankan berbagai aplikasi dalam bentuk container — mulai dari web app, database, sampai service AI lokal seperti Ollama.