Qué son los archivos dotfiles y cómo gestionarlos con chezmoi

A lo largo de los meses y años de uso de un equipo los usuarios vamos configurando el sistema con las aplicaciones necesarias y configurando esas aplicaciones a las preferencias de cada usuario. El problema es que cuando hay que mudarse a otro sistema porque se cambia a un equipo más nuevo y potente o porque deja de funcionar por un motivo de software o por una mala actualización que requiere reinstalar el sistema. Para estos casos y como medida de seguridad es recomendable hacer copias de seguridad de los datos con lo que migrarlos a otro equipo es menos complicada. Sin embargo, hacer copias de las configuraciones de los programas no es tán habitual con lo que si no se hace al instalar un nuevo sistema requiere configurarlo tal como se tenía anteriormente lo que requiere una buena cantidad de tiempo que hay que volver a dedicar en una nueva instalación.

En GNU/Linux buena parte de los archivos de configuración de los programas se guardan en los archivos dotfiles.

Qué son los archivos dotfiles

Los archivos dotfiles son archivos dedicados a guardar la configuración de los programas. Se guardan en la carpeta personal del usuario (/home/${usuario}) y se denominan dotfiles porque su nombre empieza por un punto, en GNU/Linux los archivos que empiezan por punto son especiales ya que son archivos que los exploradores de archivos ocultan por defecto.

• Arch Linux Wiki Dotfiles

En GNU/Linux uno de los principales archivos dotfiles es el archivo de configuración de inicio del intérprete de línea de comandos, que en el caso de Bash su archivo dotfile es ~/.bashrc y en el caso de zsh es ~/.zshrc. Al igual que estos dos archivos dotfiles en la carpeta personal del usuario se guardan multitud de otros como la configuración para realizar conexiones SSH cuyos dotfiles de configuración del usuario se guardan en el directorio ~/.ssh. Los propios entornos de escritorio guardan otra buena cantidad de archivos dotfiles con las configuraciones integradas en el entorno de escritorio.

Este es el contenido de mi archivo ~/.bashrc en el que he configurado los colores de los elementos del símbolo del sistema en la línea de comandos, cierta configuración para que el símbolo del sistema cambien cuando el directorio de trabajo es una carpeta de código fuente del sistema de control de versiones de Git.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

#
# ~/.bashrc
#

# If not running interactively, don't do anything
[[ $- != *i* ]] && return

alias ls='ls --color=auto'
PS1='[\u@\h \W]\$ '

#
complete -cf sudo

GIT_PS1_SHOWDIRTYSTATE="true"
GIT_PS1_SHOWSTASHSTATE="true"
GIT_PS1_SHOWUNTRACKEDFILES="true"
GIT_PS1_SHOWUPSTREAM="true"
GIT_PS1_SHOWCOLORHINTS="true"
source ~/.git-prompt.sh

PS1='[\[\033[01;34m\]\u\[\033[00m\]@\[\033[01;35m\]\h\[\033[00m\] \W]\$ '
PROMPT_COMMAND='__git_ps1 "[\[\033[01;34m\]\u\[\033[00m\]@\[\033[01;35m\]\h\[\033[00m\] \W" "]\$ "'

export EDITOR=vim

export SDKMAN_DIR="/home/picodotdev/.sdkman"
[[ -s "/home/picodotdev/.sdkman/bin/sdkman-init.sh" ]] && source "/home/picodotdev/.sdkman/bin/sdkman-init.sh"

Cómo gestionar los archivos dotfiles

Una forma de migrar los archivos dotfiles de un sistema a otro es haciendo una copia de estos y restaurándolos en el otro sistema. Sin embargo, los problemas son que las copias de seguridad no permiten mantener un registro de los cambios que se realizan a cada uno de estos archivos, no es tan fácil mantener sincronizadas todas las copias de los archivos entre varios equipos que pueden ser de diferentes sistemas operativos como GNU/Linux, macOS o Windows y algunos archivos de configuración tienen requerimientos de seguridad que hay que mantener depositados en un almacén seguro como son las claves privadas SSH de conexión o algunas credenciales. Además de programas como el programa KeePassXC para guadar contraseñas y secretos de forma segura también soportan funcionalidades de cifrado y descifrado para algunos datos.

