Manage Your Systems with Nix Package Manager
Published: 2020-07-13 06:40:11

---
title: Manage Your Systems with Nix Package Manager
published: true
description: Nix Package Manager
tags: 
//cover_image: https://direct_url_to_image.jpg
---

# Nix Package Manager

We will walk through the Nix Package Manager and how we can build immutable systems. This is my first attempt to get Nix for all of my machines mostly Debian's(2 Laptops and 1 Desktop) and a MacBook.

The quickest way to install Nix is to open a terminal and run the following command (as a user other than root with sudo permission):

```shell
curl -L https://nixos.org/nix/install | sh
```

Add `source $HOME/.nix-profile/etc/profile.d/nix.sh` to your .bashrc or .zshrc.

```shell
echo 'source $HOME/.nix-profile/etc/profile.d/nix.sh' >> ~/.bashrc
```
## The Basics

After installation we have some new commands available:

    * nix-env used to install dependencies and alter your current profile
    * nix-shell used to start shells based on nix expressions
    * nix-store used to query or manipulate the nix store

### Install a Package

```shell
nix-env -iA nixpkgs.clojure 

# Output
installing 'clojure-1.10.1.507'
building '/nix/store/y6r745pjimp232bgknncx27a074i4j0z-user-environment.drv'...
created 44 symlinks in user environment
```

### Query a Package

```shell
nix-env -qaP 'consul'

# Output
nixpkgs.consul                      consul-1.7.2
nixpkgs.consul-alerts               consul-alerts-0.6.0
nixpkgs.consul-template             consul-template-0.19.4
nixpkgs.prometheus-consul-exporter  consul_exporter-0.3.0

```

### Uninstall a Package

```shell
nix-env -e clojure

#Output
uninstalling 'clojure-1.10.1.507'
```

# Nix Shell

Nix-shell lets you open a shell in a new environment.

In Nix; an environment is a collection of derivations (aka functions) that are put into your PATH. 
   
We can create an environment by creating a .nix file to define the environment. Create a file called consul.nix with below content

### Derivations

Nix is built around the concept of derivations. A derivation is simply defined as "a build action". It produces 1 (or maybe more) output paths in the nix store.

```shell
with import <nixpkgs> {};

let
  clj = pkgs.clojure;
in
stdenv.mkDerivation rec {
  name = "clojure-environment";

  buildInputs = [
    clj
    pkgs.leiningen
  ];

  shellHook = ''
    echo "using clojure: ${clojure.name}"
  '

```

and finally login to your env shell

```shell
nix-shell packages/clojure.nix
using clojure: clojure-1.10.1.507

```

### To install packages from Non NixOS 

```shell
{ pkgs ? import <nixpkgs> {} }:
with import <nixpkgs> {};

pkgs.stdenv.mkDerivation {
  name = "consul";

  src = pkgs.fetchurl {
    url = "https://releases.hashicorp.com/consul/1.8.0/consul_1.8.0_linux_amd64.zip";

    sha256 = "98df3e0a8ede84794fa4d20b1b6b5d52ad3b983dec916c4d612cecba7c48a421";
  };
  phases = ["unpackPhase" "installPhase"];



  unpackPhase = ''


'';

  installPhase = ''
    mkdir -p $out/bin
    ${pkgs.unzip}/bin/unzip $src -d $out/bin
    chmod +x $out/bin/consul

  '';
}

```

### To run it

```shell
nix-env -f consul.nix -i
```

# The stdenv

The standard build environment in the Nix Packages collection provides an environment for building Unix packages.

To build a package with the standard environment, you use the function stdenv.mkDerivation, instead of the primitive built-in function derivation, e.g.

```shell
with import <nixpkgs> {};

let
  py = pkgs.python;
in
stdenv.mkDerivation rec {
  name = "python-environment";

  buildInputs = [
    py
  ];

  shellHook = ''
    echo "using python: ${python.name}"
  '
```
### The standard environment provides the following packages:
```shell
    The GNU C Compiler, configured with C and C++ support.
    GNU coreutils (contains a few dozen standard Unix commands).
    GNU findutils (contains find).
    GNU diffutils (contains diff, cmp).
    GNU sed.
    GNU grep.
    GNU awk.
    GNU tar.
    gzip and bzip2.
    GNU Make. 
    Bash. 
    The patch command.
```

### Phases
```
    patch phase
    configure phase
    build phase
    check phase
    install phase
    buildup phase
```
 
# Nix Expressions

Nix is not just a package manager. Nix is OS and a Language too.

The Nix expression language is a pure, lazy, functional language. Purity means that operations in the language don't have side-effects (for instance, there is no variable assignment). Laziness means that arguments to functions are evaluated only when they are needed. Functional means that functions are “normal” values that can be passed around and manipulated in interesting ways. The language is not a full-featured, general-purpose language. Its main job is to describe packages, compositions of packages, and the variability within packages.

To read more 

https://nixos.org/nix/manual/#ch-expression-language

In this blog, we just looked into just a small functionality of NIX. NIX is much more than that.

Happy Nixing!