Diferencia entre revisiones de «Contenedores»
(→Ejercicio 7) |
|||
(No se muestran 56 ediciones intermedias de 4 usuarios) | |||
Línea 3: | Línea 3: | ||
= Paso 1: Instalar docker = | = Paso 1: Instalar docker = | ||
− | + | Para instalar el paquete oficial: | |
− | |||
<syntaxhighlight lang="bash"> | <syntaxhighlight lang="bash"> | ||
− | + | apt update | |
− | + | apt install docker.io | |
− | |||
− | |||
</syntaxhighlight> | </syntaxhighlight> | ||
Línea 17: | Línea 14: | ||
<syntaxhighlight lang="bash"> | <syntaxhighlight lang="bash"> | ||
− | sudo | + | sudo service docker status |
</syntaxhighlight> | </syntaxhighlight> | ||
Línea 35: | Línea 32: | ||
Pulsamos la tecla 'q' para salir. | Pulsamos la tecla 'q' para salir. | ||
+ | Si el servicio aparece inactivo, puedes lanzarlo con: | ||
+ | |||
+ | <syntaxhighlight lang="bash"> | ||
+ | systemctl enable docker | ||
+ | systemctl start docker | ||
+ | </syntaxhighlight> | ||
= Paso 2: Ejecutar docker con nuestro usuario = | = 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 | Para no necesitar sudo al utilizar docker, añadiremos a nuestro usuario al grupo | ||
Línea 49: | Línea 54: | ||
volviendo a insertar nuestras credenciales. | 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. | |
− | |||
− | DockerHub | ||
− | existen imágenes preconfiguradas | ||
− | imágenes | ||
− | Podremos realizar búsquedas en este repositorio | + | Podremos realizar búsquedas en este repositorio ''DockerHub'' puedes emplear el siguiente comando: |
<syntaxhighlight lang="bash"> | <syntaxhighlight lang="bash"> | ||
Línea 62: | Línea 64: | ||
</syntaxhighlight> | </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"> | <syntaxhighlight lang="bash"> | ||
− | |||
docker login | docker login | ||
− | |||
</syntaxhighlight> | </syntaxhighlight> | ||
− | + | Tras introducir tu usuario y contraseña, puedes comenzar a publicar tus propias imágenes. | |
<syntaxhighlight lang="bash"> | <syntaxhighlight lang="bash"> | ||
− | + | docker push MI_IMAGEN | |
− | |||
− | docker push | ||
</syntaxhighlight> | </syntaxhighlight> | ||
+ | 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 = | = Paso 4: Comprobar imágenes en nuestra máquina = | ||
Línea 93: | Línea 92: | ||
</syntaxhighlight> | </syntaxhighlight> | ||
− | + | Inicialmente, no tenemos imágenes en almacenamiento, podemos descargarnos la imagen oficial de Ubuntu: | |
− | |||
<syntaxhighlight lang="bash"> | <syntaxhighlight lang="bash"> | ||
− | docker pull | + | docker pull ubuntu:latest |
− | |||
</syntaxhighlight> | </syntaxhighlight> | ||
− | Ahora si, ya debería de aparecernos la imagen | + | Ahora si, ya debería de aparecernos la imagen ''ubuntu''. |
− | Comentar también que cada imagen puede tener | + | 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: |
− | |||
− | latest, que es el tag que se descarga por defecto, pero nosotros podemos | ||
− | especificar otro, por ejemplo: | ||
<syntaxhighlight lang="bash"> | <syntaxhighlight lang="bash"> | ||
− | docker pull | + | docker pull ubuntu:focal |
− | |||
</syntaxhighlight> | </syntaxhighlight> | ||
− | + | 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: | + | = Paso 5: Lanzar un contenedor = |
Un contenedor no es más que una imagen de docker ejecutándose, sería similar a | Un contenedor no es más que una imagen de docker ejecutándose, sería similar a | ||
Línea 156: | Línea 149: | ||
Al crear los contenedores utilizando el comando 'run', tenemos varias opciones: | 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: | |
− | |||
− | |||
<syntaxhighlight lang="bash"> | <syntaxhighlight lang="bash"> | ||
− | docker | + | docker run -ti ubuntu bash |
</syntaxhighlight> | </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 | + | Para salir del contenedor, escribimos 'exit' o pulsamos 'CTRL + D' |
− | + | ||
− | + | == Paso 5.2 Lanzar en segundo plano (-d) == | |
<syntaxhighlight lang="bash"> | <syntaxhighlight lang="bash"> | ||
− | docker | + | docker run -d hello-world |
</syntaxhighlight> | </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"> | <syntaxhighlight lang="bash"> | ||
− | docker | + | docker logs 2ec1daae4676a4e84dc04fd91399c1dfe92119544ff12ee307991fe573d3db64 |
</syntaxhighlight> | </syntaxhighlight> | ||
− | + | Otro ejemplo, con la imagen de Ubuntu: | |
− | |||
<syntaxhighlight lang="bash"> | <syntaxhighlight lang="bash"> | ||
− | + | docker run -dti ubuntu | |
− | |||
− | |||
− | |||
− | |||
</syntaxhighlight> | </syntaxhighlight> | ||
− | |||
− | |||
− | |||
== Paso 5.3: Añadir variables de entorno a un contenedor == | == Paso 5.3: Añadir variables de entorno a un contenedor == | ||
Línea 211: | Línea 195: | ||
<syntaxhighlight lang="bash"> | <syntaxhighlight lang="bash"> | ||
− | docker run -ti -e TEST=test | + | docker run -ti -e TEST=test ubuntu bash |
− | |||
− | |||
</syntaxhighlight> | </syntaxhighlight> | ||
− | + | Ahora, desde el contenedor podemos comprobar el valor de la variable de entorno ''$TEST''. | |
− | |||
− | |||
− | |||
− | |||
− | |||
+ | <syntaxhighlight lang="bash"> | ||
+ | echo $TEST | ||
+ | test | ||
+ | </syntaxhighlight> | ||
− | = Paso 6: | + | = Paso 6: Listar contenedores en ejecución = |
− | Hemos estado haciendo pruebas y ejecutando contenedores en el paso anterior, | + | 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. |
− | 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: | Tenemos dos opciones para ver los contenedores: | ||
Línea 236: | Línea 215: | ||
</syntaxhighlight> | </syntaxhighlight> | ||
− | + | o la versión corta: | |
<syntaxhighlight lang="bash"> | <syntaxhighlight lang="bash"> | ||
Línea 246: | Línea 225: | ||
<syntaxhighlight lang="bash"> | <syntaxhighlight lang="bash"> | ||
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES | CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES | ||
− | e2bde5f5500c | + | e2bde5f5500c ubuntu "bash" 6 minutes ago Exited (0) 2 seconds ago pensive_sammet |
− | 544ad27dbc3c | + | 544ad27dbc3c ubuntu "bash" 7 minutes ago Exited (0) 7 minutes ago serene_elgamal |
− | |||
</syntaxhighlight> | </syntaxhighlight> | ||
− | En la información veremos que el contenedor tiene el estado exited, eso quiere | + | 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: |
− | decir que no se está ejecutando y ya ha finalizado. Vamos a hacer una prueba | ||
− | para ver un contendor ejecutándose: | ||
<syntaxhighlight lang="bash"> | <syntaxhighlight lang="bash"> | ||
− | docker run -d | + | docker run -d ubuntu sleep 30 |
</syntaxhighlight> | </syntaxhighlight> | ||
− | Con el comando sleep 30 esperamos 30 segundos hasta que termine el comando, | + | 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"> | <syntaxhighlight lang="bash"> | ||
Línea 268: | Línea 243: | ||
<syntaxhighlight lang="bash"> | <syntaxhighlight lang="bash"> | ||
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES | CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES | ||
− | eacceb27d52d | + | eacceb27d52d ubuntu "sleep 30" 12 seconds ago Up 11 seconds sharp_pasteur |
</syntaxhighlight> | </syntaxhighlight> | ||
− | Vamos a ver | + | Vamos a ver alguna opciones más de la orden ''run''. |
− | |||
− | |||
− | == Paso 6.1: | + | == Paso 6.1: Dar un nombre al contenedor (--name) == |
− | Por defecto, docker creará automáticamente un nombre como hemos visto en las | + | 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'': |
− | salidas del comando 'docker ps -a' | ||
<syntaxhighlight lang="bash"> | <syntaxhighlight lang="bash"> | ||
− | docker run - | + | docker run -ti --name mi_ubuntu ubuntu |
− | |||
</syntaxhighlight> | </syntaxhighlight> | ||
− | |||
== Paso 6.2: Eliminar contenedor cuando termine (--rm) == | == Paso 6.2: Eliminar contenedor cuando termine (--rm) == | ||
Línea 290: | Línea 260: | ||
Vamos a mezclar todo lo visto anteriormente: | Vamos a mezclar todo lo visto anteriormente: | ||
− | * | + | * Lanzar en segundo plano (-d) |
* Ejecutar contenedor durante 30 segundos (sleep 30) | * Ejecutar contenedor durante 30 segundos (sleep 30) | ||
* Dar un nombre a la imagen (--name) | * Dar un nombre a la imagen (--name) | ||
Línea 296: | Línea 266: | ||
<syntaxhighlight lang="bash"> | <syntaxhighlight lang="bash"> | ||
− | docker run -d --rm --name bye-bye | + | docker run -d --rm --name bye-bye ubuntu sleep 30 |
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
</syntaxhighlight> | </syntaxhighlight> | ||
− | + | Antes y una vez pasados los 30 segundos, podemos comprobar que el contenedor ha desaparecido. | |
<syntaxhighlight lang="bash"> | <syntaxhighlight lang="bash"> | ||
docker ps -a | docker ps -a | ||
</syntaxhighlight> | </syntaxhighlight> | ||
− | |||
− | |||
− | |||
= Paso 7: Parar y eliminar contenedores = | = Paso 7: Parar y eliminar contenedores = | ||
Línea 329: | Línea 290: | ||
<syntaxhighlight lang="bash"> | <syntaxhighlight lang="bash"> | ||
− | docker run -d --name my_container | + | docker run -d -ti --name my_container ubuntu bash |
docker ps -a | docker ps -a | ||
</syntaxhighlight> | </syntaxhighlight> | ||
Línea 352: | Línea 313: | ||
Veremos que ya no tenemos el contenedor y está correctamente eliminado. | Veremos que ya no tenemos el contenedor y está correctamente eliminado. | ||
− | |||
= Paso 8: Conectarnos a un contenedor que se está ejecutando en segundo plano = | = Paso 8: Conectarnos a un contenedor que se está ejecutando en segundo plano = | ||
− | Vamos a ejecutar de nuevo un contenedor que no termine | + | Vamos a ejecutar de nuevo un contenedor que no termine: |
− | |||
<syntaxhighlight lang="bash"> | <syntaxhighlight lang="bash"> | ||
− | docker run -d --name to_attach | + | docker run -d -ti --name to_attach ubuntu bash |
</syntaxhighlight> | </syntaxhighlight> | ||
Línea 370: | Línea 329: | ||
</syntaxhighlight> | </syntaxhighlight> | ||
− | Veremos | + | Veremos la orden bash ejecutándose, para terminar, hacemos un 'CTRL + C', y ahora, veremos que ha pasado con el contenedor: |
− | ahora, veremos que ha pasado con el contenedor: | ||
<syntaxhighlight lang="bash"> | <syntaxhighlight lang="bash"> | ||
Línea 381: | Línea 339: | ||
finalizado. | finalizado. | ||
+ | ''Nota:'' Para salir del contenedor '''sin detenerlo''' hacemos 'CTRL + P' seguido 'CTRL + Q' | ||
= Paso 9: Ejecutar en un contenedor otro comando = | = Paso 9: Ejecutar en un contenedor otro comando = | ||
Línea 388: | Línea 347: | ||
<syntaxhighlight lang="bash"> | <syntaxhighlight lang="bash"> | ||
− | docker run -d --name | + | docker run -d -ti --name mi-contenedor ubuntu bash |
</syntaxhighlight> | </syntaxhighlight> | ||
− | Ahora, vamos a ejecutar un comando en ese contenedor. El comando exec es similar | + | Ahora, vamos a ejecutar un comando en ese contenedor con el nombre ''mi-contenedor''. |
− | al comando run, pero para ejecutar un comando dentro de un contenedor: | + | El comando exec es similar al comando run, pero para ejecutar un comando dentro de un contenedor: |
<syntaxhighlight lang="bash"> | <syntaxhighlight lang="bash"> | ||
− | docker exec -ti | + | docker exec -ti mi-contenedor ls |
</syntaxhighlight> | </syntaxhighlight> | ||
− | Ahora estamos dentro del contenedor creado anteriormente | + | Ahora estamos dentro del contenedor creado anteriormente: |
− | |||
<syntaxhighlight lang="bash"> | <syntaxhighlight lang="bash"> | ||
Línea 405: | Línea 363: | ||
</syntaxhighlight> | </syntaxhighlight> | ||
− | Aquí veremos en el listado de procesos que hay | + | Aquí veremos en el listado de procesos que hay en ejecución. |
Ahora vamos a salirnos del contenedor, escribiendo 'exit' o 'CTRL + D', y | Ahora vamos a salirnos del contenedor, escribiendo 'exit' o 'CTRL + D', y | ||
Línea 414: | Línea 372: | ||
</syntaxhighlight> | </syntaxhighlight> | ||
− | Ahora veremos que el contenedor se sigue ejecutando | + | 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 |
+ | |||
+ | <syntaxhighlight lang="bash"> | ||
+ | docker run -d -ti --name mi-ejemplo ubuntu bash | ||
+ | </syntaxhighlight> | ||
− | + | Ahora, vamos a crear una carpeta en el contenedor y comprobar que esa carpeta existe: | |
− | |||
− | |||
<syntaxhighlight lang="bash"> | <syntaxhighlight lang="bash"> | ||
− | docker | + | docker exec mi-ejemplo mkdir test |
+ | docker exec mi-ejemplo ls | ||
</syntaxhighlight> | </syntaxhighlight> | ||
− | + | Veremos que la carpeta existe, pero, ¿qué ocurre si para el contenedor? | |
− | |||
<syntaxhighlight lang="bash"> | <syntaxhighlight lang="bash"> | ||
− | docker | + | docker container stop mi-ejemplo |
− | |||
</syntaxhighlight> | </syntaxhighlight> | ||
− | + | Y volvemos a lanzarlo: | |
− | volvemos a | ||
<syntaxhighlight lang="bash"> | <syntaxhighlight lang="bash"> | ||
− | + | docker container rm mi-ejemplo | |
− | docker container rm | + | docker run -d -ti --name mi-ejemplo ubuntu bash |
− | docker run -d --name | + | docker exec mi-ejemplo ls |
− | docker exec | ||
</syntaxhighlight> | </syntaxhighlight> | ||
− | Podemos comprobar que la carpeta creada anteriormente, no existe | + | Podemos comprobar que la carpeta creada anteriormente, no existe. |
− | contenedor | + | |
− | + | ¿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'': | ||
+ | |||
+ | <syntaxhighlight lang="bash"> | ||
+ | docker run -d -ti ubuntu bash | ||
+ | </syntaxhighlight> | ||
− | + | Suponiendo que el contenido está identificado con el ID 56ef5b312334 | |
− | + | Instalamos el paquete ping: | |
− | |||
<syntaxhighlight lang="bash"> | <syntaxhighlight lang="bash"> | ||
− | docker | + | docker exec 56ef5b312334 apt -y install ping |
− | |||
− | |||
− | |||
</syntaxhighlight> | </syntaxhighlight> | ||
− | + | Generamos la imagen derivada con el nombre ''ubuntu-con-ping'': | |
− | |||
<syntaxhighlight lang="bash"> | <syntaxhighlight lang="bash"> | ||
− | docker | + | docker commit 56ef5b312334 ubuntu-con-ping |
− | |||
</syntaxhighlight> | </syntaxhighlight> | ||
+ | Ya podemos para nuestro contendor: | ||
− | = | + | <syntaxhighlight lang="bash"> |
+ | docker stop 56ef5b312334 | ||
+ | </syntaxhighlight> | ||
− | + | Y lanzar un nuevo contenedor a partir de la imagen ''ubuntu-con-ping'': | |
− | contenedor. Primero crearemos una carpeta que hará de volumen en nuestra | + | |
− | máquina, que será la que luego montemos para docker: | + | <syntaxhighlight lang="bash"> |
+ | docker run -d -ti ubuntu-con-ping bash | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | == 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: | ||
<syntaxhighlight lang="bash"> | <syntaxhighlight lang="bash"> | ||
Línea 490: | Línea 461: | ||
<syntaxhighlight lang="bash"> | <syntaxhighlight lang="bash"> | ||
− | docker run --rm -ti -v /home/ubuntu/volumen:/volumen:rw | + | docker run --rm -ti -v /home/ubuntu/volumen:/volumen:rw ubuntu bash |
mkdir /volumen/test | mkdir /volumen/test | ||
touch /volumen/test/file | touch /volumen/test/file | ||
Línea 508: | Línea 479: | ||
nuestra máquina y el contenedor de forma sencilla. | 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 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 | ||
+ | </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: | |
− | |||
− | contenido siguiente: | ||
<syntaxhighlight lang="bash"> | <syntaxhighlight lang="bash"> | ||
Línea 519: | Línea 510: | ||
@hug.get('/welcome') | @hug.get('/welcome') | ||
− | def welcome(username=" | + | def welcome(username="unknown"): |
""" Say welcome to username """ | """ Say welcome to username """ | ||
return "Welcome " + username | return "Welcome " + username | ||
</syntaxhighlight> | </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". | |
− | |||
− | mensaje "Welcome LSO". | ||
− | + | Una vez tengamos los dos ficheros creados en nuestra máquina virtual, podemos construir nuestra imagen: | |
− | |||
<syntaxhighlight lang="bash"> | <syntaxhighlight lang="bash"> | ||
− | + | docker build -t app:v1 -f Dockerfile . | |
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
</syntaxhighlight> | </syntaxhighlight> | ||
Vamos a explicar para que sirve cada línea: | Vamos a explicar para que sirve cada línea: | ||
− | * FROM: servirá para basarnos en una imagen existente, en este caso, una imagen | + | * 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 | * ENV: para crear variables de entorno | ||
− | * RUN: para ejecutar comandos, ya sea para crear una carpeta, instalar | + | * 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 | * COPY: para copiar datos desde nuestra máquina a la imagen | ||
* WORKDIR: para cambiar el directorio de trabajo | * WORKDIR: para cambiar el directorio de trabajo | ||
− | * CMD: este comando será ejecutado por defecto al iniciar un contenedor a partir | + | * CMD: este comando será ejecutado por defecto al iniciar un contenedor a partir de esta imagen |
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | Esto | + | 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 | 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 | contenedor basado en esa imagen. Para comprobar que la imagen se ha creado | ||
Línea 577: | Línea 548: | ||
<syntaxhighlight lang="bash"> | <syntaxhighlight lang="bash"> | ||
docker run --name my-app --rm -d -p 8001:8000 app:v1 | docker run --name my-app --rm -d -p 8001:8000 app:v1 | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | ''Nota:'' docker supone que la redirección de puerto es TCP, para una redirección de puertos UDP, puedes usar: | ||
+ | |||
+ | <syntaxhighlight lang="bash"> | ||
+ | ... -p 8001:8000/udp | ||
</syntaxhighlight> | </syntaxhighlight> | ||
Línea 606: | Línea 583: | ||
Esto nos servirá para tener opciones por defecto y que el usuario pueda | 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. | cambiarlo a su antojo, como por ejemplo contraseñas u otros detalles. | ||
− | |||
= Paso 12: Eliminar imágenes = | = Paso 12: Eliminar imágenes = | ||
Línea 713: | Línea 689: | ||
** on-failure: solo intenta reiniciarse si el contenedor termina con fallo | ** 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 | ** 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 | + | * Utilizará el fichero Dockerfile creado en el paso 11 para generar la imagen a usar. |
− | usar. | ||
* Expondrá el puerto 8000 del contenedor en el 8000 de nuestra máquina | * 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 | * Montará un volumen, se hace de forma similar a la línea de comandos | ||
Línea 721: | Línea 696: | ||
El segundo servicio, web2: | El segundo servicio, web2: | ||
− | * Utilizará el fichero Dockerfile también, la diferencia entre este y el primer | + | * 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 | |
− | |||
− | * depends_on hará que para ejecutar este servicio, su dependencia tenga ya que | ||
− | |||
* Ejecutaremos un comando el cual sustituirá al comando de la imagen | * Ejecutaremos un comando el cual sustituirá al comando de la imagen | ||
El tercer servicio, web3: | El tercer servicio, web3: | ||
− | * Utilizará la imagen ostauffer/curl que es un imagen mínima que contiene el | + | * 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 | |
− | * restart: en este caso, hasta que el comando no se ejecute correctamente, se | ||
− | |||
* depends_on igual que el servicio 2, dependerá del servicio 1 | * depends_on igual que el servicio 2, dependerá del servicio 1 | ||
* Ejecutaremos un comando para llamar desde el servicio 3 al servicio 1 | * Ejecutaremos un comando para llamar desde el servicio 3 al servicio 1 | ||
− | |||
== Paso 13.1: Construir docker-compose == | == Paso 13.1: Construir docker-compose == | ||
− | En el caso de existir servicios que tengan Dockerfiles, esto hará que se | + | 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: |
− | |||
− | que contenga un Dockerfile: | ||
<syntaxhighlight lang="bash"> | <syntaxhighlight lang="bash"> | ||
Línea 748: | Línea 715: | ||
</syntaxhighlight> | </syntaxhighlight> | ||
− | Con esto se generarán las imágenes necesarias para ejecutar todos los | + | Con esto se generarán las imágenes necesarias para ejecutar todos los servicios. |
− | servicios. | ||
− | |||
== Paso 13.2: Iniciar docker-compose == | == Paso 13.2: Iniciar docker-compose == | ||
Línea 787: | Línea 752: | ||
* El nombre que le hemos dado en el docker-compose ha funcionado correctamente | * El nombre que le hemos dado en el docker-compose ha funcionado correctamente | ||
* Vemos que los comandos son los correctos también | * Vemos que los comandos son los correctos también | ||
− | * web2 está parado por que la política de reinicio es apagar cuando se termine | + | * 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 | * web 3 está parado por que el comando ha terminado con un salida correcta | ||
Línea 802: | Línea 766: | ||
Podemos comprobar que tanto cambiar la variable de entorno como crear un | Podemos comprobar que tanto cambiar la variable de entorno como crear un | ||
volumen ha funcionado correctamente. | volumen ha funcionado correctamente. | ||
− | |||
== Paso 13.3: Parar docker-compose == | == Paso 13.3: Parar docker-compose == | ||
Línea 820: | Línea 783: | ||
Vemos que han desaparecido todos los contenedores. | 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/ | ||
+ | |||
+ | == 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("<p>This is an example web server.</p>", "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: | ||
+ | |||
+ | <syntax lang="bash"> | ||
+ | curl http://127.0.0.1:9999/ | ||
+ | </syntax> | ||
− | + | que muestre la página HTML que ofrece el servidor, que debería ser: | |
− | |||
− | + | <syntax lang="bash"> | |
− | + | <html><head><title>Welcome!</title></head><body><p>This is an example web server.</p></body></html> | |
+ | </syntax> |
Revisión actual del 18: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
- 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
- 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:
<syntax lang="bash"> curl http://127.0.0.1:9999/ </syntax>
que muestre la página HTML que ofrece el servidor, que debería ser:
<syntax lang="bash">
<html><head><title>Welcome!</title></head><body>This is an example web server.
</body></html></syntax>