PROYECTO DE CONTENERIZACION CON DOCKER DE LA
APLICACION APACHE-PHP-MYSQL TOO v0.1
El proyecto consiste en contenerizar con Docker una aplicación extensa (Too v0.1) desarrollada
por Jose de Frías en PHP y Mysql sobre Apache.
1. - En una primera fase crearemos la aplicación y la probaremos sobre una plataforma php-
apache.
2. - Crearemos una imagen/Dockerfile que contenga Apache, PHP, la librería Smarty , otras
librerias y el código fuente de la aplicación.
3. - Crearemos una imagen/Dockerfile con mysql y un volumen asignado con los datos.
4. - Crearemos el archivo docker-compose para iniciar los contenedores y probaremos que
funciona correctamente la aplicación.
5 .- Red Bridge creada automáticamente por docker-compose.
6.- Seguidamente estableceremos una pipeline de integración continua basada en Github y
CircleCI.
7.- Subiremos el proyecto a producción.
8.- Montaremos un Custer de Docker Swarm y correremos la pliacación en dicho cluster.
1 CREAR APLICACION
1 CREAMOS LA APLICACION EN UN ENTORNO DE DESARROLLO
CON PHP 7, APACHE 2, MYSQL, Y LIBRERIAS: SMARTY,
PHPEXCEL, PHP_MAILER, ETC
Sobre Apache con PHP7, Mysql y las librerias: Smarty, Phpmailer, Phpexcel, Dompdf, y redist
para pasarelas de pago.
Aplicación de gestión para mayoristas de viaje: TOOBACK (togethere BackOffice)
La probamos sobre una base de datos Mysql en un Cloud (AWS) datos de prueba.
La dejamos configurada y funcionando.
2 CREANDO IMAGEN APACHE – PHP
1 Usamos la imagen php:7.2-apache de docker hub para crear un
contenedor
Cargamos la imagen de docker hub php:7,2-apache
Esta imagen tiene apache y php instalados sobre ubuntu.
Usamos el Dockerfile que viene con la imagen cuyo contenido es el siguiente:
FROM josedefrias/php-apache:v0.5
# Para instalar extensiones ej: docker-php-ext-install mysqli
# Para ver que extensiones tenemos php -m
# Carpeta de extensiones /usr/src/php/ext/
COPY src/ /var/www/html/
Creamos las carpetas que usaremos para guardar todos los ficheros necesarios.
Es muy importante crear estas carpetas con el usuario con el que vayamos a
trabajar o nos dará problemas de permisos posteriormente.
$ mkdir php-apache
$ mkdir php-apache/src
copiamos la aplicación en src
generamos la imagen josedefrias/php-apache:v0.1 usando el fichero Dockerfile
$ docker build -t josedefrias/php-apache:v0.1 .
Llegamos a la parte de armar nuestro contenedor y ponerlo en funcionamiento. Correrá en modo
interactivo con lo que podremos ver los logs y compartirá el puerto WEB/HTTP(80). Usaremos
nuestra imágen recién creada.
Iniciamos el contenedor
$ docker run it –name phpapache -p 80:80 josedefrias/php-apache:v0.1
Podemos entrar a trabajar dentro del contenedor con:
Ya tenemos el contenedor iniciado pero la aplicación aun no funcionará ya que debemos copiar
las librerias al directorio var/www/ dentro del contenedor y configurar los ficheros php.ini,
httpd.conf y sendmail.ini:
usr/local/etc/php/php.ini
usr/local/etc/httpd.conf
var/www sendmail/senmail.ini (cuando hayamos copiado esta librería)
el proyecto esta cargado en var/www/html/
Tenre siempre estos ficheros de otro proyecto para ver los cmabios que hay que hacer en cdaa
fichero.
En php.ini muy importante paths an directories y habilitar las extendiones.
Notas a tener en cuenta durante la configuración de php y apache
Permisos de escritura en la carpeta de trabajo: Al crear el directorio dentro del proyecto donde
vamos a ir modificando nuestro código en nuestra máquina (por ejemplo www o apdd) hay que
entrar y dar permisos de lectura y escritura a esa carpeta y todas las que tenga dentro y tdos los
ficheros.
Esto es para que cuando se cree la imagen con el Dockerfile, en el nuevo contenedor, el usuario
pueda escribir en ellos. Muy importante por ejemplo para smarty.
Puede ser necesario instalar extensiones en php:
Dependiendo de la imagen de php: Si es la oficial vienen con unos comandos de docker para
instalarlas.
Docker-php-ext-install mysqli
las extendiones estan en usrsrc/php/ext/
con php -m podemos ver las que enemos instaladas
Creamos la imagen v1.0 con la que iniciaremos el trabajo de
desarrollo e integración continua posteriormente
Usando docker commit y cuando hayamos terminado de configurar el contenedor inicial
crearemos ya la primera imagen de trabajo.
Esta la imagen la usaremos para todos los procesos posteriores.
docker commit php-apache josedefrias/php-apache:v0.1
Inicialmente usamos una conexión a una base de datos en la nube de AWS pero crearemos una
una imagen de mysql con la base de datos y un volumen con los datos para completar los
procesos de aprendizaje de docker. De momento y para que funcione le damos la conexión a una
base de tados que tengamos disponible en la nube.
Es importante que nos aseguramos que podemos iniciar la imagen sin -it y con -d para que
dockercompose pueda iniciarla posteriormente. docker run d--name phpmysql -p 80:80
josedefrias/php-apache:v0.1 (por esto tuve que cambiar de un proyecto con xampp a empezar
de nuevo con php y apache).
3 CREANDO IMAGEN PARA MYSQL
Usamos la imagen mysql:latest y un volumen asignado con los
datos
Descargamos y creamos la imagen de mysql
docker run -d --name mysql-too -p 3306:3306 -e MYSQL_ROOT_PASSWORD=root -d
mysql:latest
En php7 los cientes de MySQL no tan modernos, más antiguos que la versión de MySQL no
pueden usar el plugin de autenticación activo. Como es algo bastante común, MySQL ya deja la
siguiente información comentada en el archivo de configuración /etc/mysql/my.cnf:
[mysqld]
[...]
# Remove leading # to revert to previous value for default_authentication_plugin,
# this will increase compatibility with older clients. For background, see:
# https://dev.mysql.com/doc/refman/8.0/en/server-system-
variables.html#sysvar_default_authentication_plugin
#default-authentication-plugin=mysql_native_password
Hay que habilitarla entrando en el contenedor
Docker exec -it mysql-too bash
entrando el el fichero my.cfd y descomentandola (o añadiendola si no esta)
Tras reiniciar MySQL, el funcionamiento debería ser correcto. Eso sí, tened en cuenta que si los
usuarios los habéis creado antes de cambiar el plugin de autenticación, probablemente
siga fallando, simplemente volved a regenerar los usuarios.
Ahora creamos nuestra imagen propia de mysql
docker commit mysql-too josedefrias/mysql-too:v0.1
despues reiniciar el contenedor.
Creamos un volumen para la base de datos mysql-too
Debemos crear un volumen y asignarselo a la imagen antes de acceder a la base de datos
para crear nuestros usuarios y cargar la base de datos del proyecto.
Para crear nuestro volumen usaremos la el comando
# docker volume create mysql_too
con docker volumen inspect vemos la información del volumen. Ubicacion, etc
Despues iniciamos el contenedor especificando este volumen
docker run -d -it --name mysql-too -p 3306:3306 -v mysql_too:/var/lib/mysql
josedefrias/mysql_too:v0.1
Y accedemos a la base de datos con un gestor, preferiblemente heifdie puede acceder:
Desde el propio host: host:localhost user:root pass:root puerto: 3306
Desde fuera: ip del servidor: 192,168,1,106 user:root pass:root puerto: 3306
Ahora es el momento de crear nuestro usuario too (con los privilegios necesarios) y de crear la
base de datos too e importarla de alguna copia nuestra.
Yo hice esto en accediendo con heidi desde otro equipo, ya que no encontre heidi para linux e
importe la base de datos limpia para toogethere. Esto es muy importante para que no hay
aarchivos grandes o nos fallara la subida al repositorio de GitHub.
Una vez tengamos la base de datos configurada y con los usuarios, privilegios y el esquema que
necesitemos creamos la imagen definitiva.
docker commit mysql-too josedefrias/mysql-too:v0.2
4 CREANDO DOCKER-COMPOSE PARA EL PROYECTO
Creamos el archivo docker-compose.yml para iniciar los dos
contenedores en la misma red
Creamos el archivo de tipo yaml docker-compose.yml con el siguiente código
version: "3.0"
services:
php-apache:
build: .
ports:
- "80:80"
depends_on:
- mysql-too
mysql-too:
image: josedefrias/mysql-too:v1.0
ports:
- "3306:3306"
volumes:
- mysql_too:/var/lib/mysql
Notas importantes:
1 - No es necesario indicar el puerto en el servicio mysql ya que docker creara una red con ambos
servicios conectados. Yo lo hago para poder acceder con heidi desde fuera a la base de datos.
En produccion nunca se debe hacer ya que estaremos exponiendo la base de datos. Una ventaja
de docker compose es que aisla del exterior los servicios que queramos incrementando así la
seguridad con redes propias que crea en el momento de inicar los contenedores.
2 - En la etiqueta volumenes podemos indicar la ruta y el nombre donde se creo el volumen
mysql-too utilizando así el volumen donde esta y sin tocar nada:
- mysql_too:/var/lib/mysql
O bien podemos indicar una ruta para que docker cree un nuevo volumen con los datos dentro de
nuestra carpeta de proyecto d ella siguiente manera:
- ./mysql_too:/var/lib/mysql
Si hacemos esto último habra que volver a cargar los usuarios y esquemas y además dar
permisos de escritura a la nueva carpeta que se creará y todo su contenido.
Despues ejecutamos la orden docker-compose up -d crear e iniciar los contenedores con las
dependencias entre ellos dentro de la red, los puertos indicados
docker-compose up -d
Se iniciaran ambos contenedores y nuesttra aplicación debe funcionar. Podemos acceder desde
el navegador con : localhost/
Nota importante: Si hacemos cambios en las imagenes que usamos en el docker-compose
habra que reconstruirlas con el comando docker-compose build
Si da error de permisos los solucionamos dando permisos sobre la carpeta o fichero que
nos indicque el mensaje de error en la consola
sudo chown -R oracle /home/oracle/php-apache/mysql_too/
sudo chown -R oracle /home/oracle/php-apache/mysql_too/auto.cnf
Lógicamente si estamos trabajando con el usuario root esto no pasa.
5 RED BRIDGE CREADA POR DOCKER
DOCKER NETWORK POR DEFECTO
Red Bridge es el tipo de red predeterminados.
Todos los contenedores en una red Bridge estan conectados entre si y se pueden conectar a
internet a traves de la red Bridge.
Con docker network ls veremos las redes de nuestro host local
docker network ls
Veremos que hay creada una red de docker llamada bridge creda por docker al iniciar el ic.
Con docker network inspect bridge podemos ver detalles de la red
[root@ServidorLinux7 ~]# docker network inspect bridge
[
{
"Name": "bridge",
"Id": "5e09c396b098f62bef5be4c75a0bb0b949507f9d07f224f7efc23323f44ba263",
"Created": "2020-04-17T18:04:41.855693454+02:00",
"Scope": "local",
"Driver": "bridge",
...
No hemos puesto –network bridge porque es el tipo de red que se asigna automáticamente al
contenedor si no especificamos ninguna. Para oytra serís –network none o --network hots, ...
Ejecutemos ifconfig dentro del contenedor
docker exec -it container_1 ifconfig
Pata ver los interfaces creados
Hay dos interfaces de red.
Una interfaz loopback (que es una red None para aplicaciones internas)
Una interfaz de red privada privada (para conectarse al exterior con rango de ip) Con la ip
172.17.0.2
Los contenedores dentro de la red estarán dentro del mismo rango de ip’s.
Si qusieramos crera una red lo haríamos con
docker network create --driver bridge my_bridge_network
Indicando el driver y el nombre de la red
Despues podriamos iniciar un contenedor con esta red
docker run -d--name container_3 --net my_bridge_network busybox sleep 1000
o conectar una contenedor que este en otra red
docker network connect bridge container_3
DEFINIENDO REDES DE CONTENDORES CON DOCKER COMPOSE
6 PIPELINE DE INTEGRACION CONTINUA
ESCRIBE Y EJECUTA PRUEBAS UNITARIAS DENTRO DE
CONTENEDORES
Pruebas unitarias
docker-compose run
En el proyecto del curso James Lee creo un nuevo fichero test.py para ejecutar pruebas
llamandolo con el comando docker-compse run dockerapp python test.py
Yo usare el proyecto php-web (reduciendo el peso de la base de datos para que github no de
error al no permitir ficheros de más de 100 MB)
Y no haré pruebas en un principio.
Tansolo dejare que Circle CL revise el código y poco más. (ya habrá tiempo de complicarse…)
Usar docker para nuestra integración continua
El proceso de integración ciontinua con Docker tendría los siguientes pasos:
En negrita los pasos en los que entra docker, resto es el proceso normal de integración
continua.
1 - Los desarrolladores revisarán el código de forma loca.
2 - Cuando terminene de programar alguna funcionalidad enviaran los cambios al repositorio
central
3 - El servidor de integración continua estará supervisando el repositorio central
4 - Al registrar un cambio, normalmente, provoca que se ejecute una compilación en el servidor
de integración.
5 - El proceso de compilación puede variar de una aplicación a otra pero normalmemte implicaria.
- Revisar la ultima versión del código base.
- Compilar la aplicación.
- Ejecutar las pruebas unitarias y de integración.
6 - El servidor de IC creará la imagen de docker
7 - La aplicación va dentro de una imagen y el servidor IC envía la imagen a un registro
8 – Despues el servidor de IC podrá extraer la imagen del registro para ejecutarla en otro
host ya sea para desarrollo , puesta en marcha o producción.
GitHub – Agregar key SSH a cuenta GitHub
Seguir las instrucciones del video 5.35 (al final) del curso Udemy de Docker ó estas:
URL de la cuenta Github para hacer fork:
https://github.com/jleetutorial/dockerapp
Chequeo para keys SSH existentes:
https://help.github.com/articles/checking-for-existing-ssh-keys/
Genera una nueva key SSH y agrégala al agente ssh:
https://help.github.com/articles/generating-a-new-ssh-key-and-adding-it-to-the-ssh-agent/
Agrega una nueva key SSH a tu cuenta GitHub:
https://help.github.com/articles/adding-a-new-ssh-key-to-your-github-account/
Preparar nuestro proyecto para vincularlo desde GitHub con la
cuenta de CircleCI y establecer así un flujo de trabajo
Los pasos de compilacion de CircleCI se definen en un archivo de configuración -yml dentro de un
directorio llamado .circleci que debe ubicarse en el directorio raiz del repositorio Git.
Nosotros crearemos este directorio y añadiremos dentro el fichero config.yml
Este fichero tendra
Version 2 indica la version de circleci más recientes
- En jobs: Cada archivo de configuración debe tener un trabajo de compilación. Este es el trabajo
que es ejecutado automáticamente pot circleci
-Build: Para construir nuestra imagen)
- Despues un directorio de trabajo para todo el trabajo
- Despues la imagenes docker primario. Aqui definimos el entorno de circle ci que es donde
se ejecutarán nuestros pasos. En circleci todas las pruebas se ejecutarán en contenedores
y este contenedor creará nuestros contenedores dockerapp y redis y tambien ejecutará
nuestras pruebas. Así es que básicamente son contenedores dentro de un contendor
primario.
- En resumen, lo que queremos es una imagen que instale dockery tenga git. Estos r
equisitos se satisfacen usando la imagen: docker:17.05.0-ce-git Usando esta
imagen te aseguras de usar el úlrtimo cliente docker y con git preinstalado.
Steps: (pasos dentro del trabajo de compilacion)
- checkout: Creará e inspeccionará el código fuente desde github al directorio de
trabajo que ya hemos definido arriba.
- setup_remote_docker: para crear imagenes para despliege debemos usar un
conjunto especial de claves remotas docker que crearna un entorno separado para
cada compilación por seguridad. Este entorno es remoto completamente aislado y
será configurado para ejecutra comandos docker.
- run: Instalamos docker-compose en el entorno CI a raves de un gestor de paquetes
basado en python llamado pip, que tambien tenemos que instalar aquí.
-run: Ahora ya podemos iniciar nuestros contenedores y ejecutar nuestras pruebas
dentro de esos contenedores.
Comentamos las lineas donde luego enviaremos la imagen a docker hub
Subimos el proyecto a GitHub
Usaremos nuestra cuenta de GitHub para subir nuestro repositorio y la enlazaremos con nuestra
cuenta de CircleCI donde tendremos nuestro servidor de.
Nos situamos en la carpeta del proyecto
Subir un repositorio a Git Hub
echo "# php-apache" >> README.md
git init
git add README.md (opcionale)
git add .
git commit -m "first commit"
git remote add origin git@github.com:josedefrias/php-apache.git
git push -u origin master
Nuestro repositorio quedará subido a GitHub
NOTAS PARA HACER CAMBIOS EN EL REPOSITORIO Y SUBIRLO A GITHUB
unos cambios en el codigo fuente y los enviaremos al repositorio central para probar esto.
Esperamos ver una nueva compilacion automáticamente. Esta vez compilará bien porque no
pondremos la opción de publicar en dockerHub en una nueva rama de v0.6
1 Hacemos chekout en v0.6
git checkout v0.6
2 Creamos una nueva rama desde nuestro repositorio local llamandola test-ci
git checkout -b test-ci
3 agregamos un archivo ficticio y hacemos un commit de este a git
touch dummy.txt
git add dummy.txt
git commit -m "add dummy file to test circle build" (puede darnos un error al haber
puesto el correo real cuando generamos la key de SSH. Si ocurre con ejecutar los dos
comandos que nos da el error se arregla).
Necesitamos configurar la rama superior para la rama local que acabamos de crear
git push --set-upstream origin test-ci (Una vez configurada nos bastará con git push)
REALIZAR LA COMPILACION DESDE CIRCLECI
VAMOS A LA PAGINA DE CIRCLECI CON LA SESION INICIADA EN GITHUB
Entramos en la página de circleci, le damos a login y despues inicar sesion en github
niciando sesion en github se iniciará sesion automáticamente en circleci (Menos la primera vez
que te preguntará un par de cosas)
Entramos y hacecemos click en el boton de proyecto y despues en add proyecto
Despues seleccionamos el setup del proyecto dockerapp
Le damos a manually y Start Building.
Iniciará la compilación pero dará un error de falta de un fichero json...
Nos preocuparemos de esto más adelante, ya que el proyecto es grande y hay que revisar bien .
PUBLICAR IMAGENES DOCKER DESDE CIRCLECI
Yatenemos vinculadas nuestras cuentas de CircleCI y GitHub para que se envíen
automáticamente los cambios del repositorio central de GibHub al Servicor de IC de CircleCI.
Es decir el proceso se dirige a acabar subiendo a preproduccion y producción nuestros proyectos
según vayan recibiendo mejjoras testeadas y autorizadas.
Agregando credenciales de GitHub en las variables de entorno de CircleCI
Vamos a la página de Circle ci.
Vamos al panel de workflows.
Despues accemos click en el repositorio dockerapp
En la esquina superior derecha pulsamos la rueda de configuración del proyecto
Y despues en Enviroment variable
Añadimis dos variable:
DOCKER_HUB_USER_ID (para indicar el usuario) josedefrias
DOCKER_HUB_PWD (para la password) Dacasale219
DOCKER_HUB_EMAIL (para el correo) josedefrias@ipsotravel.com
De esta manera hemos guardado nuestras credenciales de DockerHub en CircleCI
Acontinuación agregaremos las instrucciones en el archivo circle.yml para la
publicación de imágenes docker.
Primero verificamos el código fuente
git stash && git checkout v0.6
Ahora creamos una nueva rama llamada circle_ci_publish (usando la opcion -b con git)
git checkout -b circle_ci_publish
Descomentamos las lineas del config.yml de .circleci para que despues de la compilación se
publique la imagen en docker file pero solo si el resultado es exitoso.
Ahora hacemos un commit en nuestros cambios y enviarlos al repositorio central de Github
git add .circleci/config.yml
git commit -m "push to docker hub from circleCI"
git push
OJO aquí al poner git push nos sugiereuna accion:
[oracle@ServidorLinux7 dockerapp]$ git push
fatal: You are not currently on a branch.
To push the history leading to the current (detached HEAD)
state now, use
git push origin HEAD:<name-of-remote-branch>
[oracle@ServidorLinux7 dockerapp]$ git push origin HEAD:<name-of-remote-branch>
bash: error sintáctico cerca del elemento inesperado `newline'
Y entonces ejecutamos:
dockerapp]$ git push origin circle_ci_publish
[oracle@ServidorLinux7 dockerapp]$ git push origin circle_ci_publish
Total 0 (delta 0), reused 0 (delta 0)
remote:
remote: Create a pull request for 'circle_ci_publish' on GitHub by visiting:
remote: https://github.com/josedefrias/dockerapp/pull/new/circle_ci_publish
remote:
To git@github.com:josedefrias/dockerapp.git
* [new branch] circle_ci_publish -> circle_ci_publish
[oracle@ServidorLinux7 dockerapp]$
Y una nueva compilacion ha sido acyivada en circleCI
Y si todo va bien ademas se habrá añadido una nueva imagen a Docker Hub.
Con dos etiquetas.
DESPLEGANDO EL PROYECTO EN PRODUCCION
La forma más popular de desplegar contendores en producción es configurar máquinas virtuales y
luego desplegar contenedores en estas máquinas.
Se usan máquinas virtuales para considerar los problemas de seguridad. Es fundamental
garantizar que un cliente no podrá acceder al la red de otro cliente.
DOCKER MACHINE
La forma más sencilla de configurar nueva máquinas virtuales y ejecutar contendores en ellas es
mediante DOCKER MACHINE. Docker Machine puede configurar nuevas másuinas virtuales
instalar las herramientas docker en ellas y vincular el cliente Docker con las máquinas docker
remotas .
Docker machine proporciona soporte para varios controladores de proveedores de servicios en la
nube como AWS, Digital Ocean o Google app engine.
SUBIREMOS EL PROYECTO A UN DROPLET DE DIGITAL OCEAN
(Un droplet es se llaman las maquinas virtuales en Digital Ocean)
CREAMOS LA CUENTA EN DIGITAL OCEAN (SI AUN NO LA
TENEMOS)
He creado una cuenta de Digital Ocean para este proyecto. Dan 100 euros gratis para
gastar antes de dos meses. Asi es que aprovechamos ese tiempo para practicar este y
otros proyectos.
Aunque yo ya tengo token para conectar pongo la explicacion de como crearlo:
Para acceder a la cuenta de digital Ocean a traves de su api y gestionar una máquina
virtual necesitamos generar un token de acceso personal.
Los token de acceso personal funcionan como los token ordinarios de acceso que pueden
usarse para permitirnos acceder a los recursos de nuestra cuenta en DO sin necesidad de
alguna contraseña.
Hacemos click en API y despues en Generate New Token
Le damos un nombre al token por ejemplo: dockerapp
Y clickeamos en Generate Token
Ahora veras el token. Haz click en el portapapeles y copialo a un archivo y guardalo en otro lugar
donde puedas acceder a el ya que lo usaremos posteriormente.
CREAMOS LA MAQUINA VIRTUAL USANDO DOCKER-MACHINE
Para ver si tienes instalado docker machine (sino en el documento que hice del curso esta como
instalarlo)
docker-machine ls
Con docker machine podemos crear una máquina virtual en Digital Ocen con el comando docker
create con los siguiente argumentos:
driver del proveedor: --driver digitalocean
token de acceso: digitalocean-access-token
69492d79cf0cba6d3f96804ecb0895130f86da0f2a6a49ac08be782f7a4db9ac
nombre de la maquina: docker-app-machine
Y empezará el proceso de solicitud a digital ocean, instalación del docker engine en la máquina
virtual y generar los certificados:
el comando sería así.
docker-machine create --driver digitalocean --digitalocean-access-token
69492d79cf0cba6d3f96804ecb0895130f86da0f2a6a49ac08be782f7a4db9ac php-apache-
machine
Una vez termine:
Si hacemos docker-machine ls veremos nuestra máquina creada
Ahora ay que configurar el entorno del cliente docker
docker-machine env php-apache-machine
Estos mostrará los comandos necesarios para configurar el entorno de cliente docker
[oracle@ServidorLinux7 ~]$ docker-machine env php-apache-machine
export DOCKER_TLS_VERIFY="1"
export DOCKER_HOST="tcp://134.209.37.149:2376"
export DOCKER_CERT_PATH="/home/oracle/.docker/machine/machines/php-apache-machine"
export DOCKER_MACHINE_NAME="php-apache-machine"
# Run this command to configure your shell:
# eval $(docker-machine env php-apache-machine)
[oracle@ServidorLinux7 ~]$
Cuando termine nos sugiere un comando para configurar las variables de entorno que deben
configurar nuestro cliente docker y este logreconectarse a la máquina virtual que acabamos de
provisionar.
Lo ejecutamos:
eval $(docker-machine env php-apache-machine)
Con esto establecemos la maquina como activa para trabajar con ella. Ejecutamos docker-
machine ls y veremos que es la que tiene el asterisco.
ahora con.
docker info
veremos informacion de la máquina virtual
[oracle@ServidorLinux7 dockerapp]$ docker info
Con esto ya tenemos nuestra máquina virtual provista.
DESPLEGAMOS LA APLICACION EN DIGITAL OCEAN USANDO
DOCKER-MACHINE
Desplegaremos la aplicación usando el comando docker-compose
Podemos hacerlo usando otro .yml para producción
docker-compose -f prod.yml up -d
o el mismo con el que hemos estado trabajando.
docker-compose up -d
MUY IMPORTANTE ASEGURARNOS QUE ESTAMOS EN EL ENTORNO DE LA MAQUINA.
(NO SE SI LO MEJOR ES QUE LAS IMAGENES QUE HEMOS PUESTO EN EL prod.yml
ESTEN EN DOCKER-HUB )
Hacemos docker-machine ls para asegurarnos de que el asterisco este en la máquina donde
queremos desplegar el proyecto.
Se desplegará la plicación en la máquina virtual remota y podremos ver el resultado
accediendo desde el browser http://165.227.189.83/
A partir de aquí controlaremos esta máquina con los comandos de docker-machine
COMANDOS DOCKER-MACHINE
docker-machine create --driver digitalocean --digitalocean-access-token
69492d79cf0cba6d3f96804ecb0895130f86da0f2a6a49ac08be782f7a4db9ac php-apache-
machine
docker info
docker-machine ls Ver las máquinas
docker-machine stop id_maquina Parar la máquina
docker-machine startid_maquina Iniciar la máquina
docker-machine env php-apache-machine para establecer el entorno en esta :
eval $(docker-machine env php-apache-machine) es la que recomienda docker
docker-machine env –unset) Volver a la maquina anfitrion
eval $(docker-machine env --unset) es la que recomienda docker
docker-machine ssh php-apache-machine Entrar en la máquina
https://picodotdev.github.io/blog-bitix/2015/07/usar-docker-con-docker-machine-en-linux-windows-
o-mac/
Para usar Docker Machine debemos descargar el binario, darle permisos de ejecución y si
queremos añadirlo a la variable PATH del sistema.
1 $ docker-machine --version
Con los siguientes comandos podemos crear una máquina virtual para los contenedores docker,
listar las máquinas virtuales creadas, hacer SSH a ella, ejecutar un contenedor en ella, parala y
eliminar una máquina virtual además de obtener la IP asignada.
1 $ docker-machine create --driver virtualbox dev
2 $ docker-machine ls
Estableciendo las variables de entorno de la máquina virtual podemos usar el comando docker
como si de la máquina anfitrión fuera, todos los comandos de docker que lancemos se ejecutarán
contra el contenedor docker de la máquina virtual. En el siguiente caso se ejecuta el contenedor
de busybox en la máquina virtual dev. Con --unset podemos reiniciar la configuración a la
máquina anfitrión.
1 $ docker-machine env dev
2 $ eval "$(docker-machine env dev)"
3 $ docker run busybox echo "hello world"
4 $ eval "$(docker-machine env --unset)"
Podemos detener, volver a iniciar, hacer SSH y eliminar la máquina virtual con:
1 $ docker-machine start dev
2 $ docker-machine ssh dev
3 $ docker-machine stop dev
4 $ docker-machine rm dev
El directorio por defecto donde se guardarán los archivos de las máquinas virtuales es
~/.docker/machine, si queremos cambiarlo podemos utilizar el parámetro --storage-path en cada
uno de los comandos anteriores de la siguiente forma, el orden de los parámetros es importante:
1 $ docker-machine --storage-path "/run/media/picodotdev/BMOVE_ROJO/docker/machine" create --
DOCKER SWARM Y CONFIGURACION DE UN CLUSTER SWARM
DOCKER SWARM
Docker Swarm es el administrador de clusteres de Docker entre el cliente docker y estos hosts.
Cuando quieres ejecutar un servicio sera el administrador Swarm quien decida donde ejecutar
ese servicio.
Solo tienes que direccionar tu cliente docker al administrador Swarm en lugar de hacerlo en todos
y cada uno de los dockers daemonds.
Básicamente Docker Swarm puede agrupar varios Host en un cluster y distribuir contenedores
docker en estos Hosts.
CONFIGURACION
- PASO 1 Creacion de las dos máquinas virtuales
Las podemos crear utilizando el mismo comando docker-machine create que utilizamos
anteriormente.
NODO ADMINISTRADOR
docker-machine create --driver digitalocean --digitalocean-access-token
69492d79cf0cba6d3f96804ecb0895130f86da0f2a6a49ac08be782f7a4db9ac php-apache-
manager
Una vez este creada
Debemos permitir que nuestro cleinte se conecte a la máquina virtual swarm-manager con:
docker-machine env swarm-manager
Luego copiamos el comando que se nos muestra en pantalla para configurar nuestro shell. Con
esto activamos la máquina.
eval $(docker-machine env php-apache-manager)
NODO DE TRABAJO
docker-machine create --driver digitalocean --digitalocean-access-token
69492d79cf0cba6d3f96804ecb0895130f86da0f2a6a49ac08be782f7a4db9ac php-apache-node
Ahora ya tenemos las dos máquinas virtuales
- PASO 2 Nombra la primera máquina como administrador
Swarm e inicia el cluster
Nombrar la primera máquina virtual como un administrador swarm. Esto se puede hacer a traves
del comando docker swarm init que inicializará un swarm.
El docker engine modificado por este comando se convertirá en un nodo administrador en
el swarm de un solo nodo recientemente creado
Antes de ejecutar el comando asegurémonos que el entorno apunta ala máquina virtual del
administrador swarm
docker swarm init
Da un error porque dice que esta máquina tiene múltiples interfaces de red y docker swarm no
sabe cual usar para comunicarse.
[oracle@ServidorLinux7 dockerapp]$ docker swarm init
Error response from daemon: could not choose an IP address to advertise since this system has multiple addresses
on interface eth0 (64.225.56.180 and 10.17.0.6) - specify one with –advertise-addr
Por defecto, la máquina virtual viene con dos ip’s una es una ip pública y la otra una ip privada.
Aquí usaremos la ip pública para iniciar nuestro docker swarm ejecutando:
docker swarm init --advertise-addr 64.225.56.180
[oracle@ServidorLinux7 dockerapp]$ docker swarm init --advertise-addr 64.225.56.180
Swarm initialized: current node (nqit2ah2vlsk45nk0ji2il9sm) is now a manager.
To add a worker to this swarm, run the following command:
docker swarm join --token SWMTKN-1-52758ju5982a9zjyaqij72jmjlu3hh9o2zjx5sn5chxo3kbp3j-
5uxo6l299lf98vuglt4z4wsm0 165.227.109.90:2377
To add a manager to this swarm, run 'docker swarm join-token manager' and follow the instructions.
[oracle@ServidorLinux7 dockerapp]$
Ahora el cluster swarm se inicializa exitosamente
- PASO 3 Dejar que la segunda máquina se una al cluster
Swarm como un nodo de trabajo
Swarm tambien nos proporciona un comando para ejecutar si queremos agregar un nodo al
cluster swarm.
Es importante tener en cuenta que este comando debe ejecutarse en el nodo de trabajo.
Asi que aquí en lugar de cambiar la máquina virtual activa podemos ejecutar. Docker-machine ssh
en la máquinavirtual del nodo de trabajo
docker-machine ssh php-apache-node
Con esto entramos a la máquina virtual del nodo de trababajo
root@swarm-node:~#
Cuando creamos el nodo administrador nos informo de la orden que debemos dar para crear
nodos de trabajo.
Ejecutamos esa orcen dentro del nodo de trabajo
docker swarm join --token SWMTKN-1-52758ju5982a9zjyaqij72jmjlu3hh9o2zjx5sn5chxo3kbp3j-
5uxo6l299lf98vuglt4z4wsm0 165.227.109.90:2377
This node joined a swarm as a worker.
root@swarm-node:~#
Y el nodo de trabajo se ha unido al cluster
DESPLIEGE DE LA APLICACION A LA NUBE CON DOCKER SWARM
Los servicios se pueden definir en nuestro archivo docker-compose. En nuestro caso teniamos los
servicios dockerapp y redis.
La definición del servicio incluye que imagenes de docker se ejecutarán, la asignacion de puertos
y la dependencia entre servicios. Tambien surge una nueva llave: deploy que se puede usar para
equilibrar la carga y optimizar el rendimiento de cada servicio.
Un ejemplo:
el valor de réplicas a 3, lo que significa que docker ejecutará 3 instancias (contenedores) de la
imagen nginx como un servicio llamado nginx.
En resources podemos establecer límites de uso de cpu y memoria
Con restar_policy podemos pedirle a docker que reinicie los contenedore sen caso de que uno de
ellos falle.
Todo esto esta hecho para garantizar excalabilidad de ompilación y alta disponibilidad para los
servicios desplegados en un cluster Swarm.
DOCKER STACK
DOCKER STACK = DOCKER-COMPOSE EN MODO SWARM
Creamos un nuevo fichero prod_swarm.yml para nuestro swarm. Será igual que el que tenms
para producción de la anterior máquina (que no esta en claster) pero añadiendo la llave deploy.
De momento, para no complicarnos, solo dos replicas en el servicio phpapache.
A continuacion crearemos unstack a partir de nuestro archivo docker compose y lo
desplagaremos a docker swarm con el comando docker stack deploy mas la opción para el
fichero de docker compose y un combre al nuevo stack
OJO! Siempre con el entorno apuntando a nuestro manager
docker stack deploy --compose-file prod_swarm.yml php-apache_stack
[oracle@ServidorLinux7 php-apache]$ docker stack deploy --compose-file prod_swarm.yml php-apache_stack
Creating network php-apache_stack_default
Creating service php-apache_stack_phpapache
Creating service php-apache_stack_mysqltoo
ahora docker swarm a creado una red overlay por nosotros llamada apache-php_stack_default
para la comunicación cruzada de nodos. Esta red se crea automaticamente cuando ejecutamos
docker stack deploy.
docker stack ls Para ver todos los stacks
docker stack services php-apache_stack Para listar todos los servicios del stack
Ya tenemos un stack compuesto por dos servicios
Para acceder a nuestro servicio phpapache.
Primero enumeremos las direcciones ip de todas las máquinas virtuales en ejecución.
[oracle@ServidorLinux7 php-apache]$ docker-machine ls
NAME ACTIVE DRIVER STATE URL SWARM DOCKER
docker-app-machine - digitalocean Stopped Unknown
php-apache-machine - digitalocean Running tcp://165.227.189.83:2376 v19.03.8
php-apache-manager * digitalocean Running tcp://165.227.109.90:2376 v19.03.8
php-apache-node - digitalocean Running tcp://159.89.47.60:2376 v19.03.8
swarm-manager - digitalocean Stopped Unknown
swarm-node - digitalocean Stopped Unknown
Deberiamos poder acceder a phpapche desde cualquiera de los host debido a la funcionalidad de
equilibrio de carga de swarm. Usemos la ip de cualquiera de las dos máquinas del swarm en el
navegador
165.227.109.90:80
159.89.47.60
y entraremos a nuestra aplicación dockerapp
REALIZAR CAMBIOS
Tan simple como volver a ejecutar el docker stack deploy con los cambios realizados n el .yml
Agregar un contenedor, por ejemplo, a mysql: Con poner deploy en el servicio y replica: 2 bastará
docker stack deploy --compose-file prod_swarm.yml php-apache_stack
Ya no creará la red overlay porque se creo la primera ver.
Agregar un contenedor por ejemplo a mysql: Con poner deploy en el servicio y replica: 2 bastará
Ojo!!! si cambiamos alguna imagen hay que subirla a docke hub
docker stack rm dockerapp_stack PARA BORRAR EL STACK
6-44 HERRAMIENTAS DE MONITOREO DE DOCKER
docker stat id_container
docker stat
Todos los contenedores Docker se envían con una herramienta de monitoreo preconfigurada que
es Docker Stat.
El siguiente comando proporciona estadísticas de la utilización de la CPU docker, el uso de
memoria, el límite de memoria y las métricas de E / S de la red.
$ docker stats [CONTENEDOR …]
El primer comando "docker" es un comando base para la CLI de docker. Puede especificar uno o
más contenedores separados por espacios para obtener información sobre cada uno.
El siguiente comando mostrará detalles de todos los contenedores que se ejecutan en Linux
daemon
$ docker stats