Para dar solución a los problemas de la gestión de los archivos dotfiles hay varios programas específicos para la tarea, en GNU/Linux es chezmoi que también está disponible para otros sistemas operativos como macOS e incluso Windows. También es posible utilizarlo en máquinas virtuales.

El programa chezmoi y guía de uso para gestionar archivos dotfiles

chezmoi es uno de los programas dedicados a la tarea de gestionar los archivos de configuración dotfiles, hay otros varios pero chezmoi en su lista de características que soporta chezmoi comparándolo con las alternativas lo hacen más potente, además al estar basado en Go generalmente los programas en este lenguaje se componen de un único binario hace que sean muy fácilmente de instalar y fiable al carecer de dependencias externas.

Muchas de estas herramientas para gestionar archivos dotfiles se basan en un repositorio de Git en el que mantienen el control de versiones de los archivos y de cada uno de los cambios que se realizan en ellos. Entre las funcionalidades que ofrecen además de mantener el control de versiones están facilitar las tareas de uso básico como subir cambios al repositorio de Git para aplicar a otros sistemas o a un nuevo sistema y aplicar cambios al sistema local provenientes de otros sistemas, soportan variables y plantillas con las que generar el contenido de los archivos de forma dinámica y obtener datos de programas de base de datos que guardan secretos como KeePassXC entre muchos otros gestores de contraseñas.

Inicialización del repositorio

En la distribución Arch Linux el programa chezmoi se instala instalando su paquete con el gestor de paquetes. En otras distribuciones basadas en Debian o Fedora basta con buscar el nombre del paquete equivalente en esas distribuciones e instalarlo con su gestor de paquetes.

1
2

$ sudo pacman -S chezmoi

El siguiente paso es crear el repositorio de Git en local con los siguientes comandos, añadir el origen del repositorio remoto que hay que crear previamente en este caso usando un repositorio de GitHub y subir el contenido inicial.

1
2
3
4

$ chezmoi cd
$ git remote add origin https://github.com/picodotdev/dotfiles.git
$ git push -u origin main
$ exit

Compartir archivos dotfiles entre máquinas

Para inicializar el repositorio de Git de los archivos dotfiles a partir del contenido de uno existente se utiliza este comando. Aunque los archivos se puede compartir entre máquinas incluso de diferentes sistemas operativos la intención es que todos esos archivos de dotfiles de un usuario compartan la mayor similitud posible, aunque a veces por las diferencias de las máquinas no es completamente posible. Para ayudar a compartir lo más posible están las variables y plantillas, en caso de necesidad es posible administrar un dotfile completamente diferente según el sistema operativo añadiendo condiciones en las plantillas.

1
2

$ chezmoi init https://github.com/picodotdev/dotfiles.git

Ver cambios sin aplicarlos

El siguiente comando aplica los cambios a los archivos dotfiles locales a partir del contenido del repositorio de archivos dotfiles de chezmoi. Con las opciones -v se muestra información más detallada de los cambios que se aplican, y con -n permite ver que cambios se aplicarían en caso de realizar la acción sin la opción, sus opciones en formato largo son -verbose y –dry-run.

1
2

$ chezmoi --verbose --dry-run update
$ chezmoi update

El comando update actualiza el repositorio Git local con los cambios del repositorio origen y aplica los cambios a los archivos dotfiles. Otros comandos útiles son diff para ver las diferencias entre el repositorio de Git y los archivos locales, el comando apply aplica los cambios sobre los archivos dotfiles. Es importante tener en cuenta que los cambios en los dotfiles locales se sobrescriben y se pierden en caso de tener diferencias con su versión en el repositorio de Git de chezmoi.

1
2

