Introducción

Durante mucho tiempo fui usuario de Windows, pero un día decidí probar Linux y terminé por elegirlo como mi sistema operativo para trabajar. Depende de cuando leas esto quizá el cambio haya sido al revés. Pero lo dicho, llegando a un mundo nuevo para mí, decidí probar distintas distribuciones Linux para encontrar cuál era la que mejor se adaptaba al uso que le daría. Tras ver un curso en CodelyTV, pude aprender que la configuración tediosa que hacemos día tras día desde que iniciamos en una máquina se puede resumir en la simple ejecución de un script, y puedo decir que ojalá haber conocido está práctica tan simple, pero que aporta y ayuda tanto a la configuración personal.

¿Qué es un dotfile?

Las configuraciones específicas del usuario se almacenan tradicionalmente en los llamados dotfiles (archivos cuyo nombre comienza con un punto). Es una práctica común versionarlos con un sistema de control de versiones como Git para realizar un seguimiento de los cambios y sincronizarlos en varias máquinas. Es decir, gracias a esta práctica podremos pasar a una máquina nueva y configurarla a nuestro gusto, tal y como estaba la anterior de una forma muy rápida y con el mínimo esfuerzo.

En este post estaré enseñando como tener nuestro repositorio centralizado de archivos de configuración de nuestra máquina. Veremos todas las cosas que podemos automatizar (que yo he descubierto y entendido por el momento) y entre todos aprenderemos como exprimir esta práctica.

La guía

Entendiendo el workflow

Como he dicho anteriormente, el objetivo es centralizar todas las configuraciones en un repositorio, así que el proceso que debemos realizar ahora es el siguiente:

Identifica un archivo o carpeta de configuración que comienza por un punto en nuestra home (directorio raiz de tu usuario) y que queremos guardar ( usa ls -a para listarlas)
Mueve una carpeta o archivo desde la home a la carpeta “.dotfiles”
Crea un enlace simbólico para que la configuración pueda ser accedida desde la home pero estando realmente alojada en la subcarpeta “.dotfiles”( ejemplo: ln -s .dotfiles/.gitconfig $PWD/.gitconfig)

Ejemplo

mv .bashrc .dotfiles
ln -s .dotfiles/.bashrc $PWD/.bashrc

Resultado
.bashrc -> .dotfiles/.bashrc

Si necesitas borrar un enlace simbólico porque te has equivocado o la ruta donde lo almacenas ha cambiado, puedes usar el comando unlink : ( Ejemplo) unlink .bashrc

Ahora sí, es momento de automatizar esto

📦 El repo

He creado un repositorio en Github llamado “dotfiles”, que posteriormente clonaré en local en la carpeta “.dotfiles” que se alojará en mi home.

git clone git@github.com:raulpadilladelgado/dotfiles.git .dotfiles

🚫 Exclusión

Pongamos el caso de que en una carpeta queremos versionar varias carpetas, pero hay una que concretamente no queremos tener. Usemos el tan querido .gitignore.

Ejemplo:

.gitignore

shell/zsh/**/**.zwc 
shell/zsh/**/**.zwc.old 
/**/**/private-*

🏗️ Estructura

Todo organizado se encuentra mejor y luce mejor. No hay un convenio de carpetas para los dotfiles (aunque puede usar el de CodelyTV) pero puedes aplicar tu habilidad de organización para crear las distintas carpetas para los distintos programas y que quede todo organizado.

⚙️ Scripts

Para symlinks

Antes estuvimos haciendo uso de los symlinks para nuestro propósito de los dotfiles, pero era un trabajo un muy manual. Para mejorarlo y que solo la tengamos que realizar una vez, podemos hacer un script que ejecutemos cada vez que cambiemos de máquina para poder tener los dotfiles configurados en nuestra máquina de la forma más rápida y sencilla posible.

Para programas

Ya hemos visto como utilizar los dotfiles para guardar nuestros archivos de configuración y demás, pero podríamos ir un paso más allá, teniendo en nuestro proyecto de dotfiles una forma que nos permita instalar todos nuestros programas en un momento.

Opción 1 - Importamos una lista de programas que teníamos instalados

La idea es poder llevarnos la referencia de los programas que tenemos instalados para después importarlos.

Exportación

Primero vamos a sacar la lista de los programas instalados.

Si tienes MacOS, puedes usar brew para exportar e importar los programas instalados. Dicha utilidad viene instalado por defecto en MacOS.

brew bundle dump --file="$HOMEBREW_BUNDLE_FILE_PATH" --force

Si tienes Debian o derivadas, puedes usar apt para exportar los programas instalados.

sudo dpkg-query -l | awk '{if ($1 == "ii") print $2}' > packages_list.txt

Si usas Windows, puedes usar winget, el cual lleva un tiempo integrado en el sistema asi que si sueles actualizar tu PC deberías tenerlo ya.

winget export exported_winget.txt

Por último, si quieres guardas lo que has instalado con Pip (gestor de paquetes de Python) o NPM (gestor de paquetes de Node), puedes usar el siguiente comando:

