Bikin Dev Environment Reproducible dengan Nix Flakes

by Marcus Chen
Bikin Dev Environment Reproducible dengan Nix Flakes

Kamu pernah nggak, habis ganti laptop atau masuk ke server baru, terus npm install jalan tapi app-nya tetap error? Atau lebih parah: di mesin kamu works fine, tapi di mesin teman satu tim langsung meledak dengan error GLIBC_2.34 not found?

Ini bukan masalah skill. Ini masalah environment yang nggak reproducible.

Solusi konvensionalnya biasanya Docker. Tapi Docker buat dev environment itu overkill untuk solo engineer—kamu harus maintain Dockerfile, rebuild image tiap ada dependency baru, dan kadang volume mount-nya bikin IDE susah detect path. Ada cara yang lebih elegan: Nix Flakes.


Apa Itu Nix Flakes dan Kenapa Beda

Nix adalah package manager yang beda dari apt, brew, atau npm. Setiap package di Nix di-install di path unik berdasarkan hash dari semua input-nya—artinya dua versi package yang berbeda bisa coexist tanpa konflik, dan build yang sama akan selalu menghasilkan output yang sama di mesin mana pun.

Flakes adalah fitur Nix yang membungkus semua ini dalam satu file flake.nix dengan lockfile flake.lock. Mirip package.json + package-lock.json, tapi untuk seluruh dev environment kamu—bukan cuma Node packages, tapi juga versi Node-nya sendiri, PostgreSQL, Redis, bahkan environment variable.

Yang bikin gue akhirnya pindah ke Nix Flakes:

  • Reproducible: flake.lock mengunci hash exact dari setiap dependency. Tidak ada lagi "works on my machine".
  • Per-project isolation: setiap project punya environment sendiri, tidak saling kontaminasi.
  • Declarative: satu file teks yang bisa di-commit ke Git.
  • Tidak perlu Docker: kamu kerja langsung di host OS, IDE-mu happy, path-nya normal.

Install Nix Dulu

Kalau kamu di Linux atau macOS, install Nix dengan Determinate Systems installer—ini lebih reliable dari official installer dan sudah enable Flakes by default:

curl --proto '=https' --tlsv1.2 -sSf -L https://install.determinate.systems/nix | sh -s -- install

Setelah install, restart terminal, lalu verifikasi:

nix --version
# nix (Nix) 2.18.x

Kalau kamu pakai NixOS, Flakes sudah built-in. Skip bagian ini.


Bikin flake.nix Pertama untuk Project Node.js

Misalnya kamu punya project Express.js yang butuh Node 20, PostgreSQL 15, dan pnpm. Tanpa Nix, kamu harus install semua ini manual dan berharap versinya cocok.

Buat file flake.nix di root project:

{
  description = "Express API dev environment";

  inputs = {
    nixpkgs.url = "github:NixOS/nixpkgs/nixos-24.05";
    flake-utils.url = "github:numtide/flake-utils";
  };

  outputs = { self, nixpkgs, flake-utils }:
    flake-utils.lib.eachDefaultSystem (system:
      let
        pkgs = nixpkgs.legacyPackages.${system};
      in
      {
        devShells.default = pkgs.mkShell {
          buildInputs = [
            pkgs.nodejs_20
            pkgs.nodePackages.pnpm
            pkgs.postgresql_15
            pkgs.httpie        # buat testing endpoint
          ];

          shellHook = ''
            echo "Node: $(node --version)"
            echo "pnpm: $(pnpm --version)"
            echo "PostgreSQL: $(psql --version)"

            # Setup local postgres data dir kalau belum ada
            export PGDATA="$PWD/.postgres"
            export PGHOST="$PGDATA"
            export DATABASE_URL="postgresql://localhost/myapp_dev"

            if [ ! -d "$PGDATA" ]; then
              initdb --no-locale --encoding=UTF8
              echo "PostgreSQL initialized di $PGDATA"
            fi
          '';
        };
      }
    );
}

Sekarang masuk ke dev environment:

nix develop

Pertama kali akan download semua dependencies—bisa beberapa menit tergantung koneksi. Tapi setelah itu, di mesin mana pun yang punya Nix, nix develop akan menghasilkan environment yang identik.

Output yang kamu lihat:

Node: v20.11.0
pnpm: 8.15.4
PostgreSQL: psql (PostgreSQL) 15.6

Keluar dari shell dengan exit atau Ctrl+D. Environment hilang dari PATH, tapi tidak di-uninstall—Nix cache-nya tetap ada.


Jalankan PostgreSQL Lokal Tanpa Docker

Ini bagian yang paling gue suka. Daripada docker run postgres, kita jalankan PostgreSQL langsung di host, tapi terisolasi per-project via PGDATA.

Masih di dalam nix develop, jalankan:

# Start postgres di background
pg_ctl start -l "$PGDATA/postgres.log"

# Buat database
createdb myapp_dev

# Masuk ke psql
psql myapp_dev

Stop-nya:

pg_ctl stop

