✍️ 필사 모드: Nix Package Manager Deep Dive — 재현 가능한 빌드, Derivation, Flakes, NixOS 완전 정복 (2025)

make  # /usr/local/lib을 수정, /tmp 쓰기, 네트워크 fetch, 현재 시간 사용

build(
    sources = hash("foo-1.2.tar.gz"),
    deps = [hash(libcurl), hash(openssl), hash(gcc)],
    buildScript = hash("./configure && make && make install"),
    env = {"CC": "gcc"}
) → /nix/store/abc123-foo-1.2/

/nix/store/
├── 0k7n3f0bd3...-gcc-11.3.0/
├── 1q8f2r9vn4...-openssl-3.0.5/
├── 2h5m1j7xb9...-python-3.10.6/
├── 3b2s7k8pc6...-my-app-0.1/
└── ...

/nix/store/abc123-python-3.9.0/
/nix/store/def456-python-3.10.0/
/nix/store/ghi789-python-3.11.0/

~/.nix-profile/bin/python → /nix/store/def456-python-3.10.0/bin/python

Derive([
  ("out", "/nix/store/abc123-hello-2.12.1", "", "")],
  [("/nix/store/xxx-gcc-11.3.0.drv", ["out"]),
   ("/nix/store/yyy-bash-5.1.drv", ["out"])],
  ["/nix/store/zzz-hello-2.12.1.tar.gz"],
  "x86_64-linux",
  "/nix/store/www-bash-5.1/bin/bash",
  ["-e", "/nix/store/vvv-default-builder.sh"],
  [("buildInputs", ""),
   ("name", "hello-2.12.1"),
   ("out", "/nix/store/abc123-hello-2.12.1"),
   ("src", "/nix/store/zzz-hello-2.12.1.tar.gz"),
   ("system", "x86_64-linux")])

{ stdenv, fetchurl, gcc }:

stdenv.mkDerivation {
  pname = "hello";
  version = "2.12.1";

  src = fetchurl {
    url = "https://ftp.gnu.org/gnu/hello/hello-2.12.1.tar.gz";
    sha256 = "0xw6cr5jgi1ir13q6apvrivwmmpr5j8vbymp0x6ll0kcv6366hnn";
  };

  buildInputs = [ gcc ];

  buildPhase = ''
    ./configure --prefix=$out
    make
  '';

  installPhase = ''
    make install
  '';
}

# 문자열
"hello"
''
  멀티라인
  들여쓰기 유지
''

# 숫자
42
3.14

# 논리
true
false

# Null
null

# 리스트
[ 1 2 3 "four" ]

# Attribute set (dict와 유사)
{ name = "Alice"; age = 30; }

# 함수
x: x + 1

# 다인자 함수 (currying)
x: y: x + y

# Attribute set 파라미터 (destructuring)
{ name, age }: "${name} is ${toString age}"

let
  x = 1;
  y = 2;
in
  x + y  # 3

# with: attribute set을 scope에 펼치기
with { a = 1; b = 2; };
  a + b  # 3

let
  slow = builtins.trace "computed!" 42;
in
  "ignore"  # slow가 평가되지 않음 → "computed!" 출력 안 됨

# default.nix
{ pkgs ? import <nixpkgs> {} }:

pkgs.stdenv.mkDerivation {
  # ...
}

let
  add = x: y: x + y;
in
  add 1 2  # 3, currying

rec {
  x = 1;
  y = x + 1;  # rec 덕분에 같은 set 안의 x 참조 가능
}
# { x = 1; y = 2; }

stdenv.mkDerivation {
  pname = "myapp";
  version = "1.0";
  src = ./.;
  buildInputs = [ pkgs.openssl pkgs.libffi ];
  nativeBuildInputs = [ pkgs.pkg-config pkgs.cmake ];
  
  configurePhase = "cmake -DCMAKE_INSTALL_PREFIX=$out .";
  buildPhase = "make";
  installPhase = "make install";
}

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

