En cualquier proyecto de software, manejar eficazmente el back-end es esencial para lograr aplicaciones sólidas y confiables. Una excelente forma de abordar esto es mediante el despliegue de APIs construidas con Python en contenedores de Docker, facilitando consistencia y eficiencia entre diferentes entornos.
¿Qué es el back-end y cómo funciona con Python?
El back-end es aquella parte del proyecto que gestiona la lógica y el procesamiento de datos en el servidor. Utilizando Python con frameworks como Flask, puedes crear APIs ligeras y efectivas con métodos específicos que devuelven información precisa. Por ejemplo, una API Flask puede contener el método GetMyInfo encargado de ofrecer información estructurada en formato JSON.
Para visualizar el resultado podrás ejecutar un comando simple desde la terminal:
python -m flask run
Con este comando, la aplicación Flask comienza a ejecutarse localmente. Copiando la IP proporcionada con su respectivo puerto, luego puedes acceder desde un navegador agregando el método específico al final del URL (por ejemplo, /GetMyInfo). De esta forma, obtendrás confirmación visual del correcto funcionamiento de tu API.
¿Cómo desplegar una API Python dentro de Docker?
Cuando deseas asegurar que la aplicación tenga el mismo comportamiento en cualquier ambiente, Docker es una herramienta extremadamente útil. Esto implica crear un Dockerfile para preparar tu aplicación y entorno.
¿Qué es un Dockerfile y cómo crearlo para una API Python?
Un archivo Dockerfile incluye instrucciones específicas usando palabras reservadas que Docker reconoce:
python:3.12-alpine3.17)./app para Python).Aquí un ejemplo basado en la API Python mencionada:
FROM python:3.12-alpine3.17 WORKDIR /app COPY requirements.txt requirements.txt RUN pip install -r requirements.txt COPY . . CMD ["python", "-m", "flask", "run"]
Cada instrucción sigue una secuencia determinada, esencial para que Docker entienda la estructura y dónde alojar los elementos necesarios para correr tu aplicación.
¿Por qué Docker es útil para diferentes proyectos tecnológicos?
Docker utiliza términos estándar como FROM, WORKDIR, COPY, RUN y CMD, independientemente de la tecnología o plataforma que elijas trabajar. Esto significa que puedes usar estos mismos conceptos aplicados a:
Interactuar con Docker no requiere conocer tecnologías específicas, sino entender estas palabras reservadas universales.
Si deseas compartir tus experiencias o tienes alguna inquietud sobre cómo usar Docker en tus futuros desarrollos, no dudes en dejar un comentario.
Alver Joan perez
El profesor explica todo muy detallado, no da nada por sentado, muy buen curso para iniciarse en docker.
Amin Espinoza
ProfesorMuchas gracias!
Daniel Eduardo Rojas Pulido
Claro que no es lo suficientemente detallado, primero hay que instalar python y otras cosas para que funcione el Flask
Javier Martín
Despues de 30 min, entendí que debía instalar flask primero, para poder correr la primera parte del ejemplo, debes tener instalado:
y recien ahí es que puedes correr el "python -m flask run"
Todo esto asumiendo que diera un error como este "python.exe: No module named flask". ahora seguiré viendo la clase . (tenia como 3 semanas de abandono del curso porque me había quedado pegado ahí XD)
Jesus Martinez
gracias, vale oro tu comentario
Eric Daniel Cavanzo
Si sirvió resto pana, gracias
Luis Alberto Cardozo Servián
Explicación de instrucciones especificadas en el archivo Dockerfile:
Johannes A. Villasana J.
Dejaré por aquí algunos comando útiles para el Dockerfile:
## Dockerfile
- Especifica la imagen base desde la cual se construira la imagen:
FROM image:tag
- Establece el directorio de trabajo dentro del contenedor. Las instrucciones siguientes se ejecutarán en este directorio:
WORKDIR /path/to/workdir
- Copia archivos o directorios desde el sistema de archivos local al sistema de archivos del contenedor:
COPY <local> <remote>
- Ejecuta comandos durante la construcción de la imagen. Puedes usarlo para instalar paquetes, configurar el entorno.... :
RUN command
example: RUN npm install
- Proporciona el comando predeterminado a ejecutar cuando el contenedor se inicia:
CMD ["executable", "param1", "param2"]
example: CMD ["npm", "run", "dev"]
- Informa a Docker que la aplicación dentro del contenedor escuchará en el puerto especificado en tiempo de ejecución:
EXPOSE port
- Establece variables de entorno dentro del contenedor:
ENV key=value
- Crea un punto de montaje para almacenar datos persistentes fuera del contenedor:
VOLUME ["/data"]
Guillermo Jimenez
No se hizo deploy del api con docker
Jorge Marquez Robinson
Ojala lo hagan y actualicen el material
Jose Efrey Rodriguez
Desde la ruta del Dockerfile corremos
docker build -t app_python .
luego arrancamos el contenedor como es flask corre en el puerto 5000
docker run -it --rm -d -p 8081:5000 --name web_app_python app_python
ya podremos ver la api en la ruta
Juan Povea
¡Hola! Me ha encantado el curso. De verdad que explicas muy bien y aprecio muchísimo que hayas explicado los fundamentos tanto con la CLI como con Docker Desktop
PD: Soy usuario y fan de linux también :D
Amin Espinoza
ProfesorAquí hay un usuario que me simpatiza! Gracias por las palabras por el curso pero lo importante es que seas fan linuxero. ¿Qué dsitro sueles usar?
Juan Povea
JAJAJAJ actualmente uso Fedora 39 con KDE. Antes usé Zorin OS, pero me pasé hace poco porque esa distro tenía packages muy viejos. ¿Y tú? En el curso veo que usaste Ubuntu, pero no sé si esa sea la que uses diariamente
Luis Rodolfo Altuve Cáceres
Este es el repositorio del curso:
En las ramas va el contenido de la clase correspondiente.
Rafael Alexander Gonzalez Diaz
Hola profe, una pregunta. No me quedó claro por qué pones
COPY requirements.txt requirements.txt
Y luego después pones
COPY ..
No se estaría duplicando el archivo requirements.txt?
Amin Espinoza
ProfesorAh! Porque de esta manera primero instalas todo lo que necesitas y luego copias todos los archivos, quizá podríamos ponernos más detallistas y pasar uno por uno los archivos, eso haría las cosas más eficaces pero igual más elaboradas ¿no crees?
ROMMEL DUAREZ SAENZ
si, se sobreescribe
David Rangel
Es la primera vez que utilizo flask pero ya tenía instalado Python, tengo WSL (Windows Subsystem for Linux) y VSC. Para poder correr la API (1'35'' del video), utilicé los siguientes comandos en la terminal de WSL:
## dirigirte al directorio correspondiente para instalar flask cd clase_11 ## para instalar python apt install python3.10-venv ## para crear el entorno python3 -m venv .venv ## para instalar flask pip install Flask ## para correr flask python3 -m flask run
¿Qué es Flask?
Flask es un framework de Python para crear aplicaciones web y APIs. Es minimalista y popular para proyectos pequeños/medianos.
Anatomía de una app Flask mínima
python
from flask import Flask app = Flask(__name__) @app.route('/') def home(): return "Hola Mundo" @app.route('/users') def users(): return {"users": ["Ana", "Luis", "Carlos"]} if __name__ == '__main__': app.run(host='0.0.0.0', port=5000) ``` **Lo que debes entender:** | Elemento | Significado | |----------|-------------| | `from flask import Flask` | Importa la librería | | `app = Flask(__name__)` | Crea la aplicación | | `@app.route('/')` | Define una ruta/endpoint (URL) | | `def home():` | Función que responde a esa ruta | | `return "..."` | Lo que devuelve al navegador | | `app.run(host='0.0.0.0', port=5000)` | Inicia el servidor en puerto 5000 | --- ### ¿Por qué `host='0.0.0.0'`? Esto es **crítico para Docker**: - `127.0.0.1` → Solo accesible desde dentro del contenedor - `0.0.0.0` → Accesible desde fuera del contenedor (tu navegador) --- ### Archivo `requirements.txt` Probablemente verás este archivo. Lista las dependencias de Python: ``` flask==2.0.1
Docker lo usa para instalar las librerías necesarias dentro del contenedor.
Lo que cambiará en el Dockerfile
En lugar de Nginx (servidor web estático), verás algo como:
dockerfile
FROM python:3.9 WORKDIR /app COPY requirements.txt . RUN pip install -r requirements.txt COPY . . CMD ["python", "app.py"]
El flujo de Docker sigue siendo el mismo. Solo cambia qué se ejecuta adentro.
Resumen
Concepto FlaskSolo necesitas saber
@app.route()
Define URLs de la API
port=5000
Puerto por defecto de Flask
host='0.0.0.0'
Necesario para acceso desde fuera del contenedor
requirements.txt
Lista de dependencias Python
Jonathan Santoyo
¿Por qué se copia primero requirements.txt?
Daniel Eduardo Rojas Pulido
Sergio Paredes
Concuerdo, esperan que uno adivine cosas, almenos deberian decir, los requisitos previos para esta actividad son, Instala Flask, etc, etc,
Amin Espinoza
ProfesorMi querido Daniel,
Déjame contarte un tip que ha cambiado por completo mi percepción del aprendizaje en general. No espero que me den toda la información. Si estás con el curso de Docker pero no conoces Flask te recomendaría muchísimo que hagas una pausa, aprendas al menos de que va esa tecnología y vuelvas acá para continuar.
Esto me ha pasado en el desarrollo de software, al aprender de historia en novelas históricas, al leer comics y mucho más, prácticalo y verás un cambio gigante en tu percepción de las cosas.
Jonatan Oyola
no entiendo por que primero copia el requirements.txt y luego todo el codigo (donde ya esta el requirements,txt)
Jonatan, piensa en Docker como un sistema de capas superpuestas. Cada instrucción en tu Dockerfile crea una nueva capa que se guarda en caché.
Si copias todo el código primero, cualquier cambio en un archivo de texto o una línea de tu API invalida esa capa y todas las siguientes. Al copiar solo el requirements.txt primero, esa capa de instalación de dependencias se mantiene intacta mientras tus librerías no cambien.
¿Ves cómo esto evita que Docker tenga que descargar e instalar todo de nuevo cada vez que solo modificas una línea de tu código?
Jafet Brito
Les dejo una receta, por si quieren probar en cyberseguridad, Docker.
# Usamos la imagen oficial de Kali Linux como base
FROM kalilinux/kali-rolling
# Evitamos que la instalación nos interrumpa con preguntas
ENV DEBIAN_FRONTEND=noninteractive
# Instalamos todo el arsenal (¡Python y Ruby incluidos!)
RUN apt-get update && apt-get install -y \
openvpn \
metasploit-framework \
nmap \
gobuster \
wordlists \
wget \
curl \
git \
python3 \
python3-pip \
python3-venv \
ruby \
ruby-dev \
netcat-traditional \
iputils-ping \
iproute2 \
nano \
&& rm -rf /var/lib/apt/lists/*
# Instalamos Lolcat para darle estilo a la terminal
RUN gem install lolcat
# Instalamos RustScan manualmente
RUN wget \
&& dpkg -i rustscan_2.0.1_amd64.deb \
&& rm rustscan_2.0.1_amd64.deb
# Definimos nuestra carpeta base de operaciones (El túnel a Windows)
WORKDIR /arsenal
# Al iniciar el contenedor, abrimos la terminal
CMD ["/bin/bash"]
Jafet Brito
asi la instalan
docker build -t mi_kali_hacker .
asi la inician
docker run -it --rm --cap-add=NET_ADMIN -v "${PWD}:/arsenal" mi_kali_hacker
Fernando Emilio Díaz López
Si no le pones una versión específica a Alpine en tu Dockerfile, Docker utilizará la última versión disponible por defecto. Esto puede causar problemas de compatibilidad en tu aplicación, ya que los cambios en las versiones posteriores podrían afectar el comportamiento de tu entorno. Es recomendable siempre especificar la versión para asegurar que tu aplicación funcione como se espera. Esto se aplica a cualquier imagen base, no solo a Alpine.
IVAN CARAPIA BARAJAS
Juan Camilo Suarez
Hola, para obtener el json desde el contenedor, yo hice algunos ajustes a los puertos para que flask me dejara:
Asegurate de señalar el puerto en tu Dockerfile:
CMD ["python", "-m", "flask", "run", "--host=0.0.0.0", "--port=8080"].
Esto porque, flask funciona por defecto en el puerto 5000.
Y ya para terminar, en tu archivo app.py agrega esto al final:
if __name__ == "__main__": app.run(host="0.0.0.0", port=8080)
De este modo, ya te va a correr en el puerto 8080 sin ningún problema :D
Cesar Sadrak Martin Moreno
Para crear la imagen y después hacer el build utilicé los siguientes comandos
docker build -t api_python:latest ./ docker run -it --rm -d -p 8085:5000 --name api api_python
Tuve un problema con el puerto que comunica el contenedor a la aplicación (el segundo puerto), a diferencia de la página web, que nginx utiliza el puerto 80, flask utiliza por defecto el puerto 5000, por lo que si se quiere utilizar los puertos 8085:80 flask arrojara un error, ya que con el puerto 8085 el local se comunica al contenedor (Funciona siempre y cuando no estes ocupando ya ese puerto) y despues el contenedor intenta comunicarse al puerto 80 lo cual no tendrá nada ya que Flask está en el 5000.
BRAYAN MONTOYA OSORIO
Para que puedas hacer el primer paso de correr el servidor no en docker debes de:
Jhon Acevedo Lema
Es correcto, para actualizar a la última versiones
Flask==3.1.2
waitress==3.0.2
Por mejorar para una próxima versión de este curso: Hacer todo un poco más paso a paso incluyendo la instalación de python y flask, porque para los que apenas estamos empezando nos queda muy difícil adivinar, además de mostrar el paso a paso para desplegar el Flask en el contenedor, porque la repetición de los comandos de docker ya aprendidos aplicados acá nos va a hacer que el conocimiento se vaya arraigando. De nuevo tuve que recurrir a Deepseek para ver el servidor backend de Flask funcionando desde el contenedor docker.
Después de hacer lo de la clase lo que sigue es:
¡Perfecto! Analicemos cada archivo y hagamos las correcciones necesarias. He identificado varios problemas:
## Problemas Identificados:
1. **Falta especificar la aplicación Flask** (variable FLASK\_APP)
2. **Flask no está configurado para escuchar en 0.0.0.0**
3. **Falta el host y puerto en la ejecución**
4. **El archivo app.py no tiene la ejecución principal**
## Correcciones Paso a Paso:
### 1. Primero, detén y elimina el contenedor actual:
docker stop bakendflask docker rm bakendflask
### 2. Modifica el archivo app.py:
import json from flask import Flask app = Flask(\_\_name\_\_) @app.route('/getMyInfo') def getMyInfo():   value = {   "name": "Amin",   "lastname": "Espinoza",   "socialMedia": \[   {"facebookUser": "aminespinoza10"},   {"instagramUser": "aminespinoza10"},   {"xUser": "aminespinoza"},   {"linkedin": "amin-espinoza"},   {"githubUser": "aminespinoza10"}   ],   "blog": "https://aminespinoza.com",   "author": "Miranda Espinoza"   }   return json.dumps(value) @app.route('/') def home():   return json.dumps({"message": "Bienvenido a la API Flask", "status": "active"}) @app.route('/health') def health():   return json.dumps({"status": "healthy"}) \# Añadir esta parte para ejecución directa if \_\_name\_\_ == '\_\_main\_\_':   app.run(host='0.0.0.0', port=5000, debug=False)
### 3. Opción A: Modificar el Dockerfile (Recomendado):
FROM python:3.12-alpine3.17 WORKDIR /app COPY requirements.txt requirements.txt RUN pip install -r requirements.txt COPY . . \# Configurar variables de entorno ENV FLASK\_APP=app.py ENV FLASK\_RUN\_HOST=0.0.0.0 EXPOSE 5000 \# Usar este comando para producción con Waitress CMD \["python", "-m", "waitress", "--listen=0.0.0.0:5000", "app:app"]
### 3. Opción B: Si prefieres seguir usando Flask run:
FROM python:3.12-alpine3.17 WORKDIR /app COPY requirements.txt requirements.txt RUN pip install -r requirements.txt COPY . . \# Configurar variables de entorno ENV FLASK\_APP=app.py ENV FLASK\_RUN\_HOST=0.0.0.0 ENV FLASK\_RUN\_PORT=5000 EXPOSE 5000 CMD \["python", "-m", "flask", "run", "--host=0.0.0.0"]
### 4. Crea un archivo .flaskenv (opcional pero útil):
FLASK\_APP=app.py FLASK\_RUN\_HOST=0.0.0.0 FLASK\_RUN\_PORT=5000 FLASK\_DEBUG=0
## Comandos para Reconstruir y Ejecutar:
### 1. Reconstruir la imagen:
\# Desde el directorio de tu proyecto docker build -t appflask:1.1 .
### 2. Ejecutar el contenedor:
docker run -d -p 5000:5000 --name bakendflask appflask:1.1
### 3. Verificar que funcione:
\# Ver logs docker logs bakendflask \# Probar los endpoints curl http://localhost:5000/ curl http://localhost:5000/getMyInfo curl http://localhost:5000/health
## Si Prefieres una Solución Más Sencilla:
Modifica solo el Dockerfile manteniendo todo lo demás igual:
FROM python:3.12-alpine3.17 WORKDIR /app COPY requirements.txt requirements.txt RUN pip install -r requirements.txt COPY . . ENV FLASK\_APP=app.py CMD \["python", "-m", "flask", "run", "--host=0.0.0.0", "--port=5000"]
## Comandos de Diagnóstico para Verificar:
\# Verificar que el contenedor esté corriendo docker ps \# Ver logs específicos docker logs bakendflask \# Ver variables de entorno del contenedor docker exec bakendflask env | grep FLASK \# Probar dentro del contenedor docker exec bakendflask curl -s http://localhost:5000/health
## Resultado Esperado:
Después de las correcciones, cuando ejecutes:
docker logs bakendflask
Deberías ver:
 \* Running on  \* Debug mode: off
O si usas Waitress:
Serving on
**¿Qué opción prefieres probar primero?** Te recomiendo la Opción A con Waitress para producción, o la Opción B si quieres mantener Flask run para desarrollo.
