Imágenes vs Contenedores

Para entender claramente ambos conceptos, me ayuda asemejarlos a la programación habitual, entendiendo que las imágenes son como clases y los contenedores como los objetos instanciados de las clases.

La imagen contiene la base para crear un contenedor, y éste carga la imagen para empezar a funcionar. Una imagen puede ser cargada en todos los contenedores que queramos, igual que un contenedor puede cargar varias imágenes. Cualquier cambio realizado en sistema de archivos del contenedor no afecta a la imagen, pues la imagen solo se usa para la creación del contenedor.

Docker descarga las imágenes que invocamos en la consola desde DockerHub.

Gestión de contenedores

/*------------------------------------*/
/*Crear contenedor*/
docker run ubuntu
/*------------------------------------*/
/*Crear contenedor en modo interactivo
(se controla desde la consola actual)
(ubuntu:imagen, bash:comando)*/
docker run -ti ubuntu bash
/*------------------------------------*/
/*Crear contenedor en segundo plano*/
docker run -ti -d ubuntu bash
/*------------------------------------*/
/*Acceder a contenedor ejecutado en
segundo plano*/
docker exec -ti nombreDeContenedor|ID
/*------------------------------------*/
/*Crear contenedor que se borra
al finalizar su ejecución*/
docker run --rm ubuntu bash
/*------------------------------------*/
/*Arrancar contenedor*/
docker start nombreDeContenedor|ID
/*------------------------------------*/
/*Parar contenedor*/
docker stop nombreDeContenedor|ID
/*------------------------------------*/
/*Listar contenedores activos*/
docker ps
/*------------------------------------*/
/*Listar contenedores activos e 
inactivos*/
docker ps -a
/*------------------------------------*/
/*Borrar contenedores parados*/
docker container prune -f
/*------------------------------------*/
/*Borrar un contenedor*/
docker rm nombreDeContenedor|ID
/*------------------------------------*/

Gestión de imágenes

Docker Build y Dockerfile

El comando docker build es el comando que ejecuta las instrucciones del fichero dockerfile.

Archivo Dockerfile

FROM → Instrucción que inicializa el sistema de ficheros a usar.

RUN → Ejecuta un comando dentro del sistema de ficheros.

WORKDIR → Directorio del sistema de ficheros donde se ejecutaran los comandos.

ENV → Establecer variables de entorno.

EXPOSE → Puerto en el que se expondrá la imagen.

VOLUME → Especifica un volumen para nuestro contenedor.

COPY → Copiar archivo de un directorio en otro.

ENTRYPOINT | CMD → El entrypoint recibe el comando de cmd. cmd serían los argumentos de entrypoint.

FROM ubuntu:latest
RUN apt-get update -y
RUN apt-get install -y python-pip python-dev
WORKDIR /app
ENV DEBUG=True
EXPOSE 80
VOLUME /data
COPY . /app
RUN pip install -r requirements.txt
ENTRYPOINT ["python"]
CMD ["app.py"]

Comandos para imágenes

/*------------------------------------*/
/*Listar imagenes*/
docker images
/*------------------------------------*/
/*Descargar imagen a local*/
docker pull ubuntu
/*------------------------------------*/
/*Borrar todas las imagenes en local*/
docker images prune --all
/*------------------------------------*/
/*Borrar una imagen en local*/
docker rmi nombreDeImagen
/*------------------------------------*/
/*Borrar imagenes "basura"
(no tiene tag o nombre y no esta
referenciada por ningún contenedor)*/
docker images prune -f
/*------------------------------------*/
/*Taggear una imagen*/
docker tag nombreDeImagen usuario/ubuntu:0.1.0
/*------------------------------------*/
/*Iniciar sesion en DockerHub*/
docker login
/*------------------------------------*/
/*Subir imagen a DockerHub*/
docker push nombreDeImagen
/*------------------------------------*/
/*Contruir imagen a partir de receta
(fichero Dockerfile)
(para el directorio actual)*/
docker build .
/*------------------------------------*/
/*DOCKERFILE
Para crear imagen siguiendo pasos*/
FROM ubuntu
RUN apt-get update
RUN apt-get install -y ineutils-ping
RUN apt-get install -y nettools
/*------------------------------------*/

Docker almacenará en caché los resultados de la primera compilación de un Dockerfile, lo que permitirá que las compilaciones posteriores serán súper rápidas. En cada aparición de un comando RUN en el Dockerfile, Docker creará y confirmará una nueva capa en la imagen.

/******************************************/
/*Comando que se ejecuta al iniciar la imagen en un contenedor*/
CMD echo "hello world"
/******************************************/
/*Ejecutar un comando pasado como parametro a la ejucción de un contenedor*/
docker run --rm test echo "goodbye"
/******************************************/

¿Diferencia entre CMD y ENTRYPOINT?

Con CMD considera que lo que pasemos no debe formar parte de la construcción, por lo que si otro comando es pasado al contenedor interfiere con lo anterior será sobreescrito, sin embargo con entrypoint se mantendría, ya que pasa a formar parte de la construcción del contenedor.

/******************************************/
/*Añadir un ENTRYPOINT a un contenedor*/
docke run --rm --entrypoint="" test bash
/******************************************/
/*Información extensa*/
docker container inspect nombreDeContenedor
/******************************************/
/*Listar imágenes*/
docker images ls
/******************************************/
/*Borrar volumenes*/
docker volume rm nombreDeVolumen
/******************************************/
/*Definir una red, nombre, nombre de host para un contenedor*/
docker run --rm --network=none
--name nombreDeContenedor
--hostname nombreDeHost
/******************************************/
/*Crear una red*/
docker network create test
/******************************************/

Docker garantiza el aislamiento de contenedores hacía otros contenedores que están en distintas redes.

DOCKER COMPOSE

Compose es una herramienta para definir y ejecutar aplicaciones multicontenedores en Docker. Utiliza un archivo YAML para configurar los servicios de su aplicación. Luego, con un solo comando, crea e inicia todos los servicios desde su configuración.

Defina el entorno de su aplicación con un Dockerfile para que pueda reproducirse en cualquier lugar.
Defina los servicios que componen su aplicación docker-compose.yml para que puedan ejecutarse juntos en un entorno aislado.
Ejecutar docker-compose up y compose inicia y ejecuta toda su aplicación.

Ejemplo de archivo docker-compose.yml

version: '2.0'
services:
  web:
    build: .
    ports:
    - "5000:5000"
    volumes:
    - .:/code
    - logvolume01:/var/log
    links:
    - redis
  redis:
    image: redis
volumes:
  logvolume01: {}

Otros comandos

docker-compose config → verificar que nuestro compose está correctamente estructurado

Arrancar servicios con docker compose → docker-compose up docker-compose ls → listar servicios activos

docker-compose exec php bash → entrar en servicio activo

docker-compose down → Stops containers and removes containers, networks, volumes, and images created by up.