DEV Community: Dimas Rangga

Nix Series: Security Hardening

Dimas Rangga — Mon, 15 Jun 2026 05:13:48 +0000

Pada series ini kita akan melakukan dasar konfigurasi security di NixOS. Konfigurasi yang dilakukan cukup standar, seperti: ssh, firewall, dan fail2ban.

SSH (Secure Shell)

Di series nix installation kita melakukan konfigurasi sederhana untuk ssh.

services.openssh = {
  enable = true;
  ports = [
    222
  ];
  settings = {
    PermitRootLogin = "no";
  };
};

Kita akan memindahkan semua konfigurasi security hardening disebuah file security.nix. Buat directory baru modules dan buat file security.nix.

# security.nix
{
  config,
  pkgs,
  lib,
  ...
}:
{
  services.openssh = {
    enable = true;
    ports = [
      222
    ];
    settings = {
      AllowUsers = [ "vboxuser" ];
      PermitRootLogin = "no";
      LogLevel = "VERBOSE";
    };
  };

Enable Firewall

Dengan menggunakan firewall kita bisa memfilter traffic yang masuk ke VirtualBox. Edit file security.nix dan tambahkan konfigurasi ini:

networking.firewall = {
  enable = true;
  allowedTCPPorts = [
    80
    222
    443
  ];
  allowPing = true;
};

Berbeda dengan OS lainnya, di NixOS saat enable firewall secara default akan melakukan restriction terhadap incoming network.

Setup Fail2ban

Fail2ban adalah salah satu tools yang digunakan untuk memblokir IP address jika IP tersebut mencoba authentication ke komputer dan gagal sebanyak rules yang sudah kita terapkan pada fail2ban.

Tambahkan konfigurasi berikut di security.nix:

services.fail2ban = {
  enable = true;
  maxretry = 3;
  bantime = "1h";
  jails = {
    sshd.settings = {
      port = "222";
      mode = "aggressive";
    };
  };
};

Mode di fail2ban ada 3:

normal: hanya mendeteksi failed password attempts yang eksplisit
aggressive: mendeteksi lebih banyak pattern seperti invalid user, connection reset, authentication failure dari berbagai metode
extra: paling broad, termasuk pattern yang lebih jarang muncul

User Configuration

Saat ini konfigurasi user kita ada di configuration.nix, kita akan pindah konfigurasi user ke modules/users.nix:

# users.nix
{...}:
{
  users.users.vboxuser = {
    isNormalUser = true;
    extraGroups = [ "wheel" ]; # Enable ‘sudo’ for the user.
  };
}

Update `configuration.nix`

Tambahkan users.nix dan security.nix di configuration.nix dan hapus konfigurasi user dan ssh saat ini:

{
  config,
  lib,
  pkgs,
  ...
}:

{
  imports = [
    ./hardware-configuration.nix

    ./modules/security.nix
    ./modules/users.nix
  ];

  # omited
  ...
}

Setelah kita memisahkan konfigurasi user dan security, struktur file akan terlihat seperti ini:

├── configuration.nix
├── flake.lock
├── flake.nix
├── hardware-configuration.nix
├── home.nix
└── modules
    ├── security.nix
    └── users.nix

Kemudian rebuild system dengan menggunakan rebuild (karena di series sebelumnya kita sudah menambahkan alias)

Dari hasil konfigurasi yang kita lakukan, kita bisa validasi konfigurasi fail2ban di /etc/fail2ban/jail.local

Jika menggunakan OS seperti Ubuntu, kita memerlukan copy paste jail.conf -> jail.local lalu menuliskan kebutuhan konfigurasinya. Di NixOS kita tidak perlu melakukan hal tersebut dan di jail.local sudah terkonfigurasi sesuai yang kita deklarasikan pada security.nix

Testing Brute Force

Untuk testing, pertama kita butuh disconnected terlebih dahulu dari ssh saat ini:

exit

Kemudian coba ssh ke VirtualBox dan masukkan invalid password sebanyak tiga kali:

ssh -p 2222 vboxuser@127.0.0.1

Hasil seperti gambar diatas menandakan bahwa IP dari komputer sudah diblokir oleh fail2ban yang ada di VirtualBox. Kita bisa cek di VirtualBox secara langsung.

Nah untuk melakukan unban, kita bisa melakukan cara seperti ini:

# ubah IP address berdasarkan IP yang di ban
sudo fail2ban-client set sshd unbanip {IP Address}

Bonus: Secure SSH with Key Pairs

Ada cara lain untuk meningkatkan security, yaitu dengan cara menon-aktifkan password authentication pada ssh

1. Generate SSH key

Generate ssh key pada komputer (bukan di VirtualBox):

ssh-keygen -t ed25519 -C "vboxuser"

By default, ssh key akan digenerate di ~/.ssh dan key yang akan kita pasang ke users di VirtualBox adalah public key. Kita bisa salin public key dari file yang berekstensi .pub.

2. Enable SSH Agent

# enable ssh agent
eval $(ssh-agent -s)

# attach ssh key
ssh-add ~/.ssh/id_ed25519 # sesuaikan dengan nama private key

Dengan cara ini kita melakukkan attachment ssh key ke memory, sehingga kita hanya perlu input password ssh satu kali saja.

3. Update `users.nix`

Lakukan ssh ke VirtualBox:

ssh -p 2222 vboxuser@127.0.0.1

Kemudian update users.nix yang ada di ~/nix/modules:

{...}:
{
  users.users.vboxuser = {
    isNormalUser = true;
    extraGroups = [ "wheel" ]; # Enable ‘sudo’ for the user.

    openssh.authorizedKeys.keys = [
      "ssh-ed25519 AAAA... your-public-key-here"
    ];
  };
}

4. Update `security.nix`

Tambahkan konfigurasi ini pada security.nix:

services.openssh = {
  enable = true;
  ports = [
    222
  ];
  settings = {
    AllowUsers = [ "vboxuser" ];
    KbdInteractiveAuthentication = false;
    PasswordAuthentication = false;
    PermitRootLogin = "no";
  };
}

Rebuild system dan lakukan relogin ke VirtualBox.

Penutup

Konfigurasi yang telah kita lakukan mencakup tiga lapisan pertahanan dasar: SSH hardening untuk membatasi akses, firewall untuk memfilter traffic, dan Fail2ban untuk mencegah brute force. Namun dari ketiganya, beralih ke SSH key pairs adalah langkah yang paling signifikan, karena sekalipun IP rotation bisa mengakali Fail2ban, private key yang kita simpan pada komputer pribadi jauh lebih sulit untuk dicuri atau ditebak. Security bukan tentang satu solusi, melainkan tentang berlapis-lapis perlindungan yang saling melengkapi.

References

Nix Series: Basic Nix Language

Dimas Rangga — Fri, 12 Jun 2026 09:57:09 +0000

Pada series sebelumnya, kita sudah melakukan instalasi nix di VirtualBox dan setup SSH agar dapat diakses diluar VirtualBox. Sebelum kita lanjut untuk melakukan konfigurasi system lagi, kita butuh mengetahui bagaimana syntax dalam menulis program Nix dan di artikel ini kita akan mempelajari dasar syntax-nya.

Nix Language

Nix adalah purely functional language yang lazy-evaluated, digunakan untuk mengkonfigurasi Nix package manager dan NixOS. Karakteristik utama:

Purely functional: sebuah function hanya bisa mengembalikan nilai berdasarkan inputnya, tidak bisa mengubah variabel di luar scope-nya (no side effects), dan tidak ada variabel yang bisa diubah setelah didefinisikan (no mutation). Kalau kamu familiar dengan const di beberapa bahasa pemrograman, semua variabel di Nix berperilaku seperti itu.
Lazy evaluation: Nix tidak menghitung nilai suatu ekspresi sampai nilai itu benar-benar dibutuhkan. Ini artinya kamu bisa mendefinisikan ribuan package di nixpkgs tanpa semuanya dievaluasi sekaligus. Hanya yang kamu gunakan saja yang akan diproses.
Semua adalah expression: tidak ada statement di Nix, setiap baris kode selalu menghasilkan sebuah nilai. if/else bukan statement seperti di bahasa pemrograman pada umumnya, melainkan expression yang harus mengembalikan nilai dari kedua cabangnya.
Tidak ada loops: karena variabel tidak bisa diubah, loop seperti for atau while tidak ada artinya di Nix. Sebagai gantinya, kamu menggunakan fungsi seperti map dan filter, atau rekursi untuk mengolah kumpulan data.

1. Basic Data Type

Konsep	JavaScript	Nix
String	`"hello"`	`"hello"`
Number	`42`, `3.14`	`42`, `3.14`
Boolean	`true`, `false`	`true`, `false`
Null	`null`	`null`
List	`[1, 2, 3]`	`[ 1 2 3 ]`
Object	`{ a: 1 }`	`{ a = 1; }`

⚠️ Perbedaan Penting

List di Nix menggunakan spasi sebagai pemisah, bukan koma

Attribute set menggunakan = bukan :, dan setiap entry diakhiri dengan ;

Nix

let
  name    = "Alice";
  age     = 30;
  scores  = [ 10 20 30 ];
  person  = { name = "Bob"; age = 25; };
in
  person

Javascript

const name   = "Alice";
const age    = 30;
const scores = [10, 20, 30];
const person = { name: "Bob", age: 25 };

2. String

Nix memiliki beberapa cara dalam mendifinisikan string:

# String biasa
"Hello, World"

# String multiline (menggunakan '' bukan backtick)
''
  Hello
  World
''

# String interpolation, menggunakan ${} seperti template literal di JS
let name = "Alice";
in "Hello, ${name}!"    # -> "Hello, Alice!"

3. let ... in (Variable Binding)

Nix tidak punya var/const/let seperti di JS. Sebagai gantinya, kamu pakai blok let ... in. Anggap saja ini sebagai blok yang punya scope dan mengembalikan sebuah nilai.

Nix:

# Keseluruhan ekspresi ini menghasilkan "Hello, Alice!"
let
  greeting = "Hello";
  name     = "Alice";
in
  "${greeting}, ${name}!"

4. Attribute Sets

let
  person = {
    name = "Alice";
    age  = 30;
  };
in
  person.name    # -> "Alice" (dot access, sama seperti JS!)

`rec` - Recursive Attribute Sets

Di JS, kamu bisa mereferensikan this.x di dalam sebuah object. Di Nix, gunakan rec:

# Tanpa rec, ini akan ERROR karena b tidak bisa melihat a
rec {
  a = 10;
  b = a * 2;   # -> 20  ✅
}

`with` - Membawa Attributes ke Scope Saat Ini

let person = { name = "Alice"; age = 30; };
in
  with person;
  "Name: ${name}, Age: ${toString age}"

5. Functions

Di Nix, semua function hanya menerima satu argumen. Untuk multiple argumen,.

Satu Argumen

let
  greet = name: "Hello, ${name}!";
in
  greet "Alice"    # -> "Hello, Alice!"
  #     ^^^^^^ tidak perlu tanda kurung untuk memanggil function!

Attribute Set sebagai Argumen (Destructured Params)

Cara ini cocok jika kamu memerlukan beberapa argument pada function

let
  greet = { name, age }: "I'm ${name}, ${toString age} years old";
in
  greet { name = "Alice"; age = 30; }

Default Argumen

let
  greet = { name, greeting ? "Hello" }: "${greeting}, ${name}!";
in
  greet { name = "Alice"; }   # -> "Hello, Alice!"

6. Conditionals

if/else di Nix bekerja berbeda dari JavaScript. Di JS, if adalah sebuah statement yang mengeksekusi blok kode. Di Nix, if adalah sebuah expression yang menghasilkan nilai, persis seperti ternary operator di JS.

let age = 20;
in
  if age >= 18 then "adult" else "minor"

ℹ️ if/else di Nix selalu butuh cabang else karena ini adalah expression yang harus menghasilkan nilai!

7. `inherit` - Shorthand untuk Attribute Sets

Mirip seperti shorthand property name di JS, { name } alih-alih menulis { name: name }.

let
  name = "Alice";
  age  = 30;
in {
  inherit name age;   # sama dengan: name = name; age = age;
}

8. `import` - Memisahkan File

# math.nix
{
  add = x: y: x + y;
  mul = x: y: x * y;
}

# main.nix
let
  math = import ./math.nix;
in
  math.add 3 4    # -> 7

Evaluating and Testing Nix Code

Setelah mengetahui syntaxnya, kamu bisa coba-coba untuk evaluate kode nix dengan nix tools berikut:

Tool	Kegunaan	Butuh file?
`nix repl`	Scratch pad interaktif, uji syntax secara langsung	Tidak
`nix eval --expr`	One-liner cepat dari terminal	Tidak
`nix-instantiate --eval`	Evaluasi file `.nix` standalone	Ya
`nix eval .#attr`	Inspeksi nilai output dari flake	Ya (flake)
`nix build` / `nix run`	Build dan jalankan package dari flake	Ya (flake)

Contoh penggunaan nix repl:

💡 Perintah berguna di dalam REPL

:q untuk keluar dari REPL

:l <nixpkgs> untuk load nixpkgs sehingga bisa akses pkgs.nodejs dll.

:t <expr> untuk melihat tipe dari sebuah ekspresi

:? untuk melihat semua perintah yang tersedia

Contoh evaluate nix file, buat default.nix:

let
  greeting = "Hello";
  name     = "Alice";
in
  "${greeting}, ${name}!"

evaluate dengan nix-instantiate --eval

Penutup

Setelah kita mengetahui syntax dasar nix, pada series selanjutnya kita akan melanjutkan konfigurasi security hardening

Nix Series: NixOS Installation

Dimas Rangga — Thu, 11 Jun 2026 08:14:12 +0000

Pada artikel ini kita akan memulai berinteraksi dengan nix dengan cara melakukan instalasi NixOS dengan menggunakan VirtualBox. Sebelum memulai instalasi, pastikan kamu sudah membaca series introduction nix terlebih dahulu, agar tau apa itu nix.

Prerequisite

Download NixOS iso di nixos official dan pilih Minimal ISO image, karena pada artikel ini akan menggunakan versi ISO tersebut
Download VirtualBox dan install

Setup VirtualBox

Buat virtual machine baru pada VirtualBox dengan pilih New
Pilih NixOS yang sudah didownload pada ISO image
VirtualBox sudah dibuat dengan disk minimal 20GB
Start VM yang sudah kita buat

Installation Step

1. Boot Live Environment

Saat pertama booting akan ada 2 pilihan NixOS, pilih yang LTS

Tampilan setelah booting ISO NixOS

Setelah berhasil boot ke live environment, masuk sebagai root terlebih dahulu

sudo su

Prompt akan berubah dari [nixos@nixos:~]$ menjadi [root@nixos:/home/nixos]#.

⚠️ Semua perintah partisi dan instalasi harus dijalankan sebagai root. Tanpa ini akan muncul error Permission denied.

2. Check Disk Information

lsblk

Disk VirtualBox biasanya terdeteksi sebagai /dev/sda. Pastikan sebelum lanjut karena perintah berikutnya akan menghapus semua isi disk.
Pastikan outputnya seperti ini:

NAME   MAJ:MIN RM  SIZE RO TYPE MOUNTPOINTS
sda      8:0    0   20G  0 disk
sr0     11:0    1  1.6G  0 rom  /iso

3. Disk Partition

Kita pakai parted dengan skema GPT + EFI:

parted /dev/sda -- mklabel gpt
parted /dev/sda -- mkpart primary 512MB 100%
parted /dev/sda -- mkpart ESP fat32 1MB 512MB
parted /dev/sda -- set 2 esp on

Penjelasan setiap perintah:

Perintah	Fungsi
`mklabel gpt`	Membuat partition table baru bertipe GPT (standar modern, pengganti MBR)
`mkpart primary 512MB 100%`	Membuat partisi root `/` dari 512MB sampai akhir disk
`mkpart ESP fat32 1MB 512MB`	Membuat EFI System Partition dari 1MB sampai 512MB, format FAT32
`set 2 esp on`	Memberi flag `esp` pada partisi ke-2 agar UEFI firmware mengenalinya sebagai boot partition

Layout akhir:

/dev/sda
├── sda1  (512MB → 100%)  = /      → ext4, sistem NixOS
└── sda2  (1MB   → 512MB) = /boot  → FAT32, bootloader EFI

📝 Pesan You may need to update /etc/fstab setelah setiap perintah adalah normal, bukan error.

Verifikasi hasil partisi:

lsblk

Harusnya muncul sda1 dan sda2 di bawah sda.

Kenapa parted dengan GPT + EFI?
Kenapa parted dengan Skema GPT + EFI? Karena parted lebih straightforward untuk ditulis sebagai langkah-langkah sequential.

Kenapa GPT, bukan MBR? Karena GPT (GUID Partition Table) adalah pengganti MBR (Master Boot Record) dan berikut adalah perbedaannya:

	MBR	GPT
Maks partisi	4 primary	128 partisi
Maks ukuran disk	2TB	9.4ZB
Pasangan firmware	BIOS/Legacy	UEFI
Ketahanan	Partition table hanya satu salinan	Ada backup partition table di akhir disk

Karena saat membuat VM baru secara default UEFI pada VirtualBox akan aktif dan skema GPT adalah pasangan naturalnya. UEFI secara teknis bisa booting dari MBR, tapi GPT adalah standar modern dan yang direkomendasikan untuk UEFI. Kamu bisa melihat pada settings dibagian system

4. Format Partition

Jalankan perintah berikut:

mkfs.ext4 -L nixos /dev/sda1
mkfs.fat -F 32 -n boot /dev/sda2

Flag -L dan -n memberikan label pada partisi. Label ini yang dipakai saat mounting (by-label) agar lebih readable dibanding UUID.

5. Mount Partition

mount /dev/disk/by-label/nixos /mnt
mkdir -p /mnt/boot
mount -o umask=077 /dev/disk/by-label/boot /mnt/boot

6. Generate Nix Configuration

nixos-generate-config --root /mnt

Perintah ini menghasilkan dua file:

/mnt/etc/nixos/
├── configuration.nix        # konfigurasi utama
└── hardware-configuration.nix  # auto-detected hardware

7. Edit Configuration

Ubah konfigurasi pada /mnt/etc/nixos/configuration.nix, kita bisa menggunakan nano atau vim

vim /mnt/etc/nixos/configuration.nix

Untuk proses instalasi saat ini, kita hanya edit seminimal mungkin.

{ config, pkgs, ... }:

{
  imports = [ ./hardware-configuration.nix ];

  # Boot loader — gunakan systemd-boot untuk UEFI
  boot.loader.systemd-boot.enable = true;
  boot.loader.efi.canTouchEfiVariables = true;

  # Networking
  networking.hostName = "nixos-server";
  networking.networkmanager.enable = true;

  # Timezone
  time.timeZone = "Asia/Jakarta";

  # User
  users.users.vboxuser = {
    isNormalUser = true;
    extraGroups = [ "wheel" ]; # wheel = akses sudo
    initialPassword = "qwerty123";
  };

  # Package dasar
  environment.systemPackages = with pkgs; [
    curl
    git
    neovim
    wget
  ];

  # SSH — penting untuk server
  services.openssh.enable = true;

  system.stateVersion = "25.11"; # sesuaikan dengan versi NixOS yang diinstall
}

8. Install NixOS

nixos-install

Saat proses instalasi, NixOS akan memberikan prompt input password.

⚠️ Password yang muncul saat prompt instalasi adalah password untuk root sedangkan password yang sudah kita deklarasikan pada configuration.nix dibagian initialPassword adalah password untuk vboxuser.

Setelah instalasi selesai, kita bisa melakukan reboot.

reboot

9. Post Installation

Setelah proses reboot selesai, kamu bisa login dengan user vboxuser dengan password yang sudah diberikan pada initialPassword

❄ Nix Flakes ❄

Flakes adalah fitur di Nix yang mengubah cara kita mendefinisikan dan berbagi konfigurasi Nix. Sebelum Flakes ada, konfigurasi NixOS bergantung pada Nix channels. Ini semacam subscription ke versi nixpkgs tertentu yang disimpan di sistem. Permasalahannya adalah channels tidak di-lock per project, jadi dua orang yang menjalankan konfigurasi yang sama bisa mendapat hasil berbeda karena versi nixpkgs tidak identik.

Dengan Flakes, setiap konfigurasi punya file flake.nix sebagai entry point yang mendefinisikan inputs (dependency seperti nixpkgs dan home-manager) dan outputs (hasil build seperti NixOS configuration). Semua input di-lock di file flake.lock, mirip seperti package-lock.json di Node.js atau go.sum di Go, sehingga siapapun yang pakai konfigurasi yang sama akan mendapat hasil yang identik.

flake.nix       → mendefinisikan dependency dan konfigurasi
flake.lock      → mengunci versi semua dependency (auto-generated)

Flakes juga membuat konfigurasi lebih portable dan tidak terikat ke /etc/nixos, bisa disimpan di mana saja termasuk di GitHub sebagai dotfiles.

ℹ️ Flakes masih berstatus "experimental" secara resmi, tapi sudah dipakai luas di komunitas Nix dan dianggap sebagai cara yang direkomendasikan untuk mengelola konfigurasi modern.

1. Enable Flakes

Aktifkan flakes dengan cara edit configuration.nix. Gunakan nano atau nvim untuk edit file.

nvim /etch/nixos/configuration.nix

Tambahkan baris ini:

  ...
  system.stateVersion = "25.11";

  # Enable flakes
  nix.settings.experimental-features = [
    "nix-command"
    "flakes"
  ];

Lalu apply sebagai default boot

nixos-rebuild switch

Setelah flakes aktif, kita bisa memindahkan konfigurasi NixOS dari root ke home dengan cara berikut:

cp -r /etc/nixos ~/
mv nixos nix
cd nix

Nah.. dengan ini kita tidak perlu membutuhkan root lagi untuk melakukan perubahan konfigurasi pada system NixOS kita.

2. Git Setup

Langkah selanjutnya adalah initialize git, karena nix flake hanya membaca file yang sudah ditambahkan pada git (git add).

git init
git config --global user.email "johndoe@example.com" # gunakan emailmu
git config --global user.email "johndoe" # gunakan user gitmu

Kamu juga bisa setup remote origin dan dipush ke githubmu

3. Setup Flake

Tambahkan file flake.nix

touch flake.nix

Lalu deklarasikan minimum konfigurasi berikut

{
  description = "NixOS Server Configuration";

  inputs = {
    nixpkgs.url = "github:NixOS/nixpkgs/nixos-25.11";
  };

  outputs =
    {
      self,
      nixpkgs,
    }:
    {
      # nixos-server adalah hostname
      nixosConfigurations.nixos-server = nixpkgs.lib.nixosSystem {
        system = "aarch64-linux";
        modules = [
          ./configuration.nix
        ];
      };
    };
}

Stage flake.nix dengan cara git add flake.nix atau git add ., kemudian verify konfigurasi dengan cara

nix flake check

Melakukan konfigurasi akan generate flake.lock

Setelah verify sukses, kita bisa rebuild dan apply sebagai default boot:

sudo nixos-rebuild switch --flake ~/nix#nixos-server

Setiap kali kita melakukan nixos-rebuild, NixOS akan generate konfigurasi system baru kemudian apply as default dan kita bisa melihatnya dengan cara:

sudo nixos-rebuild list-generations

NixOS Rollback
Disinilah keungglan nix, kita bisa melakukan rollback ke versi sebelumnya dengan cara

sudo nixos-rebuild --rollback switch

4. Add New Package

Untuk saat ini semua konfigurasi package yang kita install ada di configuration.nix, jadi kita butuh edit file ini dan menambahkan package yang dibutuhkan.

Pada artikel ini aku akan menggunakan lazyvim sebagai code editor

...
environment.systemPackages = with pkgs; [
    curl
    git
    neovim
    tree
    wget

    # untuk neovim
    fnm # node version manager
    gcc
    nixd
    nixfmt
];

Perlu diingat, setiap kali melakukan penambahan package atau melakukan perubahan konfigurasi, kita butuh melakuakan rebuild dan apply sebagai default boot.

5. Nix Rebuild Command

Seperti yang kamu ketahui, untuk melakukan rebuild flake kita menjalankan perintah berikut:

sudo nixos-rebuild switch --flake ~/nix#nixos-server

Perintah ini memiliki sytax seperti ini:

sudo nixos-rebuild switch --flake {path_flake}#{hostname}

6. Bonus: install lazyvim

git clone https://github.com/LazyVim/starter ~/.config/nvim

Enable SSH

Kita akan melakukan setup minimum ssh untuk VirtualBox ini agar dapat kita remote dari terminal laptop. Edit configuration.nix lalu jalankan perintah nixos-rebuild

  services.openssh = {
    enable = true;
    ports = [
      222
    ];
    settings = {
      PermitRootLogin = "no";
    };
  };

⚠️ Konfigurasi ini hanya diperuntukkan praktik saja, untuk best practices konfigurasi ssh dapat dilihat pada NixOS Wiki

Agar dapat akses VirtualBox dari terminal laptop, kita membutuhkan port-forwarding. Lakukan konfigurasi port forwarding dengan cara

Shutdown VM terlebih dahulu. Kamu bisa klik close bar pada VM dan pilih shutdown
Pilih VMmu dan klik Settings
Pilih Network -> port forwarding

Tambahkan port VM: Host IP 127.0.0.1, Host Port 2222, Guest Port 222. Host port adalah target port laptop kita dan guest port adalah port dari ssh VM kita.
Apply Settings dan nyalakan VM dan pilih latest generations

Buka terminal pada laptopmu dan lakukan ssh ke VM

ssh -p 2222 vboxuser@127.0.0.1

Home Manager

Home Manager adalah tool dari komunitas Nix yang memungkinkan kita mengelola konfigurasi user secara deklaratif, seperti yang NixOS lakukan untuk konfigurasi sistem. Tanpa Home Manager, konfigurasi seperti ~/.gitconfig, ~/.bashrc, atau ~/.config/nvim/init.lua ditulis manual dan tidak reproducible.

Dengan Home Manager, semua konfigurasi user dideklarasikan di home.nix dan bisa di-reproduce di mesin manapun hanya dengan satu perintah.

	`configuration.nix`	`home.nix`
Scope	System-wide	Per user
Contoh	nginx, SSH, kernel	git config, shell aliases, dotfiles
Butuh sudo	✅	❌
Lokasi install	`/run/current-system`	`~/.nix-profile`

1. Add home.nix

home.nix

{ config, pkgs, ... }:

{
  home.username = "vboxuser";
  home.homeDirectory = "/home/vboxuser";

  home.packages = with pkgs; [
    ripgrep
    fd
    jq
  ];

  programs = {
    bash = {
      enable = true;
      shellAliases = {
        rebuild = "sudo nixos-rebuild switch --flake ~/nix#nixos-server";
      };
    };

    lazygit = {
      enable = true;
      enableBashIntegration = true;
    };
  };

  home.stateVersion = "25.11";
}

2. Update flake.nix

flake.nix

{
  description = "NixOS Server Configuration";

  inputs = {
    nixpkgs.url = "github:NixOS/nixpkgs/nixos-25.11";

    home-manager.url = "github:nix-community/home-manager/release-25.11";
    home-manager.inputs.nixpkgs.follows = "nixpkgs";
  };

  outputs =
    {
      self,
      nixpkgs,
      home-manager,
    }:
    {
      nixosConfigurations.nixos-server = nixpkgs.lib.nixosSystem {
        system = "aarch64-linux";
        modules = [
          ./configuration.nix

          home-manager.nixosModules.home-manager
          {
            home-manager.useGlobalPkgs = true;
            home-manager.useUserPackages = true;
            home-manager.users.vboxuser = import ./home.nix;
          }
        ];
      };
    };
}

3. Rebuild

Rebuild NixOS system.

sudo nixos-rebuild switch --flake ~/nix#nixos-server
source ~/.bashrc # reload bash untuk agar bisa rebuild dengan alias

Karena kita sudah menambahkan alias pada shellAliases di home.nix, maka untuk selanjutnya kita tidak perlu mengetik perintah nixos-rebuild yang panjang itu, kita hanya tinggal menjalankan perintah rebuild

Penutup

Bagaimana menurutmu setelah melewati proses yang cukup panjang untuk install dan konfigurasi NixOS, sangat menarik bukan?

Kita bisa menambahkan package dengan mudah, melakukan konfigurasi secara deklaratif, dan bisa rollback system jika tidak cocok dengan konfigurasinya.

Berikut adalah referensi yang sangat membantu untuk melakukan explorasi nix

Nix Wiki
Nix Store: adalah situs official untuk nix package
Nix Home manager: situs untuk melihat konfigurasi package di home manager

Nix Series: Introduction

Dimas Rangga — Tue, 02 Jun 2026 08:34:53 +0000

Pada series ini aku akan membahas apa itu Nix, NixOS, dan bagaimana menggunakan NixOS di server. Nix punya cara berpikir yang cukup berbeda dari package manager pada umumnya, jadi kita mulai dari dasarnya dulu.

Sedikit Sejarah Nix

Nix dikenalkan oleh Eelco Dolstra, seorang peneliti asal Belanda yang mana ia frustasi dengan cara kerja package manager yang tidak bisa menjamin konsistensi software environment. Analogi permasalahan yang coba diselesaikan oleh Dolstra sederhananya seperti ini, bayangkan kamu sedang mengerjakan sebuah project di komputermu dan semuanya berjalan lancar. Lalu kamu pindah ke komputer lain, menginstal ulang semua dependency yang kamu butuhkan dan tiba-tiba terjadi error. Error bermunculan saat install dependency, padahal kamu sudah melakukan hal yang sama persis di komputer sebelumnya. Masalah ini sering terjadi dengan sebutan "works on my machine".

Dolstra mengerjakan Nix sebagai bagian dari disertasi PhD-nya yang dipublikasikan pada 2006, berjudul "The Purely Functional Software Deployment Model". Tesis ini membahas tentang bagaimana cara deploy sebuah software yang reliable, di mana input yang sama selalu menghasilkan output yang sama. Nix pertama kali dirilis pada 2003 sebagai bagian dari riset tersebut, dan kini telah berkembang menjadi ekosistem dengan lebih dari 100.000 package.

Apa itu nix

Saat pertama kali mendengar nix beberapa orang pasti bingung karena nix bisa merujuk ke beberapa konteks sekaligus, nah pada artikel ini kita akan berkenalan dengan nix.

Sebagai Bahasa Pemrograman: Nix adalah functional programming language yang digunakan untuk menulis konfigurasi secara deklaratif. Gimana maksudnya? Sederhananya seperti ini, jika kita menggunakan OS linux seperti ubuntu, debian, arch, dll., untuk installasi sebuah package kita harus menjalankan perintah apt-get install atau pacman dan disetiap package yang sudah kita install, lokasi file konfigurasi berada ditempat yang berbeda-beda. Dengan menggunakan nix kita tidak perlu melakukan installasi dan konfigurasi sebuah package secara imperative, kita hanya perlu mendeklarasikan package dan konfigurasi yang kita butuhkan lalu di evaluasi.
Sebagai Package Manager: Nix adalah package manager yang mengevaluasi seluruh konfigurasi pada file .nix. Berbeda dengan package manager lainnya seperti apt atau pacman. Nix menyimpan semua package secara isolate di /nix/store
Sebagai OS: NixOS adalah linux distribution yang menggunakan nix sebagai package manager yang dikelola secara deklaratif, seluruh konfigurasi sistem pun ditulis dalam nix language, mulai dari networking, user, service, sampai bootloader.

Sekarang kita sudah tahu bahwa "Nix" bukan satu hal: ia adalah bahasa, package manager, sekaligus OS. Untuk memahami kenapa tiga hal ini bisa menyatu, kita perlu melihat bagaimana Nix bekerja di balik layar.

Bagaimana Nix bekerja

Masalah dengan package manager

Ketika kamu menginstal software dengan apt install atau brew install, biasanya file-file program ini ditempatkan di lokasi standar seperti /usr/lib/ atau /usr/bin/. Ini terlihat tertata dengan rapi, tapi dapat menimbulkan masalah dikemudian hari. Contoh masalah yang bisa saja terjadi adalah dependency hell, sebuah situasi dimana dua aplikasi butuh versi library yang berbeda tapi tidak bisa berjalan secara bersamaan

Situasi bermasalah: "Dependency Hell"

Aplikasi A  ──────────────►  butuh Python 3.8
                                    │
                             FILE DI /usr/lib/python3.8/
                                    │
Aplikasi B  ──────────────►  butuh Python 3.11
                                    │
                             ⚠️  KONFLIK!
                             Tidak bisa dua versi
                             di tempat yang sama!

Solusi Nix: Storage Khusus di `/nix/store`

Nix mengatasi masalah ini dengan pendekatan yang berbeda. Setiap package disimpan di direktori khusus: /nix/store. Yang membuatnya unik adalah setiap package memiliki nama folder yang berisi hash, semacam identifier unik berdasarkan isi package itu sendiri.

/nix/store/
│
├── 9xgd3k2lmn7pqrs123abc456def7890z-firefox-120.0/  ← Firefox versi 120
│   ├── bin/firefox
│   └── lib/...
│
├── 7hqw8p9rst456mnop789qrs012tuv3456-firefox-119.0/ ← Firefox versi 119
│   ├── bin/firefox                         (bisa hidup berdampingan!)
│   └── lib/...
│
├── 2abc4d5efg789wxyz012345abc678def90-python-3.8.18/ ← Python 3.8
│   └── lib/...
│
└── 5jkl6m7nop012ghi345jkl678mno9012p-python-3.11.6/ ← Python 3.11
    └── lib/...                             (keduanya ada sekaligus!)

Dua versi Python, dua versi Firefox; semuanya bisa diinstall dan digunakan tanpa konflik, karena masing-masing punya identifier yang unik.

Sistem Hash: Unique Signature Build

Hash sebagai unique identifier (deretan 32 karakter seperti 9xgd3k2lmn7pqrs123abc456def7890z) ini dihitung dari seluruh definisi pembuatan package mulai dari: source code, dependency, compiler yang digunakan, bahkan environment variable yang dipakai saat build. Jika ada satu hal yang berbeda maka hashnya akan berbeda juga.

┌─────────────────────────────────────────────────────────────┐
│            CARA NIX MEMBERI NAMA SEBUAH PACKAGE             │
│                                                             │
│  Input:                                                     │
│  ┌─────────────────────────────────┐                        │
│  │ • Source code Firefox 120.0     │                        │
│  │ • Versi GCC yang dipakai        │    ──► HASH ──         │
│  │ • Semua library dependency-nya  │   9xgd3k2l...          │
│  │ • Versi library-library itu     │   (32 karakter)        │
│  └─────────────────────────────────┘                        │
│                                                             │
│  Hasilnya:                                                  │
│  /nix/store/9xgd3k2lmn7pqrs123abc456def7890z-firefox-120.0/ │
│                                                             │
│  Ubah SATU hal kecil → hash BERBEDA →                       │
│  folder BERBEDA → tidak akan pernah bentrok!                │
└─────────────────────────────────────────────────────────────┘

Ini disebut content-addressed storage. Jika apapun berubah dari inputs → hashnya berbeda → path di store berbeda → package yang berbeda.

Karena hash inilah yang membuat nix menjamin reproducibility.

Reproducible Builds: Kunci Utama Nix

Inilah keunggulan terbesar Nix: reproducibility.

Karena setiap package dibuild dari definisi yang deterministic, siapapun yang menjalankan build yang sama akan mendapat hasil yang identik, di komputer mana pun.

Tanpa Nix:
┌──────────┐         ┌──────────┐         ┌──────────┐
│ Laptop A │         │ Laptop B │         │  Server  │
│ Python   │         │ Python   │         │ Python   │
│ 3.11.2   │  ≠ ≠ ≠  │ 3.11.6   │  ≠ ≠ ≠  │ 3.11.8   │
│ pip 22.x │         │ pip 23.x │         │ pip 24.x │
│ numpy    │         │ numpy    │         │ numpy    │
│ 1.24.0   │         │ 1.25.1   │         │ 1.26.0   │
└──────────┘         └──────────┘         └──────────┘
"Works on my machine!" 😩

─────────────────────────────────────────────────────

Dengan Nix:
┌──────────┐         ┌──────────┐         ┌──────────┐
│ Laptop A │         │ Laptop B │         │  Server  │
│ Python   │         │ Python   │         │ Python   │
│ 3.11.6   │  = = =  │ 3.11.6   │  = = =  │ 3.11.6   │
│ numpy    │         │ numpy    │         │ numpy    │
│ 1.25.1   │         │ 1.25.1   │         │ 1.25.1   │
└──────────┘         └──────────┘         └──────────┘
Works perfectly! ✅

Binary vs Source: Bagaimana Nix Memutuskan?

Saat kamu menggunakan nix dan melakukan installasi sebuah package, kamu bisa melihat ada proses copy atau build from source pada package tersebut. Nix tidak selalu melakukan build dari source dan nix memiliki mekanisme yang disebut substituters (atau binary cache).

Nix evaluate expression → dapat hash/
└── Nix lookup ke binary cache: "Ada /nix/store/<hash>-nodejs-20.11.0 ?"/
    ├── Ada → Download binary langsung (substitute)
    └── Tidak ada → Build dari source secara lokal

Default binary cache untuk NixOS/nixpkgs adalah cache.nixos.org yang dimanage oleh Hydra (Nix's CI system). Hydra secara otomatis build semua package di nixpkgs dan menyimpan hasilnya ke cache, sehingga mayoritas package populer sudah tersedia sebagai binary dan tidak perlu di-build ulang dari source.

Perlu dicatat: jika kamu menggunakan nixpkgs-unstable (channel yang lebih baru), ada kemungkinan binary cache untuk package tertentu belum tersedia karena Hydra belum selesai build-nya, sehingga Nix akan fall back ke build dari source secara lokal.

Alasan Nix Lebih Unggul dari Package Manager Lain

Tidak ada lagi “Dependency Hell”

Seperti yang sudah dijelaskan diatas, Nix memungkinkan berbagai versi package terinstall secara bersamaan. Dengan apt atau brew, kamu tidak bisa melakukan installasi secara native untuk dua package dengan versi yang berbeda.

Bisa Rollback sistem

Saat melakukan upgrade sistem, Nix tidak langsung menggantikan package yang sudah terinstall. Sebaliknya, Nix membangun generation baru yang berisi versi package yang sudah diperbarui, sementara generation lama tetap utuh di sistem.

Setiap kali kamu menjalankan perintah berikut, Nix secara otomatis membuat generation baru:

# NixOS
sudo nixos-rebuild switch

# Nix Darwin
sudo darwin-rebuild switch

Konsep generation inilah yang membuat Nix aman untuk diupgrade. Jika sesuatu berjalan tidak semestinya setelah upgrade, kamu bisa rollback ke generation sebelumnya tanpa perlu reinstall atau konfigurasi ulang apapun. Cukup dengan satu command atau memilih generation dari boot menu:

# Rollback ke generation sebelumnya
sudo nixos-rebuild switch --rollback

# Atau pilih generation spesifik dari daftar
nix-env --list-generations
nix-env --switch-generation 2

Berikut ilustrasinya:

Riwayat "generasi" sistemmu:

  gen 1          gen 2          gen 3 (sekarang)
┌────────┐     ┌────────┐     ┌────────┐
│Firefox │     │Firefox │     │Firefox │
│ 118    │     │ 119    │     │ 120    │
│Python  │     │Python  │     │Python  │
│ 3.10   │     │ 3.10   │     │ 3.11   │
└────────┘     └────────┘     └────────┘
                   ▲                │
                   │                │ ada yang salah?
                   └────────────────┘
          rollback → kembali ke gen 2
          atau pilih gen 1 dari boot menu!

Development Environment yang Terisolasi

Nix memiliki fitur nix develop dan nix shell yang memungkinkan kita untuk membuat development environment yang terisolasi per-project, mirip virtualenv di python atau node_modules di Node.js.

Project A butuh Node 18 + PostgreSQL 14:
$ cd project-a && nix develop
→ Masuk environment: Node 18, PostgreSQL 14 ✓

Project B butuh Node 20 + PostgreSQL 16:
$ cd project-b && nix develop
→ Masuk environment: Node 20, PostgreSQL 16 ✓

Keduanya terisolasi, tidak saling mengganggu

Environment ini didefinisikan dalam file flake.nix (cara modern) atau shell.nix (cara lama). Dengan Nix Flakes (fitur yang kini menjadi standar de facto), kamu bisa mendefinisikan seluruh dependency project dalam satu file flake.nix yang ter-lock (mirip package-lock.json di Node.js), sehingga siapapun yang clone project tersebut akan mendapat environment yang sama persis.

# Contoh flake.nix sederhana
{
  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 {
          packages = [ pkgs.nodejs_20 ];
        };
      }
    );
}

