Merge branch '00-fundamentos-de-linux'

Author: crsanti

00-fundamentos-linux/.gitignore

@@ -0,0 +1,2 @@
+.vagrant/
+*.log

00-fundamentos-linux/01-entornos-linux/00-sistema-de-ficheros.md

@@ -0,0 +1,78 @@
+# Sistema de ficheros
+
+En Linux y Unix todo es un fichero. Los directorios son ficheros y los dispositivos son ficheros. Los ficheros están organizados en un árbol jerárquico donde existe la relación padre-hijos (los directorios pueden contener otros directorios u otros ficheros). Todos los ficheros parten de una ruta raíz que se representa con el carácter `/`. Cualquier fichero puede ser referenciado por un nombre de ruta. El directorio `/` sirve como punto de montaje para el resto de directorios del sistema. Un punto de montaje no es más que un directorio vacío que sirve para que sean montados otros directorios de una partición de un disco.
+
+Un nombre de ruta absoluto comienza con el carácter `/` del que siguen todos los directorios hijos que deben ser atravesados para llegar al fichero, cada uno separado por el signo `/`.
+
+Un nombre de ruta relativo es aquel que no comienza por `/`. En este caso el árbol de directorios se recorre a partir de un punto determinado que cambia según el directorio actual donde nos encontremos (contexto). En cada directorio hay dos directorios especiales: `.` que representa el contexto o directorio actual, y `..` que representa al directorio padre del contexto.
+
+Este es un ejemplo de un directorio representado por su ruta absoluta:
+
+```
+/var/lib/
+```
+
+Este es un ejemplo de un fichero representado por su ruta absoluta:
+
+```
+/usr/bin/echo
+```
+
+Este es un ejemplo del directorio anterior representado por ruta relativa tomando `/home/myusername` como contexto actual:
+
+```
+../../var/lib/
+```
+
+Este es un ejemplo del fichero anterior representado por ruta relativa tomando `/usr/` como contexto actual:
+
+```
+./bin/echo
+```
+
+El carácter especial `~` representa el directorio _home_ en forma de ruta absoluta del usuario actual. El directorio _home_ para usuarios finales suelen estar localizados dentro de `/home/` seguidos de una carpeta que representa el _login_ del usuario. Si tenemos un usuario `alfredo` su directorio _home_ será `/home/alfredo`. Esto suele ser diferente de otros usuarios del sistema que son utilizados para ejecutar demonios o procesos en segundo plano. El _home_ del usuario `root` es `/root/`.
+
+Este es un ejemplo de una ruta absoluta de un fichero dentro del directorio `Downloads` de mi _home_ siendo un usuario cuyo login es _alfredo_:
+
+```
+~/Downloads/file.txt
+```
+
+Es equivalente a:
+
+```
+/home/alfredo/Downloads/file.txt
+```
+
+Los ficheros o directorios pueden contener espacios y otros caracteres especiales. Estos caracteres deben escaparse con una `\` a la hora de acceder a ellos o estar encerrados entre comillas.
+
+Los siguientes ejemplos representan directorios con espacios:
+
+```
+~/My\ Videos/
+"~/My Videos/"
+~/"My Videos"/
+```
+
+## Directorios especiales del sistema
+
+La estructura de ficheros del sistema suelen seguir el [Estandar de Jerarquía de Sistema de Ficheros](https://www.pathname.com/fhs/pub/fhs-2.3.html) aunque algunos directorios pueden variar ligeramente según la distribución:
+
+- `/bin` contiene los comandos de terminal más comunes.
+- `/boot` contiene los ficheros necesarios para arrancar el sistema, incluyendo el kernel, la imagen disco RAM y los ficheros de configuración del gestor de arranque.
+- `/dev` contiene todos los ficheros que representan los dispositivos. Estos son tipos de ficheros especiales que apuntan a diferentes.dispositivos hardware en el sistema, incluyendo discos duros.
+- `/etc` contiene los ficheros de configuración del sistema, que afectan al comportamiento del sistema para todos los usuarios.
+- `/home` contiene los directorios principales de los usuarios.
+- `/lib` contiene entre otras cosas módulos de kernel y librerías dinámicas muy importantes
+- `/media` está pensado para ser utilizado como punto de montaje de dispositivos externos (discos duros, CDs, DVDs, etc).
+- `/mnt` también está pensado para ser utilizado como punto de entrada de montaje de dispositivos externos, concretamente los temporales (sistema de ficheros en red, dispositivos extraíbles, etc).
+- `/opt` está pensado para contener software adicional del sistema que no esté manejado por el gestor de paquetes.
+- `/proc` es un sistema de ficheros virtuales que utiliza el kernel como mecanismo para enviar información a los procesos.
+- `/root` es el directorio del usuario administrador.
+- `/run` es un sistema de ficheros temporal para almacenar información de procesos pasajeros.
+- `/sbin` contiene comandos administrativos importantes que suelen ser utilizados por el superusuario.
+- `/srv` está pensado para contener directorios de servicios de sistema como HTTP, FTP, etc.
+- `/sys` es otro sistema de ficheros virtuales del que se puede obtener o establecer configuraciones para el kernel.
+- `/tmp` está concebido para ser un directorio de ficheros temporales para las aplicaciones.
+- `/usr` contiene la mayoría de aplicaciones y utilidades a la que los usuarios tienen acceso.
+- `/var` está dedicado a contener datos variables de aplcaciones como logs, bases de datos, correos.

00-fundamentos-linux/01-entornos-linux/01-gestion-de-paquetes.md

@@ -0,0 +1,199 @@
+# Gestión de paquetes
+
+## Introducción
+
+En los sistemas Linux existen varios métodos para instalar programas en el sistema. La opción más primitiva y abierta es descargar el código fuente del programa, compilarlo e instalarlo asegurándonos previamente que tenemos todas las dependencias instaladas. Este método de instalación provee generalmente de un fichero `Makefile` con el listado de instrucciones para ser usadas por el comando `make` para compilar e instalar.
+
+La otra opción para manejar la gestión de aplicaciones es usar un gestor de paquetes. Un gestor de paquetes es un conjunto de programas que se encargan de instalar, actualizar y eliminar aplicaciones del sistema de forma automática.
+
+Los programas en Linux vienen empaquetados (y comprimidos) en un único fichero donde además de la funcionalidad del programa trae información sobre sí mismo, dependencias, hash de verificación, distribuidor, versión, etc. Existen diferentes formatos de paquetes que están enfocados en distribuciones específicas como `.deb` o `.rpm`. Las más generales utilizan `.tar.gz` o `.tar.xz`
+
+El gestor de paquetes puede variar en función de la distribución que estemos usando, pero todos cumplen la misma funcionalidad común.
+
+Ejemplos de gestores de paquetes:
+
+- `zypper` - utilizados en sistemas SUSE y openSUSE entre otros.
+- `dpkg`, `apt-get` y compañía - utilizados en sistemas basados en Debian (existen muchos basados en estos como `snap`, `aptitude`, `synaptic`, etc).
+- `pacman` - utilizados en sistemas basados en Arch (`yay` y derivados para el repositorio AUR).
+- `rpm`, `yum` y su sucesora `dnf` - utilizados en sistemas basados en Red Hat Enterprise Linux.
+- `nix` - gestor de paquetes sin distribución específica
+- `portage` - utilizados en sistemas basadaos en Gentoo
+
+Las distribuciones que utilizan gestores de paquetes obtienen sus paquetes de **repositorios**. Los repositorios son servidores públicos cuyo objetivo es almacenar paquetes a disposición de los usuarios. Existen repositorios oficiales y no oficiales. Los paquetes que provienen de repositorios oficiales son mantenidos por las entidades que crearon la distribución. Los repositorios no oficiales son mantenidos por la comunidad para aportar paquetes que los creadores de la distribución no admiten como paquetes core por diversos motivos (por ejemplo, filosofía OpenSource).
+
+> Los siguientes ejemplos están basados sobre una máquina Ubuntu, cuyo gestor de paquetes oficial más utilizado es `apt`.
+> Todos los ejemplos de comandos precedidos con un `#` indican que requieren de permisos de superusuario para ser ejecutados. Los que empiezan por `$` pueden ser ejecutados por cualquier usuario común.
+
+## Gestión de paquetes en Ubuntu.
+
+El gestor de paquetes `apt` está separado en diferentes programas independientes:
+
+- `apt-get`: Encargado de instalar, desinstalar, actualizar paquetes y sincronizar la lista de paquetes con los repositorios.
+- `apt-cache`: Encargado de servir información relacionada con los paquetes (buscar paquetes, mostrar información de paquetes, etc).
+- `apt`: Sucesor de `apt-get` y `apt-cache` cuya API aún no es del todo estable, pero es bastante funcional.
+- `apt-key`: Encargado de manipular la lista de claves para autenticar paquetes. Útil si utilizamos repositorios externos, ya que las claves de los repositorios oficiales son manejadas automáticamente. Cuando descargamos un paquete está firmado digitalmente para asegurar su autenticifidad.
+- `add-apt-repository`: Encargado de añadir o eliminar un repositorio de la lista de repositorios.
+
+El listado de repositorios habilitados se encuentra en `/etc/apt/sources.list`.
+
+### Sincronizar caché de paquetes con los repositorios
+
+Para saber qué paquetes están disponibles en los repositorios junto con sus versiones hace falta sincronizarse con los repositorios que tengamos configurados. Este proceso es importante a la hora de instalar paquetes ya que sin él podríamos requerir un paquete que ya no exista o sea demasiado antiguo.
+
+Para actualiza la caché de paquetes utilizamos el comando:
+
+```shell
+# apt-get update
+```
+
+O con `apt`:
+
+```shell
+# apt update
+```
+
+### Instalar y actualizar paquetes específicos
+
+Para instalar paquetes utilizamos el comando:
+
+```shell
+# apt-get install <package1> <package2> ... <packageN>
+```
+
+Ejemplo:
+
+```shell
+# apt-get install nodejs npm
+```
+
+Admite varias opciones como `-q` para instalación silenciosa, `-s` para realizar simulación de instalacíon sin realmente añadirlo al sistema o `-y` para que no nos pida confirmación de instalación.
+
+Si intentamos instalar un paquete que esté instalado ya en el sistema intentará actualizarlo si existiesen nuevas versiones del mismo. En caso de no haber actualizaciones no realizará cambios en el sistema a menos que utilicemos los flags que empiezan por `--allow` (man apt-get) para forzar una reinstalación. También podemos especificar que sólo actualice paquetes sin añadirlos en caso de que no estuviese previamente instalados con el flag `--only-upgrade`.
+
+También podemos utilizar `apt`:
+
+```shell
+# apt install nodejs npm
+```
+
+### Actualizar todos los paquetes:
+
+Para actualizar todos los paquetes con versiones nuevas disponibles sin tener que especificar uno por uno utilizaremos el comnado:
+
+```shell
+# apt-get upgrade
+```
+
+O utilizando `apt`:
+
+```shell
+# apt upgrade
+```
+
+Para obtener un listado de paquetes con actualizaciones nuevas podemos ejecutar:
+
+```shell
+$ apt list --upgradable
+```
+
+Con `apt-get` no existe una forma simple de ver este listado, pero una opción es utilizar la opción `-s` para simular la actualización y así ver los paquetes:
+
+```shell
+$ apt-get upgrade -s
+```
+
+### Eliminar paquetes:
+
+Para eliminar paquetes utilizaremos el comando:
+
+```shell
+# apt-get remove <package1> <package2> ... <packageN>
+```
+
+Ejemplo:
+
+```shell
+# apt-get remove nodejs npm
+```
+
+Admite diversos flags como `-y` para no pedir confirmación, `-s` para simular el borrado, etc.
+
+Si añadimos el signo `+` al final del nombre del paquete lo instalará en vez de borrar. Por ejemplo, `nodejs+` instalará `nodejs` en vez de borrarlo.
+
+Es importante saber que `apt-get remove` elimina los paquetes pero deja los ficheros de configuración en el sistema. Para eliminar también sus ficheros de configuración utilizaremos `apt-get purge`:
+
+```shell
+# apt-get purge nodejs npm
+```
+
+Si utilizamos `apt` tenemos tanto `apt remove` y `apt purge` para las dos operaciones mencionadas.
+
+Si por algún motivo tenemos alguna dependencia _huérfana_ de paquetes, es decir, dependencias que no han sido eliminadas al desinstalar un paquete utilizaremos el siguiente comando para eliminarlas:
+
+```shell
+# apt-get autoremove
+```
+
+O utilizando `apt`:
+
+```shell
+# apt autoremove
+```
+
+### Buscar paquetes en los repositorios:
+
+Para buscar paquetes en los repositorios utilizaremos:
+
+```shell
+$ apt-cache search <package>
+```
+
+Esto buscará en los repositorios los paquetes que tengan relación directa o indirecta con el nombre del paquete que hayamos puesto o paquetes con nombres similares.
+
+Ejemplo:
+
+```shell
+$ apt-cache search npm
+```
+
+Utilizando `apt`:
+
+```shell
+$ apt search npm
+```
+
+### Ver datos de un paquete:
+
+Para obtener información de uno o varios paquetes utilizaremos:
+
+```shell
+$ apt-cache show <package1> <package2> ... <packageN>
+```
+
+Ejemplo:
+
+```shell
+$ apt-cache show npm
+```
+
+O si utilizamos `apt`:
+
+```shell
+$ apt show npm
+```
+
+### Mostrar paquetes instalados
+
+La interfaz de `apt-cache` no tiene ningún flag para obtener un listado de paquetes instalado, pero el comando `dpkg` sí:
+
+```shell
+$ dpkg -l
+```
+
+Todos los paquetes que comiencen por `ii` están instalados en el sistema.
+
+Utilizando `apt`:
+
+```shell
+$ apt list --installed
+```