Tutorial realizado con Docker en Centos 7

tutorialDockerCentos7.md

Instalar docker en centos 7

$> sudo yum update -y
$> sudo yum install docker
$> sudo systemctl start docker

para que este disponible cuando se inicia la maquina

$> sudo systemctl enable docker

En caso de error de sock

$> sudo groupadd docker
$> sudo chown root:docker /var/run/docker.sock
$> sudo usermod -a -G docker miUsuario

o puede ser:

$> sudo usermod -aG docker $(whoami)

debe mostrar los contenedores

$> docker ps

Note: En centos 7 viene instalado por defecto un firewall, se debe bajar el firewall se lanza antes que docker t por este motivo, no lo deja partir correctamente (verificar si funciona antes de bajar el firewall)

$> sudo systemctl stop firewalld
$> sudo systemctl mask firewalld
$> sudo chkconfig docker on
$> docker ps

---

Solo es otra opcion, no se hace en centos

instalacion coreos -->sistema operativo linux basico, es el gestor de contenedores (talvez necesite virtualbox, vagrant, git-scm).

$> git clone https://github.com/coreos/coreos-vagrant.git
$> cd coreos-vagrant/ -->entrar en el dir para ejecutar
$> vagrant up --> ejecutar

---

Comandos Basicos

$> docker version
$> docker -v

Descargar imagen en docker

$> docker pull busybox
$> docker images -->puedo ver las imagenes descargadas

Para ejecutar he iniciar un contenedor

$> docker run busybox echo Hello
$> docker ps --> muestra contenedores activos
$> docker ps -a --> muestra los contenedores detenidos

En el caso de que una imagen no exista, docker la descargara y la ejecutara.

$> docker run alpine echo hello
$> docker images --> debera mostrar las dos imagenes
$> docker ps -a --> mostrara los contenedores detenidos.

---

Ciclo de vida de los contenedores (es una ejecucion sobre una imagen)

$> docker ps 
$> docker ps -a

• alpine es una imagen basada en busybox, con gestor de paquetes incluido.
• esta indicando que vamos incorporar la entrada estandar sobre el contenedor,
• siempre hay q terminar con un comando. (el contenedor no se detiene, podre ejecutar comandos)
• docker siempre se ejecuta con usuario root

$> docker run -i alpine /bin/sh

con el comando anterior se creara un nuevo contenedor. (ahora hay 3)

otra opcion es usar un tty de la imagen

$> docker run -t alpine /bin/sh

debera iniciar una "consola" con root, similar a los siguiente:

$> / # ls

si le doy listar, debera mostrarme que el docker anterior con -t, se sigue ejecutando:

$> docker ps

Para cerrar el contenedor, se usa el "container id" con el comando:

$> docker ps

luego usar (con los primeros 3 dihgtos del id se puede identificar):

$> docker stop 94c

si se lista, mostrara en los detenidos el contenedor y no en los funcionales.

Si quiero borrar un contenedor:

$> docker rm 9c4

o

$> docker rm por_nombre_del_container

Tambien se podrian ejecutar opciones en conjunto "-i" entrada estandar y "-t" para unirnos al terminal por defecto de la imagen:

$> docker run -it alpine /bin/sh

con lo anterior, podriamos configurar este contenedor, ejecutando comandos dentro de este conedor.

Si quiero iniciar nuevamente un contenedor

$> docker start 4ce

Para llamar o entrar nuevamente al container, usar (para configurar):

$> docker attach 4ce

---

Trabajo con contenedores

crear contenedor sin arrancarlo:

$> docker create -it alpine /bin/sh

no retornara el id real completo, no el resumido

una forma de mostrar los contenedores con su identificador completo es:

$> docker ps -a --no-trunc

para inniciar el conedor previamente creado, se puede hacer por id o por nombre

$> docker start nombre_container

otra opcion para unirnos a una ejecucion de container y ejecutar comandos en este caso "ls":

$> docker exec nombre_contenedor ls

o de forma interactiva mostrando el formato de consola:

$> docker exec -it nombre_contenedor ls

o tambien unirnos a la shell, a diferencia de attach. si salimos, no terminamos el contenedor, osea seguira activo.

$> docker exec -it nombre_contenedor /bin/sh

no es posible eliminar un contenedor en estado activo:

$> docker stop 4ce
$> docker rm nombre_contenedor

o se puede forzar el borrado con (no importara si esta detenido):

$> docker rm -f nombre_contenedor

