Gerard Braad (dotfiles)

Gerard Braad's dotfiles using `git`, `stow`, and `zsh`

These are my dotfiles that I use for all my workstation and developement environments on a daily basis. I share it because I got frustrated about moving a tarball around (and being scared of losing it). This eventually happened when my notebook got stolen. It is 'very personal' (my way of working), so, this is not an ideal solution for you. Treat it as, "what you see is what it is"...

These dotfiles are based around a few helpers that deal with setting up development containers, network functions and connectivity to my homelab services

dotfiles
handles installation and update of my dotfiles
devenv, devbox
deals with running instant development environments as containers with Podman
machine
create VMs using bootc image-based deployments of devenv, homelab, apps and others, utilizing macadam and machinefile
proxy
sets environment to use a proxy to access services
davfs
connects to remote WebDAV endspoints for file sharing
tailscale
aliases and commands for use with my tailnet
secrets
simple encrypt and decrypt for tokens and TOTP
app
installing and running according to application definitions as Actionfiles
action / run
automation framework using Actionfiles, a markdown-based file for script execution
screen
smart(er) handling of local and remote screen session with tmux
dotini, appini
global and local configuration of dotfiles, and applications, using the Actionfile's config-block or ini-files with git config
playbook, notebook
helpers to execute and edit Ansible playbooks and Jupyter notebooks
Applications
apps, actions, devenvs, machines, services, userctl, playbooks, notebooks, ...
...

Note

Since I continously change how I work, so do these files and scripts. Do not use this directly, but take parts and learn from it.

Related side-projects

Actionfile

A Markdown-based configuration file that describes a set of actions, scripts, or tasks for use in automation workflows

Machinefile

A simple executor that allows you to run Dockerfile/Containerfile commands directly on a local or remote host

One-line install

curl -fsSL https://dotfiles.gbraad.nl/install.sh | sh

Note

This script uses the stable downstream to install.

Extensions for VS Code

Dotfiles checker - Marketplace, Open VSX Registry

An extension that checks for and install my personal dotfiles

Dotfiles tools - Marketplace, Open VSX Registry

An extension that automates devenv.zsh and machine.zsh.

Dot environment (`.dotfiles` without install)

settings.json

{
    "terminal.integrated.defaultProfile.linux": "dot",
    "terminal.integrated.profiles.linux": {
        "dot": {
            // absolute path is necessary (no variables)
            "path": "/home/.../.dotfiles/bash/.local/bin/dot"
        },
        "dotscreen": {
            "path": "/home/.../.dotfiles/bash/.local/bin/dotscreen"
        }
    }
}

tasks.json

{
    "version": "2.0.0",
    "tasks": [
        {
            "label": "dot",
            "type": "shell",
            "problemMatcher": [],
            "command": "~/.dotfiles/bash/.local/bin/dot"
            //"command": "zsh"    // when dot is used as default terminal
        },
        {
            "label": "dotscreen",
            "type": "shell",
            "problemMatcher": [],
            "command": "~/.dotfiles/bash/.local/bin/dotscreen"
            //"command": "screen"
        }
    ]
}

Note

Tasks are run in the default termina. If this is set to dot, any function that has been defined, can be run directly.

Feature for devcontainers

Install my personal dotfiles as a feature during the devcontainer build process.

    "features": {
        "ghcr.io/gbraad-dotfiles/devcontainer-features/dotfiles:latest": {}
    }

Containers

These are container images with the dotfiles and dependencies installed, able to run as a system container.

devenv dotfedora env, dev dotfedora [system|shell|exec] for Fedora
devenv dotdebian env, dev dotdebian [system|shell|exec] for Debian
... dotalma for AlmaLinux
... dotcentos for CentOS Stream
... dotubi9 for RHEL UBI9
... dotubuntu for Ubuntu
... dotalpine for Alpine

Image-based Virtual Machines

The machine.zsh-helper assists in the process to set up and run image-based virtual machines. This is called a Bootable Container (bootc). Disk images are stored as OCI artifacts.

$ machine dotfiles [download|create|start|console]

Manual process using `virt-install`

You can otherwise also run

$ wget https://github.com/gbraad-dotfiles/upstream/releases/download/250223/almalinux-disk.qcow2 \
     -O base.qcow2
$ sudo virt-install \
    --name base --os-variant fedora-eln \
    --cpu host --vcpus 4 --memory 4096 \
    --import --disk ./base.qcow2,format=qcow2

Instant Developer Environments

Fedora, with golang
Debian, with golang
AlmaLinux, with golang
CentOS, with golang
UBI9, with golang
Ubuntu, with golang

Usage in Jupyter notebooks

%load_ext dotfiles

%%dotscript
country

> The Netherlands

%%dotscript
proxy ndisguise
country

> Germany

out=%dotini dotfiles file
%code out ini

out=%dot ps ax
%code out

%app list services
%app pinger service install
%app pinger service status

Note

To use the extension, stow ipython needs to be run. More information can be found in the dedicated gbraad-dotfiles/notebooks repository with examples.

GitHub Actions

GitHub Action: `install-action`

      - name: Install dotfiles action
        uses: gbraad-dotfiles/install-action@main

GitHub Action: `dotfiles-action`

      - name: Run dotfiles command
        uses: gbraad-dotfiles/dotfiles-action@main
        with:
          action: update

GitHub Action: `devenv-action`

      - name: Run devenv command
        uses: gbraad-dotfiles/devenv-action@main
        with:
          prefix: dotfedora
          command: exec  #  [create/system/noinit|start|apps|...]
          args: cat /etc/os-release

GitHub Action: `devbox-action`

      - name: Run devbox command
        uses: gbraad-dotfiles/devbox-action@main
        with:
          prefix: fedora
          command: exec  #  [create|start|apps|...]
          args: cat /etc/os-release

GitHub Action: `machine-action`

      - name: Run machine command
        uses: gbraad-dotfiles/machine-action@main
        with:
          prefix: dotfedora
          command: download   #  [create|start|stop|...]

GitHub Action: `app-action`

      - name: Run app install
        uses: gbraad-dotfiles/app-action@main
        with:
          appname: vivaldi
          action: install

GitHub Action: `dot-action`

      - name: Requiremnent for dot
        run: |
          sudo apt update
          sudo apt install -y zsh

      - name: Run dot command - devenv dotfedora exec cat /etc/os-release
        uses: gbraad-dotfiles/dot-action@main
        with:
          run: |
            devenv dotfedora exec cat /etc/os-release

Note

This runs the specified commands without the need to 'install' the dotfiles. It is required for the runner to have zsh installed.

Ansible

Ansible role: `gbraad.dotfiles` and playbooks

    - name: Install dotfiles
      hosts: localhost
      roles:
        - role: gbraad.dotfiles
          vars:
            user: gbraad

Ansible role: `gbraad.dotfiles-devenv`

    - name: Run devenv command
      hosts: localhost
      roles:
        - role: gbraad.dotfiles-devenv
          vars:
            prefix: gofedora
            command: start

Ansible role: `gbraad.dotfiles-apps`

    - name: Run app installs
      hosts: localhost
      roles:
        - role: gbraad.dotfiles-apps
          vars:
            appname: vivaldi
            action: install

Ansible role: `gbraad.dotfiles-machine`

    - name: Run Go build vm
      hosts: localhost
      roles:
        - role: gbraad.dotfiles-machine
          vars:
            prefix: gofedora
            command: start