Docker es una solución gratuita y de código abierto para desarrollar, implementar y administrar aplicaciones en una virtualización ligera a nivel de sistema operativo. En esta guía, demostraremos cómo crear una aplicación Python dentro de un contenedor Docker.
Requisitos previos
Para realizar los pasos demostrados en esta guía, necesitará los siguientes componentes:
-
Un sistema Linux. Consulte cómo configurar su propio VPS Ubuntu en CloudSigma.
-
La última versión de Docker instalada y configurada. Obtenga más información sobre cómo instalar Docker en Ubuntu.
Contenedores Docker
Al ejecutar varios programas dentro del mismo entorno, las cosas pueden fallar (y fallarán). Cuantos más programas agregue, más inestable se volverá. Puede que no sea un gran problema para la gente común. Sin embargo, cuando se trata de aplicaciones de misión crítica, puede haber consecuencias graves.
Cuantas más aplicaciones se introduzcan en el sistema, mayor será la superficie de ataque. Una sola aplicación comprometida puede provocar fácilmente la caída de todo el sistema.
Para resolver estos problemas, podemos utilizar contenedores Docker para el aislamiento (sandboxing) a nivel de software:
-
Las aplicaciones dentro del contenedor tendrán acceso limitado a los archivos.
-
Las aplicaciones en contenedores no pueden ver otros procesos que se ejecutan en el sistema.
-
Al contenedor se le puede asignar una cantidad específica de recursos de hardware.
-
Los puertos de red de un contenedor no se exponen al exterior.
-
Empaquetado consistente de casi cualquier cosa en entornos locales y de producción.
Para demostrarlo, vamos a compilar un servidor Python simple dentro de un contenedor Docker, transformar el contenedor en una imagen y desplegar la imagen dentro de un entorno de producción simulado.
Step 1 – Filesystem Configuration
Para alojar el proyecto, primero vamos a crear un directorio dedicado:
|
1 |
mkdir -pv python-server-container/ |
|
1 |
cd !$ |
Dentro del directorio, cree un subdirectorio src para almacenar nuestro código:
|
1 |
mkdir -pv src/ |
Step 2 – Building the Python Server
En este paso, vamos a crear un servidor HTTP simple en Python. Cree el archivo server.py:
|
1 |
touch server.py |
Ábralo en un editor de texto:
|
1 |
nano server.py |
Introduzca el siguiente código Python:
|
1 2 3 4 5 6 7 8 9 10 11 |
from http.server import HTTPServer, SimpleHTTPRequestHandler def run(server_class=HTTPServer, handler_class=SimpleHTTPRequestHandler): """server entrypoint""" server_address = ("0.0.0.0", 8080) httpd = server_class(server_address, handler_class) print("starting server...") httpd.serve_forever() if __name__ == "__main__": run() |
Aquí,
-
Estamos utilizando la clase HTTPServer y solicitando un manejador de la biblioteca estándar de Python, manteniendo el programa simple.
-
La función run inicia una instancia de HTTPserver.
-
Como sugieren los argumentos de server_address, el servidor escuchará cualquier conexión entrante en el puerto 8080.
Ahora, verificaremos si el servidor funciona como se espera. Inicie el servidor:
|
1 |
python3 server.py |
Desde una nueva terminal, podemos usar curl para enviar una solicitud al servidor:
|
1 |
curl -iv localhost:8080 |
Alternativamente, puede acceder al enlace en un navegador web:
|
1 |
http://localhost:8080 |
Step 3 – Creating a Dockerfile
Un Dockerfile contiene las instrucciones necesarias para generar una imagen de Docker. Las instrucciones del archivo se siguen secuencialmente. Obtenga más información sobre Dockerfile.
Cree un nuevo Dockerfile para nuestro proyecto:
|
1 |
touch Dockerfile |
Ahora, introduceremos los códigos necesarios en él. Ábralo en un editor de texto:
|
1 |
nano Dockerfile |
Introduzca el siguiente código:
|
1 2 3 4 5 6 7 8 9 |
FROM python:latest ENV SRC_DIR /usr/bin/src/test_server/src COPY src/* ${SRC_DIR}/ WORKDIR ${SRC_DIR} ENV PYTHONUNBUFFERED=1 CMD ["python", "server.py"] |
Aquí,
-
Cualquier Dockerfile debe comenzar con la directiva FROM. En nuestro caso, estamos declarando Python como la base de la imagen de Docker.
-
La directiva ENV SRC_DIR especifica la ubicación del directorio del contenedor.
-
La directiva COPY copia los archivos desde el directorio src que actualmente aloja el servidor Python.
-
La variable PYTHONBUFFERED=1 especifica que Python imprimirá y registrará la salida directamente en STDOUT. De lo contrario, los registros no se enviarían a ningún búfer.
-
La directiva CMD especifica un comando predeterminado para ejecutar al iniciar el contenedor. En este caso, estamos usando la directiva para iniciar nuestro servidor Python.
Paso 4 – Generación de la imagen de Docker
Con el Dockerfile listo, ahora podemos crear una imagen. Ejecute el siguiente comando de Docker para iniciar el proceso:
|
1 |
docker build . -t python_server |
Aquí,
-
La bandera -t se utiliza para etiquetar nuestra imagen de Docker como python_server.
-
Docker descargará todos los componentes necesarios y los combinará en una imagen.
Paso 5 – Ejecución de la imagen
La imagen está lista para la implementación. Podemos ejecutarla usando el siguiente comando:
|
1 |
docker run -p 8080:8080 python_server |
Aquí, estamos reenviando el puerto 8080 desde la máquina local a la imagen de Docker usando la bandera -p.
Podemos validar fácilmente si el servidor está activo y funcionando usando curl:
|
1 |
curl -iv localhost:8080 |
Paso 6 – Terminación del servidor
Desde la terminal, presione “Ctrl + C” para finalizar el proceso de Docker:
Paso 7 – Exportación e importación de la imagen de Docker
Ahora tenemos una imagen de Docker funcional que aloja nuestro servidor Python. Con la ayuda de las funciones de exportación e importación de Docker, podemos migrarla a cualquier otro sistema.
Primero, verifique la lista de imágenes de Docker en el sistema actual:
|
1 |
docker images |
Nuestro objetivo es la imagen de Docker python_server que acabamos de crear. El siguiente comando la exportará como un archivo TAR:
|
1 |
docker save python_server:latest > python_server.tar |
Después de transferir el archivo python_server.tar a la máquina de destino, use el siguiente comando para importar la imagen de Docker:
|
1 |
docker load < python_server.tar |
Reflexiones finales
En esta guía, demostramos cómo compilar una imagen de Docker a partir de una aplicación Python. Creamos un servidor web Python simple y compilamos una imagen de Docker a partir de él. La imagen de Docker ahora se puede implementar en cualquier entorno y esperar un comportamiento consistente.
¿Le interesa obtener más información sobre Docker? Consulte las siguientes guías:
-
Compilar e implementar una aplicación Flask con Docker en Ubuntu 20.04
-
Cómo proteger y escalar una aplicación Django con Docker, Nginx y Let’s Encrypt
-
Cómo implementar WordPress con contenedores Docker en Ubuntu 20.04
¡Feliz informática!
Comentarios
Aún no hay comentarios. Sea el primero.