Revisión actual del 17:28 18 dic 2023

En esta práctica aprenderemos a utilizar docker para desplegar contenedores.

Contenido

1 Paso 1: Instalar docker
2 Paso 2: Ejecutar docker con nuestro usuario
3 Paso 3: Repositorio de imágenes de contenedores DockerHub
4 Paso 4: Comprobar imágenes en nuestra máquina
5 Paso 5: Lanzar un contenedor
6 Paso 6: Listar contenedores en ejecución
- 6.1 Paso 6.1: Dar un nombre al contenedor (--name)
- 6.2 Paso 6.2: Eliminar contenedor cuando termine (--rm)
7 Paso 7: Parar y eliminar contenedores
8 Paso 8: Conectarnos a un contenedor que se está ejecutando en segundo plano
9 Paso 9: Ejecutar en un contenedor otro comando
10 Paso 10: Persistencia en contenedores
- 10.1 Paso 10.1: Crear una imagen derivada de la imagen base
- 10.2 Paso 10.2: Mantener la persistencia mediante volúmen
11 Paso 11: Crear nuestra propia imagen docker
12 Paso 12: Eliminar imágenes
13 Paso 13: Varios docker a la vez (docker-compose)
14 Paso 14: Ejercicios

Paso 1: Instalar docker

Para instalar el paquete oficial:

apt update
apt install docker.io

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

sudo service docker status

Debería mostrar algo similar a lo siguiente:

● 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

Pulsamos la tecla 'q' para salir.

Si el servicio aparece inactivo, puedes lanzarlo con:

systemctl enable docker
systemctl start docker

Paso 2: Ejecutar docker con nuestro usuario

Si estamos dentro de una máquina virtual como root esto no hace falta.

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

sudo usermod -aG docker ubuntu

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:

docker search hello-world

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

docker pull hello-world

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:

docker login

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

docker push MI_IMAGEN

Este paso es opcional, sólo en caso de que se quieran subir imágenes de contenedores a la nube de docker.

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

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

docker images

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

docker pull ubuntu:latest

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:

docker pull ubuntu:focal

Para traernos la versión de la imagen de Ubuntu focal (20.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:

docker run hello-world

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

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/

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

Lanzar una terminal en el contenedor en modo interactivo
Lanzar en segundo plano y conectarnos posteriormente al contenedor

Paso 5.1: Lanzar 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:

docker run -ti ubuntu bash

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 Lanzar en segundo plano (-d)

docker run -d hello-world

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:

docker logs 2ec1daae4676a4e84dc04fd91399c1dfe92119544ff12ee307991fe573d3db64

Otro ejemplo, con la imagen de Ubuntu:

docker run -dti ubuntu

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:

docker run -ti -e TEST=test ubuntu bash

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

echo $TEST
test

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:

docker container ls -a

o la versión corta:

docker ps -a

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

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

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:

docker run -d ubuntu sleep 30

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:

docker ps -a

CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS                      PORTS               NAMES
eacceb27d52d        ubuntu              "sleep 30"          12 seconds ago      Up 11 seconds                                   sharp_pasteur

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:

docker run -ti --name mi_ubuntu ubuntu

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)

docker run -d --rm --name bye-bye ubuntu sleep 30

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

docker ps -a

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:

docker container prune
docker ps -a

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:

docker run -d -ti --name my_container ubuntu bash
docker ps -a

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

docker stop my_container
docker stop e4901956f108
docker ps -a

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.

docker container rm my_container
docker container rm my_container
docker ps -a

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:

docker run -d -ti --name to_attach ubuntu bash

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

docker attach to_attach

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

docker ps -a

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.

Nota: Para salir del contenedor sin detenerlo hacemos 'CTRL + P' seguido 'CTRL + Q'

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:

docker run -d -ti --name mi-contenedor ubuntu bash

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

docker exec -ti mi-contenedor ls

Ahora estamos dentro del contenedor creado anteriormente:

ps -a

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:

docker ps -a

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

Paso 10: Persistencia en contenedores

Al hacer exit y salir de un contenedor, se pierden todos los cambios que hemos realizado. Los

docker run -d -ti --name mi-ejemplo ubuntu bash

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

docker exec mi-ejemplo mkdir test
docker exec mi-ejemplo ls

Veremos que la carpeta existe, pero, ¿qué ocurre si para el contenedor?

docker container stop mi-ejemplo

Y volvemos a lanzarlo:

docker container rm mi-ejemplo
docker run -d -ti --name mi-ejemplo ubuntu bash
docker exec mi-ejemplo ls

Podemos comprobar que la carpeta creada anteriormente, no existe.

¿Qué podemos hacer para mantener la modificaciones realizadas sobre un contenedor?

Paso 10.1: Crear una imagen derivada de la imagen base

Es posible crear una imagen derivada, con modificaciones, a partir de una imagen existente mediante la orden commit.

Por ejemplo, si queremos una imagen ubuntu que incluya el programa ping ya instalado, tendríamos que lanzar un contenedor a partir de la imagen ubuntu:

docker run -d -ti ubuntu bash

Suponiendo que el contenido está identificado con el ID 56ef5b312334

Instalamos el paquete ping:

docker exec 56ef5b312334 apt -y install ping

