mbr4v0v/tutorialDockerCentos7.md

## tutorialDockerCentos7.md

      
    Raw
  

              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 <edgardo.a.v@gmail.com>" -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 miempresa@172.17.0.2 -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 student@172.17.0.2 -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 APACHE_SERERADMIN=webmaster@personal.cl 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 APACHE_SERERADMIN=webmaster@personal.cl --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 yo@micorreo.cl

#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 student@192.168.15.33 -p 32771
student@192.168.15.33's password: 
Permission denied, please try again.
student@192.168.15.33'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