Wiki de EGC - Contribuciones del usuario [es]

Tutorial Campo de entrenamiento de Docker

2024-12-16T10:43:55Z

Pabcabmar3: Añadida explicación para Arch Linux

= Prerrequisitos =

== Instalación Docker ==

=== Instrucciones para instalar Docker en Ubuntu 22.04 (Jammy Jellyfish) ===

Antes de comenzar a utilizar Docker, necesitamos asegurarnos de que está instalado en nuestro sistema. Aquí te mostramos cómo hacerlo.

Primero, actualizaremos la lista de paquetes disponibles en tu sistema. Este paso asegura que tu sistema tenga la información más reciente sobre qué paquetes se pueden instalar y actualizar:

<syntaxhighlight lang="bash">
sudo apt update
</syntaxhighlight>

A continuación, instala algunos paquetes necesarios que permiten a `apt` manejar repositorios sobre HTTPS. Esto es importante porque garantiza que tu sistema puede descargar software de fuentes seguras y confiables:

<syntaxhighlight lang="bash">
sudo apt install apt-transport-https ca-certificates curl software-properties-common
</syntaxhighlight>

Ahora, es momento de añadir la clave GPG del repositorio oficial de Docker a tu sistema. Esta clave es esencial porque se utiliza para verificar que el software que descargas es auténtico y no ha sido alterado por terceros:

<syntaxhighlight lang="bash">
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg
</syntaxhighlight>

A continuación, añadirás el repositorio de Docker a las fuentes de `apt`. Este paso es necesario para que tu sistema sepa dónde buscar las actualizaciones y versiones de Docker:

<syntaxhighlight lang="bash">
echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
</syntaxhighlight>

Después de añadir el repositorio, es recomendable actualizar la lista de paquetes nuevamente. Esto permite que `apt` reconozca el nuevo repositorio de Docker:

<syntaxhighlight lang="bash">
sudo apt update
</syntaxhighlight>

Finalmente, puedes instalar Docker con el siguiente comando. Este comando instalará la versión más reciente de Docker Community Edition (CE) en tu sistema:

<syntaxhighlight lang="bash">
sudo apt install docker-ce
</syntaxhighlight>

Para asegurarte de que Docker se ha instalado correctamente y está funcionando, verifica el estado del servicio Docker. Al ejecutar este comando, deberías ver que el servicio está activo y en ejecución:

<syntaxhighlight lang="bash">
sudo systemctl status docker
</syntaxhighlight>

En caso de que no estés trabajando con Ubuntu o con una distribución de GNU/Linux basada en Ubuntu (como Linux Mint, en el caso de algunos compañeros), las instrucciones son diferentes. Si usas Arch o una distribución basada en Arch, como Endeavour, tendrás que usar el gestor de paquetes '''pacman''' y es tan sencillo como:

<syntaxhighlight lang="bash">
sudo pacman -Syyu && sudo pacman -S docker
</syntaxhighlight>

El primer comando actualizará tu base de datos de paquetes local y posteriormente actualizará los paquetes como tal, mientras que el segundo comando instalará docker en tu sistema. Además, por defecto ya tendrás permiso de super usuario sobre docker, por lo que no es recomendable que interactúes directamente con el socket. Finalmente, debes arrancar el servicio de systemd mediante el siguiente comando:

<syntaxhighlight lang="bash">
sudo systemctl start docker
</syntaxhighlight>

No obstante, cuando quieras detenerlo, tienes que desactivar 2 servicios por separado: docker.service (basta con escribir "docker"), y docker.socket.

<syntaxhighlight lang="bash">
sudo systemctl stop docker.socket docker
</syntaxhighlight>

=== Uso de Docker sin `sudo` ===

Por defecto, Docker necesita permisos de administrador para ejecutar sus comandos. Sin embargo, puedes añadir tu usuario al grupo `docker` para evitar tener que usar `sudo` cada vez que ejecutes comandos de Docker. Esto simplifica el uso de Docker y hace que sea más conveniente:

<syntaxhighlight lang="bash">
sudo usermod -aG docker ${USER}
</syntaxhighlight>

Después de ejecutar este comando, necesitarás cerrar la sesión y volver a iniciarla para que los cambios surtan efecto. Si prefieres no cerrar la sesión, puedes aplicar los cambios usando:

<syntaxhighlight lang="bash">
su - ${USER}
</syntaxhighlight>

Si tuvieras problemas de permisos con el socket de Docker, una forma de solucionarlo es:

<syntaxhighlight lang="bash">
sudo chmod 666 /var/run/docker.sock
</syntaxhighlight>

Este comando permite lectura y escritura en el socket para todos los usuarios, pero es una solución temporal y no la más segura. Puede ser útil para probar si el problema es de permisos.

= Tutorial de Iniciación a Docker =

== Docker básico: primer contacto ==

Para comenzar a trabajar con Docker, es fundamental asegurarte de que todo está funcionando correctamente en tu sistema.

=== 1. Ejecutar tu primer contenedor: "Hello World" ===

El primer paso en Docker es ejecutar un contenedor básico que te confirme que todo está configurado adecuadamente. Para ello, utilizaremos la imagen "hello-world", que está diseñada para asegurarse de que Docker está instalado y funcionando correctamente.

Abre tu terminal y ejecuta el siguiente comando:

<syntaxhighlight lang="bash">
docker run hello-world
</syntaxhighlight>

Este comando realiza varias acciones:
* Descarga la imagen: Si no tienes la imagen "hello-world" en tu máquina, Docker la descargará desde Docker Hub, que es un repositorio de imágenes Docker.
* Crea un contenedor: Una vez que la imagen está disponible, Docker crea un nuevo contenedor basado en ella.
* Ejecuta el contenedor: Finalmente, Docker ejecuta el contenedor, que mostrará un mensaje de bienvenida en tu terminal.

Si todo ha funcionado correctamente, deberías ver un mensaje que comienza con "Hello from Docker!". ¡Esto significa que tu instalación de Docker está en buen estado!

=== 2. Ver las imágenes disponibles en tu sistema ===

Después de ejecutar un contenedor, Docker guarda una copia de la imagen en tu sistema. Para ver las imágenes que tienes localmente, usa el siguiente comando:

<syntaxhighlight lang="bash">
docker images
</syntaxhighlight>

Este comando mostrará una lista de todas las imágenes almacenadas en tu sistema local. Aquí deberías ver la imagen de "hello-world" que acabas de descargar.

=== 3. Descargando una imagen de Ubuntu ===

Ahora, vamos a descargar una imagen que es más útil para el desarrollo: Ubuntu. Para hacerlo, ejecuta el siguiente comando:

<syntaxhighlight lang="bash">
docker pull ubuntu
</syntaxhighlight>

Este comando descargará la última versión de la imagen de Ubuntu desde Docker Hub. Tener la imagen de Ubuntu te permitirá ejecutar una versión ligera de este sistema operativo dentro de un contenedor.

=== 4. Ejecutar un contenedor interactivo con Ubuntu ===

Docker te permite ejecutar contenedores en modo interactivo, lo que significa que puedes acceder a una terminal dentro del contenedor y trabajar en él como si fuera una máquina independiente. Para hacerlo, ejecuta el siguiente comando:

<syntaxhighlight lang="bash">
docker run -it ubuntu bash
</syntaxhighlight>

Este comando hace lo siguiente:
* `-it`: Esta opción combina dos parámetros: `-i` (interactivo) y `-t` (terminal), permitiéndote interactuar con el contenedor a través de una terminal.
* `ubuntu`: Especifica que quieres crear el contenedor a partir de la imagen de Ubuntu.
* `bash`: Es el comando que se ejecutará dentro del contenedor. Aquí es donde decides qué shell usar.

Al usar `bash`, estás utilizando el shell por defecto de Ubuntu, que proporciona un entorno interactivo completo con muchas características avanzadas. Puedes probar algunos comandos de Linux como `ls`, `pwd`, o incluso instalar software usando `apt`.

Cuando termines de trabajar en el contenedor, puedes salir escribiendo `exit`. Esto detendrá el contenedor y te devolverá a tu terminal principal.

*Nota sobre los shells*: A veces, podrías ver `bash`, `/bin/bash` o `sh` al acceder a un contenedor.
* `bash` y `/bin/bash` se refieren al mismo shell, pero `/bin/bash` especifica la ruta exacta al ejecutable. Esto es útil en sistemas donde la variable de entorno PATH no está configurada adecuadamente.
* `sh` es un shell más básico y compatible que puede no tener todas las características de `bash`, por lo que es preferible usar `bash` cuando esté disponible.