# Imperative (전통)
nix-env -iA nixpkgs.hello
hello  # 실행

# Declarative (선호)
# ~/.config/nixpkgs/home.nix 또는 NixOS configuration.nix 편집
home.packages = [ pkgs.hello ];

nix-shell -p python3 nodejs_20 postgresql_15
# 새 셸. 여기서만 python3, node 20, postgresql 15 사용 가능
exit  # 원래 환경으로

# 스크립트에 shebang
#!/usr/bin/env nix-shell
#! nix-shell -i python3 -p python3 python3Packages.requests
import requests
print(requests.get("https://example.com").text)

# shell.nix
{ pkgs ? import <nixpkgs> {} }:

pkgs.mkShell {
  buildInputs = with pkgs; [
    rustc
    cargo
    rust-analyzer
    pkg-config
    openssl
  ];
  
  shellHook = ''
    echo "Welcome to my-rust-project"
  '';
}

# .envrc
use nix

nix-build default.nix
# 결과: ./result → /nix/store/...-my-app-0.1/

nix-channel --update
nix-env -u

{
  description = "My Rust project";

  inputs = {
    nixpkgs.url = "github:NixOS/nixpkgs/nixos-23.11";
    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.rustc pkgs.cargo ];
        };
        packages.default = pkgs.rustPlatform.buildRustPackage {
          pname = "myapp";
          version = "0.1.0";
          src = ./.;
          cargoLock.lockFile = ./Cargo.lock;
        };
      }
    );
}

{
  "nodes": {
    "nixpkgs": {
      "locked": {
        "lastModified": 1700000000,
        "narHash": "sha256-...",
        "owner": "NixOS",
        "repo": "nixpkgs",
        "rev": "abc123...",
        "type": "github"
      }
    }
  }
}

# 환경 진입
nix develop

# 빌드
nix build

# 실행 (원격도 가능)
nix run github:some/project

# Flake 업데이트
nix flake update

# 특정 input만 업데이트
nix flake lock --update-input nixpkgs

# /etc/nixos/configuration.nix
{ config, pkgs, ... }:

{
  # 부트로더
  boot.loader.systemd-boot.enable = true;

  # 호스트명
  networking.hostName = "my-laptop";

  # 타임존
  time.timeZone = "Asia/Seoul";

  # 사용자
  users.users.alice = {
    isNormalUser = true;
    extraGroups = [ "wheel" "docker" ];
    shell = pkgs.zsh;
  };

  # 시스템 패키지
  environment.systemPackages = with pkgs; [
    vim
    firefox
    git
    docker
  ];

  # 서비스
  services.openssh.enable = true;
  services.nginx = {
    enable = true;
    virtualHosts."example.com" = {
      root = "/var/www";
      enableACME = true;
      forceSSL = true;
    };
  };

  services.postgresql = {
    enable = true;
    package = pkgs.postgresql_15;
    authentication = ''
      local all all trust
    '';
  };

  # 네트워킹
  networking.firewall.allowedTCPPorts = [ 80 443 22 ];

  system.stateVersion = "23.11";
}

sudo nixos-rebuild switch

sudo nixos-rebuild switch --rollback

sudo nixos-rebuild test

sudo nixos-rebuild dry-run

# ~/.config/home-manager/home.nix
{ config, pkgs, ... }:

{
  home.username = "alice";
  home.homeDirectory = "/home/alice";
  home.stateVersion = "23.11";

  home.packages = with pkgs; [
    ripgrep
    fd
    bat
    eza
  ];

  programs.git = {
    enable = true;
    userName = "Alice";
    userEmail = "alice@example.com";
    aliases = {
      st = "status";
      co = "checkout";
    };
  };

  programs.neovim = {
    enable = true;
    extraConfig = ''
      set number
      set tabstop=4
    '';
  };

  programs.zsh = {
    enable = true;
    oh-my-zsh = {
      enable = true;
      theme = "robbyrussell";
      plugins = [ "git" "docker" ];
    };
  };
}

