devbox.id

Developer tools, self-hosted dev environments, productivity for solo engineers

Devbox: Self-Hosted Development Tools di Laptopmu

by Marcus Chen
Devbox: Self-Hosted Development Tools di Laptopmu

Environment Dev Bentrok Lagi, Capek?

Kamu lagi ngerjain dua proyek sekaligus — satu pakai Node 16, satunya butuh Node 20. Atau Python 3.9 vs 3.11. Tiap kali pindah proyek, kamu nvm use dulu, ganti virtualenv, terus lupa aktifin yang bener, dan boom — error aneh yang buang 30 menit buat debug.

Itu masalah klasik yang bikin frustrasi. Solusi selama ini? Docker. Tapi Docker bawa overhead sendiri: image gede, daemon yang makan RAM, dan docker-compose.yml yang makin lama makin kompleks cuma buat development environment.

Devbox menawarkan pendekatan lain. Ini adalah devbox self-hosted development tools yang jalan di atas Nix package manager — isolated, reproducible, dan nggak butuh container sama sekali.

Devbox Itu Apa, Sebenernya?

Devbox adalah CLI tool buatan Jetpack.io yang nge-wrap Nix supaya developer biasa bisa pakai tanpa harus ngerti Nix dari nol. Konsepnya simpel:

  • Setiap proyek punya devbox.json — semacam package.json-nya development environment.
  • Kamu devbox shell → masuk ke isolated shell dengan tools yang udah didefinisiin.
  • Keluar dari shell → environment balik bersih, nggak polusi sistem.

Ini bukan virtual machine, bukan container. Ini isolated shell environment yang pakai Nix store di /nix/store. Jauh lebih ringan dari Docker untuk use case development.

Install Devbox

Satu command, jalan di Linux dan macOS:

curl -fsSL https://get.jetpack.io/devbox | bash

Script ini akan install Nix dulu kalau belum ada, terus install devbox binary-nya. Prosesnya makan 2–5 menit tergantung koneksi.

Verifikasi:

devbox version
# Output: 0.x.x

Gotcha #1: Di macOS dengan SIP aktif, installer Nix butuh restart terminal setelah selesai. Kalau devbox command not found, tutup terminal dan buka lagi.

Setup Proyek Pertama: Node + PostgreSQL

Misalnya kamu mau setup environment untuk proyek Express.js yang butuh Node 20 dan PostgreSQL 15 — tanpa install global, tanpa Docker.

mkdir proyek-express && cd proyek-express
devbox init

Ini bikin devbox.json kosong:

{
  "packages": [],
  "shell": {
    "init_hook": null,
    "scripts": {}
  }
}

Tambah packages yang kamu butuh:

devbox add nodejs@20 postgresql@15 git

Devbox langsung pull dari Nix package registry. devbox.json sekarang jadi:

{
  "packages": [
    "nodejs@20",
    "postgresql@15",
    "git"
  ],
  "shell": {
    "init_hook": [
      "echo 'Environment siap. Node: $(node -v), PG: $(psql --version)'"
    ],
    "scripts": {
      "start": "node index.js",
      "db:init": "initdb -D .devbox/pgdata && pg_ctl -D .devbox/pgdata -l .devbox/pg.log start"
    }
  }
}

Masuk ke environment:

devbox shell

Sekarang cek versi:

node -v   # v20.x.x
psql --version  # psql (PostgreSQL) 15.x
which node  # /nix/store/....-nodejs-20/bin/node

Node 20 dan PostgreSQL 15 tersedia di shell ini. Keluar dari shell, node -v balik ke versi global sistem kamu (atau not found kalau emang nggak install global).

Jalanin PostgreSQL Lokal Tanpa Docker

Ini bagian yang paling gue suka. Biasanya untuk dev database, orang langsung reach for Docker. Dengan devbox, PostgreSQL bisa jalan langsung sebagai proses lokal.

Masih di dalam devbox shell, inisialisasi database:

# Inisialisasi data directory
initdb -D .devbox/pgdata

# Start PostgreSQL
pg_ctl -D .devbox/pgdata -l .devbox/pg.log start

# Buat database untuk proyek
createdb myapp_dev

# Masuk ke psql
psql myapp_dev

Database jalan di .devbox/pgdata — di dalam folder proyek. Nggak ada daemon global, nggak ada port conflict sama PostgreSQL lain yang mungkin jalan di sistem.

Stop database:

pg_ctl -D .devbox/pgdata stop

Gotcha #2: Data directory .devbox/pgdata jangan di-commit ke Git. Tambah ke .gitignore:

.devbox/pgdata/
.devbox/pg.log

devbox.json Sebagai Kontrak Environment

Ini yang bikin devbox powerful buat tim atau kalau kamu sendiri kerja di beberapa mesin.

Commit devbox.json dan devbox.lock ke Git. Siapapun yang clone repo dan jalanin devbox shell akan dapat exact same versions dari semua tools — down to the patch version.

git add devbox.json devbox.lock
git commit -m "chore: add devbox environment config"

Kalau teman kamu pull dan jalanin devbox shell, Nix akan download exact same packages dari cache. Nggak ada lagi "di laptop gue jalan kok" karena environment-nya literally sama.