=== 5. Ver los contenedores en ejecución ===

Si quieres ver qué contenedores están activos en tu sistema, utiliza el siguiente comando:

<syntaxhighlight lang="bash">
docker ps
</syntaxhighlight>

Este comando te mostrará una lista de los contenedores que están en ejecución. Si acabas de salir del contenedor de Ubuntu, no verás nada en la lista, porque el contenedor se detuvo al salir.

Si deseas ver todos los contenedores, incluidos los que están detenidos, puedes usar:

<syntaxhighlight lang="bash">
docker ps -a
</syntaxhighlight>

Esto te mostrará todos los contenedores, indicando su estado actual (en ejecución o detenidos).

=== 6. Eliminar contenedores y liberar espacio ===

Después de trabajar con contenedores, puede que desees eliminar algunos para liberar espacio en tu máquina. Para eliminar un contenedor, primero necesitas conocer su ID o nombre, que puedes obtener con `docker ps -a`. Luego, puedes eliminarlo usando:

<syntaxhighlight lang="bash">
docker rm id_contenedor
</syntaxhighlight>

Si deseas eliminar todos los contenedores detenidos de una vez, usa este comando:

<syntaxhighlight lang="bash">
docker rm $(docker ps -aq)
</syntaxhighlight>

Esto es especialmente útil cuando tienes muchos contenedores detenidos y quieres limpiar tu sistema rápidamente.

=== 7. Limpiar imágenes que ya no necesitas ===

También puedes liberar espacio eliminando imágenes que ya no necesites. Para eliminar una imagen, primero lista todas las imágenes con:

<syntaxhighlight lang="bash">
docker images
</syntaxhighlight>

Luego, usa el siguiente comando para eliminar una imagen específica:

<syntaxhighlight lang="bash">
docker rmi id_imagen
</syntaxhighlight>

== Trabajando de manera interactiva con contenedores ==

=== 8. Mantener un contenedor vivo en segundo plano ===

Cuando desees ejecutar un contenedor pero no necesitas interactuar directamente con él, puedes ejecutarlo en segundo plano (modo "detached"). Esto es útil para contenedores que corren servicios como servidores web o bases de datos. Para ejecutar un contenedor en modo detached, usa el siguiente comando:

<syntaxhighlight lang="bash">
docker run -td ubuntu bash
</syntaxhighlight>

Aquí:
* `-t`: Asigna un terminal virtual al contenedor, pero en este caso, como el contenedor se ejecuta en segundo plano, no podrás interactuar con él directamente.
* `-d`: Indica que el contenedor debe ejecutarse en modo "detached".

Puedes comprobar que el contenedor se está ejecutando usando `docker ps`.

=== 9. Acceder a un contenedor en segundo plano ===

Si necesitas acceder a un contenedor que se está ejecutando en segundo plano, puedes hacerlo usando el siguiente comando:

<syntaxhighlight lang="bash">
docker exec -ti id_contenedor bash
</syntaxhighlight>

Esto te permitirá interactuar con el contenedor como si estuvieras en su terminal. Recuerda que debes sustituir `id_contenedor` por el ID real de tu contenedor.

= Trabajando con Puertos y Volúmenes en Docker =

Uno de los conceptos más importantes en Docker es el manejo de puertos y volúmenes. Los volúmenes permiten que los datos persistan incluso cuando un contenedor se detiene o se elimina. Esto es fundamental para aplicaciones en producción donde la pérdida de datos no es aceptable.

En este tutorial, utilizaremos un '''bind mount''' para servir archivos HTML personalizados en un contenedor NGINX y también exploraremos cómo trabajar con '''volúmenes'''.

== Creando un Contenedor NGINX con Archivos HTML Personalizados ==

Vamos a ejecutar un servidor web básico utilizando la imagen oficial de NGINX. Para comenzar, ejecuta el siguiente comando para iniciar el contenedor:

<syntaxhighlight lang="bash">
docker run -it --rm -d -p 8080:80 --name web nginx
</syntaxhighlight>