# 개인 dotfiles repo의 flake.nix
{
  inputs.home-manager.url = "github:nix-community/home-manager";
  
  outputs = { self, nixpkgs, home-manager, ... }: {
    homeConfigurations."alice@laptop" = home-manager.lib.homeManagerConfiguration {
      pkgs = nixpkgs.legacyPackages.x86_64-linux;
      modules = [ ./home.nix ];
    };
    homeConfigurations."alice@mac" = home-manager.lib.homeManagerConfiguration {
      pkgs = nixpkgs.legacyPackages.aarch64-darwin;
      modules = [ ./home.nix ];
    };
  };
}

nixpkgs/
├── pkgs/
│   ├── applications/
│   │   ├── editors/
│   │   │   ├── vim/
│   │   │   └── emacs/
│   │   ├── graphics/
│   │   ├── networking/
│   │   └── ...
│   ├── development/
│   │   ├── compilers/
│   │   │   ├── gcc/
│   │   │   ├── rust/
│   │   │   └── ...
│   │   ├── libraries/
│   │   └── python-modules/
│   ├── servers/
│   ├── tools/
│   └── top-level/
│       ├── all-packages.nix
│       └── ...
├── nixos/
│   ├── modules/
│   ├── release.nix
│   └── ...
└── lib/

git clone https://github.com/NixOS/nixpkgs
cd nixpkgs
# 새 패키지 추가
vim pkgs/applications/misc/myapp/default.nix
# 변경 사항 빌드
nix-build -A myapp
# PR 제출

# 빌드
nix-build

# 업로드
nix copy --to s3://my-bucket result/

# 다른 머신에서 설정
nix.settings.substituters = [ "s3://my-bucket" ];
nix.settings.trusted-public-keys = [ "mykey:..." ];

cachix use myproject
# 이제 myproject.cachix.org에서 자동 다운로드

nix-serve --port 8080 &
# 이 머신을 바이너리 캐시로 사용 가능

# flake.nix
devShells.default = pkgs.mkShell {
  buildInputs = with pkgs; [
    nodejs_20
    yarn
    postgresql
    redis
  ];
  
  shellHook = ''
    export DATABASE_URL="postgresql://localhost/myapp"
    echo "Welcome to myapp dev environment"
  '';
};

name: CI
on: [push]
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v4
    - uses: DeterminateSystems/nix-installer-action@main
    - uses: DeterminateSystems/magic-nix-cache-action@main
    - run: nix develop --command cargo test

nix build .#my-app
# ./result에 결과물

let
  myVim = pkgs.vim.override {
    features = "huge";
    python3Support = true;
  };
in
  myVim

let
  overlays = [
    (self: super: {
      myPackage = super.callPackage ./my-package.nix {};
      python3 = super.python311;  # 기본 python을 3.11로
    })
  ];
  pkgs = import <nixpkgs> { inherit overlays; };
in
  pkgs

src = fetchurl {
  url = "https://example.com/foo-1.0.tar.gz";
  sha256 = "sha256-abc...";
};

src = fetchFromGitHub {
  owner = "user";
  repo = "project";
  rev = "v1.0.0";
  sha256 = "sha256-def...";
};

buildFHSEnv {
  name = "my-fhs-env";
  targetPkgs = pkgs: with pkgs; [ libz openssl ];
  runScript = "bash";
}

devShells.rust = pkgs.mkShell { buildInputs = [ pkgs.rustc pkgs.cargo ]; };
devShells.node = pkgs.mkShell { buildInputs = [ pkgs.nodejs ]; };
devShells.default = pkgs.mkShell {
  inputsFrom = [ devShells.rust devShells.node ];
};

devShells.default = pkgs.mkShell {
  buildInputs = [ pkgs.python39 pkgs.python39Packages.django_3 ];
};

devShells.default = pkgs.mkShell {
  buildInputs = [ pkgs.python312 pkgs.python312Packages.fastapi ];
};

services.nginx = {
  enable = true;
  virtualHosts."myapp.com" = {
    locations."/" = {
      proxyPass = "http://localhost:8080";
    };
  };
};