Bandingkan ini sama .nvmrc yang cuma pin Node version tapi nggak pin tools lain, atau Dockerfile yang butuh Docker daemon dan build time.

Integrasi direnv: Auto-Activate Environment

Masuk manual ke devbox shell tiap kali buka folder proyek itu ribet. Devbox punya integrasi dengan direnv yang bisa auto-activate environment.

Install direnv dulu:

# macOS
brew install direnv

# Ubuntu/Debian
apt install direnv

Hook direnv ke shell kamu. Tambah ke ~/.bashrc atau ~/.zshrc:

eval "$(direnv hook bash)"   # kalau pakai bash
# atau
eval "$(direnv hook zsh)"    # kalau pakai zsh

Di folder proyek, generate .envrc:

devbox generate direnv --print-envrc > .envrc
direnv allow

Sekarang tiap kamu cd ke folder proyek, environment langsung aktif. cd keluar, environment nonaktif. Ini yang gue pakai sehari-hari — zero friction.

Gotcha #3: Pertama kali setup direnv, kamu harus jalanin direnv allow di setiap proyek. Ini by design — security feature supaya .envrc arbitrary nggak bisa auto-execute.

Scripts di devbox.json: Ganti Makefile

Devbox punya fitur scripts yang bisa jadi pengganti sederhana untuk Makefile atau npm scripts untuk orchestrate development tasks.

Contoh devbox.json yang lebih lengkap:

{
  "packages": [
    "nodejs@20",
    "postgresql@15",
    "redis@7"
  ],
  "shell": {
    "init_hook": [
      "export DATABASE_URL=postgresql://localhost/myapp_dev",
      "export REDIS_URL=redis://localhost:6379"
    ],
    "scripts": {
      "dev": "node --watch index.js",
      "db:start": "pg_ctl -D .devbox/pgdata -l .devbox/pg.log start",
      "db:stop": "pg_ctl -D .devbox/pgdata stop",
      "db:reset": "dropdb myapp_dev && createdb myapp_dev && node migrate.js",
      "redis:start": "redis-server --daemonize yes --logfile .devbox/redis.log",
      "services:start": "devbox run db:start && devbox run redis:start"
    }
  }
}

Jalanin script:

devbox run services:start
devbox run dev

Environment variables di init_hook otomatis tersedia di semua scripts. Nggak perlu .env file untuk development config yang nggak sensitif.

Perbandingan: Devbox vs Docker untuk Dev Environment

Gue nggak bilang devbox selalu lebih baik dari Docker. Ini konteks yang jelas:

Pakai devbox kalau:

  • Kamu solo developer atau tim kecil yang butuh isolated dev environment
  • Proyek butuh multiple language versions (Node + Python + Go dalam satu repo)
  • Kamu mau environment yang reproducible tanpa overhead container
  • Deployment target kamu bukan container (VPS bare metal, misalnya)

Tetap pakai Docker kalau:

  • Kamu butuh test behavior aplikasi di dalam container (karena production pakai Docker)
  • Tim besar dengan workflow yang udah established di sekitar Docker Compose
  • Kamu butuh network isolation antar services yang ketat
  • Ada dependency yang nggak ada di Nix packages (jarang, tapi ada)

Untuk devbox self-hosted development tools di laptop atau VPS development pribadi, devbox menang di simplicity dan resource usage.

Setup di VPS untuk Remote Development

Bonus: devbox juga works great di VPS buat remote dev setup. Install sama seperti lokal:

# Di VPS (Ubuntu 22.04)
curl -fsSL https://get.jetpack.io/devbox | bash

# Clone repo
git clone https://github.com/kamu/proyek.git
cd proyek

# Langsung dapat environment yang sama
devbox shell

Kombinasiin ini sama VS Code Remote SSH atau JetBrains Gateway, dan kamu punya full dev environment di VPS yang bisa diakses dari mana aja — konsisten sama environment lokal karena devbox.lock di-commit.

Ini yang gue lakuin buat proyek-proyek yang butuh resource lebih dari laptop: dev di VPS 4 core / 8GB RAM, laptop cuma jadi terminal.

Yang Gue Lakuin Sekarang

Semua proyek baru gue mulai dengan devbox init. Workflow-nya:

  1. devbox init di root proyek
  2. devbox add semua tools yang dibutuhin
  3. Setup init_hook untuk environment variables development
  4. Setup scripts untuk common tasks (db:start, dev, test)
  5. Commit devbox.json dan devbox.lock
  6. Setup direnv supaya auto-activate

Proyek lama yang masih pakai Docker Compose untuk dev environment, gue migrate bertahap — mulai dari ganti service database dulu, terus language runtime.

Kalau kamu mau coba, mulai dari proyek baru yang kecil dulu. Jalanin devbox add nodejs@20 dan rasain bedanya. Nix package registry punya hampir semua tools yang developer butuhkan — dari ffmpeg sampai kubectl sampai awscli.

Cek available packages di search.nixos.org — ini jadi referensi utama kamu buat nyari nama package yang tepat sebelum devbox add.