Para personalizar la creacion de un contenedor:

$> docker run -it --name=nombreContainer nombreImagen /my/comando
$> docker run -it --name=miAlpine alpine /bin/sh	

al listarlos, debera insicar le nombe "miAlpine"

otra opcion es pasar informacion al contenedor a la hora de ser ejecutado en el host fisico de docker, crear un archivo:

$> nano miTexto.txt

luego se mandara a un contenedor (no entendi la utilidad)

$> cat miTexto.txt | docker run -i alpine wc -l

---

Comandos avanzados con contenedores

Si quiero borrar un contenedor inmediatamente finalize su ejecucion, puedo hacer lo siguiente:

$> docker run -rm imagen

Muestra solo los id del los contenedores "-a" lista los inactivos

$> docker ps -a -q

Muestra los id completos de los contenedores:

$> docker ps -a -q --no-trunc

Muestra el id del ultimo contenedor ejecutado

$> docker ps -a -q -l

borrar todos los contenedores, pasandole como valor la lista de contenedores.

$> docker rm $(docker ps -a -q)

Si quiero borrar solo el ultimo

$> docker rm $(docker ps -a -q -l)

---

Creacion de imagenes

iniciamos un nuevo contenedore interactivo de la imagen alpine

$> docker run -it alpine /bin/sh

dentro del contenedor, actualizamos los paquetes de alpine

$> apk update
$> apk upgrade

Instalo un editor:

$> apk add nano

Salimos del contenedor con exit y listamos los contenedores para crear su imagen:

$> docker ps

Para ver las opciones de commit, quien crea las imagenes

$> docker commit --help

Para crear la imagen:

$> docker commit -a "un dato <[email protected]>" -m "version 1.0" af8 miContainer/alpine:nano
$> docker commit -a "informacion personal" -m "version o mensaje del commit" nombre_o_id_container 
nombreParaimagen/SO_del_container:elPrograma_que_ejecuta

Esto debe retornar el id unico de la imagen

para listar las imagenes:

$> docker images

para crear un nuevo container de la imagen recientemente creada:

$>docker run -it miContainer/alpine:nano /bin/sh

si ejecuto nano dentro del container, este debera estar instalado por defecto.

Docker puede tener 120 layer (no se que es un layer)

Otra opcion es trabajar con imagenes ya creadas, ir a hub.docker.com O pueden ser instaladas desde la misma consola:

$> docker search ubuntu

Filtrar por estrellas mayores a 10

$> docker search -s 10 ubuntu

Para descargar una imagen, hay dos modos:

$> docker pull unaImagen
$> docker run unaImagen

Primero la busca en local y ve si existe, si no lo baja del hub de docker NOTA: ubuntu pesa solo 188mb

borrado de imagenes, pasando el id, si hay un contenedor usandolo, no deja borrar, se debera detener el contenedor y luego intentar borrar la imagen

$> docker rmi 9f6

---

Aprovisionamiento de contenedores, para crear imagenes completamente funcionales

Instalaremos openssh para que otro usuario pueda administrar este contenedor

$> docker run -it alpine /bin/sh
$> apk update
$> apk upgrade
$> apk add openssh

configurar contenedor de alpin

$> mkdir /var/run/sshd

agregamos un usuario para que se pueda conectar

$> adduser miUsuario 

vemos el directorio

$> ls /home

introducir al usuario a sudo

$> apk add sudo
$> visudo

Buscar y descomentar "%wheel ALL=(ALL) ALL", para que todos los usuario que pertenescan al grupo "wheel" sean sudo

instalar nano:

$> apk add nano

Si el terminal se be de forma extraña, se puede setear para usar el que queramos:

$> export TERM=xterm-color

vamos a agregar el usuario al grupo wheel

$> nano /etc/group

y editamos la linea del grupo "wheel", quedando asi:

wheel:x:10:root,miempresa

Mostramos los grupos del usuario:

$> groups miempresa

Activamos las directivas ssh para que se conecten los root

$> nano /etc/ssh/sshd_config

buscamos la directiva "PermitRootLogin" y la cambiamos a "no" (no permitira el acceso de root) podemos salir del contenedor con exit

creamos una nueva imagen:

$> docker ps -a
sudo docker commit d9c mialpinecreado/alpine:ssh
retorna --> sha256:fa043cd3bb80b686353a9db4632521dfa48b2c1f6b0f4c9c4b04ba672a7b1a53