Tidak Mengotori Sistem

Berbeda dengan package manager konvensional, Nix menyimpan setiap package di lokasi terisolasi di bawah /nix/store. Tidak ada file yang tersebar ke berbagai direktori sistem seperti /usr/lib atau /etc.

Dengan struktur penyimpanan yang terisolasi seperti ini, Nix tahu persis mana yang masih dibutuhkan dan mana yang sudah tidak. Jadi saat kamu menjalankan nix-collect-garbage, hanya package yang benar-benar tidak dibutuhkan oleh siapapun yang akan dihapus. Tidak ada file sisa (leftover) yang tertinggal di sudut-sudut sistem, seperti yang sering terjadi setelah apt remove di Ubuntu.

Penutup

Dependency hell sudah jadi masalah lama di dunia software, dan Nix adalah salah satu jawaban tepat untuk masalah tersebut. Lahir dari frustasi nyata seorang peneliti pada 2003, Nix kini telah berkembang menjadi ekosistem yang mencakup lebih dari 100.000 package, dengan komunitas yang aktif dan terus bertumbuh.

Empat hal yang perlu diingat:

Nix adalah bahasa untuk mendeskripsikan software secara deklaratif.
Nix adalah package manager yang menyimpan setiap package secara terisolasi di /nix/store.
Reproducibility: build yang sama menghasilkan output yang identik di mesin mana pun.
NixOS adalah OS di mana seluruh konfigurasi sistem (dari networking hingga bootloader) ditulis dalam Nix language.