#Para pip (gestor de paquetes python)
pip freeze >"$DOTFILES_PATH/langs/python/requirements.txt"

#Para npm (gestor de paquetes de node)
ls -1 /usr/local/lib/node_modules | grep -v npm >"$DOTFILES_PATH/langs/js/global_modules.txt"

Importación

Ahora que ya tenemos los programas exportados en un archivo, podemos importarlos en nuestra nueva máquina.

Si has usado brew, puedes usar el siguiente comando:

brew bundle --file="$HOMEBREW_BUNDLE_FILE_PATH" --force

Si has usado apt, puedes usar el siguiente comando:

sudo xargs -a packages_list.txt apt install

Si has usado winget, puedes usar el siguiente comando:

winget import exported_winget.txt

Si has usado pip o npm, puedes usar el siguiente comando:

#Para pip
pip install -r "$DOTFILES_PATH/langs/python/requirements.txt"

#Para npm
xargs -I_ npm install -g "_" <"$DOTFILES_PATH/langs/js/global_modules.txt"

¿Usas paquetes snap?. Este gestor de paquetes que usan las distribuciones de canonical permite la exportación e importación de los datos de las aplicaciones instaladas. Para ello, sigue los siguientes pasos:

Vacía el directorio (para tener solo la última copia de seguridad de cada programa): /var/lib/snapd/snapshots

Exportación (nos dará un ZIP por programa): snap save

Mueve los archivos a tu proyecto de dotfiles: mv /var/lib/snapd/snapshots .dotfiles/apps/snap

Haz un symlink a la ruta /var/lib/snapd/snapshots

Instala los snap en la máquina nueva (puedes hacer un script que te lea la lista): snap install app1 app2 app3

Finalmente, ejecuta la restauración (el ID es el número por el que comienzan todos los archivos zip, debería ser sencillo porque probablemente todos se te hayan exportado con el mismo ID haciendo referencia a que se exportaron en el mismo proceso): snap restore <id>

Algunas apps como spotify llegan a pesar 1 GB que entiendo que puede ser por temas de caché y canciones descargadas, por lo que sería conveniente reducirlo primero antes de añadirlo al proyecto o no incluir algo así.

Opción 2 - Creamos nuestro propio script de instalación

Además de crear tu propio script, también puedes hacer uso de algunos predeterminados como es Alfred o cualquier otro que encuentres y que te sea útil. Igualmente, la manera de crear el nuestro propio es muy sencilla. Te ejemplifico uno:

#!/bin/bash
#Get ROOT access (only need to specify a password one time)
echo <paswword> | sudo -S echo 
echo "Now you can use sudo without given password"
#Install via apt
sudo apt install app1 app2 app3 -y
#Fix failed installations
sudo apt install -f -y
#Install via snap
sudo snap install app1 app2 app3

Tras tener nuestro script solo nos queda darle permisos de ejecución y ejecutarlo.

Cabe destacar que ambas opciones son compatibles entre sí, por lo que puedes usar ambas a la vez. Si por lo que sea con la primera opción no consigues exportar algún programa, puedes añadirlo en tu segunda opción a tu script de instalación.

Me quiero llevar las bases de datos que tengo configuradas en IntelliJ

En este caso he optado por copiar en un archivo txt las conexiones y también el archivo donde IntelliJ almacena las claves que recuerda para la configuración de una conexión. ¿Cómo lo hice?, muy sencillo:

Para copiar la configuración de una conexión

Si tienes varios data sources que quieres guardar, simplemente selecciónalos todos a la vez y elige la misma opción que lo que hará será copiar todos a la vez.

Para llevarte las contraseñas

Vamos a cambiar como IntelliJ almacena las contraseñas para que lo haga en un archivo que incluyamos en nuestro dotfile. Nos vamos a:

File | Settings | Appearance and behavior | System settings | Passwords

Y activamos la siguiente opción

Ahora ya podemos añadir a nuestro dotfile el archivo que se muestra en el path.

Busca ejemplos comunes que se apliquen a ti

Cada uno puede tener sus casos personales en los que tiene que guardar unas cosas u otras, pero llegados a este punto hay muchos que son comunes para usuarios de Linux, MacOS o Windows. Las configuraciones de la shell que uses, la configuración de git, amazon wer services, scripts para agilizar los symlinks, etc. Seguro que por GitHub puedes encontrar muchos ejemplos como el de CodelyTV que te expliqué más arriba. Te puedo ejemplificar como quedó la estructura de uno propio muy sencillo a medida que he ido comprendiendo como trabajar con estos archivos.

Conclusión

Con mi propia experiencia te puedo decir que lo mejor es que el proyecto debe vaya evolucionando a tus necesidades haciendo que crezca a medida que lo necesitas, de esta manera tendrás el control y no se volverá un caos. No intentes añadir demasiado ya sea visto en otras plantillas o demás si no lo comprendes o necesitas.

Finalmente, si te ha gustado o tienes otras ideas, tips, mejoras… no dudes en proponerlas.