$> docker images
REPOSITORY              TAG                 IMAGE ID            CREATED              SIZE
mialpinecreado/alpine   ssh                 fa043cd3bb80        28 seconds ago       12.13 MB

Para iniciar mi docker:

$> docker run -it fa043cd3bb80 /bin/sh

o

$> docker run -it mialpinecreado/alpine:ssh /bin/sh

---

Ejecucion en segundo plano (diferencia entre correr un contenedor en segundo o en primer plano)

correr un contenedor nuevo con la imagen anteriormente creado

$> docker run mialpinecreado/alpine:ssh /usr/sbin/sshd
Could not load host key: /etc/ssh/ssh_host_rsa_key
Could not load host key: /etc/ssh/ssh_host_dsa_key
Could not load host key: /etc/ssh/ssh_host_ecdsa_key
Could not load host key: /etc/ssh/ssh_host_ed25519_key
sshd: no hostkeys available -- exiting.

Si esta estubiese bien configurado, podriamos indicar que el contenedor se ejecute en modo demonio (segundo plano)

$> docker run -d mialpinecreado/alpine:ssh /usr/sbin/sshd
40e5c43cb4fe5d7efdfca7cbee8cda398e818b4a93c3d57cff5d4bea4939b619

en este caso, solo nos devuelve el id, los errores o la ejecucion, la realiza en segundo plano (deattach)

"docker ps" no mostrara nada, ya q no se ejecuto por errores en el inicio, para saber los errores del contenedor:

$> docker logs 40e

con lo anterior sabremos los motivos del porque no arranco correctamente.

---

Abrir puertos en los contenedores, para poder conectarnos:

Limpiamos docker, ya q ni los contenedores ni la imagen es util, ya que se encuentra con errores. Por este motivo todos los contenedores que se creen, tendran errores.

Listamos los contenedores detenidos

$> docker ps -a

Borramos los contenedores no usados

$> docker rm 40e5c43cb4fe ff0fe8a6bacd

Listamos las imagenes

$> docker images

Borramos la imagen creada anteriormente:

$> docker rmi mialpinecreado/alpine:ssh

Arrancamos un nuevo contenedor de la imagen con ssh instalado

$> docker start 2df
$> docker attach  2df

$> cat /etc/ssh/sshd_config | grep _key
#HostKey /etc/ssh/ssh_host_rsa_key
#HostKey /etc/ssh/ssh_host_dsa_key
#HostKey /etc/ssh/ssh_host_ecdsa_key
#HostKey /etc/ssh/ssh_host_ed25519_key
# The default is to check both .ssh/authorized_keys and ssh/authorized_keys2
# but this is overridden so installations will only check .ssh/authorized_keys
#AuthorizedKeysFile      .ssh/authorized_keys

Creo la llaves indicadas, solicita passphrase, se puede dejar en blanco

$> ssh-keygen -b 2048 -t rsa -f /etc/ssh/ssh_host_rsa_key -q
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
$> ssh-keygen -b 2048 -t rsa -f /etc/ssh/ssh_host_dsa_key -q
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
$> ssh-keygen -b 2048 -t rsa -f /etc/ssh/ssh_host_ecdsa_key -q
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
$> ssh-keygen -b 2048 -t rsa -f /etc/ssh/ssh_host_ed25519_key -q
Enter passphrase (empty for no passphrase):
Enter same passphrase again:

Verifico:

Usuario creado

$> ls /home/
miempresa

usuario en grupo correcto

$> groups miempresa
miempresa wheel

Y lo anterior, la creacion de llaves en los directorios corrector y la inhabilitacion del usuario root en ssh Se puesde salir del contenedor con exit

Para crear la imagen nueva, verificamos que no este en uncionamiento

$> docker ps -a

creamos la imagen:

$> docker commit 2df mialpine/alpine:ssh
sha256:8a7f628e9d65bcd8d5674d97d32a52ef48ce1b504e289e0f59e90f70c5f40b13

Mostramos las imagenes:

$> docker images
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
mialpine/alpine     ssh                 8a7f628e9d65        2 minutes ago       12.14 MB
<none>              <none>              77ee99edfe40        2 minutes ago       12.14 MB
docker.io/alpine    latest              02674b9cb179        9 days ago          3.984 MB

En base a la nueva imagen creada, se creara un nuevo contenedor, en este caso no saldra error de ssh:

$> docker run mialpine/alpine:ssh /usr/sbin/sshd
CONTAINER ID        IMAGE                 COMMAND             CREATED             STATUS                      PORTS               NAMES
63cfc71e0fe5        mialpine/alpine:ssh   "/usr/sbin/sshd"    13 seconds ago      Exited (0) 11 seconds ago                       serene_heyrovsky
2dfd8b1f3a4f        alpine                "/bin/sh"           21 minutes ago      Exited (0) 7 minutes ago                        happy_snyder

Se creo con nomrbe "serene_heyrovsky" podemos ver el log con (debera estar vacio):

$> docker logs 63c

crearemos un nuevo contenedor, pero esta vez en formato "segundo plano" (deattach) se agrega "-d", para que el contenedor se inicie como demonio se agrega "-D", para que ssh se inicie como demonio se agrega "-p", para habilitar el puerto 22 en el contenedor

$> docker run -d -p 22 mialpine/alpine:ssh /usr/sbin/sshd -D
6eba5989a46c840f4494d1f446c6252455f35343ad2f150a7202060348ff8201

Listamos los contenedores activos, y aparece el recien creado con una redireccion de puerto

$> docker ps
CONTAINER ID        IMAGE                 COMMAND               CREATED             STATUS              PORTS                   NAMES
6eba5989a46c        mialpine/alpine:ssh   "/usr/sbin/sshd -D"   34 seconds ago      Up 31 seconds       0.0.0.0:32768->22/tcp   admiring_leavitt

para verificar el puerto del host fisico (mostrara una lista grande, pero solo pegue el necesario):

$> sudo netstat -ntulp
tcp6       0      0 :::32768                :::*                    LISTEN      20005/docker-proxy- 

Si inicio un nuevo contenedor de la imagen, docker se encargara de autoasignar los puertos disponibles

Si quiero asignar un puerto he impedir q docker lo haga por mi (indico que se asigna el 50000 redireccionado al 22):

docker run -d -p 50000:22 mialpine/alpine:ssh /usr/sbin/sshd -D

---

Acceso mediante SSH

borro todas los contenedores

$> sudo docker rm -f $(sudo docker ps -a -q)

Creo un nuevo contenedor a partir de la imagen

$> docker run -d -p 50000:22 --name=ssh_server mialpine/alpine:ssh /usr/sbin/sshd -D
b17e0fc071d0972205fdc69ca5b811072771b2f0e19fd547b1566b50aca84756

Configuramos como acceder al server ssh lo siguiente muestra la configuracion del contenedor

$> docker inspect ssh_server

Obtiene solo la ip de conexion del contenedor

$> docker inspect --format='{{.NetworkSettings.IPAddress}}' ssh_server

Se le da puerto 22 ya q solo desde afuera se realiza la redireccion del puerto 50000

$> ssh [email protected] -p 22

Si lo hago desde afuera del host fisico

$> ssh miempresa@ipHostFisico -p 50000	

Para mas detalles dentro del container

$>pwd
$>sudo apk update

---

Aprovisionamiento mediante ficheros

$> mkdir dockerfiles
$> cd dockerfiles/
$> mkdir alpine
$> cd alpine/
$> nano Dockerfile

#cual es la imagen base : la version
FROM alpine:latest
#quien es el usuario o corporacion q se encarga de mantener la imagen
MAINTAINER miempresa
#Actualizacion del sistema e instalacion de servicio ssh
RUN apk update
RUN apk upgrade
RUN apk add openssh bash nano sudo
#Creo un grupo llamado student
RUN addgroup student
#Creo un al usuario y lo asigno al grupo con igual nombre
RUN adduser -s /bin/bash -G student student -D
#Cambio o creo la contraseña de student, en este caso la contraseña es "student"
RUN echo student:student | chpasswd
#-ri edicion fichero group 
#/s sustitucion de una cadena
RUN sed -ri 's/(wheel:x:10:root)/\1,student/' /etc/group
#Para permisos root con el editor sed
RUN sed -ri 's/# %wheel ALL=\(ALL\) ALL/%wheel ALL=\(ALL\) ALL/' /etc/sudoers
#cambios de shell del usuario
RUN sed -ri 's;^(root:x:0:0:root:/root:)/bin/ash;\1/bin/bash;' /etc/passwd
RUN mkdir /var/run/sshd
#edito fichero para impedir el accesso con root
RUN sed -i 's/^#PermitRootLogin.*/PermitRootLogin no/' /etc/ssh/sshd_config
#creo las llaves para ssh
#variable de entorno de entorno
ENV KEYGEN="ssh-keygen -b 2048 -t rsa -f"
RUN $KEYGEN /etc/ssh/ssh_host_rsa_key -q -N ""
RUN $KEYGEN /etc/ssh/ssh_host_dsa_key -q -N ""
RUN $KEYGEN /etc/ssh/ssh_host_ecdsa_key -q -N ""
RUN $KEYGEN /etc/ssh/ssh_host_ed25519_key -q -N ""
#exponer el puerto 22, indica al demon docker que puede crear un portfordwar al puerto 22, esto con -P despues del docker run
EXPOSE 22
#RUN EJECUTA un comando dentro del contenedor
#RUN siempre es la ultima opcion y solo puede haber 1
CMD ["/usr/sbin/sshd","-D"]

