---
# System prepended metadata

title: Fundamentos de Docker
tags: [talleres_mln]

---

# Fundamentos de Docker
###### tags: `talleres_mln`

En este taller aprenderás los conceptos básicos de Docker, cómo construir imágenes personalizadas, trabajar con redes y comunicación entre contenedores, y utilizar Docker Compose para orquestar tus contenedores. Con ejemplos prácticos y comandos útiles, adquirirás las habilidades necesarias para aprovechar al máximo los próximos talleres de Mastering in Lightning.

**Tabla de contenido**
[TOC]

## Autor
Twitter para correcciones, comentarios o sugerencias: [@ibiko1](https://twitter.com/ibiko1)

El presente tutorial fue elaborado para el [Seminario socrático de Mastering Lightning](https://libreriadesatoshi.com/) a través de [@libreriadesatoshi](https://twitter.com/libdesatoshi).

## Requerimientos :information_source: 
:::info
1. Tener instalada una distribución de Linux basada en Debian, preferiblemente Ubuntu. 
2. Para Windows, tener la versión Windows 10 versión 2004 y posteriores (compilación 19041 y posteriores) o Windows 11
3. Para Mac, disponer de un Mac con chipset Intel.
:::

## Introducción
Docker, es una herramienta de virtualización que te permite crear y gestionar contenedores, entornos aislados y autónomos que contienen todo lo necesario para que una aplicación o servicio funcione sin problemas en diferentes sistemas operativos.

En este tutorial, sentaremos las bases necesarias para que puedas utilizar máquinas Docker específicamente configuradas para la red Lightning Network en talleres posteriores. Aprenderás los conceptos básicos de Docker, desde la instalación hasta la ejecución de contenedores, y explorarás cómo Docker puede ayudarte a crear y mantener entornos consistentes y portátiles.

Con Docker, podrás desplegar rápidamente una máquina virtual de Lightning Network en tu sistema, sin tener que lidiar con configuraciones complejas y requisitos específicos de la red. Esto te permitirá centrarte en la experimentación con la red Lightning Network, sin preocuparte por los detalles técnicos del entorno subyacente.

:::success
1. **Instalación**:
    - En **Windows**: Descargar e instalar Docker Desktop, usando el backend WSL 2 (Subsistema de Windows para Linux)
    - En **Ubuntu Linux**: Instalar Docker siguiendo la guía de comandos.
    - En **MacOs**: Descargar e instalar Docker Desktop.
2. **Conceptos básicos de Docker**:
    - Imágenes: Aprenderás a buscar, descargar y utilizar imágenes de Docker.
    - Contenedores: Descubrirás cómo crear, ejecutar y detener contenedores en Docker, y cómo gestionar su estado.
    - Volumenes: Aprenderás a utilizar volúmenes en Docker para persistir datos más allá del ciclo de vida de un contenedor.
3. **Construcción de imágenes personalizadas**:
    - *Dockerfile*: Aprenderás a crear un archivo Dockerfile, que define los pasos necesarios para construir una imagen personalizada.
    - Construcción de imágenes: Utilizarás el Dockerfile para construir una imagen personalizada y luego la ejecutarás en un contenedor.
4. **Redes y comunicación entre contenedores**:
    - Redes en Docker: Explorarás cómo Docker maneja las redes y cómo puedes conectar contenedores entre sí.
    - Comunicación entre contenedores: Aprenderás a establecer comunicación y enlaces entre contenedores para crear aplicaciones complejas.
5. **Orquestación de contenedores con Docker Compose**:
    - Docker Compose: Introducción a Docker Compose, una herramienta para definir y gestionar aplicaciones multi-contenedor.
    - Configuración de servicios: Aprenderás a definir servicios en un archivo YAML y a ejecutarlos usando Docker Compose.
:::

## Instalación

### En Windows

En este apartado, te guiaré a través del proceso de instalación de Docker en Windows utilizando WSL 2 (Windows Subsystem for Linux 2). WSL 2 es una capa de compatibilidad que te permite ejecutar un entorno Linux en tu sistema Windows, lo cual es especialmente útil para utilizar Docker de manera eficiente.

La combinación de Docker con WSL 2 en Windows te brinda la capacidad de utilizar Docker en un entorno Linux nativo dentro de tu sistema operativo Windows. Esto te permitirá aprovechar todas las ventajas de Docker y utilizar imágenes y comandos de Docker de forma transparente como si estuvieras en un entorno Linux puro.

En este tutorial, aprenderás cómo configurar WSL 2 en tu sistema Windows, instalar una distribución de Linux compatible, como Ubuntu, y luego instalar Docker dentro de WSL 2. Una vez que hayas completado estos pasos, estarás listo para comenzar a utilizar Docker en tu entorno Windows con todas las funcionalidades y beneficios que ofrece.

No importa si eres nuevo en Docker o si ya tienes experiencia previa, este tutorial te brindará los pasos necesarios para configurar Docker en Windows utilizando WSL 2. ¡Comencemos el proceso de instalación y prepárate para aprovechar al máximo Docker en tu entorno Windows!

#### Requisitos
Lo primero que debemos habilitar en nuestro equipo es la configuración de la Virtualización a nivel de BIOS. Aquí os dejo un par de ejemplos, puede variar dependiendo del equipo:
* [Tutorial genérico](https://bce.berkeley.edu/enabling-virtualization-in-your-pc-bios.html).
* [Tutorial de HP](https://support.hp.com/co-es/document/ish_5637144-5698274-16#:~:text=Encienda%20el%20equipo%20y%20pulse,Seleccione%20Habilitar)
* [Tutorial ASUS](https://www.asus.com/latin/support/FAQ/1043786/)

El siguiente paso será habilitar en la configuración de Windows la "Plataforma de Máquinas Virtuales" y "[Windows Subsystem para Linux](https://learn.microsoft.com/es-es/windows/wsl/install)". 
Para ello hacemos lo siguiente:
* Vamos a inicio, abrimos el Panel de Control.
* Después haz clic en "Programas y características" y luego en "Activar o desactivar las características de Windows".
* Y hacia el final de la lista buscamos las opciones señaladas en la captura y las marcamos:

![](https://hackmd.io/_uploads/r1-CdD083.png)

Tras aplicar los cambios Windows nos pedirá reiniciar. Al reiniciar, comprobamos en la pestaña de rendimiento del Gestor de Tareas, si está activado todo correctamente, buscando "Virtualización: Activa".
![](https://hackmd.io/_uploads/H1cVtv0Un.png)


#### Instalación de WSL
Ahora ya puedes instalar todo lo que necesitas para ejecutar WSL con un solo comando. Abre PowerShell o el símbolo del sistema de Windows en modo administrador, haciendo clic con el botón derecho y seleccionando "Ejecutar como administrador", y utiliza el siguiente comando para actualizar WSL.
```
wsl --update
```
![](https://hackmd.io/_uploads/B1dD9w0I3.png)

Ejecutamos el reinicio de WSL:
```
wsl --shutdown
```

Instalamos una máquina con la distribución de Ubuntu:
```
wsl --install -d Ubuntu
```

![](https://hackmd.io/_uploads/SkottvC83.png)

Este comando habilitará las funciones necesarias para ejecutar WSL e instalar la distribución Ubuntu de Linux. Esta instalación Linux, no es una máquina de Docker todavía, pero es una requisito necesario para que Docker funcione al avanzar en este tutorial.

La primera vez que inicies una distribución de Linux recién instalada, se abrirá una ventana de consola y se te pedirá que esperes a que los archivos se descompriman y se almacenen en tu máquina, asegurate de tener espacio sufiente para tus máquinas.

![](https://hackmd.io/_uploads/SyhcYDRI2.png)


##### Comandos WSL (Opcionales)
* Ver la Lista de distribuciones de Linux disponibles:
```bash=
wsl --list --online
```
Verás una lista de las distribuciones de Linux disponibles a través de la tienda on-line.

* Lista de distribuciones de Linux instaladas
```bash=
wsl --list --verbose
```

#### Instalación de Docker
Descargamos el instalador (Docker Desktop Installer.exe), puedes obtenerlo desde [Docker Hub](https://docs.docker.com/desktop/install/windows-install/) y hacer clic en el botón "Docker Desktop for Windows".

![](https://hackmd.io/_uploads/HJPd0CiBn.png)

Haz doble clic en Docker Desktop Installer.exe para ejecutar el instalador y sigue los pasos

:::info
Si tu cuenta de administrador es diferente de tu cuenta de usuario, debes agregar el usuario al grupo **"docker-users"**. Ejecuta "Administración de equipos" como administrador y ve a "Usuarios y grupos locales" > "Grupos" > "docker-users". Haz clic derecho para agregar el usuario al grupo. Cierra sesión y vuelve a iniciarla para que los cambios surtan efecto.
:::

#### Arrancar Docker
Docker Desktop no se inicia automáticamente después de la instalación. Para iniciar Docker Desktop:
![](https://hackmd.io/_uploads/Skvggw9Ih.png)
Busca Docker y selecciona "Docker Desktop" en los resultados de búsqueda.

El menú de Docker (![](https://hackmd.io/_uploads/BJ5bxD982.png)) muestra la ventana del Acuerdo de Servicio de Suscripción de Docker.

Selecciona "Aceptar" para continuar. Docker Desktop se iniciará después de que aceptes los términos.

![](https://hackmd.io/_uploads/S1EIowRL2.png)

Tras esto abrimos el terminal de Windows con el comando "cmd" o PowerShell y lanzamos la máquina de prueba hello-world.

```bash=
docker run hello-world
```
Este comando descarga una imagen de prueba y la ejecuta en un contenedor. Cuando se ejecuta el contenedor, imprime un mensaje de confirmación y sale.

Has instalado e iniciado con éxito Docker Engine y lanzado una máquina hello-world.

### En Ubuntu Linux
Docker funciona en máquinas x86_64 o amd64 y en la mayoría de distribuciones, aquí os dejo enlaces a la página de Docker para [Fedora](https://docs.docker.com/desktop/install/fedora/) y para [Debian](https://docs.docker.com/desktop/install/debian/). 

En este taller nos centraremos en la instalación en [Ubuntu](https://docs.docker.com/desktop/install/ubuntu/), ya que suele ser la más extendida.

#### Requisitos
Aquí puedes comprobar que el [soporte a la virtualización de KVM](https://docs.docker.com/desktop/install/linux-install/#kvm-virtualization-support) está activo, en distribuciones modernas suele venir ya soporte pero no está de más comprobarlo, ya que Docker Desktop ejecuta una máquina virtual que lo requiere.

#### Instalación de Docker
Lo más sencillo es añadir el repositorio de Docker a Ubuntu e instalar mediante apt-get. Aquí puedes como hacerlo en la [guía](https://docs.docker.com/engine/install/ubuntu/#install-using-the-repository) de Docker. De todos modos, te resumo los pasos.

##### Añadir repositorio
1. Actualiza el índice de paquetes apt e instala paquetes para permitir que apt use un repositorio a través de HTTPS:
```bash=
sudo apt-get update
sudo apt-get install ca-certificates curl gnupg
```
2. Agrega la clave GPG oficial de Docker:
```bash
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg
```
3. Usa el siguiente comando para configurar el repositorio:
```bash=
echo \
  "deb [arch="$(dpkg --print-architecture)" signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
  "$(. /etc/os-release && echo "$VERSION_CODENAME")" stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
```

 ##### Instalar Docker Engine
1. Actualiza el índice del paquete apt:
```bash=
sudo apt-get update
```
2. Instala Docker Engine, containerd y Docker Compose:
```bash=
sudo apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
```
3. Verifica que la instalación de Docker Engine se haya realizado correctamente ejecutando la imagen hello-world.
```bash=
sudo docker run hello-world
```
Este comando descarga una imagen de prueba y la ejecuta en un contenedor. Cuando se ejecuta el contenedor, imprime un mensaje de confirmación y sale.

Has instalado e iniciado con éxito **Docker Engine**.

### En MacOS

Docker funciona tanto máquinas con chip Intel como en máquinas con chip Apple Silicon (M1, M2, ...).

En este taller nos centraremos en la instalación en [Intel](https://docs.docker.com/desktop/install/mac-install/#mac-with-intel-chip), por que es el modelo que dispongo, pero [aquí](https://docs.docker.com/desktop/install/mac-install/#mac-with-apple-silicon) podéis ver como hacerlo para Apple Silicon.

#### Requisitos
macOS debe ser la versión 11 o posterior. Eso es Big Sur (11), Monterey (12) o Ventura (13). Es recomendable actualizar a la última versión de macOS.

No instalar VirtualBox anterior a la versión 4.3.30, ya que no es compatible con Docker Desktop.

#### Instalación de Docker Desktop
1. Descarga la versión Docker Desktop para chip Intel.
![](https://hackmd.io/_uploads/ry3HK-6Uh.png)

3. Haz doble clic en **Docker.dmg** para abrir el instalador y, a continuación, arrastra el icono de Docker a la carpeta Aplicaciones.
![](https://hackmd.io/_uploads/SJ9DobTU3.png)

4. Haz doble clic en Docker.app en la carpeta Aplicaciones para iniciar Docker.

5. El menú de Docker (![](https://hackmd.io/_uploads/H1ykcZaL3.png)) muestra la ventana Acuerdo de servicio de suscripción de Docker. Acepta los términos para continuar.

6. En la ventana de instalación, selecciona la configuración recomendada (requiere contraseña). Esto permite que Docker Desktop establezca automáticamente los ajustes de configuración necesarios.

7. Selecciona Finalizar y arrancará Docker, puede tardar dependiendo de tu máquina
![](https://hackmd.io/_uploads/r1TgjZa82.png)

#### Comprobar la instalación
Abrimos al terminal de Mac y lanzamos el siguiente comando.
```bash=
docker run hello-world
```
![](https://hackmd.io/_uploads/rJBPhWpUn.png)

Si vemos "Hello from Docker!" nuestra instalación ha funcionado correctamente y ya tenemos Docker en nuestra máquina.

## Conceptos básicos de Docker
Aquí tienes una breve explicación de los componentes básicos que forman Docker. Estos conceptos de imágenes, contenedores y volúmenes son fundamentales para comprender el funcionamiento de Docker.

### Imágenes
   - Las imágenes en Docker son plantillas que contienen todo lo necesario para ejecutar una aplicación o servicio. Una imagen incluye el sistema operativo, las bibliotecas, las dependencias y el código de la aplicación, así como cualquier configuración adicional requerida.
   - Puedes buscar y descargar imágenes de [Docker Hub](https://hub.docker.com/), es el repositorio público de imágenes, o incluso crear tus propias imágenes personalizadas utilizando un archivo de Dockerfile.

### Contenedores
   - Los contenedores en Docker son instancias en ejecución de una imagen. Un contenedor es un entorno aislado y autónomo que se ejecuta de manera independiente en el sistema operativo host. Cada contenedor tiene su propio sistema de archivos, procesos y recursos, pero comparte el mismo kernel del sistema operativo host.
   - Los contenedores son ligeros, portátiles y escalables. Puedes crear, iniciar, detener, reiniciar y eliminar contenedores de forma rápida y sencilla. Los contenedores te permiten encapsular y distribuir aplicaciones junto con todas sus dependencias.

### Volúmenes
   - Los volúmenes en Docker son mecanismos de almacenamiento que permiten persistir datos más allá del ciclo de vida de un contenedor. Los volúmenes son independientes de los contenedores y se pueden utilizar para compartir y almacenar datos de forma duradera.
   - Puedes crear volúmenes en Docker y asociarlos a contenedores en ejecución, son útiles cuando deseas mantener los datos intactos incluso si se detiene o elimina el contenedor.

Cada componente tiene asociados unos comandos que podemos utilizar, [aquí](https://docs.docker.com/get-started/docker_cheatsheet.pdf) os dejo la "cheatsheet" con los principales.

## Comandos básicos de Docker
### Imágenes
- Vamos a buscar una imágen en Docker Hub de servidor web [nginx](https://hub.docker.com/_/nginx):
```bash=
docker search nginx
```
![](https://hackmd.io/_uploads/S1e6UfpUn.png)

- Descargamos la imágen oficial: 
```bash=
docker pull nginx
```
![](https://hackmd.io/_uploads/HJuXDzaL2.png)


- Listamos las imágenes descargadas en nuestro equipo:
```bash=
docker images
```
![](https://hackmd.io/_uploads/Skgvwz683.png)


- Creamos un contenedor a partir de una imagen de nginx y lo publicamos en el puerto 80:
```bash=
docker run -d -p 80:80 nginx
```
Si todo ha ido bien vamos a la página localhost:80 en nuestro navegador y aparecerá lo siguiente:
![](https://hackmd.io/_uploads/S12cuGaI2.png)

¡Nuestro servidor web nginx está funcionando sobre Docker!

### Contenedores
- Listamos los contenedores en ejecución: 
```bash=
docker ps
```
Fiajos que nuestra imagen nginx tiene ahora un "CONTAINER_ID" y "NAMES" para identificarla, con cualquiera de estos datos podemos realizar los siguiente comandos.
![](https://hackmd.io/_uploads/SkBIFMTIn.png)

Docker, si no especificamos un nombre al contenedor los nombra con nombre curiosos. Para especificar nosotros un nombre, debemos crear el contenedor de este modo:
```bash=
docker run -d --name mynginx1 -p 80:80 nginx
```

- Listamos todos los contenedores (incluso los detenidos): 
```bash=
docker ps -a
```
- Detenemos el contenedor en ejecución de nginx (debemos usar lo que aparece en NAMES o el CONTAINER_ID):
```bash=
docker stop mynginx1
```
- Iniciar un contenedor detenido:
```bash=
docker start mynginx1
```
- Eliminar un contenedor detenido:
```bash=
docker rm mynginx1
```
- Ejecutamos el comando 'df -lh' dentro de un contenedor en ejecución: 
```bash=
docker exec -it mynginx1 df -lh
```
![](https://hackmd.io/_uploads/rkwUTGpL3.png)

- También podemos usar el comando 'sh' para acceder al terminal de nuestro contenedor con:
```bash=
docker exec -it mynginx1 sh
```
![](https://hackmd.io/_uploads/r13YAfpU2.png)
Para salir usamos 'exit'.


### Volúmenes en Docker
- Creamos un volumen llamado config_volumen: 
```bash=
docker volume create config_volumen
```
- Listar los volúmenes creados:
```bash=
docker volume ls
```
![](https://hackmd.io/_uploads/Sypf1XTL2.png)

- Asociamos el volumen config_volumen a un nuevo contenedor llamado 'mynginx2' en el puerto 90, basado en la imágen nginx:
```bash=
docker run -d --name mynginx2 -v config_volumen:/mnt -p 90:90 nginx
```
Entramos en nuestro contenedor y creamos un fichero en el directorio /mnt, llamado prueba_fichero. Añadimos el texto "datos de prueba".
![](https://hackmd.io/_uploads/BkErgXTLh.png)

Si borramos ese contenedor, los datos existententes en el volumen seguirán existiendo, con esto evitamos perder datos. Recuerda que al borrar el contenedor, todos los cambios realizados sobre él desaparecen, salvo que estén guardados en un volumen.


## Construcción de imágenes personalizadas
1. Deten y elimina los contenedores nginx que tengas en marcha.

2. Crea un archivo llamado "Dockerfile" en un directorio vacío.

3. Abre el archivo "Dockerfile" con un editor de texto y escribe las siguientes instrucciones:

```bash=
# Usa la imagen base de Nginx
FROM nginx

# Copia el archivo de configuración personalizado a la ubicación correcta
COPY nginx.conf /etc/nginx/nginx.conf

# Copia cualquier contenido estático o archivos de sitio web a la carpeta de documentos de Nginx
COPY website/ /usr/share/nginx/html
```
En este ejemplo, se utiliza la imagen base oficial de Nginx disponible en Docker Hub. Luego, se copia un archivo de configuración personalizado (llamado "nginx.conf") y cualquier contenido estático o archivos de sitio web de la carpeta "website" a la ubicación apropiada en el contenedor.

4. Crea el archivo de configuración "nginx.conf": Crea un archivo llamado "nginx.conf" en el mismo directorio donde se encuentra el Dockerfile.

5. Abre el archivo "nginx.conf" con un editor de texto y puedes utilizar la siguiente configuración básica:

```javascript=
events {
    use           epoll;
    worker_connections  128;
}

http {
    server {
        listen 80;
        server_name localhost;

        location / {
            root /usr/share/nginx/html;
            index index.html;
        }
    }
}
```
Esta configuración básica indica que el servidor Nginx debe escuchar en el puerto 80, usar el archivo "index.html" como página principal y servir los archivos desde la carpeta "/usr/share/nginx/html" en el contenedor.

6. Crea la carpeta "website" y agrega archivos estáticos: 
    * Crea una carpeta llamada "website" en el mismo directorio donde se encuentra el Dockerfile.
    * Agrega cualquier contenido estático o archivos de sitio web que desees servir a través de Nginx dentro de esta carpeta.

7. Construye la imagen personalizada:
    * Abre una terminal y navega hasta el directorio que contiene el Dockerfile.

Ejecuta el siguiente comando para construir la imagen personalizada de Nginx:
```bash=
docker build -t mi-nginx .
```
![](https://hackmd.io/_uploads/rJhXU7682.png)


8. Ejecuta un contenedor basado en la imagen personalizada:

Una vez que la construcción se complete correctamente, puedes ejecutar un contenedor basado en la imagen personalizada utilizando el siguiente comando:

```bash=
docker run -p 80:80 mi-nginx
```
Esto mapeará el puerto 80 del contenedor al puerto 80 de tu máquina host, lo que te permitirá acceder al servidor Nginx desde tu navegador en "http://localhost".

![](https://hackmd.io/_uploads/Sy1pDmaIh.png)


Con estos pasos, has creado un Dockerfile personalizado para un servidor Nginx sencillo. Puedes personalizar aún más el fichero Dockerfile y la configuración de Nginx según tus necesidades, [aquí](https://docs.docker.com/engine/reference/builder/) encontrarás mucha más información acerca de la posibilidades de Dockerfile.

## Redes y comunicaciones entre contenedores
Una de las características poderosas de Docker es su capacidad para conectar y comunicar contenedores entre sí mediante redes. Esto permite crear aplicaciones distribuidas y desplegar microservicios que se comunican a través de redes internas.

Docker proporciona diferentes tipos de redes para facilitar la comunicación entre contenedores. Algunos de los tipos de redes más comunes son:
* **Redes predeterminadas**: Docker crea una red predeterminada llamada "bridge" que permite la comunicación entre contenedores en el mismo host. Los contenedores pueden comunicarse utilizando los nombres de host o las direcciones IP asignadas por Docker.
* **Redes personalizadas**: Puedes crear tus propias redes personalizadas para aislar y gestionar la comunicación entre contenedores. Esto te permite agrupar contenedores en redes específicas y controlar su conectividad.
* **Redes externas**: Docker también te permite conectar contenedores a redes externas, como la red del host o redes definidas por el usuario en tu sistema. Esto facilita la comunicación con otros recursos de red fuera del entorno de Docker.

A continuación, te presento algunos comandos y explicaciones breves para trabajar con redes en Docker:
* Crea una nueva red personalizada en Docker con el nombre especificado
```bash=
docker network create <nombre_red>
```
* Lista todas las redes disponibles en Docker.
```bash=
docker network ls
```
* Muestra información detallada sobre una red específica, incluidos los contenedores conectados a ella
```bash=docker
docker network inspect <nombre_red>:
```
* Conecta un contenedor existente a una red específica
```bash=
docker network connect <nombre_red> <nombre_contenedor>: 
```
* Desconecta un contenedor de una red específica.
```bash=
docker network disconnect <nombre_red> <nombre_contenedor>
```
Con estas herramientas, puedes crear y administrar redes en Docker para permitir la comunicación entre tus contenedores. Esto facilita el desarrollo de aplicaciones distribuidas y el despliegue de servicios interconectados. Es decir, creando una red e incluyendo los contenedores en la misma, entre ellos podría compartir los recursos que necesitasen permanenciendo aislados.

Recuerda que Docker proporciona muchas más opciones y funcionalidades relacionadas con redes. Puedes explorar la documentación oficial de Docker para obtener más información y profundizar en el tema.


## Orquestación de contenedores con Docker Compose
**Docker Compose** es una herramienta que te permite definir y administrar aplicaciones de varios contenedores. Con Docker Compose, puedes definir la configuración de tus servicios en un archivo YAML y luego utilizar un solo comando para iniciar y detener todos los contenedores de manera coordinada.

A continuación, te guiaré a través de los pasos básicos para utilizar Docker Compose creando una máquina nginx con una configuración básica.

### Instalación
Asegúrate de tener Docker Compose instalado en tu sistema. Puedes consultar la documentación oficial de Docker para obtener instrucciones detalladas sobre cómo instalarlo.
#### Instalación de Docker Compose en Ubuntu
1. Abre un terminal en tu sistema Ubuntu.
2. Actualiza los paquetes del sistema ejecutando el siguiente comando:
```bash=
sudo apt update
```
3. Instala Docker Compose ejecutando el siguiente comando:
```bash=
sudo apt install docker-compose
```
4. Verifica la instalación ejecutando el siguiente comando para mostrar la versión de Docker Compose:
```bash=
docker-compose --version
```

#### Instalación de docker-compose en Mac y Windows
Tanto en Windows como en Mac, la instalación de docker-compose se hace cuando instalamos Docker Desktop. De todos modos, verifica que funciona correctamente con este comando:
```bash=
docker-compose --version
```

### Archivo de configuración
Creamos un archivo YAML llamado "docker-compose.yml" en el directorio de tu proyecto. Y aprovecharemos los ficheros que creamos en el punto "Construcción de imágenes personalizadas". 
![](https://hackmd.io/_uploads/rk3ogVaUn.png)

En este archivo, definirás la configuración de tus servicios, incluyendo el nombre del servicio, la imagen Docker a utilizar, los puertos expuestos y cualquier otra configuración relevante.



### Definición de servicios
Dentro del archivo "docker-compose.yml", utiliza la sintaxis YAML para definir tus servicios. Cada servicio se representa como un bloque de código con su nombre, imagen, puertos, volúmenes y cualquier otra configuración necesaria. Puedes definir tantos servicios como necesites para tu aplicación.

```bash=
version: '3'
services:
  nginx:
    image: nginx
    ports:
      - 80:80
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf
    networks:
      - mynetwork

networks:
  mynetwork:
```
En este ejemplo, hemos definido un servicio llamado "nginx" que utiliza la imagen de Nginx desde Docker Hub. El servicio expone el puerto 80 del contenedor y lo asigna al puerto 80 del host. Además, hemos definido un volumen para montar un archivo de configuración personalizado llamado "nginx.conf" en la ruta "/etc/nginx/nginx.conf" dentro del contenedor. Por último, hemos creado una red llamada "mynetwork" para permitir la comunicación entre los servicios.

### Comandos básicos
Una vez que hayas definido tu archivo "docker-compose.yml", puedes utilizar los siguientes comandos para gestionar tus servicios:

Inicia todos los servicios definidos en tu archivo de configuración.
```bash=
docker-compose up -d
```
![](https://hackmd.io/_uploads/S1CDRm6In.png)

Muestra el estado de los contenedores de tus servicios.
```bash=
docker-compose ps
```

Detiene y elimina todos los contenedores de tus servicios.
```bash=
docker-compose down
```
![](https://hackmd.io/_uploads/SJ-ZeE6Ih.png)


Muestra los registros de log de tus servicios.
```bash=
docker-compose logs
```
Estos son solo algunos de los comandos básicos más utilizados con Docker Compose. También existen otras opciones y comandos más avanzados que puedes explorar según tus necesidades.

### Añadir un nuevo servicio

Ahora que ya tenemos funciona un servicio de nginx nos gustaría añadir un nuevo servicio de base de datos, mysql por ejemplo. Tendríamos que hacer lo siguiente:

1. Elimina el fichero docker-compose.yml y crea uno nuevo con este contenido:
```bash=
version: '3'
services:
  nginx:
    image: nginx
    ports:
      - 80:80
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf
    networks:
      - mynetwork

  mysql:
    image: mysql
    environment:
      - MYSQL_ROOT_PASSWORD=secret
    networks:
      - mynetwork

networks:
  mynetwork:
```
Hemos añadido realmente, el servicio "mysql" que usa la imágen "mysql" del repositorio Docker Hub y la hemos incluido en la misma red "network" donde estará el servicio "nginx".

2. Lanza el comando "docker-compose up -d" y lo primero que hará será descargar la imágen docker Mysql:
![](https://hackmd.io/_uploads/Bk6ufETL2.png)

3. Comprueba que están tanto el contenedor nginx y mysql, funcionando:
![](https://hackmd.io/_uploads/BJ-JX46In.png)


Como se puede ver **Docker Compose** simplifica enormemente la gestión de aplicaciones de varios contenedores, permitiéndote orquestar y coordinar fácilmente su funcionamiento. Es especialmente útil para entornos de desarrollo y pruebas, así como para despliegues locales.

Recuerda que puedes encontrar más información detallada y ejemplos prácticos en la documentación oficial de Docker Compose.




## Enlaces
Aquí os dejo algunos enlaces para complementar la información de este taller.
- [Docker Curriculum](https://docker-curriculum.com/)
- [Docker CLI Reference](https://docs.docker.com/engine/reference/run/)
- [Curso Docker de PeladoNerd](https://www.youtube.com/watch?v=CV_Uf3Dq-EU&ab_channel=PeladoNerd)
- [Guía Docker de FaztCode](https://www.youtube.com/watch?v=NVvZNmfqg6M&ab_channel=FaztCode)
- [WSL 2](https://learn.microsoft.com/es-es/windows/wsl/install)

## :zap: Donaciones
:::success
Si te fue útil este material puedes agradecer a  @ibiko1, enviándole un aporte vía Lightning Address: ifuensan@ln.tips
:::