Karena PGDATA di-set ke .postgres di dalam project folder, setiap project punya instance PostgreSQL sendiri. Tidak ada port conflict, tidak ada shared state antar project.

Gotcha: Tambahkan .postgres/ ke .gitignore-mu. Data PostgreSQL tidak perlu di-commit.

echo ".postgres/" >> .gitignore

Tambah direnv Biar Otomatis

Masuk-keluar nix develop manual itu cukup menyebalkan kalau kamu sering berpindah project. Solusinya: direnv.

direnv otomatis load/unload environment variable dan shell hooks saat kamu cd ke direktori project.

Install direnv:

# macOS
brew install direnv

# Ubuntu/Debian
apt install direnv

Tambahkan hook ke shell config kamu:

# Untuk bash (~/.bashrc)
eval "$(direnv hook bash)"

# Untuk zsh (~/.zshrc)
eval "$(direnv hook zsh)"

Buat file .envrc di root project:

use flake

Lalu allow:

direnv allow

Sekarang setiap kali kamu cd ke folder project, environment langsung aktif. cd keluar, environment hilang. Tidak perlu nix develop manual lagi.

Gotcha: Pertama kali direnv allow setelah edit flake.nix, kamu harus run direnv reload atau cd keluar-masuk lagi.


Struktur Project Setelah Setup

Berikut struktur yang gue pakai untuk project Express:

my-express-api/
├── .envrc              # direnv config: "use flake"
├── .gitignore          # include .postgres/
├── flake.nix           # dev environment declaration
├── flake.lock          # lockfile — COMMIT INI
├── package.json
├── pnpm-lock.yaml
└── src/
    └── index.js

Yang penting: commit flake.lock. File ini yang memastikan semua orang (atau kamu di mesin lain) mendapat versi yang sama persis. Jangan .gitignore file ini.


Contoh Nyata: Tambah Redis ke Environment

Misalnya project berkembang dan sekarang butuh Redis untuk session store. Cukup edit flake.nix:

buildInputs = [
  pkgs.nodejs_20
  pkgs.nodePackages.pnpm
  pkgs.postgresql_15
  pkgs.redis          # tambah ini
  pkgs.httpie
];

shellHook = ''
  # ... existing hooks ...

  export REDIS_URL="redis://localhost:6379"

  # Auto-start redis kalau belum jalan
  if ! redis-cli ping &>/dev/null; then
    redis-server --daemonize yes --logfile "$PWD/.redis.log"
    echo "Redis started"
  fi
'';

Keluar dari shell, masuk lagi:

exit
nix develop

Nix download Redis, lock versinya di flake.lock, dan Redis langsung jalan via shellHook. Teman tim kamu tinggal git pull dan nix develop—tidak perlu install Redis manual.


Gotcha yang Perlu Kamu Tahu

1. Download pertama itu lama. Nix harus download binary dari cache. Koneksi internet bagus membantu, tapi kalau kamu di jaringan lambat, pertimbangkan untuk setup Nix binary cache lokal dengan attic atau cachix. Untuk penggunaan sehari-hari setelah initial download, sangat cepat.

2. macOS dan Linux punya packages yang sedikit beda. Kadang nama package atau availability-nya berbeda antar platform. flake-utils.lib.eachDefaultSystem menangani ini, tapi kalau ada package yang platform-specific, kamu perlu conditional logic:

buildInputs = [
  pkgs.nodejs_20
] ++ pkgs.lib.optionals pkgs.stdenv.isDarwin [
  pkgs.darwin.apple_sdk.frameworks.Security
];

3. Beberapa npm packages butuh native dependencies. Kalau node-gyp error, kamu perlu tambah build tools:

buildInputs = [
  pkgs.nodejs_20
  pkgs.python3    # node-gyp butuh ini
  pkgs.gcc
  pkgs.gnumake
];

4. VS Code dan IDE lain. Kalau pakai VS Code, install extension mkhl.direnv. Extension ini otomatis detect environment dari direnv sehingga IntelliSense, linting, dan formatter-mu pakai binary yang benar dari Nix shell.


Yang Gue Lakuin Sekarang

Semua project gue—baik yang pakai Node, Python, maupun Go—sekarang punya flake.nix masing-masing. Waktu onboarding project lama di mesin baru turun dari "satu sore penuh" jadi sekitar 15 menit (mostly waiting for Nix download).

Langkah lanjutan yang worth di-explore:

  1. process-compose: tool untuk run multiple services (postgres, redis, worker) sekaligus dari satu config file, bisa diintegrasikan ke shellHook.
  2. Home Manager: kalau mau Nix-ify seluruh dotfiles dan user environment kamu, bukan cuma per-project.
  3. Nix binary cache dengan attic: self-host cache server biar download pertama lebih cepat, terutama kalau tim kamu mulai pakai Nix juga.

Coba mulai dari satu project yang paling sering kamu setup ulang. Bikin flake.nix-nya, commit flake.lock-nya, dan rasakan bedanya saat harus setup di mesin baru.