Primeros pasos en Docker
Tags: beginners, tutorial, docker, linux
Published: 2021-11-22 07:54:11

[Docker](https://www.docker.com) es un software de código abierto que automatiza el despliegue de aplicaciones con el uso de contenedores. Esto hace que sea más fácil empaquetar y aislar el  software para que  pueda implementarse más tarde en otro entorno. Todo esto proporcionando una API muy fácil de usar.

Podrá surgir la duda _"¿Qué es un contenedor?"_ en algunos. Un contenedor es la unidad  de software estándar que encapsula el código y todas sus dependencias para que una aplicación se ejecute de manera eficiente y sólida independientemente del entorno en el que se implemente.

Las instrucciones para crear el contenedor son llamadas "imagen". Esta imagen se puede compartir, y podrá replicar con totalidad el contenedor original en cualquier sitio donde se despliegue. Dentro de estas instrucciones se encuentra el código, herramientas de sistema, librerías y configuraciones del contenedor.

Hay tres diferentes tipos de contenedores Docker:

- Estándar: contenedores creados según las guías de Docker para poder ser ejecutados en cualquier entorno.
- Ligeros: contenedores que comparten el núcleo del sistema operativo, por lo que no necesitan un OS por cada aplicación. Esto aumenta la eficiencia del servidor y reduce los costes del servidor y de licencias.
- Seguros: este tipo de contenedor Docker proporciona un aislamiento seguro.    


## Arranca tu primer contenedor

Ahora que conoces conceptos básicos, prueba arrancar tu primer contenedor. Abre tu terminal e introduce el comando `docker run hello-world`. Solo con esperar unos segundos, la pantalla mostrará algo como lo siguiente:

![Terminal](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/kcplgd9w1z9zx09ul7zs.png)

Listo. Arrancaste tu primer contenedor, y esto se verá reflejado en tu aplicación de Docker. Este contenedor solo muestra texto, y se encuentra en el repositorio publico de imágenes en [DockerHub](https://hub.docker.com).  


## Generar un archivo Docker

Para crear un _Dockerfile_ debemos abrir nuestro editor de texto y definir las instrucciones. El nombre del fichero no es importante (es Dockerfile por default), se puede usar cualquiera y tener varios en una misma carpeta. Para su estructura, se usan palabras clave/reservadas. Un ejemplo básico es:

```
FROM Ubuntu | Sistema operativo/Proyecto a usar
LABEL author = [] | Indica a Docker información extra
RUN apt update | Permite ejecutar secuencias de comandos
EXPOSE 80 443 | Expone uno o más puertos
CMD npm start | Ejecuta un comando de arranque
```  


## Docker Compose

_Compose_ es una herramienta para definir y ejecutar aplicaciones Docker de varios contenedores que funciona en cualquier entorno. Con _Compose_, usas un archivo YAML para configurar los servicios de tu aplicación. Luego, con un solo comando, creas e inicias todos los servicios desde su configuración.

Usar _Compose_ es un proceso de tres pasos básicamente:

1. Defina el entorno de su aplicación con un _Dockerfile_ para que pueda reproducirse en cualquier lugar.
2. Defina los servicios que componen su aplicación en docker-compose.yml para que puedan ejecutarse juntos en un entorno aislado.
3. Ejecute `docker compose up` y el comando Docker compose inicia y ejecuta toda tu aplicación.

Un archivo `docker-compose.yml` luce así:

```
version: "3.9"  # optional since v1.27.0
services:
  web:
    build: .
    ports:
      - "5000:5000"
    volumes:
      - .:/code
      - logvolume01:/var/log
    links:
      - redis
  redis:
    image: redis
volumes:
  logvolume01: {}
```  


## Docker Compose Override

De forma predeterminada, Compose lee dos archivos, un archivo `docker-compose.yml` y un archivo `docker-compose.override.yml` opcional. Por convención, `docker-compose.yml` contiene su configuración base. El archivo _override_ (anular), como su nombre lo indica, puede contener anulaciones de configuración para servicios existentes o servicios completamente nuevos.

Cuando ejecuta `docker-compose up`, lee el archivo _override_ automáticamente.  

## Docker Ignore

Antes de que la CLI envíe el contexto al docker daemon, busca un archivo `.dockerignore` en el directorio raíz del contexto. Si este archivo existe, la CLI modifica el contexto para excluir archivos y directorios que coinciden con los patrones en él. Esto ayuda a evitar el envío innecesario de archivos y directorios grandes o confidenciales al daemon y potencialmente agregarlos a imágenes mediante `ADD` o `COPY`.

Un ejemplo de un archivo `.dockerignore` es:

```
# comment
*/temp*
*/*/temp*
temp?
```

Este archivo causaría el siguiente comportamiento:  


Regla | Comportamiento
--- | --- 
`# comment` | Ignorado
`*/temp*` | Excluye archivos y directorios cuyos nombres comiencen con temp en cualquier subdirectorio inmediato de la raíz.
`*/*/temp*` | Excluye archivos y directorios que comiencen con temp de cualquier subdirectorio que esté dos niveles por debajo de la raíz.
`temp?` | Excluya archivos y directorios en el directorio raíz cuyos nombres sean una extensión de un carácter de temp.  



## Comandos  

### Básicos

- `docker info` Provee información sobre cuántos contenedores se están ejecutando, deteniéndose y cuántas imágenes hemos descargado.
- `docker pull [imagen]` Descarga la imagen, extrayendo su última versión del registro público.
- `docker run [imagen]` Busca la imagen localmente y, si no está allí, la imagen se extrae automáticamente de la biblioteca de imágenes y, una vez más, tenemos un shell interactivo en ejecución.
- `docker ps` Muestra todos los contenedores actuales. El ID del contenedor, la imagen que se está utilizando cuando se creó, el estado actual, los puertos expuestos y un nombre generado aleatoriamente para el contenedor para facilitar la administración.
- `docker stats` Muestra cuántos recursos están usando.
- `docker images` Permite ver las imágenes que hemos descargado localmente e información sobre ellas.  

### Build (Construir)

- `docker build -t [imagen] .` Crea una imagen a partir del Dockerfile en el directorio actual y etiqueta la imagen.
- `docker image ls` Enlista todas las imágenes que se almacenan localmente con Docker Engine.
- `docker image rm [imagen]` Elimina una imagen local.  

### Share (Compartir)

- `docker tag myimage:1.0 [registro/imagen]` Re-etiqueta una imagen local con un nuevo nombre de imagen y etiqueta.
- `docker push [registro/imagen]` Envía una imagen a un registro.  

### Run (Ejecutar)

- `docker container run --name web -p
5000:80 [imagen]:3.9` Ejecuta un contenedor desde la versión 3.9 de la imagen, nombra el contenedor en ejecución _"Web"_ y expone el puerto 5000 externamente,
mapeado al puerto 80 dentro del contenedor.
- `docker container stop web` Detiene un contenedor en ejecución a través de SIGTERM.
- `docker container kill web` Detiene un contenedor en ejecución a través de SIGKILL.
- `docker network ls` Enlista las redes.
- `docker container ls` Enlista los contenedores en ejecución (agregue --all para incluir contenedores detenidos)
- `docker container rm -f $(docker ps -aq)` Elimina todos los contenedores en ejecución y detenidos.
- `docker container logs --tail 100 web` Imprime las últimas 100 líneas de los registros de un contenedor.