---

Build from files

para hacer uso del archivo "Dockerfile", este debe estar en el mismo directorio de la imagen, para esto se usa "." o se debera indicar en donde se encuentra el archivo

$> sudo docker build -t miempresa/alpine .

$> docker images
REPOSITORY                     TAG                 IMAGE ID            CREATED             SIZE
miempresa/alpine                latest              3acb3b3aadfa        10 seconds ago      13.15 MB

$> sudo docker ps -a
CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS              PORTS               NAMES

$> sudo docker ps
CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS              PORTS               NAMES

$> sudo docker run -d -P --name=testing miempresa/alpine
87eff73a573a646f8a3ccd2fc08444396b6dfe52f541d842dd682b0b40097b55

$> sudo docker ps
CONTAINER ID        IMAGE               COMMAND               CREATED             STATUS              PORTS                   NAMES
87eff73a573a        miempresa/alpine     "/usr/sbin/sshd -D"   20 seconds ago      Up 17 seconds       0.0.0.0:32769->22/tcp   testing

$> sudo docker inspect testing | grep IPAddress
"SecondaryIPAddresses": null,
"IPAddress": "172.17.0.2",
"IPAddress": "172.17.0.2",

$> ssh [email protected] -p 32769

La clave es "student"

Para probar si tengo privilegios de sudo, puedo instalar algun servicio

$> sudo apk add apache2

Aprovisionamiento de Ubuntu https://docs.docker.com/engine/examples/running_ssh_service/#build-an-egsshd-image

---

Copiando ficheros externos

https://github.com/dicotraining/docker-sample

$> sudo yum install -y git
$> cd dockerfiles/	

Docker soporta github o bitbucket

fork https://github.com/edgardo001/docker-sample

$> docker build -t ubuntu/apache https://github.com/dicotraining/docker-sample.git
$> docker images
REPOSITORY                     TAG                 IMAGE ID            CREATED             SIZE
ubuntu/apache                  latest              b074be4d25ee        3 minutes ago       262.5 MB

$> docker run -d -P --name testing_apache ubuntu/apache
$> docker ps -a

---

Variables de entorno

ver que variables de entorno se estan usando sobre un contenedor

$> docker exec testing_apache env

crear un nuevo contenedor cambiando 1 de las variables de entorno

$> docker run -d -P --name testing_apache2 -e [email protected] ubuntu/apache

List nuevamente

$> docker exec testing_apache env

Tambien se puede usar desde un txt, ej "env.txt" con "APACHE_SERVERALIAS=myServer.local" en su interior

$> docker run -d -p 32777:80 --name testing_apache3 -e [email protected] --env-file ./env.txt ubuntu/apache

List nuevamente

$> docker exec testing_apache env

---

Links (unir contenedores), no se exponen los puertos y se crea un tunel en que solo los contenedores se comunican

$> docker ps -a
$> docker run -d --name web_server ubuntu/apache
$> docker ps
$> docker run -d --name ssh_server

con quien se hara el link : elAliasQueSeLeDaAlLink

$> docker run -d --name ssh_server --link web_server:web mialpine/alpine
$> docker exec ssh_server env

ambas ips se mostraran en el fichero host (web_server y ssh_server)

$> docker exec ssh_server cat /etc/hosts

---

Volumenes (volumenes de datos persistentes en el contenedor)

$> docker run -d --name sample1_apache -v /webapps ubuntu/apache

Se creara una carpeta en la raiz del contenedor, llamada "webapps"

$> docker exec -it sample1_apache /bin/bash
$> cd webapps

en el dockeFile se puede agregar unas lineas para agregar el volumen y pasar ficheros al interior:

VOLUME /webapps
ADD ./fichero.txt /webapps/ficheroEnCarpetaVolumen.txt

