Cara Deploy Aplikasi dari GitHub di Dalang.io (Wajib Pakai Dockerfile)

Deploy dari GitHub ke Dalang.io, Langkah demi Langkah

App Hosting dari GitHub membangun repository kamu menjadi aplikasi yang online di alamat seperti https://nama-aplikasi-1a2b3c4d.svc.dalang.io. Setiap kali kamu git push ke branch yang dipilih, aplikasi dibangun ulang dengan sendirinya.

Ada satu syarat yang tidak bisa dilewati: repository harus punya file Dockerfile. Dockerfile adalah cara kamu memberi tahu Dalang.io bagaimana aplikasimu dibangun dan dijalankan. Tanpa itu, build tidak bisa dimulai. Panduan ini menjelaskan syarat-syaratnya, lalu langkah deploy dan perawatan sehari-hari.

Syarat sebelum mulai

Akun Dalang.io dengan kredit yang cukup. Pembayaran dari saldo kredit atau lewat Xendit.
Akun GitHub yang sudah terhubung ke Dalang.io. Ini cukup dilakukan sekali, lewat login GitHub di dashboard.
Repository dengan Dockerfile di folder paling atas (root). Namanya harus persis Dockerfile, dengan huruf D besar, tanpa ekstensi. Dockerfile yang ada di subfolder tidak dibaca.
Image dasar berbasis Alpine. Ini yang paling sering terlewat, dijelaskan di bawah.
Aplikasi yang mendengarkan di satu port (yang kamu tulis di EXPOSE).

Kenapa harus Alpine?

Aplikasi dijalankan sebagai container sistem ringan yang memakai tool Alpine Linux di dalamnya untuk jaringan dan menjalankan aplikasi. Image berbasis Debian atau Ubuntu tetap bisa dibuild, tetapi tidak bisa menyala. Jadi pilih varian -alpine:

Bahasa	Gunakan	Hindari
Node.js	`node:22-alpine`	`node:22`, `node:22-slim`
Python	`python:3.12-alpine`	`python:3.12`, `python:3.12-slim`
PHP	`php:8.3-cli-alpine`	`php:8.3-apache`
Go	build di `golang:1.21-alpine`, jalankan di `alpine:latest`	`golang` biasa sebagai image akhir

Kalau pustaka yang kamu pakai butuh paket sistem, pasang dengan apk add di Dockerfile.

Contoh Dockerfile

Semua contoh di bawah bisa kamu lihat dan salin dari repository publik kami: example-app-go, example-app-php, dan example-app-fastapi.

Node.js

FROM node:22-alpine
WORKDIR /app
COPY package*.json ./
RUN npm ci --omit=dev
COPY . .
EXPOSE 3000
CMD ["node", "server.js"]

Go (multi-stage, hasil akhir kecil)

FROM golang:1.21-alpine AS builder
WORKDIR /app
COPY go.mod ./
COPY . .
RUN CGO_ENABLED=0 GOOS=linux go build -o main .

FROM alpine:latest
WORKDIR /app
COPY --from=builder /app/main .
EXPOSE 3000
CMD ["./main"]

PHP

FROM php:8.3-cli-alpine
WORKDIR /app
COPY . /app
EXPOSE 8000
CMD ["php", "-S", "0.0.0.0:8000", "-t", "/app"]

Python (FastAPI)

FROM python:3.12-alpine
WORKDIR /app
RUN pip install fastapi "uvicorn[standard]"
COPY main.py .
EXPOSE 8000
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

Dua hal yang berlaku untuk semua bahasa:

Aplikasi harus mendengarkan di 0.0.0.0, bukan hanya 127.0.0.1, supaya bisa dijangkau dari luar container.
Tulis EXPOSE dengan port yang benar-benar dipakai aplikasi. Dari situlah port terdeteksi saat kamu membuat aplikasi.

Langkah deploy di dashboard

Buka Services, lalu Create, dan pilih App Hosting dari GitHub.
Pilih repository. Daftarnya memuat semua repository yang bisa diakses akun GitHub-mu, dan ada kolom pencarian.
Pilih branch. Dashboard memeriksa apakah ada Dockerfile di branch itu dan memberi tahu hasilnya. Tanpa Dockerfile, kamu tidak bisa lanjut.
Cek port. Port terisi otomatis dari EXPOSE dan diberi tanda “Terdeteksi dari Dockerfile”. Kalau Dockerfile-mu tidak punya EXPOSE, isi sendiri port yang didengarkan aplikasimu.
Isi environment variables jika perlu, misalnya DATABASE_URL atau kunci API. Ini opsional. Variabel PORT sudah diatur otomatis sesuai port di atas.
Pilih periode dan cara bayar. Satu bulan Rp 25.000, atau satu tahun Rp 300.000 yang sudah termasuk custom domain gratis. Harga belum termasuk PPN 11%, jadi totalnya Rp 27.750 per bulan atau Rp 333.000 per tahun. Dashboard menampilkan total akhir sebelum kamu mengonfirmasi.
Tinjau dan buat. Setelah pembayaran berhasil, build dimulai otomatis dan kamu dibawa ke halaman detail aplikasi.

