Contenedores

2020-02-04T11:29:54Z

Frabotrom:

En esta práctica aprenderemos a utilizar [https://es.wikipedia.org/wiki/Docker_(software) docker] para desplegar contenedores.

= Paso 1: Instalar docker =

Vamos a añadir un nuevo repositorio, ya que docker no está en los repositorios
oficiales:

<syntaxhighlight lang="bash">
sudo apt update
sudo apt install docker.io
</syntaxhighlight>

Para ver si está todo bien y se ha instalado correctamente, comprobaremos que el
servicio está activo:

<syntaxhighlight lang="bash">
sudo service docker status
</syntaxhighlight>

Debería mostrar algo similar a lo siguiente:

<syntaxhighlight lang="bash">
● docker.service - Docker Application Container Engine
Loaded: loaded (/lib/systemd/system/docker.service; enabled; vendor preset: enabled)
Active: active (running) since Mon 2019-08-26 09:41:40 UTC; 37s ago
Docs: https://docs.docker.com
Main PID: 3630 (dockerd)
Tasks: 8
CGroup: /system.slice/docker.service
└─3630 /usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock
</syntaxhighlight>

Pulsamos la tecla 'q' para salir.

Si el servicio aparece inactivo, puedes lanzarlo con:

<syntaxhighlight lang="bash">
sudo service docker start
</syntaxhighlight>

= Paso 2: Ejecutar docker con nuestro usuario =

Para no necesitar sudo al utilizar docker, añadiremos a nuestro usuario al grupo
docker:

<syntaxhighlight lang="bash">
sudo usermod -aG docker ubuntu
</syntaxhighlight>

Para que el cambio tenga efecto, tendremos que cerrar la sesión de nuestro
usuario y abrirla de nuevo. Podemos hacerlo fácilmente pulsando CTRL + D y
volviendo a insertar nuestras credenciales.

= Paso 3: Repositorio de imágenes de contenedores DockerHub =

Docker ofrece un servicio de nube denominado ''DockerHub'' que puede ser empleado como red social para compartir tus imágenes de Docker. En ''DockerHub'' existen además imágenes de contenedores preconfiguradas de software, muchas de ellas oficiales (ofrecidas por el propio fabricante del software) que se podrán emplear como base para construir nuevas imágenes adaptadas a nuestras necesidades.

Podremos realizar búsquedas en este repositorio ''DockerHub'' puedes emplear el siguiente comando:

<syntaxhighlight lang="bash">
docker search hello-world
</syntaxhighlight>

Para descargarnos la imagen de ''hello-world'' podemos usar la orden ''pull'':

<syntaxhighlight lang="bash">
docker pull hello-world
</syntaxhighlight>

También podemos publicar imágenes propias, esto require '''registro de usuario''' en la nube de ''DockerHub'', lo que '''no''' es obligatorio para la realización de esta práctica. Para subir una imagen, hay que validarse como usuario en la nube de ''DockerHub'':

<syntaxhighlight lang="bash">
docker login
</syntaxhighlight>

Tras introducir tu usuario y contraseña, puedes comenzar a publicar tus propias imágenes.

<syntaxhighlight lang="bash">
docker push MI_IMAGEN
</syntaxhighlight>

= Paso 4: Comprobar imágenes en nuestra máquina =

Para ver las imágenes que tenemos en nuestra máquina, utilizaremos el comando:

<syntaxhighlight lang="bash">
docker images
</syntaxhighlight>

Inicialmente, no tenemos imágenes en almacenamiento, podemos descargarnos la imagen oficial de Ubuntu:

<syntaxhighlight lang="bash">
docker pull ubuntu:latest
</syntaxhighlight>

Ahora si, ya debería de aparecernos la imagen ''ubuntu''.

Comentar también que cada imagen puede tener varias etiquetas, por ejemplo, la imagen ubuntu, cuando la hemos visto en el listado de imágenes, venía con el tag latest, que es el tag que se descarga por defecto, pero nosotros podemos especificar otro, por ejemplo:

<syntaxhighlight lang="bash">
docker pull ubuntu:bionic
</syntaxhighlight>

Para traernos la versión de la imagen de Ubuntu ''bionic'' (18.04).

Ahora tendremos dos imágenes con diferente etiqueta, que serían como las diferentes versiones de cada imagen.

= Paso 5: Lanzar un contenedor =

Un contenedor no es más que una imagen de docker ejecutándose, sería similar a
una máquina virtual, aunque mucho más liviano.

Para crear un contenedor, utilizaremos una imagen, en este caso, la imagen
hello-world. Hacemos lo siguiente:

<syntaxhighlight lang="bash">
docker run hello-world
</syntaxhighlight>

Esto nos mostrará el siguiente mensaje si todo está correcto:

<syntaxhighlight lang="bash">
Hello from Docker!
This message shows that your installation appears to be working correctly.

To generate this message, Docker took the following steps:
1. The Docker client contacted the Docker daemon.
2. The Docker daemon pulled the "hello-world" image from the Docker Hub.
(amd64)
3. The Docker daemon created a new container from that image which runs the
executable that produces the output you are currently reading.
4. The Docker daemon streamed that output to the Docker client, which sent it
to your terminal.

To try something more ambitious, you can run an Ubuntu container with:
$ docker run -it ubuntu bash

Share images, automate workflows, and more with a free Docker ID:
https://hub.docker.com/

For more examples and ideas, visit:
https://docs.docker.com/get-started/
</syntaxhighlight>

Al crear los contenedores utilizando el comando 'run', tenemos varias opciones:

== Paso 5.1: Ejecutar una terminal en el contenedor en modo interactivo (-ti) ==

Para este ejemplo vamos a utilizar otra imagen diferente, en este caso vamos a utilizar una imagen de ubuntu.

Vamos a lanzar un contenedor y ejecutar una terminal en el que se va a ejecutar el programa '''bash''' que me ofrece un interprete de órdenes:

<syntaxhighlight lang="bash">
docker run -ti ubuntu bash
</syntaxhighlight>

La opción ''-t'' indica que se crea un terminal en el contenedor. Y la opción ''-i'' indica que el contenedor se ejecuta en modo interactivo.

Al acceder al contenedor de ''ubuntu'' nos aparece un ''hash'' en el prompt de la shell, que identifica a la instancia del contenedor (es valor es similar al que muestra la orden ''docker container ls'').

Para salir del contenedor, escribimos 'exit' o pulsamos 'CTRL + D'

== Paso 5.2 Ejecutar en segundo plano (-d) ==

<syntaxhighlight lang="bash">
docker run -d hello-world
</syntaxhighlight>

Nos mostrará el id del contenedor y se ejecutará en segundo plano, por lo que la salida que antes obtuvimos, ahora no se muestra. Para poder ver esta salida,
podemos utilizar el comando logs y el id mostrador anteriormente:

<syntaxhighlight lang="bash">
docker logs 2ec1daae4676a4e84dc04fd91399c1dfe92119544ff12ee307991fe573d3db64
</syntaxhighlight>

== Paso 5.3: Añadir variables de entorno a un contenedor ==

Utilizaremos la imagen anterior, y vamos a añadir una variable de entorno
llamada TEST que contenga el valor 'test'. A parte, también ejecutaremos la
terminal como antes, para comprobar con el comando echo, que la variable de
entorno está creada correctamente:

<syntaxhighlight lang="bash">
docker run -ti -e TEST=test ubuntu bash
</syntaxhighlight>

Ahora, desde el contenedor podemos comprobar el valor de la variable de entorno ''$TEST''.

<syntaxhighlight lang="bash">
echo $TEST
test
</syntaxhighlight>

= Paso 6: Listar contenedores en ejecución =

Hemos estado haciendo pruebas y ejecutando contenedores en el paso anterior, vamos a ver donde se encuentran estos contenedores que hemos ejecutado, y después veremos algunas opciones más del comando run.

Tenemos dos opciones para ver los contenedores:

<syntaxhighlight lang="bash">
docker container ls -a
</syntaxhighlight>

o la versión corta:

<syntaxhighlight lang="bash">
docker ps -a
</syntaxhighlight>

Ambas hacen lo mismo, y debería de mostrarnos una salida similar a la siguiente:

<syntaxhighlight lang="bash">
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
e2bde5f5500c ubuntu "bash" 6 minutes ago Exited (0) 2 seconds ago pensive_sammet
544ad27dbc3c ubuntu "bash" 7 minutes ago Exited (0) 7 minutes ago serene_elgamal
</syntaxhighlight>

En la información veremos que el contenedor tiene el estado exited, eso quiere decir que no se está ejecutando y ya ha finalizado. Vamos a hacer una prueba para ver un contendor ejecutándose:

<syntaxhighlight lang="bash">
docker run -d ubuntu sleep 30
</syntaxhighlight>

Con el comando sleep 30 esperamos 30 segundos hasta que termine el comando, asíque durante esos 30 segundos, el contenedor estará ejecutándose, veámoslo:

<syntaxhighlight lang="bash">
docker ps -a
</syntaxhighlight>

<syntaxhighlight lang="bash">
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
eacceb27d52d ubuntu "sleep 30" 12 seconds ago Up 11 seconds sharp_pasteur
</syntaxhighlight>

Vamos a ver alguna opciones más de la orden ''run''.

== Paso 6.1: Dar un nombre al contenedor (--name) ==

Por defecto, docker creará automáticamente un nombre como hemos visto en las salidas del comando ''docker ps -a''. Podemos establecer el nombre del contenedor que queramos con la opción ''--name'':

<syntaxhighlight lang="bash">
docker run -d --name mi_ubuntu ubuntu
</syntaxhighlight>

== Paso 6.2: Eliminar contenedor cuando termine (--rm) ==

Vamos a mezclar todo lo visto anteriormente:

* Lanzar en segundo plano (-d)
* Ejecutar contenedor durante 30 segundos (sleep 30)
* Dar un nombre a la imagen (--name)
* Eliminar contenedor cuando termine (--rm)

<syntaxhighlight lang="bash">
docker run -d --rm --name bye-bye ubuntu sleep 30
</syntaxhighlight>

Antes y una vez pasados los 30 segundos, podemos comprobar que el contenedor ha desaparecido.

<syntaxhighlight lang="bash">
docker ps -a
</syntaxhighlight>

= Paso 7: Parar y eliminar contenedores =

Los contenedores podemos pararlos o eliminarlos, veamos como hacerlo. Antes que
nada, borraremos todos los contenedores que estén terminados, para ello:

<syntaxhighlight lang="bash">
docker container prune
docker ps -a
</syntaxhighlight>

Ya lo hemos dejado todo limpio para seguir, ahora vamos a crear un contenedor,
utilizando un comando de linux que no termina, para que así se quede
ejecutándose el contenedor infinitamente:

<syntaxhighlight lang="bash">
docker run -d -ti --name my_container ubuntu bash
docker ps -a
</syntaxhighlight>

Vamos a pararlo (podemos utilizar el nombre dado o el id):

<syntaxhighlight lang="bash">
docker stop my_container
docker stop e4901956f108
docker ps -a
</syntaxhighlight>

Veremos que ya ha terminado, y ahora vamos a eliminarlo, pero solo este
contenedor, no como previamente que eliminamos todos. Lo mismo que para pararlo,
podemos utilizar el nombre o el id.

<syntaxhighlight lang="bash">
docker container rm my_container
docker container rm my_container
docker ps -a
</syntaxhighlight>

Veremos que ya no tenemos el contenedor y está correctamente eliminado.

= Paso 8: Conectarnos a un contenedor que se está ejecutando en segundo plano =

Vamos a ejecutar de nuevo un contenedor que no termine:

<syntaxhighlight lang="bash">
docker run -d -ti --name to_attach ubuntu bash
</syntaxhighlight>

Ahora, vamos a conectarnos a este contenedor que está ejecutándose en segundo
plano:

<syntaxhighlight lang="bash">
docker attach to_attach
</syntaxhighlight>

Veremos la orden bash ejecutándose, para terminar, hacemos un 'CTRL + C', y ahora, veremos que ha pasado con el contenedor:

<syntaxhighlight lang="bash">
docker ps -a
</syntaxhighlight>

Lo veremos parado, por que lo que hemos hecho ha sido conectarnos al contenedor
y parar el comando que se estaba ejecutando, así que ahora tenemos el contenedor
finalizado.

= Paso 9: Ejecutar en un contenedor otro comando =

Vamos a ver otresta vez como ejecutar un comando en un contenedor que ya está
ejecutándose:

<syntaxhighlight lang="bash">
docker run -d -ti --name to_exec ubuntu bash
</syntaxhighlight>

Ahora, vamos a ejecutar un comando en ese contenedor. El comando exec es similar
al comando run, pero para ejecutar un comando dentro de un contenedor:

<syntaxhighlight lang="bash">
docker exec -ti to_exec ls
</syntaxhighlight>

Ahora estamos dentro del contenedor creado anteriormente:

<syntaxhighlight lang="bash">
ps -a
</syntaxhighlight>

Aquí veremos en el listado de procesos que hay en ejecución.

Ahora vamos a salirnos del contenedor, escribiendo 'exit' o 'CTRL + D', y
comprobemos el estado del contenedor:

<syntaxhighlight lang="bash">
docker ps -a
</syntaxhighlight>

Ahora veremos que el contenedor se sigue ejecutando, no como en el paso anterior.

= Paso 10: Persistencia en contenedores =

Vamos a ver que los contenedores no mantienen los datos por defecto, solo nos
dan un servicio pero los datos NO son persistentes. Creemos un contenedor que
vamos a dejar ejecutándose:

<syntaxhighlight lang="bash">
docker run -d -ti --name to_expire ubuntu bash
</syntaxhighlight>

Ahora, vamos a crear una carpeta en el contenedor y comprobar que esa carpeta
existe:

<syntaxhighlight lang="bash">
docker exec to_expire mkdir test
docker exec to_expire ls
</syntaxhighlight>

Veremos que la carpeta existe, pero, ¿qué ocurre si eliminamos el contedor y
volvemos a crear uno?

<syntaxhighlight lang="bash">
docker container stop to_expire
docker container rm to_expire
docker run -d -ti --name to_expire ubuntu bash
docker exec to_expire ls
</syntaxhighlight>

Podemos comprobar que la carpeta creada anteriormente, no existe si el
contenedor termina. Si quisíeramos mantener una persistencia de datos, tenemos
varias opciones:

== Paso 10.1: Mantener la persistencia cambiando la imagen base ==

Repetimos los pasos anteriores, pero antes de parar el contenedor, vamos a
guardar el estado del contener en la imagen:

<syntaxhighlight lang="bash">
docker run -d -ti --name to_save ubuntu bash
docker exec to_save mkdir test
docker commit to_save ubuntu
docker stop to_save
</syntaxhighlight>

Ahora, vamos a para el contenedor y ejecutar uno nuevo para probar que los datos
han persistido:

<syntaxhighlight lang="bash">
docker run -d -ti --name to_save_v2 ubuntu:con_directorio_test bash
docker exec to_save_v2 ls
</syntaxhighlight>

Esto crea una imagen ubuntu con la etiqueta "con_directorio_test".

== Paso 10.2: Mantener la persistencia creando volúmenes ==

La otra opción para mantener los datos es montar un volumen al ejecutar el
contenedor. Primero crearemos una carpeta que hará de volumen en nuestra
máquina, que será la que luego montemos para docker:

<syntaxhighlight lang="bash">
mkdir /home/ubuntu/volumen
</syntaxhighlight>

Ahora vamos a montar la carpeta al ejecutar el contenedor, lo hacemos con la
opción -v, la cual tiene 3 campos separados por ':':

# El volumen en nuestra máquina
# Donde se montará el volumen dentro del contenedor
# Opciones de mmontaje, por ejemplo rw (read and write) o ro (read only)

<syntaxhighlight lang="bash">
docker run --rm -ti -v /home/ubuntu/volumen:/volumen:rw ubuntu bash
mkdir /volumen/test
touch /volumen/test/file
exit
</syntaxhighlight>

Una vez nos salgamos del contenedor, podemos ver que en nuestra máquina están
los datos:

<syntaxhighlight lang="bash">
ls /home/ubuntu/volumen/
ls /home/ubuntu/volumen/test
</syntaxhighlight>

La próxima vez que ejecutemos un contenedor, si montamos ese volumen, los datos
estarán ahí, además esta forma tiene el beneficio de compartir datos entre
nuestra máquina y el contenedor de forma sencilla.

= Paso 11: Crear nuestra propia imagen docker =

Para crear una imagen de un contenedor con una aplicación de Python hug, creamos en primer lugar la carpeta que contendrá los ficheros que nos permiten crear la imagen.

<syntaxhighlight lang="bash">
mkdir miapp
cd miapp
</syntaxhighlight>

Definimos un fichero ''Dockerfile'' para definir la imagen:

<syntaxhighlight lang="bash">
FROM python:alpine

ENV USERNAME="username"
RUN mkdir /app
RUN pip install hug
COPY endpoint.py /app
WORKDIR /app
CMD hug -f endpoint.py
</syntaxhighlight>

Alternativamente, puedes crear un [[Creando imagen propia usando Ubuntu de base|Dockerfile empleando la imagen de Ubuntu]] como base en lugar de Alpine.

Y añadimos el fichero ''endpoint.py'' que emplea el framework Python hug con el contenido siguiente:

<syntaxhighlight lang="bash">
import hug

@hug.get('/welcome')
def welcome(username="unknown"):
""" Say welcome to username """
return "Welcome " + username
</syntaxhighlight>

Este fichero es un ejemplo de uso de Python hug. Si hacemos una petición a /welcome?username="LSO", esto nos devolverá el mensaje "Welcome LSO".

Una vez tengamos los dos ficheros creados en nuestra máquina virtual, podemos construir nuestra imagen:

<syntaxhighlight lang="bash">
docker build -t app:v1 -f Dockerfile .
</syntaxhighlight>

Vamos a explicar para que sirve cada línea:

* FROM: servirá para basarnos en una imagen existente, en este caso, una imagen de python alpine, que contiene python y no ocupa mucho espacio
* ENV: para crear variables de entorno
* RUN: para ejecutar comandos, ya sea para crear una carpeta, instalar dependencias o cualquier otra opción que necesitemos
* COPY: para copiar datos desde nuestra máquina a la imagen
* WORKDIR: para cambiar el directorio de trabajo
* CMD: este comando será ejecutado por defecto al iniciar un contenedor a partir de esta imagen

Esto construirá una imagen docker basada en python:alpine, en la cual hemos
guardado nuestra pequeña aplicación y se va a ejecutar cuando ejecutemos un
contenedor basado en esa imagen. Para comprobar que la imagen se ha creado
correctamente, listamos las imagenes, y debería de aparecernos una imagen con
nombre 'app' y tag 'v1':

<syntaxhighlight lang="bash">
docker images
</syntaxhighlight>

Ahora vamos a crear un contenedor de nuestra imagen, y vamos a añadir una nueva
opción, -p 8001:8000. Esta opción hará que el puerto interno 8000 del contenedor
sea expuesto en el puerto 8001 de nuestra máquina:

<syntaxhighlight lang="bash">
docker run --name my-app --rm -d -p 8001:8000 app:v1
</syntaxhighlight>

Ahora vamos a probar que funciona nuestra imagen y nuestro código. En nuestra
máquina haremos:

<syntaxhighlight lang="bash">
curl -X GET http://localhost:8001/welcome?username=LSO
</syntaxhighlight>

Comprobaremos que la salida del comando curl, es "Welcome LSO".

Antes de terminar, vamos a comprobar otro pequeño detalle que añadimos en
nuestra imagen, la variable de entorno USERNAME, vamos a comprobar que funciona:

<syntaxhighlight lang="bash">
docker exec -ti my-app ash
echo $USERNAME
</syntaxhighlight>

Funciona correctamente, pero al ejecutar el contenedor, podemos cambiar esta
variable de entorno como vimos en uno de los pasos anteriores:

<syntaxhighlight lang="bash">
docker run --rm -ti -e USERNAME=me app:v1 ash
echo $USERNAME
</syntaxhighlight>

Esto nos servirá para tener opciones por defecto y que el usuario pueda
cambiarlo a su antojo, como por ejemplo contraseñas u otros detalles.

= Paso 12: Eliminar imágenes =

Veremos que después de todas las pruebas que hemos estado haciendo, tenemos
muchas imágenes, y algunas de las cuales no nos servirán o no las utilizaremos,
así que podemos borrarlas para ahorrar espacio.

Al igual que con los contenedores, tenemos una opción para borrar imágenes que
no se utilicen:

<syntaxhighlight lang="bash">
docker image prune
</syntaxhighlight>

Esto borrará imágenes intermedias que se utilizan a veces para construir
nuestras imágenes o imágenes que hemos intentado construir y nos han fallado.

La otra opción para borrar imágenes una a una, sería utilizando el comando
docker rmi y utilizar el nombre de la imagen o el id. Si esta es la salida de
'docker images':

<syntaxhighlight lang="bash">
REPOSITORY TAG IMAGE ID CREATED SIZE
app v1 18609c517d32 14 minutes ago 109MB
python alpine 39fb80313465 23 hours ago 98.7MB
debian latest 85c4fd36a543 13 days ago 114MB
hello-world latest fce289e99eb9 7 months ago 1.84kB
hello-world linux fce289e99eb9 7 months ago 1.84kB
</syntaxhighlight>

Podemos eliminar las imágenes de hello-world:

<syntaxhighlight lang="bash">
docker rmi hello-world
</syntaxhighlight>

ó

<syntaxhighlight lang="bash">
docker rmi fce289e99eb9
</syntaxhighlight>

= Paso 13: Varios docker a la vez (docker-compose) =

Antes de comenzar, vamos a parar todos los contenedores que tengamos abiertos,
para dejar el entorno de docker limpio, que nos vendrá bien para esta parte.

Cuando queremos ejecutar varios contenedores a la vez y que estén conectados
entre ellos fácilmente, utilizaremos docker-compose, donde con un fichero de
configuración simple en yaml, tendremos toda la configuración de lo que vamos a
ejecutar.

Primero vamos a instalar docker-compose:

<syntaxhighlight lang="bash">
sudo apt install docker-compose
</syntaxhighlight>

Ahora veamos un pequeño ejemplo donde explicaremos todos los detalles para crear
un docker-compose, en este caso, el nombre por defecto de los ficheros suele ser
docker-compose.yml, y el contenido será similar a:

<syntaxhighlight lang="bash">
version: '3'

services:
web:
container_name: web
restart: always
build:
context: .
ports:
- "8000:8000"
volumes:
- /home/ubuntu/volume:/volumen:rw
environment:
USERNAME: test
web2:
container_name: web2
build:
dockerfile: Dockerfile
context: .
depends_on:
- web
command: touch web2
web3:
container_name: web3
restart: on-failure
image: pstauffer/curl
depends_on:
- web
command: curl -X GET web:8000/welcome?username=web3
</syntaxhighlight>

En el docker-compose definimos diferentes servicios a ejecutar, en nuestro caso
hemos iniciado tres servicios diferentes, web, web2 y web3:

El primer servicio, web:

* container_name: para darle un nombre por defecto al contenedor cuando se cree
* restart: pueden ser:
** "no": si la máquina termina, no se vuelve a iniciar (opción por defecto)
** always: siempre que el contenedor termine, intenta iniciarse de nuevo
** on-failure: solo intenta reiniciarse si el contenedor termina con fallo
** unless-stopped: solo reinicia el contenedor si el usuario es el que lo termina
* Utilizará el fichero Dockerfile creado en el paso 11 para generar la imagen a usar.
* Expondrá el puerto 8000 del contenedor en el 8000 de nuestra máquina
* Montará un volumen, se hace de forma similar a la línea de comandos
* Creará una variable de entorno

El segundo servicio, web2:

* Utilizará el fichero Dockerfile también, la diferencia entre este y el primer servicio, es que si el nombre del Dockerfile cambia, tendremos que hacerlo de esta segunda forma, la primera por defecto solo buscará el fichero Dockerfile
* depends_on hará que para ejecutar este servicio, su dependencia tenga ya que estar iniciada
* Ejecutaremos un comando el cual sustituirá al comando de la imagen

El tercer servicio, web3:

* Utilizará la imagen ostauffer/curl que es un imagen mínima que contiene el comando curl
* restart: en este caso, hasta que el comando no se ejecute correctamente, se seguirá reiniciando el contenedor
* depends_on igual que el servicio 2, dependerá del servicio 1
* Ejecutaremos un comando para llamar desde el servicio 3 al servicio 1

== Paso 13.1: Construir docker-compose ==

En el caso de existir servicios que tengan Dockerfiles, esto hará que se construyan previamente, como hacer un docker build de cada uno de los servicios que contenga un Dockerfile:

<syntaxhighlight lang="bash">
docker-compose build
</syntaxhighlight>

Con esto se generarán las imágenes necesarias para ejecutar todos los servicios.

== Paso 13.2: Iniciar docker-compose ==

Para iniciar todos los servicios, ejecutaremos:

<syntaxhighlight lang="bash">
docker-compose up -d
</syntaxhighlight>

Después de esto podremos ver el logs de todos los servicios:

<syntaxhighlight lang="bash">
docker-compose logs -f
</syntaxhighlight>

Aquí veremos que el servicio 3 ha conseguido llamar correctamente al servicio 1.

Ahora veremos como docker-compose ha creado los contenedores:

<syntaxhighlight lang="bash">
docker ps -a
</syntaxhighlight>

La salida será similar a la siguiente:

<syntaxhighlight lang="bash">
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
219a4118244c pstauffer/curl "curl -X GET web:800…" 6 seconds ago Exited (0) 3 seconds ago web3
c97e894cb3ae ubuntu_web2 "touch web2" 6 seconds ago Exited (0) 4 seconds ago web2
f35d034204fc ubuntu_web "/bin/sh -c 'hug -f …" 6 seconds ago Up 5 seconds 0.0.0.0:8000->8000/tcp web
</syntaxhighlight>

Aquí vemos varios detalles:

* El nombre que le hemos dado en el docker-compose ha funcionado correctamente
* Vemos que los comandos son los correctos también
* web2 está parado por que la política de reinicio es apagar cuando se termine de ejecutar un comando
* web 3 está parado por que el comando ha terminado con un salida correcta

Vamos a comprobar ahora que en el servicio web está todo correcto:

<syntaxhighlight lang="bash">
docker exec -ti web ash
echo $USERNAME
ls /volumen
exit
</syntaxhighlight>

Podemos comprobar que tanto cambiar la variable de entorno como crear un
volumen ha funcionado correctamente.

== Paso 13.3: Parar docker-compose ==

Para parar todos los servicios:

<syntaxhighlight lang="bash">
docker-compose down
</syntaxhighlight>

Comprobamos:

<syntaxhighlight lang="bash">
docker ps -a
</syntaxhighlight>

Vemos que han desaparecido todos los contenedores.

= Paso 14: Ejercicios =

== Ejercicio 1: Variante de httpd ==

Construya una imagen ''httpd-hola-mundo'' a partir de la imagen ''httpd''. El fichero de index.html de la carpeta htdocs/ tiene que mostrar el mensaje "hola mundo".

<syntaxhighlight lang="bash">
docker pull httpd
</syntaxhighlight>

Edita el fichero Dockerfile:

<syntaxhighlight lang="bash">
nano Dockerfile
</syntaxhighlight>

Añada este contenido:

<syntaxhighlight lang="bash">
FROM httpd

COPY index.html htdocs/index.html
</syntaxhighlight>

Edita el fichero index.html:

<syntaxhighlight lang="bash">
nano index.html
</syntaxhighlight>

Añada este contenido:

<syntaxhighlight lang="bash">
<html>hola mundo</html>
</syntaxhighlight>

Construye la imagen:

<syntaxhighlight lang="bash">
docker build -t mihttpd -f Dockerfile .
</syntaxhighlight>

Ahora vamos a crear un contenedor de nuestra imagen:

<syntaxhighlight lang="bash">
sudo docker run --name mihttpd -d -p 8080:80 mihttpd
</syntaxhighlight>

Ahora vamos a probar que funciona nuestra imagen y nuestro código:
<syntaxhighlight lang="bash">
curl -X GET http://localhost:8080
</syntaxhighlight>

Tiene que salir por pantalla esto:
<syntaxhighlight lang="bash">
<html>hola mundo</html>
</syntaxhighlight>

== Ejercicio 2: aplicación flask ==

Flask es un framework python para implementar webs. Cree una imagen "miapp-flask" a partir de la imagen de "python":

* Instale flask mediante: pip install flask
* Cree la carpeta "app"
* Establezca la variable FLASK_APP a "hello.py"
* Añada el fichero "hello.py"
* Establezca el directorio de trabajo a "/app"

El fichero hello.py contiene un "hola mundo" para Flask:

<syntaxhighlight lang="python">
from flask import Flask
app = Flask(__name__)

@app.route("/")
def hello():
return "Hello World!"

if __name__ == "__main__":
app.run()
</syntaxhighlight>

Solución con alpine:

<syntaxhighlight lang="bash">
FROM python:alpine

RUN mkdir /app
RUN pip install flask
ENV FLASK_APP="app/hello.py"
COPY hello.py
WORKDIR /
CMD flask run --host=0.0.0.0
</syntaxhighlight>

Solución con Ubuntu:

<syntaxhighlight lang="bash">
FROM ubuntu:bionic

RUN apt-get update
RUN apt-get -y install python python-pip wget
RUN pip install Flask
ENV FLASK_APP="app/hello.py"
RUN mkdir /app
COPY hello.py /app
CMD flask run --host=0.0.0.0
</syntaxhighlight>

== Ejercicio 3: mysql ==

'''EN LA MÁQUINA VIRTUAL:'''

mkdir miapp

cd miapp

sudo docker pull mysql

nano Dockerfile

<syntaxhighlight lang="bash">
FROM mysql
ENV MYSQL_ROOT_PASSWORD="lacontraseñaqueyoquiera"
RUN mkdir /app
WORKDIR /app

</syntaxhighlight>

CTRL+O , ENTER Y CTRL+X (para guardar Dockerfile y salir)

sudo docker build -ti mrfdocker -f Dockerfile .

sudo docker run --name mymrf --rm -p 8001:3306 mrfdocker

sudo docker images

'''EN LA TERMINAL DEL HOST:'''

''Instalación de mysql:''

sudo apt install mysql-client-core-5.7

> sudo apt-get install mysql-server

> sudo service mysql start

''Para entrar:''

sudo mysql -u root -p -P 8001

Una vez dentro de msql:

mysql> show databases;
''
Para salir:''

exit

== Ejercicio 5: python pyramid ==

Pyramid es un framework python para implementar webs. Cree una imagen "miapp-pyramid":

* Emplee la imagen de Ubuntu como referencia, instale los paquetes python y python-pip.
* Instale Pyramid mediante: pip install pyramid
* Cree la carpeta "app"
* Añada el fichero "hello.py"
* Establezca el directorio de trabajo a "/app"
* La aplicación se lanza con la orden: python hello.py
* Compruebe que funciona con curl, la ruta a la web es http://127.0.0.1:8000/hello, suponiendo que ha empleado el puerto 8000 para exponer el servicio.

El fichero hello.py contiene un "hola mundo" para Pyramid:

<syntaxhighlight lang="bash">
from wsgiref.simple_server import make_server
from pyramid.config import Configurator
from pyramid.response import Response

def hello_world(request):
print('Request inbound!')
return Response('Docker works with Pyramid!')

if __name__ == '__main__':
config = Configurator()
config.add_route('hello', '/')
config.add_view(hello_world, route_name='hello')
app = config.make_wsgi_app()
server = make_server('0.0.0.0', 6543, app)
server.serve_forever()
</syntaxhighlight>

Este programa recibe peticiones en el puerto 6543.

== Ejercicio 6 ==

Cree una imagen derivada de Ubuntu, instale el paquete apache2, php y libapache2-mod-php.
Active el módulo de php para apache2 mediante la orden:

<syntaxhighlight lang="bash">
a2enmod php
</syntaxhighlight>

Cree la carpeta /var/www/php.

Cree el fichero index.php

<syntaxhighlight lang="php">
<?php
Print "Hello, World!";
?>
</syntaxhighlight>

y copielo a /var/www/php/.

Cree el fichero 000-default.conf y copielo a /etc/apache2/sites-enabled/

Dicho fichero contiene.

<syntaxhighlight lang="bash">
<VirtualHost *:80>
DocumentRoot /var/www/php

<Directory /var/www/php/>
Options Indexes FollowSymLinks MultiViews
AllowOverride All
Order deny,allow
Allow from all
</Directory>

ErrorLog ${APACHE_LOG_DIR}/error.log
CustomLog ${APACHE_LOG_DIR}/access.log combined
</VirtualHost>
</syntaxhighlight>

Tiene que lanzar apache con la orden: apachectl -D FOREGROUND

Tras crear la imagen, láncela mapeando el puerto 8888 al 80, pruebe que puede acceder a http://127.0.0.1:8888/php/ mediante curl

Solución:

<syntaxhighlight lang="bash">
FROM ubuntu:latest

RUN apt-get update
RUN apt-get install -y tzdata
RUN apt-get install -y apache2
RUN apt-get install -y php
RUN apt-get install -y libapache2-mod-php
RUN a2enmod php7.2
COPY index.php /var/www/php
COPY 000-default.conf /etc/apache2/sites-enabled/
CMD apachectl -D FOREGROUND
</syntaxhighlight>

Y para lanzarlo:

docker run --name my-app --rm -d -p 8001:8000 app:v1

y para probarlo:

curl -X GET http://127.0.0.1:8888/php/

Wiki de Sistemas Operativos - Contribuciones del usuario [es]

Contenedores