Revisión actual del 11:43 16 dic 2024

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:

sudo apt update

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:

sudo apt install apt-transport-https ca-certificates curl software-properties-common

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:

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

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:

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

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:

sudo apt update

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:

sudo apt install docker-ce

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:

sudo systemctl status docker

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:

sudo pacman -Syyu && sudo pacman -S docker

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:

sudo systemctl start docker

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

sudo systemctl stop docker.socket docker

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:

sudo usermod -aG docker ${USER}

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:

su - ${USER}

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

sudo chmod 666 /var/run/docker.sock

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:

docker run hello-world

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:

docker images

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:

docker pull ubuntu

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:

docker run -it ubuntu bash

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:

docker ps

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:

docker ps -a

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:

docker rm id_contenedor

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

docker rm $(docker ps -aq)

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:

docker images

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

docker rmi id_imagen

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:

docker run -td ubuntu bash

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:

docker exec -ti id_contenedor bash

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:

docker run -it --rm -d -p 8080:80 --name web nginx

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

1. Crea un directorio llamado `site-content` en tu máquina local.
2. Dentro de este directorio, crea un archivo llamado `index.html` y agrega el siguiente contenido 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>

Iniciando el Contenedor con el Volumen Montado

Ahora, ejecuta el siguiente comando para iniciar un nuevo contenedor NGINX que utilice el bind mount:

docker run -it --rm -d -p 8080:80 --name web -v ~/site-content:/usr/share/nginx/html nginx

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:

docker stop web

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:

docker volume create nginx-data

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:

docker run -it --rm -d -p 8080:80 --name web -v nginx-data:/usr/share/nginx/html nginx

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:

docker exec -it web sh

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

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

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.