$ chezmoi diff
$ chezmoi apply

Realizar cambios en los archivos dotfiles

Al empezar a usar chezmoi y a medida que se desean guardar las configuraciones de los archivos dotfiles hay que añadir los archivos y sus cambios al repositorio de Git de los archivos dotfiles. El comando que permite añadir un archivo al repositorio es add.

1
2

$ chezmoi add .bashrc

chezmoi permite editar el contenido de un archivo y añadirlo al repositorio automáticamente con el comando edit. Si un archivo dotfile se modifica con un programa externo hay que utilizar el comando add para añadirlo al repositorio después de que la aplicación haya hecho el cambio.

1
2

$ chezmoi edit .bashrc

Editar un archivo con un programa externo

1
2

$ vim .bashrc
$ chezmoi add .bashrc

• Daily operations
• How do I edit my dotfiles with chezmoi?

El editar un dotfile se puede configurar para que chezmoi lo añada al repositorio y lo suba al origen. El propio archivo de configuración de chezmoi ubicado en ~/.config/chezmoi/chezmoi.yaml es un dotfile que se puede añadir al repositorio de dotfiles. El archivo de configuración soporta varios formatos entre ellos toml y yaml.

1
2
3

git:
   autoCommit: true
   autoPush: true

Subir al repositorio cambios en los archivos dotfiles

Después de realizar cambios en los archivos dotfiles estos quedan en el repositorio de Git local en el directorio de trabajo, para subir los archivos al repositorio de Git origen es necesario hacer el commit y el push en el repositorio. chezmoi proporciona varios comandos de utilidad para trabajar con el repositorio de Git en el que se guardan los dotfiles.

Con el comando cd se entra en un modo de edición del repositorio de Git, usándolo el directorio actual de trabajo se cambia a la carpeta del repositorio de Git. Para salir de este modo hay que usar el comando exit.

1
2

$ chemoi cd

Con la carpeta de trabajo del símbolo del sistema en el repositorio de Git es posible utilizar los comandos como en cualquier otro repositorio de Git.

1
2
3

$ git status
$ git add .
$ git commit -m "Initial commit"

Si no se quiere entrar en el modo de edición del repositorio de Git se ofrece un comando para actuar contra el repositorio de Git de los dotfiles aunque el directorio de trabajo actual sea otro, anteponiendo chezmoi a lo que es el comando de git que se aplica sobre el repositorio de Git de los dotfiles.

1
2

$ chezmoi git status

Variables y plantillas

Algunos datos de los archivos dotfiles para compartirlos entre máquinas o para externalizarlos de los archivos permite guardarlos de forma externa. chezmoi soporta plantillas, una plantilla se procesa junto varias las variables y genera el contenido del archivo final del dotfile. Las plantillas no solo soportan variables sino también expresiones con condiciones.

• More complicated logic

En el caso de querer considerar a un archivo como una plantilla hay que usar el siguiente comando al añadir lo para que sea administrado.

1
2

$ chezmoi add --template ~/.bashrc

Las variables se definen en el archivo de configuración de chezmoi.

1
2
3
4
5

data:
  linux:
    username: picodotdev
  macos:
    username: worker

Además de variables propias en el archivo de configuración, chezmoi añade las suyas entre las que se pueden utilizar.

1
2

$ chezmoi data

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

