Getting Started with NixOS Flakes: A Modern Approach to Configuration Management
Published: 2023-09-01 14:59:21

## Introduction

NixOS, a Linux distribution with a unique approach to package management and system configuration, has gained popularity for its declarative and reproducible system setups. One of the recent additions to the NixOS ecosystem is "flakes," a feature that enhances package management and configuration. In this blog post, we'll introduce you to Nix flakes and explore their benefits using a sample Nix Flake configuration.

## What Are NixOS Flakes?

Before we dive into the "how," let's clarify the "what." NixOS Flakes represent a paradigm shift in the way you define, manage, and share your NixOS configurations and packages. They provide a more structured and efficient way to work with Nix expressions and Nixpkgs—the Nix packages collection.

Here are some key features of NixOS Flakes:

### 1. **Reproducibility**

Flakes promote reproducibility by ensuring that your NixOS configurations and packages are consistent across different environments and over time. This is vital for system administrators and developers who require stable and predictable system setups.

### 2. **Atomic Updates**

NixOS Flakes allow you to update your NixOS system configuration or package set as a single, atomic operation. This minimizes the risk of breaking your system during updates, a common concern in traditional Linux distributions.

### 3. **Declarative Configuration**

Just like traditional NixOS configurations, you can declare your system's configuration using Flakes. This declarative approach simplifies configuration management, making it easier to understand and maintain.

### 4. **Unified Configuration and Packages**

With Flakes, you can specify both your Nixpkgs (the package collection) and NixOS configuration in a single `flake.nix` file. This unification streamlines the management of your system and packages, reducing complexity.

### 5. **Modularity**

Flakes support a modular approach to configuration management. You can split your configuration into smaller pieces and manage them separately. This is particularly useful for large-scale systems and complex setups.

## Getting Started with NixOS Flakes

Now that we understand the "why" let's move on to the "how." Getting started with NixOS Flakes is relatively straightforward, especially if you're already familiar with Nix or NixOS.

### Prerequisites

To work with NixOS Flakes, you'll need:

- **Nix**: Ensure you have Nix installed on your system. You can find installation instructions for your platform on the [Nix website](https://nixos.org/manual/nix/stable/#chap-installation).
- **Nix 2.4 or newer**: Flakes require at least Nix version 2.4. You can check your Nix version with `nix --version`.
- Flakes Enabled: Flakes is a experimental feature and requires manual activation [more info](https://nixos.wiki/wiki/Flakes).

### Step 1: Create a Flake

1. **Initialize a New Flake**:
    
    Start by creating a new directory for your NixOS Flake project:
    
    ```bash
    mkdir my-nixos-flake
    cd my-nixos-flake
    ```
    
    Then, initialize a new Flake:
    
    ```bash
    nix flake init
    ```
    
    This command sets up the basic structure for a NixOS Flake.

![Creating a Flake](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/azb5yigv1dxws5soev2u.png)
    
2. **Edit `flake.nix`**:
    
    Open the `flake.nix` file in your favorite text editor. This file is where you define your NixOS configuration and any packages you want to include.
    
    For example, you can define your system configuration like this:
    
    ```nix
    {
      description = "Sample Nix Flake";
    
      inputs = {
          nixpkgs.url = "github:nixos/nixpkgs/nixos-unstable";
      };
    
      outputs = { self, nixpkgs }:
      let
          system = "x86_64-linux";
          pkgs = nixpkgs.legacyPackages.${system};
      in
      {
          devShells.${system}.default  =
          pkgs.mkShell
            {
              buildInputs = [
                pkgs.neovim
                pkgs.vim
                pkgs.nodejs_18
              ];
    
              shellHook = ''
                echo "Hello World"
              '';
            };
      };
    }
    ```
    
    Be sure to customize this file according to your system's requirements.

![Edit nix.conf](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/vpfh6u0o77v01na128wv.gif)
    
### Breaking Down the Configuration
    
1. **`description`**: This field provides a short description of your Flake, making it easier for others (and your future self) to understand its purpose.
2. **`inputs`**: Here, we specify the input flakes that our configuration depends on. In this case, we're using the `nixpkgs` flake from the NixOS GitHub repository.
3. **`outputs`**: This section defines what the flake produces. In our example, we have a `devShells` output that provides a development shell environment for the specified system.
4. **`system` and `pkgs`**: These variables help us target the appropriate system (in this case, "x86_64-linux") and retrieve the corresponding package set (`pkgs`) from `nixpkgs`.
5. **`buildInputs`**: Inside `mkShell`, we list the packages we want to include in our development environment. In this case, we have Neovim, Vim, and nodejs_18 as build inputs.
6. **`shellHook`**: This section allows you to specify custom shell code that will be executed when you enter the development shell. Here, we're echoing "Hello World" as an example.

### Step 2: Using the Sample Flake

To use this sample flake, you need to have Nix and flakes support installed. You can then add it to your NixOS system or use it in a development environment.

Here's how you can use the sample flake:

Enter the development environment:

```bash
nix develop
```

![Starting a Flake](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/fedgerk6n9hpu186jgta.png)

## Conclusion

Nix flakes introduce a more structured and reproducible way to manage Nix packages and configurations. While the sample configuration provided here is relatively simple, you can extend and customize it to suit your specific needs. Flakes are a powerful tool for creating, sharing, and managing Nix setups, making NixOS even more appealing for system administrators and developers seeking a reliable and declarative approach to system configuration and package management.