repository·master·Indexed 43 days ago
https://github.com/nix-community/gomod2nixA tool to convert Go applications using Go modules into Nix expressions for reproducible builds. It provides a CLI to generate gomod2nix.toml files and import Go sources into the Nix store. The project includes the buildGoApplication and mkGoEnv functions to manage Go builds and development environments within the Nix ecosystem.
To use Gomod2nix with Niv, initialize Niv and add the repository. You will then need to configure a shell.nix for your development environment and a default.nix for building your application, both of which must use the gomod2nix overlay.
$ niv init --latest
$ niv add nix-community/gomod2nixTo convert a Go application using Go modules into a Nix expression, follow these steps:
gomod2nix command. This generates a gomod2nix.toml file in your current directory.gomod2nix.toml as the modules argument in a Nix expression that calls buildGoApplication.Note: buildGoApplication must be provided via a Nix overlay as shown in the example below.
$ gomod2nixlet
pkgs = import <nixpkgs> {
overlays = [
(self: super: {
buildGoApplication = super.callPackage ./builder { };
})
];
};
in pkgs.buildGoApplication {
pname = "gomod2nix-example";
version = "0.1";
src = ./.;
modules = ./gomod2nix.toml;
}When using Niv, ensure your Nix files include the gomod2nix overlay.
Use this shell.nix for a development environment containing gomod2nix, niv, and a Go environment:
{ pkgs ? (
let
sources = import ./nix/sources.nix;
in
import sources.nixpkgs {
overlays = [
(import "${sources.gomod2nix}/overlay.nix")
];
}
) :
}:
let
goEnv = pkgs.mkGoEnv { pwd = ./.; };
in
pkgs.mkShell {
packages = [
goEnv
pkgs.gomod2nix
pkgs.niv
];
}Use this default.nix to build your Go application using buildGoApplication with the modules argument pointing to your gomod2nix.toml:
{ pkgs ? (
let
sources = import ./nix/sources.nix;
in
import sources.nixpkgs {
overlays = [
(import "${sources.gomod2nix}/overlay.nix")
];
}
) :
}:
pkgs.buildGoApplication {
pname = "myapp";
version = "0.1";
pwd = ./.;
src = ./.;
modules = ./gomod2nix.toml;
}# shell.nix example
{ pkgs ? (
let
sources = import ./nix/sources.nix;
in
import sources.nixpkgs {
overlays = [
(import "${sources.gomod2nix}/overlay.nix")
];
}
) :
}:
let
goEnv = pkgs.mkGoEnv { pwd = ./.; };
in
pkgs.mkShell {
packages = [
goEnv
pkgs.gomod2nix
pkgs.niv
];
}If you are using Nix Flakes, you can quickly initialize a project using the provided templates.
To start a standard application project:
nix flake init -t github:nix-community/gomod2nix#appTo start a project configured to build container images:
nix flake init -t github:nix-community/gomod2nix#container$ nix flake init -t github:nix-community/gomod2nix#appThe buildGoApplication function is used to create a Nix derivation for building a Go application based on a gomod2nix.toml configuration. It accepts several specific arguments to control the build process, and any additional arguments provided are passed directly to stdenv.mkDerivation.
buildGoApplication {
modules = ./gomod2nix.toml;
src = ./path/to/source;
go = pkgs.go;
subPackages = [ "cmd/myapp" ];
tags = [ "netgo" ];
ldflags = [ "-s -w" ];
nativeBuildInputs = [ pkgs.pkg-config ];
}The mkGoEnv function creates a Nix derivation that sets up a Go development environment. It uses a gomod2nix.toml file for module configuration and can optionally use a tools.go file to define required tools. Other arguments are passed verbatim to stdenv.mkDerivation.
mkGoEnv {
pwd = ./my-project;
modules = ./gomod2nix.toml;
toolsGo = ./tools.go;
}The following arguments are available for mkGoEnv:
| Argument | Description |
|---|---|
pwd | Path to working directory |
modules | Path to gomod2nix.toml (defaults to pwd + "/gomod2nix.toml") |
toolsGo | Path to tools.go (defaults to pwd + "/tools.go") |
Note: All other arguments are passed verbatim to stdenv.mkDerivation.
The following arguments are available for buildGoApplication:
| Argument | Description |
|---|---|
modules | Path to gomod2nix.toml (defaults to pwd + "/gomod2nix.toml") |
src | Path to sources (defaults to pwd) |
pwd | Path to working directory (defaults to null) |
go | The Go compiler to use (can be omitted) |
subPackages | Only build these specific sub packages |
allowGoReference | Allow references to the Go compiler in the output closure (defaults to false) |
tags | A list of tags to pass the Go compiler during the build (defaults to [ ]) |
ldflags | A list of ldflags to pass the Go compiler during the build (defaults to [ ]) |
nativeBuildInputs | A list of packages to include in the build derivation (defaults to [ ]) |
Note: All other arguments are passed verbatim to stdenv.mkDerivation.
Once inside your development shell, use the generate command to create the gomod2nix.toml file required for building.
To optimize build performance by pre-compiling dependencies in the build cache, use the --with-deps flag. This generates a list of imported packages to be pre-compiled, which significantly reduces subsequent build times for projects with many dependencies.
# Basic generation
$ gomod2nix generate
# Generation with dependency pre-compilation
$ gomod2nix generate --with-depsTo speed up development and avoid re-downloading dependencies into the Nix store, you can import them directly from your existing Go cache using the import command.
$ gomod2nix importThe gomod2nix CLI provides two primary modes of operation: generating a gomod2nix.toml file to describe Go dependencies for Nix, and importing Go sources directly into the Nix store.
gomod2nix generate: Runs the gomod2nix.toml generator. This creates a configuration file that describes how to build your Go project in Nix.gomod2nix import: Imports Go sources into the Nix store. This is used when you want to bring specific Go packages into the Nix environment.All flags are persistent and can be used with the commands above:
--dir <string>: The Go project directory. Defaults to ./.--outdir <string>: The directory where the output (e.g., gomod2nix.toml) will be written. Defaults to the project directory.--jobs <int>: The maximum number of concurrent jobs to run. Defaults to 10.--with-deps: A boolean flag. When present, it includes dependencies in gomod2nix.toml to help prime the build cache.# Example: Generate a config file for the current directory with dependency caching
gomod2nix generate --with-deps
# Example: Generate a config file for a specific directory and output it elsewhere
gomod2nix generate --dir ./my-go-app --outdir ./nix-config
# Example: Import packages from a specific directory
gomod2nix import --dir ./my-go-appThe import command is used to bring Go sources into the Nix store. This is typically used when you want to manage Go dependencies as Nix store paths.
Flags for import:
--dir: The Go project directory containing the sources to import.--jobs: The maximum number of concurrent jobs for the import process.# Import sources from a specific directory
gomod2nix import --dir ./my-go-project