4. Nix를 사용하여 패키지 빌드

Let’s build and run CMake:

nix build "nixpkgs#cmake"
./result/bin/cmake --help

Let’s build and run Pandoc:

nix build "nixpkgs#pandoc"
./result/bin/pandoc --version

Let’s build and run npm:

nix build "nixpkgs#nodePackages.npm"
./result/bin/npm --help

ls result/bin을 실행하면 패키지에 npx도 ​​포함되어 있는 것을 알 수 있습니다.

Let’s build and run pip:

nix build "nixpkgs#python3Packages.pip"
./result/bin/pip --help

Let’s build and run kubectl:

nix build "nixpkgs#kubectl"
./result/bin/kubectl --help

Let’s build and run ripgrep:

nix build "nixpkgs#ripgrep"
./result/bin/rg --help

Let’s build and run scalafmt:

nix build "nixpkgs#scalafmt"
./result/bin/scalafmt --version

Here’s the package definition that builds our C++ package:

{
  packages = forAllSystems ({ pkgs }: {
    default =
      let
        binName = "zero-to-nix-cpp";
        cppDependencies = with pkgs; [ boost gcc poco ];
      in
      pkgs.stdenv.mkDerivation {
        name = "zero-to-nix-cpp";
        src = self;
        buildInputs = cppDependencies;
        buildPhase = "c++ -std=c++17 -o ${binName} ${./main.cpp} -lPocoFoundation -lboost_system";
        installPhase = ''
          mkdir -p $out/bin
          cp ${binName} $out/bin/
        '';
      };
  });
}

For the full flake, see flake.nix on GitHub or run cat flake.nix. What you see here is a derivation that defines how to build the package, more specifically the mkDerivation function provided by Nix’s standard environment.

The package that results when you run nix build is a CLI tool that outputs a message. To run that tool:

./result/bin/zero-to-nix-cpp

You should see this output:

Hello from Nix + C++!

Here’s the package definition that builds our Haskell package:

{
  packages = forAllSystems ({ pkgs }: {
    default = pkgs.haskellPackages.mkDerivation {
      pname = "zero-to-nix-haskell";
      version = "0.1.0";
      src = self;
      license = pkgs.lib.licenses.cc-by-sa-40;
      executableHaskellDepends = with pkgs.haskellPackages; [
        base
      ];
    };
  });
}

For the full flake, see flake.nix on GitHub or run cat flake.nix. What you see here is a derivation that defines how to build the package, more specifically the haskellPackages.developPackage function provided by Nixpkgs.

The package that results when you run nix build is a CLI tool that outputs a message. To run that tool:

./result/bin/zero-to-nix-haskell

You should see this output:

Hello from inside a Haskell program built with Nix!

Here’s the package definition that builds our JavaScript package:

{
  packages = forAllSystems ({ pkgs }: {
    default = pkgs.buildNpmPackage {
      name = "zero-to-nix-javascript";

      buildInputs = with pkgs; [
        nodejs_latest
      ];

      src = self;

      npmDeps = pkgs.importNpmLock {
        npmRoot = ./.;
      };

      npmConfigHook = pkgs.importNpmLock.npmConfigHook;

      installPhase = ''
        mkdir $out
        cp dist/index.html $out
      '';
    };
  });
}

For the full flake, see flake.nix on GitHub or run cat flake.nix. What you see here is a derivation that defines how to build the package, more specifically the buildNpmPackage function, which is a wrapper around Nix’s built-in derivation function.

The package that results when you run nix build is a website built using the [Vite] framework. To view that website, open the HTML file at result/index.html.

Python 패키지를 빌드할 수 있는 패키지 정의는 다음과 같습니다.

{
  packages = forAllSystems ({ pkgs }: {
    default =
      let
        python = pkgs.python39;
      in
      python.pkgs.buildPythonApplication {
        name = "zero-to-nix-python";

        buildInputs = with python.pkgs; [ pip ];

        src = ./.;
      };
  });
}

전체 플레이크는 GitHub에서 flake.nix를 참조하거나 cat flake.nix를 실행하세요. 여기 보이는 것은 패키지 빌드 방법을 정의하는 derivation입니다. 더 구체적으로는 Nix의 내장 derivation 함수를 감싸는 buildPythonApplication 함수입니다.

결과 패키지는 터미널에 출력하는 실행 파일입니다. 패키지를 실행하려면 다음을 수행하세요.

./result/bin/zero-to-nix-python

다음과 같은 터미널 출력이 표시됩니다.

Hello from inside a Python program built with Nix!

다음은 Go 패키지를 빌드할 수 있게 해주는 패키지 정의입니다.

{
  packages = forAllSystems ({ pkgs }: {
    default = pkgs.buildGoModule {
      name = "zero-to-nix-go";
      src = self;
      vendorHash = "sha256-Ay1/QqbO2MyYgqJZKxrt1FZzLSgXbhSK3ceFPUlFujw=";
      goSum = ./go.sum;
      subPackages = [ "cmd/zero-to-nix-go" ];
    };
  });
}

전체 플레이크는 GitHub에서 flake.nix를 참조하거나 cat flake.nix를 실행하세요. 여기 보이는 것은 패키지 빌드 방법을 정의하는 derivation입니다. 더 구체적으로는 Nix의 내장 derivation 함수를 감싸는 buildGoModule 함수입니다.

nix build를 실행하면 Gin 프레임워크를 사용하여 빌드된 웹 서버 패키지가 생성됩니다. 패키지를 실행하려면 다음을 수행하세요.

./result/bin/zero-to-nix-go

다른 창에서 curl http://localhost:8080을 실행하여 서버로부터 메시지를 받습니다.

Rust 패키지를 빌드할 수 있게 해주는 패키지 정의는 다음과 같습니다.

{
  packages = forAllSystems ({ pkgs }: {
    default =
      let
        rustPlatform = pkgs.makeRustPlatform {
          cargo = pkgs.rustToolchain;
          rustc = pkgs.rustToolchain;
        };
      in
      rustPlatform.buildRustPackage {
        name = "zero-to-nix-rust";
        src = ./.;
        cargoLock = {
          lockFile = ./Cargo.lock;
        };
      };
  });
}

전체 플레이크는 GitHub에서 flake.nix를 참조하거나 cat flake.nix를 실행하세요. 여기 보이는 것은 패키지 빌드 방법을 정의하는 derivation입니다. 더 구체적으로는 Nix의 내장 derivation 함수를 감싸는 buildRustPackage 함수입니다.

터미널에 출력되는 실행 파일인 결과 패키지를 실행하려면 다음을 실행하세요.

./result/bin/zero-to-nix-rust

You should see this terminal output:

Hello from Nix + Rust!

거짓말은 하지 않겠습니다. Scala 패키징은 꽤 까다롭습니다. 다행히도 sbt-derivation이라는 서드파티 프로젝트가 있는데, 이 프로젝트는 Nix의 내장 derivation 함수를 감싸는 편리한 mkSbtDerivation 함수를 포함하여 유용한 도우미들을 제공합니다.

이 패키지의 전체 구성 요소는 GitHub에서 flake.nix를 참조하거나 cat flake.nix를 실행하세요. 터미널에 출력되는 실행 파일인 최종 패키지를 실행하려면 다음을 실행하세요.

./result/bin/zero-to-nix-scala

You should see this terminal output:

Hello from Nix + Scala!