Learning curve Nix memang curam, dan bagian terberatnya bukan di syntax melainkan perubahan mental model dari imperatif ke deklaratif. Tapi kabar baiknya: begitu kamu "klik" dengan cara berpikirnya, kamu akan sulit kembali ke cara lama. Di artikel berikutnya, kita akan mulai menginstall Nix dan mencoba langsung fitur-fitur yang sudah dibahas di sini.

DEV Community: Dimas Rangga

Nix Series: Security Hardening

SSH (Secure Shell)

Enable Firewall

Setup Fail2ban

User Configuration

Update configuration.nix

Testing Brute Force

Bonus: Secure SSH with Key Pairs

1. Generate SSH key

2. Enable SSH Agent

3. Update users.nix

4. Update security.nix

Penutup

References

Nix Series: Basic Nix Language

Nix Language

1. Basic Data Type

2. String

3. let ... in (Variable Binding)

4. Attribute Sets

rec - Recursive Attribute Sets

with - Membawa Attributes ke Scope Saat Ini

5. Functions

Satu Argumen

Attribute Set sebagai Argumen (Destructured Params)

Default Argumen

6. Conditionals

7. inherit - Shorthand untuk Attribute Sets

8. import - Memisahkan File

Evaluating and Testing Nix Code

Penutup

