docker (first contact) [miguel angel torres egea]

Aquesta pàgina és només de lectura. Podeu veure'n el codi font, però no podeu canviar-la. Consulteu el vostre administrador si penseu que això és degut a algun error.
= docker (first contact)
{{tag>docker}}
== un poco de historia
  * 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

== enlaces de interés
  * docs docker:
    - [[https://docs.docker.com/engine/tutorials/dockerizing/]]
    - [[https://docs.docker.com/engine/tutorials/usingdocker/]]
    - [[https://docs.docker.com/engine/tutorials/dockerimages/]]
    - [[https://docs.docker.com/engine/tutorials/networkingcontainers/]]
    - [[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]]
    * [[https://github.com/wsargent/docker-cheat-sheet/#volumes]]


== instalación
  - Asegurarse que disponemos de https y certificados en APT:<code bash>$ sudo apt-get install apt-transport-https ca-certificates</code>
  - Añadir clave GPG de los repositorios DOCKER: <code bash>$ sudo apt-key adv --keyserver hkp://p80.pool.sks-keyservers.net:80 --recv-keys 58118E89F3A912897C070ADBF76221572C52609D</code>
  - Añadir un nuevo repositorio en ''/etc/apt/sources.list.d/docker.list'':<code bash>deb https://apt.dockerproject.org/repo ubuntu-xenial main</code>
  - Actualizar información respositorios, instalar: <code bash>$ sudo apt-get update ; sudo apt-get install docker.io</code>
  - Añadir nuestro usuario al grupo de DOCKER para poder trabajar sin SUDO:<code bash>$ sudo usermod -a -G docker $USER</code>
  - Refrescamos el grupo para poder trabajar sin cerrar sesión (este comando hace de docker nuestro grupo principal durante la sesión):<code>$ newgrp docker</code>
== imágenes
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:<code bash>$ docker search <cadena></code>
  * para descargar una imagen: <code bash>$ docker pull <nombre_imagen></code>
  * para ver las imágenes descargadas: <code bash>$ docker images</code>
  * para borrar una imagen: <code bash>$ docker rmi <nombre_imagen></code>
  * añadir tag a imagen (crea copia de la imagen):<code bash>$ docker tag <nombre_imagen> <usuario>/<nombre_imagen>:<tag></code>

Pendiente:
  * <code bash>$ docker images --digest | head</code>


== contenedores
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

=== mantenimiento (de contenedores)
  * listar todos los contenedores existentes:<code bash>$ docker ps -a</code>
  * listar todos los contenedores activos:<code bash>$ docker ps</code>
  * listar los últimos contenedores creados:<code bash>$ docker ps -l</code>
  * parar un contenedor: <code bash>$ docker stop <nombre_contenedor></code>
  * borrar un contenedor (no ha de estar en funcionamiento): <code bash>$ docker rm <nombre_contenedor></code>
  * convertir un contenedor en imagen: <code bash>$ docker commit -m "<comentario>" -a "<autor>" <id_contenedor> <repositorio>:<nombre_imagen></code>

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

=== ejecución
  * crear (si no existe) y ejecutar en modo interactivo (i) con pseudoterminal (t):<code bash>$ docker run -it <nombre_contenedor></code>
  * ejecutar en modo interactivo, borrar al salir:<code bash>$ docker run -it --rm <nombre_contenedor></code>
  * poner en marcha un contenedor: <code bash>$ docker start <nombre_contenedor></code>
  * poner en marcha contenedor como demonio (-d), mapeo de puerto y ejecución de comando:<code bash>$ docker run -d <nombre_imagen> -p <puerto_local>:<puerto_docker> <comando></code>
  * poner en marcha contenedor con nombre propio:<code bash>$ docker run -d <nombre_imagen> --name <nombre_propio_contenedor></code>
  * poner en marcha contenedor mapeando los puertos aleatoriamente (se consulta en ''$ docker ps'':<code bash>$ docker run -d -P <nombre_imagen></code>
  * acceder a un contenedor en marcha: <code bash>$ docker attach <nombre_contenedor></code>
  * salir de un contenedor (detach), haciendo que continue funcionando: '' CONTROL+P + CONTROL+Q ''
  * abrir un terminal en un contenedor:<code bash>$ docker exec -it <nombre_contenedor> bash</code>

=== funcionamiento
  * mostrar la salida (STDOUT) de un contenedor, con watch (estilo ''tail -f'':<code bash>$ docker -f logs <nombre_contenedor></code>
  * mostrar procesos de un contenedor:<code bash>$ docker top <nombre_contenedor></code>
  * información del contenedor en formato JSON:<code bash>$ docker inspect <nombre_contenedor></code>
  * recoger una clave del JSON:<code bash>$ docker inspect -f '<clave JSON>' <nombre_contenedor></code>

=== networking
Por defecto, el motor de docker crea una serie de redes para trabajar con los contenedores:
  * host
  * bridge

también existen los drivers ''overlay'' -> ???

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


  * mostrar redes de docker:<code bash>$ docker network ls</code>
  * inspeccionar red:<code bash>$ docker network inspect <red></code>
  * desconectar contenedor de una red:<code bash>$ docker network disconnect <red> <nombre_contenedor></code>
  * mapear puerto del contenedor, devuelve puerto de máquina local:<code bash>$ docker port <nombre_contenedor> <puerto></code>
  * crear red propia (tipo bridge, flag -d): <code bash>docker network create -d bridge <nombre_red></code>
  * ejecutar contenedor con una red propia:<code bash>$ docker run -d --network=<nombre_red> <nombre_imagen></code>
  * añadir contenedor en marcha a una red propia:<code bash>$ docker network connect <nombre_red> <nombre_contenedor></code>
  * averiguar IP de contenedor:<code bash>$ docker inspect --format='{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' <nombre_contenedor></code>


=== Data Volumes
es un directorio especificado trabajando en UFS((Union File System - [[https://docs.docker.com/engine/reference/glossary/#union-file-system]])) que:
  * los Volumenes se inicializan al crear el contenedor. Si existe información en el punto de montaje, esta se copiará al Volumen
  * los Volumenes se puede compartir y reusar entre contenedores
  * los cambios se aplican directamente en los Volumenes
  * los cambios en los Volumenes no se aplican cuando se actualiza una imagen
  * los Volumenes no son destruidos al destruir el contenedor que los usa
  * se puede acceder a los volúmenes creados en: ''/var/lib/docker/volumes''


  * añadir un Volumen anónimo a un contenedor "al vuelo":<code bash>$ docker run -d -P --name web -v /webapp training/webapp</code>
  * añadir un Volumen anónimo a un contenedor "al vuelo" y borrar todo al salir:<code bash>$ docker run -d -rm --name web -v /webapp training/webapp</code>
  * crear un Volumen para su posterior uso:<code bash>$ docker volume create -d <plugin> -o size=20GB --name <nombre_volumen></code>
    * "flocker" es un plugin de Volumen que provee de multi-hosts
    * [[https://docs.docker.com/engine/extend/legacy_plugins/#/volume-plugins|lista de plugins para la creación de Volumenes]]
  * añadir Volumen existente a contenedor:<code bash>$ docker run -d -P -v <nombre_volumen>:/<path_contenedor> ....</code>
  * añadir un directorio local en un contenedor, con opción de solo-lectura (ro):<code bash>$ docker run -d -P --name web -v <path_local>:<path_contenedor>[:ro] training/webapp python app.py</code>
  * añadir fichero local en contenedor: <code bash>$ docker run --rm -it -v ~/.bash_history:/root/.bash_history <nombre_imagen> <comando></code>
  * crear Volumen usando contenedor y compartir entre varios contenedores. El directorio será ''/dbdata''. Se pueden añadir varios ''--volumes''. Permite contatenar entre los diferentes contenedores (db3):<code bash>$ docker create -v /dbdata --name dbstore training/postgres /bin/true
$ docker run -d --volumes-from dbstore --name db1 training/postgress
$ docker run -d --volumes-from dbstore --name db2 training/postgress
$ docker run -d --volumens-from db1 --name db3 training/postgress</code>
  * backup de Volumenes (en host local). Crea un .tar del Volumen /dbdata en el directorio loca en curso. Destruye todo al finalizar:<code bash>$ docker run --rm --volumes-from dbstore -v $(pwd):/backup ubuntu tar cvf /backup/backup.tar /dbdata</code>
  * restore de tar:<code bash>$ docker run -v /dbdata --name dbstore2 ubuntu /bin/bash
$ docker run --rm --volumes-from dbstore2 -v $(pwd):/backup ubuntu bash -c "cd /dbdata && tar xvf /backup/backup.tar --strip 1"</code>
  * mostrar Volumenes: <code bash>$ docker volume ls</code>
  * mostrar Volumenes clgados (huérfanos): <code bash>$ docker volume ls -f dangling=true</code>
  * borrar volúmenes:<code bash>$ docker volume rm <nombre_volumen>
  * borrar Volumenes con el borrado del contenedor:<code bash>$ docker rm -v <nombre_contenedor></code>

Pendiente:
  * Volume labels

== otros comandos
<code bash>$ docker version</code>
<code bash>$ docker info</code>

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

formato del dockerfile:
<code>
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
</code>

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

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



== repositorio de imágenes
para subir una imagen a los repositorios públicos (Docker Hub)

  * autentificación con docker.com:<code bash>$ docker login -u <usuario></code>
  * subir imagen a repositorio:<code bash>$ docker push <usuario>/<nombre_imagen></code>