'''Explicación del Comando:'''
* `docker run`: Este comando se utiliza para crear y ejecutar un nuevo contenedor.
* `-it`: Esta opción combina dos parámetros:
* `-i`: Mantiene la entrada estándar (stdin) abierta incluso si no estás conectado.
* `-t`: Asigna un pseudo-terminal al contenedor, lo que permite interactuar con él.
* `--rm`: Indica que el contenedor debe ser eliminado automáticamente cuando se detiene. Esto ayuda a mantener limpio el entorno de trabajo.
* `-d`: Ejecuta el contenedor en modo "detached", lo que significa que se ejecutará en segundo plano.
* `-p 8080:80`: Mapea el puerto 80 del contenedor al puerto 8080 de tu máquina local. Esto te permitirá acceder al servidor web en `http://localhost:8080`.
* `--name web`: Asigna un nombre al contenedor. En este caso, lo llamamos "web".
* `nginx`: Especifica la imagen que se utilizará para crear el contenedor. En este caso, se utiliza la imagen oficial de NGINX.

=== Servir Archivos HTML Personalizados ===

Por defecto, NGINX busca archivos para servir en el directorio `/usr/share/nginx/html` dentro del contenedor. Necesitamos colocar nuestros archivos HTML en este directorio. Una forma sencilla de hacerlo es utilizando un '''bind mount'''. Esto nos permitirá vincular un directorio de nuestra máquina local y mapearlo dentro de nuestro contenedor en ejecución.

==== Creando una Página HTML Personalizada ====
# Crea un directorio llamado `site-content` en tu máquina local.
# Dentro de este directorio, crea un archivo llamado `index.html` y agrega el siguiente contenido HTML:

<syntaxhighlight lang="html">
<!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Docker Nginx</title>
</head>
<body>
<h2>Hello from Nginx container</h2>
</body>
</html>
</syntaxhighlight>

==== Iniciando el Contenedor con el Volumen Montado ====
Ahora, ejecuta el siguiente comando para iniciar un nuevo contenedor NGINX que utilice el '''bind mount''':

<syntaxhighlight lang="bash">
docker run -it --rm -d -p 8080:80 --name web -v ~/site-content:/usr/share/nginx/html nginx
</syntaxhighlight>

'''Explicación del Comando:'''
* `-v ~/site-content:/usr/share/nginx/html`: Esta opción crea un '''bind mount''' que mapea el directorio `~/site-content` de tu máquina local al directorio `/usr/share/nginx/html` en el contenedor. Esto permite que cualquier archivo que coloques en `~/site-content` esté disponible dentro del contenedor.

=== Accediendo a tu Página HTML ===
Una vez que el contenedor esté en funcionamiento, abre tu navegador favorito y navega a `http://localhost:8080`. Deberías ver tu página HTML personalizada renderizada en la ventana del navegador.

=== Deteniendo el Contenedor ===
Si deseas detener el contenedor en cualquier momento, utiliza el siguiente comando:

<syntaxhighlight lang="bash">
docker stop web
</syntaxhighlight>

=== Persistencia de Datos con Volúmenes ===
Los volúmenes permiten que los datos persistan más allá del ciclo de vida del contenedor. Si detienes o eliminas el contenedor, los archivos que colocaste en un volumen seguirán estando disponibles.

== Ejemplo de Uso de Volúmenes ==

Ahora, veamos cómo crear un contenedor NGINX utilizando un volumen para persistir datos.

=== Creando un Volumen ===
Primero, crea un volumen utilizando el siguiente comando:

<syntaxhighlight lang="bash">
docker volume create nginx-data
</syntaxhighlight>

'''Explicación del Comando:'''
* `docker volume create nginx-data`: Este comando crea un volumen llamado `nginx-data`, que se puede utilizar para almacenar datos de forma persistente.

=== Iniciando el Contenedor con el Volumen ===
Ahora, ejecuta el siguiente comando para iniciar un nuevo contenedor NGINX utilizando el volumen que acabas de crear:

<syntaxhighlight lang="bash">
docker run -it --rm -d -p 8080:80 --name web -v nginx-data:/usr/share/nginx/html nginx
</syntaxhighlight>

'''Explicación del Comando:'''
* `-v nginx-data:/usr/share/nginx/html`: Esta opción mapea el volumen `nginx-data` al directorio `/usr/share/nginx/html` en el contenedor. Cualquier archivo que coloques en este volumen persistirá incluso si el contenedor se detiene o se elimina.

=== Accediendo al Contenedor y Agregando Archivos ===
Para agregar archivos al volumen, puedes usar el siguiente comando para acceder a la terminal del contenedor:

