docker

• docker monta un sistema de containerización que permite lanzar nuevas instancias de S.O. aprovechando los recursos (hard) de la máquina Y el kernel del SO ya corriendo, lo que hace más óptimo el aprovechamiendo de recursos que las máquinas virtuales (que recrean un ordenador al completo, con sus propios kernels y sistemas de ficheros)
• Se basa en la tecnología LXC (LinuX Containers) presente en el kernel desde la versión 3.8
• Grandes beneficios:
  • portabilidad de aplicaciones
  • aislamiento de procesos
  • prevenir la fragilidad del exterior
  • manejo de recursos
• Partes de funcionamiento de Docker:
  • docker daemon
  • docker CLI
  • docker image index
• Elementos de Docker:
  • contenedores
  • imágenes
  • dockerfiles

• docs docker:
  1. https://docs.docker.com/engine/tutorials/dockerizing/
  2. https://docs.docker.com/engine/tutorials/usingdocker/
  3. https://docs.docker.com/engine/tutorials/dockerimages/
  4. https://docs.docker.com/engine/tutorials/networkingcontainers/
  5. https://docs.docker.com/engine/tutorials/dockervolumes/

• otros enlaces de la red (básicos)
  • http://www.muylinux.com/2016/04/19/tutorial-docker
  • https://www.adictosaltrabajo.com/tutoriales/docker-for-dummies/
  • https://www.digitalocean.com/community/tutorials/how-to-install-and-use-docker-getting-started
  • https://www.digitalocean.com/community/tutorials/how-to-install-and-use-docker-on-ubuntu-16-04

• más enlaces (más avanzados)
  • https://www.digitalocean.com/community/tutorials/docker-explicado-como-crear-contenedores-de-docker-corriendo-en-memcached-es

1. Asegurarse que disponemos de https y certificados en APT:

   $ sudo apt-get install apt-transport-https ca-certificates

2. Añadir clave GPG de los repositorios DOCKER:

   $ sudo apt-key adv --keyserver hkp://p80.pool.sks-keyservers.net:80 --recv-keys 58118E89F3A912897C070ADBF76221572C52609D

3. Añadir un nuevo repositorio en /etc/apt/sources.list.d/docker.list:

   deb https://apt.dockerproject.org/repo ubuntu-xenial main

4. Actualizar información respositorios, instalar:

   $ sudo apt-get update ; sudo apt-get install docker.io

5. Añadir nuestro usuario al grupo de DOCKER para poder trabajar sin SUDO:

   $ sudo usermod -a -G docker $USER

6. Refrescamos el grupo para poder trabajar sin cerrar sesión (este comando hace de docker nuestro grupo principal durante la sesión):

   $ newgrp docker

Las imágenes son las plantillas a partir de las cuales creamos los contenedores de trabajo (como instanciar el objeto de una clase en OOP)

existe en https://www.docker.com/ un repositorio de imágenes para descargar, tanto oficiales de distros como de usuarios.

• para buscar imágenes disponibles en contenedores:

  $ docker search <cadena>

• para descargar una imagen:

  $ docker pull <nombre_imagen>

• para ver las imágenes descargadas:

  $ docker images

• para borrar una imagen:

  $ docker rmi <nombre_imagen>

• añadir tag a imagen (crea copia de la imagen):

  $ docker tag <nombre_imagen> <usuario>/<nombre_imagen>:<tag>

Pendiente:

• $ docker images --digest | head

El contenedor (en el principio de su existencia) coge la referencia de una imagen y se crea.

Se pueden crear tantos contenedores de la misma imagen como se precisen

• listar todos los contenedores existentes:

  $ docker ps -a

• listar todos los contenedores activos:

  $ docker ps

• listar los últimos contenedores creados:

  $ docker ps -l

• parar un contenedor:

  $ docker stop <nombre_contenedor>

• borrar un contenedor (no ha de estar en funcionamiento):

  $ docker rm <nombre_contenedor>