Y se puede generar nuevamente una imagen con :

$> docker build -t sample/volumes .

---

Volumenes en el sistema amfitrion

$> mkdir webpages
$> cd webpages

Si elimino el contenedor este tipo de volumen seguira existiendo

$> docker run -d -p 32777:80 --name sample1 -e APACHE_DOCUMENTROOT=/webapps -v ~/webpages:/webapps ubuntu/apache

"-v ~/webpages:/webapps" mapea una carpeta del host anfitrion (fisico) con una del contenedor

direcciona un volumen de otro contenedor a este contenedor

$> docker run -d -p 32777:80 --name sample2 --volumes-from sample1 -e APACHE_DOCUMENTROOT=/webapps ubuntu/apache

---

Supervisor

Un contenedor esta diseñado para ejecutar un solo comando, aca se vera la opcion de ejecutar varios comandos (servicios)

#--Dockerfile-- 
FROM ubuntu:14.04
MAINTAINER yo [email protected]

#Update the package repository
RUN apt-get update -y && apt-get upgrade -yqq

#Install PHP 5.5 and apache2
RUN apt-get install -y php5-cli php5 php5-mcrypt php5-curl php5-pgsql
#install openssh
RUN apt-get install -y openssh-server supervisor
RUN mkdir -p /var/run/sshd

#add the student user with su permission
RUN useradd -d /home/student -m -s /bin/bash student
RUN echo student:student | chpasswd
RUN usermod -aG sudo student
RUN sed -i 's/PermitRootLogin without-password/PermitRootLogin no/' /etc/ssh/sshd_config

#configuration of supervisor
RUN mkdir -p /var/log/supervisor
#ADD permite autodescomprmir un tar
#COPY solo copia
COPY ./supervisord.conf /etc/supervisor/sypervisord.conf

#configure apache
ADD ./config/001-docker.conf /etc/apache2/sites-available/
RUN ln -s /etc/apache2/sites-available/001-docker.conf /etc/apache2/sites-enabled/


# Set Apache environment variables (can be changed on docker run with -e)
ENV APACHE_RUN_USER www-data
ENV APACHE_RUN_GROUP www-data
ENV APACHE_LOG_DIR /var/log/apache2
ENV APACHE_PID_FILE /var/run/apache2.pid
ENV APACHE_RUN_DIR /var/run/apache2
ENV APACHE_LOCK_DIR /var/lock/apache2
ENV APACHE_SERVERADMIN admin@localhost
ENV APACHE_SERVERNAME localhost
ENV APACHE_SERVERALIAS docker.localhost
ENV APACHE_DOCUMENTROOT /var/www/html

EXPOSE 80 22
COPY ./scripts/info.php /var/www/html/info.php
CMD ["/usr/bin/supervisord","-c","/etc/supervisor/sypervisord.conf"]

Se debera crear en la misma carpeta de Dockerfile

#--supervisord.conf--
[supervisord]
#Para que no actue como demonio
nodaemon = true
#almacenar log
logfile = /var/log/supervisor/supervisord.log
#Si hay ficheros hijos de los servicios que "supervisor" debe arrancar (apache2 y ssh), estos tambien se agregaran al log
childlogdir = /var/log/supervisor
#El tamaño maximo de los ficheros log
logfile_maxbyte = 10MB