Tunggu status berubah dari Building menjadi Running. Alamat aplikasimu ada di tab Overview, pada bagian Deployment Info.

Paket standar memberi 1 core CPU, RAM 128 MiB, dan penyimpanan 2 GiB untuk container aplikasi.

Build ulang otomatis setiap push

Saat aplikasi dibuat, Dalang.io memasang webhook di repository-mu. Mulai saat itu:

Kamu git push ke branch yang dipilih.
GitHub memberi tahu Dalang.io.
Dalang.io mengambil kode terbaru, membangun ulang image dari Dockerfile-mu, lalu mengganti container lama dengan yang baru.

Beberapa hal yang perlu kamu tahu:

Build ulang hanya berjalan selama langganan aktif.
Setiap build memakan waktu beberapa menit. Saat container diganti, aplikasi sempat tidak tersedia sebentar.
Kamu bisa memicu build tanpa push lewat tombol Rebuild di halaman detail.
Perkembangan build bisa dilihat di tab Build Logs. Kalau build gagal, penyebabnya ada di sana.

Mengelola aplikasi setelah online

Halaman detail aplikasi punya beberapa tab:

Tab	Gunanya
Overview	Status, spesifikasi, alamat aplikasi, dan info langganan
Terminal	Shell langsung ke container aplikasi untuk memeriksa sesuatu
Environment	Mengubah port dan environment variables
Build Logs	Riwayat build dan log lengkapnya
Running Logs	Log aplikasi yang sedang berjalan
Access & network	Domain dan akses

Mengubah environment variables

Buka tab Environment, tambah, ubah, atau hapus variabel, lalu pilih Save and rebuild. Variabel yang disimpan dipakai mulai build berikutnya. Aplikasi yang sedang berjalan tidak berubah sebelum di-rebuild, karena itu tombol Save and rebuild menyimpan dan langsung membangun ulang. Nilai variabel disamarkan sampai kamu memilih Show values.

Mengubah port

Port juga diatur di tab Environment. Port awal diambil dari EXPOSE, dan ikut berubah saat kamu mengganti EXPOSE di Dockerfile, selama kamu belum menetapkan port lain secara manual. Kalau kamu sudah mengisi port sendiri, port itu tidak akan diganti otomatis. Log build memberi peringatan bila EXPOSE atau variabel PORT tidak sama dengan port yang dipakai. Perubahan port juga berlaku mulai build berikutnya.

Aplikasi ini stateless

Container dibangun ulang dari Dockerfile pada setiap build. File yang ditulis aplikasi ke disk container akan hilang saat build berikutnya. Simpan data di tempat lain:

Database di container Dalang.io (PostgreSQL, MySQL, MariaDB, atau Redis), lalu sambungkan lewat environment variable.
Layanan penyimpanan eksternal untuk berkas unggahan.

Kalau ada yang tidak berjalan

Gejala	Penyebab yang paling umum	Yang dilakukan
Tidak bisa melanjutkan di langkah repository	Tidak ada `Dockerfile` di root branch itu	Tambahkan, namanya persis `Dockerfile`, lalu pilih branch yang benar
Build gagal	Kesalahan di Dockerfile atau kodenya	Baca tab Build Logs dari bawah
Build berhasil tetapi aplikasi tidak menyala	Image dasar bukan Alpine	Ganti ke varian `-alpine`
Aplikasi “Running” tetapi halaman error 502	Aplikasi mendengarkan di port yang berbeda dari port aplikasi, atau hanya di `127.0.0.1`	Samakan port di tab Environment, dan dengarkan di `0.0.0.0`
Perubahan environment tidak terasa	Belum di-rebuild	Pilih Save and rebuild atau tombol Rebuild
Data hilang setelah build	Aplikasi menyimpan data di disk container	Pindahkan ke database atau penyimpanan eksternal
Push tidak memicu build	Branch yang di-push bukan branch aplikasi, atau langganan sudah berakhir	Cek branch di Deployment Info dan masa aktif langganan

Ringkasannya

Siapkan Dockerfile di root repository, dengan image dasar Alpine, EXPOSE yang benar, dan aplikasi yang mendengarkan di 0.0.0.0.
Hubungkan GitHub sekali, lalu buat aplikasi di Create → App Hosting dari GitHub.
Setiap git push ke branch aplikasi membangun ulang aplikasi otomatis.
Ubah environment variables dan port di tab Environment, lalu rebuild.
Anggap container stateless: data penting disimpan di luar container.

Siap mencoba? Buat aplikasi dari GitHub sekarang.