{
  "chezmoi": {
    "arch": "amd64",
    "args": [
      "chezmoi",
      "data"
    ],
    "cacheDir": "/home/picodotdev/.cache/chezmoi",
    "configFile": "/home/picodotdev/.config/chezmoi/chezmoi.yaml",
    "executable": "/usr/bin/chezmoi",
    "fqdnHostname": "archlinux",
    "group": "picodotdev",
    "homeDir": "/home/picodotdev",
    "hostname": "archlinux",
    "kernel": {
      "osrelease": "5.16.5-arch1-1",
      "ostype": "Linux",
      "version": "#1 SMP PREEMPT Tue, 01 Feb 2022 21:42:50 +0000"
    },
    "os": "linux",
    "osRelease": {
      "ansiColor": "38;2;23;147;209",
      "bugReportURL": "https://bugs.archlinux.org/",
      "buildID": "rolling",
      "documentationURL": "https://wiki.archlinux.org/",
      "homeURL": "https://archlinux.org/",
      "id": "arch",
      "logo": "archlinux-logo",
      "name": "Arch Linux",
      "prettyName": "Arch Linux",
      "supportURL": "https://bbs.archlinux.org/"
    },
    "sourceDir": "/home/picodotdev/.local/share/chezmoi",
    "username": "picodotdev",
    "version": {
      "builtBy": "",
      "commit": "",
      "date": "2022-02-02T13:17:34Z",
      "version": "2.11.0"
    },
    "workingTree": "/home/picodotdev/.local/share/chezmoi"
  }
}

En los archivos de plantilla las variables se referencian con la siguiente expresión entre llaves.

1
2

{{ .chezmoi.username }} {{ .chezmoi.os }}

El comando execute-template permite evaluar una plantilla con el contenido de las variables, esto permite comprobar el funcionamiento de las plantillas y comprobar que generan el contenido deseado al evaluarse, a partir de una plantilla proporcionada como argumento del programa o desde el contenido de un archivo de plantilla.

1
2

$ chezmoi execute-template "{{ .chezmoi.username }} {{ .chezmoi.os }}"
$ chezmoi execute-template < dot_zshrc.tmpl

Gestionar secretos

Algunas variables por su contenido sensible por motivos de seguridad hay que protegerlos y no deben ser compartidos, esto es importante tenerlo en cuenta ya que el contenido que se usa al repositorio de los dotfiles cualquier usuario que tenga acceso a él puede ver su contenido, esto incluye credenciales e incluso claves SSH. Estos secretos se han de almacenar de forma diferente y no el repositorio de Git de los dotfiles sobre todo si el repositorio de Git es público como puede ser el caso de si se utiliza un hospedaje como GitHub.

La forma que utiliza chezmoi para guardar estos secretos es utilizar un programa de base de datos cifrada para guardar credenciales como los gestores de contraseñas. Uno de ellos es KeePassXC pero chezmoi soporta muchos entre los que están los más populares. chezmoi es capaz de recuperar usuarios, contraseñas e incluso valores de atributos del apunte guardado en la base de datos cifrada.

• Password manager integration

La siguiente variable de configuración indica donde se guarda la base de datos de secretos en este caso de KeePassXC.

1
2

keepassxc:
   database: "/home/user/Credentials.kdbx"

Y en las plantillas se utiliza la siguiente expresión para recuperar credenciales del apunte indicado y valores de atributos que puede ser cualquier contenido como una clave SSH privada.

1
2
3

username = {{ (keepassxc "example.com").UserName }}
password = {{ (keepassxc "example.com").Password }}
{{ keepassxcAttribute "SSH Key" "private-key" }}

Otras características

Los dotfiles de algunos programas son más complejos de los de este ejemplo y hay varios programas que los utilizan, ¿no sería maravilloso poder utilizar los archivos de otros usuarios que comparten en sus repositorios de dotfiles? lo es y es posible utilizar estos archivos dotfiles de otros usuarios, no solo para utilizarlos sino como ejemplo de cómo se configura alguna propiedad del dotfile sobre todo si la documentación oficial del dotfile no es amplia o no es lo suficientemente clara. En la wiki de Arch Linux hay una colección de repositorios de usuarios con ejemplos de dotfiles con ejemplos para intérpretes de comandos, gestores de ventanas y entornos de escritorio, editores, terminal, multiplexores de terminal entre varios otros programas.

• Include dotfiles from elsewhere

chezmoi también soporta cifrado con la utilidad de cifrado gpg y age, si se quiere guardar algún dotfile sensible en el repositorio de Git sin exponer su contenido pero sin utilizar un gestor de contraseñas.

• Encryption