systemd.services.myapp = {
  description = "My App";
  wantedBy = [ "multi-user.target" ];
  serviceConfig = {
    ExecStart = "${pkgs.myapp}/bin/myapp";
    Restart = "always";
  };
};

# flake.nix
{
  outputs = { self, nixpkgs }: {
    packages.x86_64-linux = {
      frontend = nixpkgs.legacyPackages.x86_64-linux.callPackage ./frontend {};
      backend = nixpkgs.legacyPackages.x86_64-linux.callPackage ./backend {};
      cli = nixpkgs.legacyPackages.x86_64-linux.callPackage ./cli {};
    };
    
    devShells.x86_64-linux.default = nixpkgs.legacyPackages.x86_64-linux.mkShell {
      buildInputs = with nixpkgs.legacyPackages.x86_64-linux; [
        nodejs_20
        rustc
        cargo
        go
      ];
    };
  };
}

error: attempt to call something which is not a function but a set, 
at /nix/store/.../pkgs/top-level/all-packages.nix:1234:5
...

nix-collect-garbage -d  # 모든 세대, 모든 참조 없는 것 제거
nix-collect-garbage --delete-older-than 30d  # 30일 이전만

┌─────────────────────────────────────────────────────┐
│                Nix Cheat Sheet                       │
├─────────────────────────────────────────────────────┤
│ 핵심 원칙:                                             │
│   Build = Pure Function                               │
│   Same inputs → Same outputs                          │
│   /nix/store/<hash>-<name>                           │
│                                                       │
│ 언어:                                                  │
│   순수 함수형, 게으른 평가                              │
│   String, Int, List, AttrSet, Function              │
│   let/in, with, rec                                  │
│                                                       │
│ Derivation:                                           │
│   빌드 레시피 (.drv)                                  │
│   Inputs: src, deps, script, env                     │
│   Output: /nix/store/ 경로                            │
│                                                       │
│ Flakes (2021+):                                      │
│   flake.nix + flake.lock                             │
│   재현 가능성 보장                                     │
│   inputs + outputs                                    │
│   nix develop / build / run                          │
│                                                       │
│ NixOS:                                                │
│   전체 OS를 configuration.nix에                       │
│   nixos-rebuild switch                                │
│   원자적 + 롤백 가능                                   │
│                                                       │
│ Home Manager:                                         │
│   사용자 환경 관리                                     │
│   Cross-platform (Mac + Linux)                       │
│   Dotfile 버전 관리                                   │
│                                                       │
│ nixpkgs:                                              │
│   100,000+ 패키지                                    │
│   세계 최대 저장소                                     │
│   Hydra가 prebuilt                                    │
│                                                       │
│ Binary Cache:                                         │
│   cache.nixos.org (공식)                              │
│   Cachix (상용)                                      │
│   Self-hosted 가능                                    │
│                                                       │
│ 주요 명령:                                             │
│   nix develop    (dev shell)                         │
│   nix build      (빌드)                              │
│   nix run        (실행)                              │
│   nix flake update (업데이트)                         │
│                                                       │
│ 패턴:                                                  │
│   shell.nix / flake.nix                              │
│   Override, Overlay                                   │
│   fetchurl/fetchFromGitHub (+ hash)                  │
│   buildFHSEnv (FHS 호환)                              │
│                                                       │
│ 통합:                                                  │
│   direnv (자동 환경)                                  │
│   GitHub Actions + magic-nix-cache                   │
│   Docker (nix로 이미지 빌드)                          │
│                                                       │
│ 장점:                                                  │
│   진짜 재현성                                          │
│   여러 버전 공존                                       │
│   원자적 롤백                                          │
│   선언적                                               │
│                                                       │
│ 단점:                                                  │
│   가파른 학습 곡선                                     │
│   에러 메시지                                          │
│   일부 소프트웨어 호환성                                │
│   디스크 사용량                                        │
└─────────────────────────────────────────────────────┘