Nix Series: NixOS Installation

Prerequisite

Setup VirtualBox

Installation Step

1. Boot Live Environment

2. Check Disk Information

3. Disk Partition

4. Format Partition

5. Mount Partition

6. Generate Nix Configuration

7. Edit Configuration

8. Install NixOS

9. Post Installation

❄ Nix Flakes ❄

1. Enable Flakes

2. Git Setup

3. Setup Flake

4. Add New Package

5. Nix Rebuild Command

6. Bonus: install lazyvim

Enable SSH

Home Manager

1. Add home.nix

2. Update flake.nix

3. Rebuild

Penutup

Nix Series: Introduction

Sedikit Sejarah Nix

Apa itu nix

Bagaimana Nix bekerja

Masalah dengan package manager

Solusi Nix: Storage Khusus di /nix/store

Sistem Hash: Unique Signature Build

Reproducible Builds: Kunci Utama Nix

Binary vs Source: Bagaimana Nix Memutuskan?

Alasan Nix Lebih Unggul dari Package Manager Lain

Tidak ada lagi “Dependency Hell”

Bisa Rollback sistem

Development Environment yang Terisolasi

Tidak Mengotori Sistem

Penutup

Referensi:

Update `configuration.nix`

3. Update `users.nix`

4. Update `security.nix`

`rec` - Recursive Attribute Sets

`with` - Membawa Attributes ke Scope Saat Ini

7. `inherit` - Shorthand untuk Attribute Sets

8. `import` - Memisahkan File

Solusi Nix: Storage Khusus di `/nix/store`