Generamos la imagen derivada con el nombre ubuntu-con-ping:

docker commit 56ef5b312334 ubuntu-con-ping

Ya podemos para nuestro contendor:

docker stop 56ef5b312334

Y lanzar un nuevo contenedor a partir de la imagen ubuntu-con-ping:

docker run -d -ti ubuntu-con-ping bash

Paso 10.2: Mantener la persistencia mediante volúmen

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:

mkdir /home/ubuntu/volumen

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)

docker run --rm -ti -v /home/ubuntu/volumen:/volumen:rw ubuntu bash
mkdir /volumen/test
touch /volumen/test/file
exit

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

ls /home/ubuntu/volumen/
ls /home/ubuntu/volumen/test

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.

mkdir miapp
cd miapp

Definimos un fichero Dockerfile para definir la imagen:

FROM ubuntu

RUN apt -y update
RUN apt -y upgrade
RUN apt -y install python3-hug
RUN mkdir /app
COPY endpoint.py /app
WORKDIR /app
CMD hug -f endpoint.py

Alternativamente, puedes crear un 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:

import hug

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

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:

docker build -t app:v1 -f Dockerfile .

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':

docker images

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:

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

Nota: docker supone que la redirección de puerto es TCP, para una redirección de puertos UDP, puedes usar:

... -p 8001:8000/udp

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

curl -X GET http://localhost:8001/welcome?username=LSO

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:

docker exec -ti my-app ash
echo $USERNAME

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

docker run --rm -ti -e USERNAME=me app:v1 ash
echo $USERNAME

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:

docker image prune

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':

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

Podemos eliminar las imágenes de hello-world:

docker rmi hello-world

ó

docker rmi fce289e99eb9

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:

sudo apt install docker-compose

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:

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

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:

docker-compose build

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:

docker-compose up -d

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

docker-compose logs -f

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

Ahora veremos como docker-compose ha creado los contenedores:

docker ps -a

La salida será similar a la siguiente:

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

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:

docker exec -ti web ash
echo $USERNAME
ls /volumen
exit

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:

docker-compose down

Comprobamos:

docker ps -a

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".

docker pull httpd

Edita el fichero Dockerfile:

nano Dockerfile

Añada este contenido:

FROM httpd

COPY index.html htdocs/index.html

Edita el fichero index.html:

nano index.html

Añada este contenido:

<html>hola mundo</html>

Construye la imagen:

docker build -t mihttpd -f Dockerfile .

Ahora vamos a crear un contenedor de nuestra imagen:

sudo docker run --name mihttpd -d -p 8080:80 mihttpd

Ahora vamos a probar que funciona nuestra imagen y nuestro código:

curl -X GET http://localhost:8080

Tiene que salir por pantalla esto:

<html>hola mundo</html>

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:

from flask import Flask
app = Flask(__name__)

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

if __name__ == "__main__":
    app.run()

Solución con alpine:

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

Solución con Ubuntu:

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

Ejercicio 3: mysql

EN LA MÁQUINA VIRTUAL:

mkdir miapp

cd miapp

sudo docker pull mysql

nano Dockerfile

FROM mysql
ENV MYSQL_ROOT_PASSWORD="lacontraseñaqueyoquiera"
RUN mkdir /app
WORKDIR /app

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:

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()

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:

a2enmod php

Cree la carpeta /var/www/php.

Cree el fichero index.php

<?php 
Print "Hello, World!";
?>

y copielo a /var/www/php/.

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

Dicho fichero contiene.

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

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:

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

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/

Ejercicio 7

Instale el paquete netcat-traditional en una imagen de contenedor de ubuntu. Lance la orden:

nc -u -l -p 8080

en el contenedor. Asegúrese de crear una redirección de puertos de 9999 desde el host al puerto 8080 en el contenedor.

Desde fuera del contenedor, pruebe a conectarse con:

nc -u 127.0.0.1 9999

Ejercicio 8

Cree una imagen derivada de "ubuntu" con un Dockerfile que incluya soporte de python y lance el siguiente código en Python:

<syntax lang="python"> from http.server import BaseHTTPRequestHandler, HTTPServer import time

hostName = "0.0.0.0" serverPort = 8080

class MyServer(BaseHTTPRequestHandler):

   def do_GET(self):
       self.send_response(200)
       self.send_header("Content-type", "text/html")
       self.end_headers()
       self.wfile.write(bytes("<html><head><title>Welcome!</title></head>", "utf-8"))
       self.wfile.write(bytes("<body>", "utf-8"))

self.wfile.write(bytes("

This is an example web server.

", "utf-8"))

       self.wfile.write(bytes("</body></html>", "utf-8"))

if __name__ == "__main__":

   webServer = HTTPServer((hostName, serverPort), MyServer)
   print("Server started http://%s:%s" % (hostName, serverPort))

   try:
       webServer.serve_forever()
   except KeyboardInterrupt:
       pass

   webServer.server_close()
   print("Server stopped.")

</syntax>

Llame a su imagen "python-http-server". Lance una instancia de la imagen "python-http-server" mapeando el puerto 9999 al puerto 8888/tcp del contenedor. Compruebe con:

que muestre la página HTML que ofrece el servidor, que debería ser:

<html><head><title>Welcome!</title></head><body>