<syntaxhighlight lang="bash">
docker exec -it web sh
</syntaxhighlight>

Una vez dentro del contenedor, puedes crear un archivo HTML directamente en el volumen:

<syntaxhighlight lang="bash">
echo "<!doctype html><html lang='en'><head><meta charset='utf-8'><title>Docker Nginx</title></head><body><h2>Hello from Nginx Volume</h2></body></html>" > /usr/share/nginx/html/index.html
</syntaxhighlight>

=== Accediendo a tu Página HTML ===
Ahora abre tu navegador y navega a `http://localhost:8080`. Deberías ver el contenido del archivo HTML que acabas de crear.

=== Conclusión ===
Hemos aprendido a manejar puertos y volúmenes en Docker, creando un contenedor NGINX que sirve nuestros propios archivos HTML personalizados. Hemos visto cómo utilizar '''bind mounts''' para desarrollo y '''volúmenes''' para persistencia de datos. Esto es fundamental para desarrollar aplicaciones web que requieren persistencia de datos.

== Documentación oficial ==

Para más información y detalles sobre todas las características de Docker, consulta la [documentación oficial de Docker](https://docs.docker.com/).

= Conclusión =

¡Felicidades! Ahora has completado un tutorial básico sobre Docker. Has aprendido a instalar Docker, ejecutar contenedores, administrar imágenes, y cómo utilizar volúmenes para persistencia de datos. Continúa explorando las capacidades de Docker para mejorar tu flujo de trabajo y desarrollo de software.

Tutorial Campo de entrenamiento de Vagrant

2024-11-20T19:47:01Z

Pabcabmar3: Añadida explicación rápida de vim para la gente que nunca lo haya usado

= Vagrant =

== Instalación de Vagrant ==

Instrucciones para instalar Vagrant, VirtualBox y Ansible sobre Ubuntu 22.04 (Jammy Jellyfish):

<syntaxhighlight lang="bash">
# Actualizar la lista de paquetes
sudo apt update

# Instalar vagrant, ansible y virtualbox
sudo apt install vagrant ansible virtualbox
</syntaxhighlight>

Si el paquete vagrant no está disponible tendrás que añadir manualmente el repo oficial y la clave GPG:

<syntaxhighlight lang="bash">
wget -O - https://apt.releases.hashicorp.com/gpg | sudo gpg --dearmor -o /usr/share/keyrings/hashicorp-archive-keyring.gpg
echo "deb [signed-by=/usr/share/keyrings/hashicorp-archive-keyring.gpg] https://apt.releases.hashicorp.com $(lsb_release -cs) main" | sudo tee /etc/apt/sources.list.d/hashicorp.list
sudo apt update && sudo apt install vagrant ansible virtualbox
</syntaxhighlight>

== Introducción a Vagrant ==

Vagrant es una herramienta que permite crear y gestionar entornos de máquinas virtuales de forma sencilla y reproducible. Para comenzar, ejecutaremos una máquina sencilla utilizando una box de Ubuntu.

=== Pasos iniciales ===

==== ¿Por qué no debemos tener más de un `Vagrantfile` en el mismo directorio? ====

En Vagrant, cada directorio puede contener solo un archivo `Vagrantfile`. Este archivo es el que Vagrant utiliza para configurar y gestionar las máquinas virtuales. Si tienes más de un `Vagrantfile` en el mismo directorio, Vagrant no sabrá cuál utilizar y esto causará errores. '''Por lo tanto, es importante organizar los ejercicios en directorios separados para mantener los entornos de trabajo independientes.'''

'''Recomendación''': Cada vez que trabajes en un ejercicio de Vagrant, crea una carpeta diferente para cada entorno. De este modo, te asegurarás de que cada `Vagrantfile` está aislado y no interfiere con otros.

==== Crear un directorio para el primer ejercicio ====

Antes de empezar con la creación de la máquina virtual, vamos a crear un directorio para este ejercicio. Esto es esencial para que el entorno de trabajo esté organizado y no interfiera con otros posibles proyectos o ejercicios.

<syntaxhighlight lang="sh">
# Crear un directorio para el ejercicio
$ mkdir ejercicio1
$ cd ejercicio1
</syntaxhighlight>

==== Inicializar un entorno con un `Vagrantfile` ====

Ahora que tenemos el directorio preparado, vamos a inicializar un entorno de trabajo con Vagrant. Al ejecutar el siguiente comando, Vagrant creará un archivo llamado `Vagrantfile`, que contendrá la configuración básica para la máquina virtual que vamos a levantar.

<syntaxhighlight lang="sh">
# Inicializar un entorno con la box ubuntu/trusty32
$ vagrant init ubuntu/trusty32
</syntaxhighlight>

Esto generará un archivo `Vagrantfile` en el directorio actual, que contiene las configuraciones predeterminadas para crear una máquina virtual basada en Ubuntu 14.04 (Trusty Tahr).

===== Explicación del `Vagrantfile` Generado =====

Cuando ejecutas el comando `vagrant init`, Vagrant genera un archivo llamado `Vagrantfile` en el directorio actual. Este archivo contiene la configuración básica para la máquina virtual. A continuación se muestra un ejemplo de un `Vagrantfile` básico y una explicación de cada parte.

<syntaxhighlight lang="ruby">
# -*- mode: ruby -*-
# vi: set ft=ruby :

Vagrant.configure("2") do |config|

# Definición de la Box
config.vm.box = "ubuntu/trusty32"

# Redirección de puertos
# Este comando es útil si se quiere acceder a servicios dentro de la máquina
config.vm.network "forwarded_port", guest: 80, host: 8080

# Carpeta compartida entre la máquina host y la máquina virtual
config.vm.synced_folder ".", "/vagrant"

# Habilitar el uso de VirtualBox como proveedor
config.vm.provider "virtualbox" do |vb|
# Personalización de la memoria RAM para la VM
vb.memory = "1024"
end

end
</syntaxhighlight>

====== Descripción de cada sección ======

'''Configuración Básica de Vagrant''':
<pre>
Vagrant.configure("2") do |config|
</pre>

Esta línea indica que se está utilizando la versión 2 de la configuración de Vagrant. El bloque que sigue (`do |config|`) define todas las configuraciones para la máquina virtual.

'''Box a utilizar''':
<pre>
config.vm.box = "ubuntu/trusty32"
</pre>

Define la box que se utilizará para crear la máquina virtual. En este caso, se utiliza una box de Ubuntu 14.04 de 32 bits, pero puedes cambiarla a cualquier otra según tus necesidades.

'''Redirección de puertos''':
<pre>
config.vm.network "forwarded_port", guest: 80, host: 8080
</pre>

Esta línea establece la redirección de puertos entre la máquina virtual y el host. En este caso, se redirige el puerto 80 de la máquina virtual al puerto 8080 del host. Esto es útil para acceder a servicios como un servidor web que esté corriendo dentro de la máquina virtual desde el navegador del host.

'''Carpeta compartida''':
<pre>
config.vm.synced_folder ".", "/vagrant"
</pre>

Aquí se establece una carpeta compartida entre el host y la máquina virtual. El primer parámetro (`"."`) se refiere a la carpeta actual en el host, y el segundo (`"/vagrant"`) es la carpeta en la máquina virtual. Cualquier archivo colocado en la carpeta del host será accesible dentro de la máquina virtual y viceversa.

'''Configuración de VirtualBox''':
<pre>
config.vm.provider "virtualbox" do |vb|
vb.memory = "1024"
end
</pre>

Esta sección configura el proveedor de virtualización a utilizar (en este caso, VirtualBox). En este caso, se ha configurado para que la máquina virtual tenga 1 GB de memoria RAM (1024 MB). Puedes ajustar este valor según los recursos disponibles en tu máquina.

==== Levantar la máquina virtual ====

Con el `Vagrantfile` listo, es hora de levantar la máquina virtual. El siguiente comando descargará la imagen de la box (si no está previamente descargada) y creará una máquina virtual según las especificaciones del `Vagrantfile`.

<syntaxhighlight lang="sh">
# Levantar la máquina virtual
$ vagrant up
</syntaxhighlight>

Este proceso puede tardar algunos minutos dependiendo de la velocidad de tu conexión a Internet, ya que Vagrant descargará la box y configurará la máquina virtual.

==== Verificar que tenemos dos sistemas funcionando ====

Una vez que la máquina virtual esté en funcionamiento, podemos verificar que todo está bien ejecutándose. Primero, accedemos a la máquina virtual a través de SSH y comprobamos el nombre del sistema operativo con el siguiente comando:

<syntaxhighlight lang="sh">
# Conecta a la máquina virtual a través de SSH y ejecuta una orden
$ vagrant ssh -c 'hostnamectl' # Si pide contraseña, utiliza 'vagrant'
</syntaxhighlight>

La opción -c de la orden anterior hace que tras conectarse por SSH y ejecutar la orden 'hostnamectl' en la máquina virtual, regresa automáticamente al host. Así que en esta misma terminal puedes verificar el sistema operativo del host para comprobar que estamos trabajando con dos sistemas diferentes:

<syntaxhighlight lang="sh">
# En el host, verificar el sistema operativo
$ hostnamectl
</syntaxhighlight>

==== Ver el estado de las máquinas virtuales ====

Puedes comprobar el estado de todas las máquinas virtuales que Vagrant está gestionando con el siguiente comando. Esto te permitirá ver si tu máquina está funcionando correctamente:

<syntaxhighlight lang="sh">
# Ver el estado de las máquinas virtuales
$ vagrant global-status
</syntaxhighlight>

==== Entrar en la máquina virtual ====

Si deseas interactuar con la máquina virtual, puedes acceder a ella en cualquier momento utilizando SSH. El siguiente comando te permitirá iniciar sesión en la máquina virtual:

<syntaxhighlight lang="sh">
# Iniciar sesión en la máquina virtual
$ vagrant ssh # Si pide contraseña, utiliza 'vagrant'
</syntaxhighlight>

==== Crear un fichero en el sistema guest ====

Dentro de la máquina virtual, podemos crear un archivo para comprobar que tenemos acceso al sistema de archivos. El siguiente comando creará un archivo de texto llamado `hola.txt` en el directorio `/home` de la máquina virtual.
Con el comando "vi" realmente estamos abriendo el editor "vim". Cuando entres notarás que aunque escribas, no aparece texto. Esto es porque te encuentras en el modo "normal". Para escribir, presiona "i" (cambiar a modo "insert") y escribe lo que sea. Cuando termines, pulsa "esc" para volver a modo normal. Finalmente, pulsa ":" para entrar en modo "command line", y escribe "wq" ("w" para "write", es decir, guardar cambios; y "q" para "quit", es decir, salir de vim):

<syntaxhighlight lang="sh">
# Crear un archivo en el sistema de archivos de la VM
$ cd /home
$ sudo vi hola.txt
</syntaxhighlight>

Dentro del archivo, puedes escribir cualquier contenido y guardarlo.

==== Apagar la máquina y liberar recursos ====

Cuando hayas terminado de trabajar, es recomendable apagar la máquina para liberar recursos en tu máquina local. Puedes hacerlo con el siguiente comando:

<syntaxhighlight lang="sh">
#Sal de la terminal de la máquina virtual
$ exit
# Apagar la máquina
$ vagrant halt #(la opción -f simula un apagado forzado)
</syntaxhighlight>

Esto apagará la máquina virtual y liberará los recursos que estaba utilizando.

==== Levantar la máquina nuevamente ====

Al levantar nuevamente la máquina virtual, podemos comprobar que el archivo que creamos sigue existiendo en el sistema. Vagrant guarda el estado de la máquina virtual, por lo que los cambios realizados se conservan entre apagados y arranques:

<syntaxhighlight lang="sh">
# Iniciar de nuevo la máquina
$ vagrant up
# Entrar en la máquina mediante ssh
$ vagrant ssh
# Verificar que el fichero sigue presente
$ cat /home/hola.txt
</syntaxhighlight>

==== Parar y destruir la máquina virtual ====

Cuando ya no necesitemos la máquina virtual, podemos detenerla y destruirla para liberar los recursos del sistema. El siguiente comando apagará la máquina y la eliminará completamente:

<syntaxhighlight lang="sh">
# Salir de la máquina virtual
$ exit
# Destruir la máquina y liberar los recursos
$ vagrant destroy
</syntaxhighlight>

== Gestión de Boxes ==

Vagrant gestiona las boxes, que son imágenes de máquinas virtuales preconfiguradas. Es importante saber cómo listar y eliminar las boxes cuando ya no las necesitemos.

<syntaxhighlight lang="sh">
# Lista de boxes disponibles en nuestro sistema local
$ vagrant box list

# Para eliminar una box
$ vagrant box remove ubuntu/trusty32
</syntaxhighlight>

== Carpetas Compartidas y Redirección de Puertos ==

En este ejercicio, aprenderás a trabajar con carpetas compartidas entre el sistema host y la máquina virtual, y a configurar la redirección de puertos para acceder a servicios dentro de la máquina virtual desde el host.

==== Crear un directorio para el segundo ejercicio ====

Vamos a crear un nuevo directorio para este ejercicio. Esto nos permite mantener los entornos de trabajo aislados:

<syntaxhighlight lang="sh">
# Crear un directorio para el segundo ejercicio
$ mkdir ejercicio2
$ cd ejercicio2
</syntaxhighlight>

==== Inicializar el entorno con la box "obihann/nginx" ====

Vamos a utilizar la box "obihann/nginx", que es una imagen preconfigurada con Nginx. Inicializamos el entorno con esta box:

<syntaxhighlight lang="sh">
# Inicializar un entorno con la box obihann/nginx
$ vagrant init obihann/nginx
</syntaxhighlight>

==== Levantar la máquina virtual ====

Ahora que hemos configurado el entorno con la box de Nginx, levantamos la máquina virtual:

<syntaxhighlight lang="sh">
# Levantar la máquina
$ vagrant up
</syntaxhighlight>

==== Verificar la carpeta compartida ====

Vagrant crea automáticamente una carpeta compartida en la máquina virtual. Para verificar que esta carpeta existe, ejecutamos el siguiente comando dentro de la máquina virtual:

<syntaxhighlight lang="sh">
# Verificar el directorio compartido
$ ls /vagrant
</syntaxhighlight>

Esta carpeta `/vagrant` está vinculada al directorio en el host donde ejecutaste el comando `vagrant init`.

==== Configurar la redirección de puertos ====

La máquina virtual que estamos usando ejecuta un servidor Nginx en el puerto 80. Para poder acceder a este servidor desde el navegador del host, necesitamos redirigir el puerto 80 de la máquina virtual al puerto 8080 de nuestro host. Para hacer esto, editamos el `Vagrantfile` y agregamos la siguiente línea:

<syntaxhighlight lang="ruby">
config.vm.network "forwarded_port", guest: 80, host: 8080
</syntaxhighlight>

Esto hará que el servidor Nginx en el puerto 80 de la máquina virtual sea accesible desde el puerto 8080 en tu máquina host.

==== Recargar la máquina virtual ====

Después de realizar cambios en el `Vagrantfile`, debemos recargar la máquina virtual para aplicar la configuración:

<syntaxhighlight lang="sh">
# Recargar la máquina para aplicar cambios
$ vagrant reload
</syntaxhighlight>

==== Añadir un archivo index.html ====

Para comprobar que la redirección de puertos funciona correctamente, añadimos un archivo `index.html` en el directorio `/www` de la máquina virtual. Este archivo se mostrará cuando accedamos a la dirección `localhost:8080` en el navegador.

<syntaxhighlight lang="sh">
# Entrar en la máquina virtual
$ vagrant ssh
# Ir al directorio vagrant/www
$ cd /vagrant/www
# Crear el archivo index.html dentro de la máquina virtual
$ echo '<h1>Bienvenido a Nginx en Vagrant</h1>' > index.html
</syntaxhighlight>

Ahora, desde el navegador del host, podemos ver el sistema funcionando en la dirección http://localhost:8080/.

==== Modifica el archivo index.html desde el host====

Para comprobar que la carpeta compartida funciona correctamente, puedes modificar el archivo `index.html` del directorio `www` en la propia máquina anfitriona. Este es el archivo que se muestra cuando accedemos a la dirección `localhost:8080` en el navegador.

<syntaxhighlight lang="sh">
# Desde el host
$ echo '<h2>Modificado desde el host</h2>' >> www/index.html
</syntaxhighlight>

Ahora, desde el navegador del host, podemos ver la modificación realizada al visitar de nuevo la dirección http://localhost:8080/.

==== Parar y destruir la máquina virtual ====

Al igual que en el primer ejercicio, es recomendable apagar y destruir la máquina para liberar recursos cuando hayamos terminado de trabajar con ella:

<syntaxhighlight lang="sh">
# Apagar la máquina
$ vagrant halt

# Destruir la máquina
$ vagrant destroy
</syntaxhighlight>