Contenido del curso
Despliegue de API Flask en Docker paso a paso
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
student
Amin Espinoza
teacher
Daniel Eduardo Rojas Pulido
student
Javier Martín
student
Jesus Martinez
student
Eric Daniel Cavanzo
student
Fredy Daniel Flores Lemus
studentAmin Espinoza
teacher
Luis Alberto Cardozo Servián
student
Guillermo Jimenez
student
Jorge Marquez Robinson
student
Jose Efrey Rodriguez
student
Johannes A. Villasana J.
student
Juan Povea
studentAmin Espinoza
teacherJuan Povea
student
Rafael Alexander Gonzalez Diaz
studentAmin Espinoza
teacher
ROMMEL DUAREZ SAENZ
student
Luis Rodolfo Altuve Cáceres
student
David Rangel
studentDaniel Eduardo Rojas Pulido
student
Sergio Paredes
studentAmin Espinoza
teacher
Jonathan Santoyo
student
Nicolas Rocha
student
IVAN CARAPIA BARAJAS
student
Juan Camilo Suarez
student
Cesar Sadrak Martin Moreno
student
Fernando Emilio Díaz López
student
BRAYAN MONTOYA OSORIO
student
Jhon Acevedo Lema
student
Juan Jose Tovar
student
Frank Recinos
student
Samuel Soto Hoyos
studentEl 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:
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
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"]
¡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
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
Este es el repositorio del curso:
En las ramas va el contenido de la clase correspondiente.
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 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.
¿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
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.
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.
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
Espero este aporte le sirve a las personas que intentaron hacer deploy y no les funcionó:
En el siguiente comando:
docker run -d -p 8081:5000 --name dockapi_v1_1 flaskapi:V1.1
8081 es el puerto que le estoy asignando a docker para que el cliente intente acceder a el (mi pc a traés del navegador). 5000 es el puerto que docker va a usar para redirigir el request hecho a tráves de 8081. Cómo flask usa el puerto 5000 para escuchar, eso significa que tan pronto el request sea reenviado, flask va a estar listo para atender el request.
La clave está en usar el mismo puerto tanto en el comando run :5000, cómo en el docker file
CMD ["python","-m","flask","run","--host=0.0.0.0", "--port=5000"]
En este caso, podría no usarse porque FLASK por defecto escucha en el puerto 5000.
Finalmente, para acceder a la aplicación, a través de la URL debe usarse, solo en este caso: localhost:8081/getMyInfo
El curso es muy bueno, el profesor tiene el don de explicar, si tienes otro curso mas avanzado de docker, escribe cual es, para que podamos seguirlo.
[Curso de Docker Avanzado](https://platzi.com/cursos/docker-avanzado/)