• convertir un contenedor en imagen:

  $ docker commit -m "<comentario>" -a "<autor>" <id_contenedor> <repositorio>:<nombre_imagen>

el nombre del contenedor puede ser su CONTAINER_ID o si NAME (según aparece en el listado generado con el comando correspondiente)

• crear (si no existe) y ejecutar en modo interactivo (i) con pseudoterminal (t):

  $ docker run -it <nombre_contenedor>

• ejecutar en modo interactivo, borrar al salir:

  $ docker run -it --rm <nombre_contenedor>

• poner en marcha un contenedor:

  $ docker start <nombre_contenedor>

• poner en marcha contenedor como demonio (-d), mapeo de puerto y ejecución de comando:

  $ docker run -d <nombre_imagen> -p <puerto_local>:<puerto_docker> <comando>

• poner en marcha contenedor con nombre propio:

  $ docker run -d <nombre_imagen> --name <nombre_propio_contenedor>

• poner en marcha contenedor mapeando los puertos aleatoriamente (se consulta en $ docker ps:

  $ docker run -d -P <nombre_imagen>

• acceder a un contenedor en marcha:

  $ docker attach <nombre_contenedor>

• salir de un contenedor (detach), haciendo que continue funcionando: CONTROL+P + CONTROL+Q
• abrir un terminal en un contenedor:

  $ docker exec -it <nombre_contenedor> bash

• mostrar la salida (STDOUT) de un contenedor, con watch (estilo tail -f:

  $ docker -f logs <nombre_contenedor>

• mostrar procesos de un contenedor:

  $ docker top <nombre_contenedor>

• información del contenedor en formato JSON:

  $ docker inspect <nombre_contenedor>

• recoger una clave del JSON:

  $ docker inspect -f '<clave JSON>' <nombre_contenedor>

Por defecto, el motor de docker crea una serie de redes para trabajar con los contenedores:

• host
• bridge

Aunque permite crear propias y añadir contenedores a ellas para que se hablen de manera aislada

• mostrar redes de docker:

  $ docker network ls

• inspeccionar red:

  $ docker network inspect <red>

• desconectar contenedor de una red:

  $ docker network disconnect <red> <nombre_contenedor>

• mapear puerto del contenedor, devuelve puerto de máquina local:

  $ docker port <nombre_contenedor> <puerto>

• crear red propia (tipo bridge, flag -d):

  docker network create -d bridge <nombre_red>

• ejecutar contenedor con una red propia:

  $ docker run -d --network=<nombre_red> <nombre_imagen>

• añadir contenedor en marcha a una red propia:

  $ docker network connect <nombre_red> <nombre_contenedor>

• averiguar IP de contenedor:

  docker inspect --format='{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' <nombre_contenedor>

$ docker version

$ docker info

los «dockerfiles» son ficheros de procesamiento que le dicen a docker como construir una nueva imagen de manera «desatendida»

formato del dockerfile:

FROM ubuntu
MAINTAINER <autor>
ENV http_proxy http://user:pass@proxy/
ENV https_proxy http://user:pass@proxy/
RUN apt-get update
RUN apt-get install apache2 -y
RUN echo "<h1>Apache with Docker</h1>" > /var/www/html/index.html
EXPOSE 80
ENTRYPOINT apache2ctl -D FOREGROUND

1. FROM: imagen base
2. MAINTAINER: autor de la imagen
3. ENV: variables de entorno en la imagen base
4. RUN: ejecuta una sentencia en la imagen base
5. EXPOSE: abrimos el puerto especificado en el contenedor para que se pueda mapear desde el anfitrion
6. ENTRYPOINT: que se debe ejecutar cada vez que se ejecute el contenedor

$ docker build -t <autor>/<imagen> <path_fichero_docker>

para subir una imagen a los repositorios públicos (Docker Hub)

• autentificación con docker.com:

  $ docker login -u <usuario>

• subir imagen a repositorio:

  $ docker push <usuario>/<nombre_imagen>