[include]
#En esta ruta se puede agregar cualquier fichero de configuracion de otras aplicaciones
#en este caso se agregaran todos los .conf en su interior
files = /etc/supervisor/conf.d/*.conf

[program:sshd]
#arranca servicio ssh
command = /usr/sbin/sshd -D

[program:apache2]
#arranca servicio apache2
command = /usr/sbin/apache2 -D FOREGOUND

para usar los anterior:

$> sudo docker build -t ubuntu/supervisor .

Se verifica la imagen

$> sudo docker images
REPOSITORY                     TAG                 IMAGE ID            CREATED             SIZE
ubuntu/supervisor              latest              3fea5e1dcdcd        25 seconds ago      295.8 MB

Se crea un nuevo contenedor de la imagen creada

$> sudo docker run -d -P ubuntu/supervisor

Se verifica el contenedor creado

$> sudo docker ps
CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS                                          NAMES
8a40f1188dba        ubuntu/supervisor   "/usr/bin/supervisord"   28 seconds ago      Up 25 seconds       0.0.0.0:32771->22/tcp, 0.0.0.0:32770->80/tcp   sharp_lamport

Listar puertos de un contenedor

$> sudo docker port 8a4
22/tcp -> 0.0.0.0:32771
80/tcp -> 0.0.0.0:32770

Ver los log del contendor (no figura errores)

$> sudo docker logs 8a4
2017-05-23 15:36:44,912 CRIT Supervisor running as root (no user in config file)
2017-05-23 15:36:44,916 INFO supervisord started with pid 1
2017-05-23 15:36:45,918 INFO spawned: 'sshd' with pid 9
2017-05-23 15:36:45,921 INFO spawned: 'apache2' with pid 10
2017-05-23 15:36:46,031 INFO exited: apache2 (exit status 0; not expected)
2017-05-23 15:36:47,033 INFO success: sshd entered RUNNING state, process has stayed up for > than 1 seconds (startsecs)
2017-05-23 15:36:47,034 INFO spawned: 'apache2' with pid 17
2017-05-23 15:36:47,099 INFO exited: apache2 (exit status 0; not expected)
2017-05-23 15:36:49,103 INFO spawned: 'apache2' with pid 18
2017-05-23 15:36:49,178 INFO exited: apache2 (exit status 0; not expected)
2017-05-23 15:36:52,183 INFO spawned: 'apache2' with pid 19
2017-05-23 15:36:52,259 INFO exited: apache2 (exit status 0; not expected)
2017-05-23 15:36:53,260 INFO gave up: apache2 entered FATAL state, too many start retries too quickly

Pruebas necesarias

$> curl localhost:32770

ver ip que tenemos

$> ip a show eno1
eno1: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast state UP qlen 1000
    link/ether 00:21:5e:6c:fc:e2 brd ff:ff:ff:ff:ff:ff
    inet 192.168.15.33/24 brd 192.168.15.255 scope global eno1
       valid_lft forever preferred_lft forever
    inet6 fe80::221:5eff:fe6c:fce2/64 scope link 
       valid_lft forever preferred_lft forever

probar ssh y entrar a probar la maquina

$> ssh [email protected] -p 32771
[email protected]'s password: 
Permission denied, please try again.
[email protected]'s password: 
Welcome to Ubuntu 14.04.5 LTS (GNU/Linux 3.10.0-514.16.1.el7.x86_64 x86_64)

* Documentation:  https://help.ubuntu.com/
Last login: Tue May 23 15:45:03 2017 from 192.168.15.33

verificar version del sistema operativo

$> student@8a40f1188dba:~$ cat /etc/issue
\Ubuntu 14.04.5 LTS \n \l

ver log de "supervisor"

$> student@8a40f1188dba:~$ cat /var/log/supervisor/supervisord.log 
2017-05-23 15:36:44,912 CRIT Supervisor running as root (no user in config file)
2017-05-23 15:36:44,916 INFO supervisord started with pid 1
2017-05-23 15:36:45,918 INFO spawned: 'sshd' with pid 9
2017-05-23 15:36:45,921 INFO spawned: 'apache2' with pid 10
2017-05-23 15:36:46,031 INFO exited: apache2 (exit status 0; not expected)
2017-05-23 15:36:47,033 INFO success: sshd entered RUNNING state, process has stayed up for > than 1 seconds (startsecs)
2017-05-23 15:36:47,034 INFO spawned: 'apache2' with pid 17
2017-05-23 15:36:47,099 INFO exited: apache2 (exit status 0; not expected)
2017-05-23 15:36:49,103 INFO spawned: 'apache2' with pid 18
2017-05-23 15:36:49,178 INFO exited: apache2 (exit status 0; not expected)
2017-05-23 15:36:52,183 INFO spawned: 'apache2' with pid 19
2017-05-23 15:36:52,259 INFO exited: apache2 (exit status 0; not expected)
2017-05-23 15:36:53,260 INFO gave up: apache2 entered FATAL state, too many start retries too quickly
2017-05-23 15:45:06,015 CRIT reaped unknown pid 31)

verificar log de otros elementos en el interiror de supervisor

$> student@8a40f1188dba:~$ ll /var/log/supervisor/                
total 12
drwxr-xr-x. 2 root root    207 May 23 15:36 ./
drwxrwxr-x. 7 root syslog  205 May 23 15:26 ../
-rw-------. 1 root root    688 May 23 15:36 apache2-stderr---supervisor-vycm8N.log
-rw-------. 1 root root     93 May 23 15:36 apache2-stdout---supervisor-p3elFV.log
-rw-------. 1 root root      0 May 23 15:36 sshd-stderr---supervisor-N5RLWh.log
-rw-------. 1 root root      0 May 23 15:36 sshd-stdout---supervisor-cVQzul.log
-rw-r--r--. 1 root root   1012 May 23 15:45 supervisord.log

ver uno de los log con privilegios de root

student@8a40f1188dba:~$ sudo cat /var/log/supervisor/apache2-stderr---supervisor-vycm8N.log 
[sudo] password for student: 
AH00558: apache2: Could not reliably determine the server's fully qualified domain name, using 172.17.0.3. Set the 'ServerName' directive globally to suppress this message
AH00558: apache2: Could not reliably determine the server's fully qualified domain name, using 172.17.0.3. Set the 'ServerName' directive globally to suppress this message
AH00558: apache2: Could not reliably determine the server's fully qualified domain name, using 172.17.0.3. Set the 'ServerName' directive globally to suppress this message
AH00558: apache2: Could not reliably determine the server's fully qualified domain name, using 172.17.0.3. Set the 'ServerName' directive globally to suppress this message

---

Reinicio Automatico (para que se inicien junto al sistema anfitrion)

con la opcion "--restart", este soporta 3 flags

-no indica q no se va a reinicia (predeterminado) -on-failure[max-retries] reinicia en caso de error en la ejecucion (se puede pasar el numero de veces que se quiere intentar reiniciar) -always siempre reiniciara (usado para iniciar el contenedor cuando se reinicie el sistema anfitrion)

$> docker run -d -P --name=testing_server --restart always ubuntu/supervisor

---

Reinicio como servicio

gestores de procesos: upstart, systemd, supervisord, en este caso se usara systemd (comando systemctl)

no se usa -d (modo demonio), ya q el sistema se encargara de iniciar, de lo contrario podria tener fallas

$> docker run -P --name=testing_server ubuntu/supervisor

se creara un fichero para el inicio

$>nano /etc/systemd/system/testing.service

#--testing.service--
[Unit]
Description=Testing container
#para arrancar el servicio, previamente debe estar iniciardo el servicio de docker y los servicios de red
Requires=docker.service network-online.target
#tambien se debe indicar que los mismo servicio deben permanecer activos despues de levantar
After=docker.service network-online.targer

[Service]
#Siempre reiniciara el contenedor
Restart=always

#Si se quiere crear el contenedor siempre q se inicie el sistema(de ser necesario, se pueden agregar "ExecStartPre")
#mata un proceso docker llamado testing_server
#ExecStartPre = /usr/bin/docker kill testing_server
#remueve un contenedor llamdo testing_server
#ExecStartPre = /usr/bin/docker rm testing_server
#se usara "ExecStartPre" en caso de querer crear siempre el contenedor desde 0
#se reemplazara el comando "ExecStart" para correr y crear el contenedor
#ExecStart=/usr/bin/docker run -P --name=testing_server ubuntu/supervisor


#indica que el servicio docker iniciar ese contenedor
ExecStart=/usr/bin/docker start -a testing_server
#realiza dos intentos para detener el contenedor
ExecStop=/usr/bin/docker stop -t 2 testing_server

[Install]
#indica como va a inicializarce el contenedor o aplicacion, en este caso multi usuario
Wantedby=multi-user.target

habilitar el servicio

$> sudo systemctl enable /etc/systemd/system/testing.service

Opcional, pero se deberia realizar Recargamos los servicios

$> sudo systemctl daemon-reload

Se consulta si el servicio esta habilitado

$> sudo systemctl is-enabled testing.service; echo $?

tambien se puede ver con:

$> sudo systemctl status testing.service

Para iniciarlo

$> sudo systemctl start testing.service

Para muchos casos funciona sin problema, pero en otros que no como "core os", ejecutar lo siguiente:

$> sudo cp /usr/lib/systemd/system/docker.service /etc/systemd/system/multi-user.target.wants/

Modificar el "fichero multi-user.target.wants]"

$> sudo nano /etc/systemd/system/multi-user.target.wants/docker.service

Agregar en "Execstart" el flag "--restart=false" para que docker no reinicie automaticamente los contenedores

$> sudo systemctl daemon-reload

despues reiniciar y probar.

si mato o detengo la ejecucion del contendor, deberia automaticamente volver a levantarlo

$> sudo docker kill testing_server
$> sudo docker stop -t 2 testing_server

Brutal!!!! Sigue asi

Muy buen tutorial, lo seguí paso a paso y me dejó clarito.
Saludos