Despliegue de API Flask en Docker paso a paso
Contenido del curso
Alver Joan perez
Amin Espinoza
Profesor
Daniel Eduardo Rojas Pulido
Javier Martín
Jesus Martinez
Eric Daniel Cavanzo
Fredy Daniel Flores Lemus
Amin Espinoza
Profesor
Luis Alberto Cardozo Servián
Johannes A. Villasana J.
Guillermo Jimenez
Jorge Marquez Robinson
Jose Efrey Rodriguez
Juan Povea
Amin Espinoza
ProfesorJuan Povea
Luis Rodolfo Altuve Cáceres
Rafael Alexander Gonzalez Diaz
Amin Espinoza
Profesor
ROMMEL DUAREZ SAENZ
David Rangel
Jonathan Santoyo
Nicolas Rocha
Daniel Eduardo Rojas Pulido
Sergio Paredes
Amin Espinoza
Profesor
Jonatan Oyola
Jafet Brito
Jafet Brito
Fernando Emilio Díaz López
IVAN CARAPIA BARAJAS
Juan Camilo Suarez
Cesar Sadrak Martin Moreno
BRAYAN MONTOYA OSORIO
Jhon Acevedo Lema
El profesor explica todo muy detallado, no da nada por sentado, muy buen curso para iniciarse en docker.
Muchas gracias!
Claro que no es lo suficientemente detallado, primero hay que instalar python y otras cosas para que funcione el Flask
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)
gracias, vale oro tu comentario
Si sirvió resto pana, gracias
Que buena la energía que transmite este profesor al enseñar, seria genial tener mas cursos con el.
Muchas gracias Fredy! Espero que sea así, ha sido una experiencia muy divertida!
Explicación de instrucciones especificadas en el archivo Dockerfile:
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"]
No se hizo deploy del api con docker
Ojala lo hagan y actualicen el material
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
¡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
Aquí 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?
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
Este es el repositorio del curso:
En las ramas va el contenido de la clase correspondiente.
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?
Ah! 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?
si, se sobreescribe
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
¿Por qué se copia primero requirements.txt?
¿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
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.
Concuerdo, esperan que uno adivine cosas, almenos deberian decir, los requisitos previos para esta actividad son, Instala Flask, etc, etc,
Mi 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.
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?
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"]
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
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.
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
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.
Para que puedas hacer el primer paso de correr el servidor no en docker debes de:
Es correcto, para actualizar a la última versiones
Flask==3.1.2
waitress==3.0.2
