Introducción al desarrollo de una interfaz de programación de aplicaciones RESTful con Flask y Python
En nuestro equipo de desarrollo, necesitábamos crear una API para un proyecto web que estábamos construyendo. Decidimos utilizar Flask en Python para hacerlo, ya que Flask es un micro-framework que es fácil de aprender y configurar, y Python es un lenguaje de programación poderoso y popular. Además, Flask proporciona un enfoque sencillo para crear una API RESTful, lo que permite que nuestras aplicaciones web interactúen con otras aplicaciones web a través de una interfaz de programación.
Una API RESTful es una interfaz de programación de aplicaciones que sigue un conjunto de restricciones arquitecturales basadas en HTTP. Esto significa que se puede acceder a los recursos a través de URLs, lo que hace que la API sea fácil de entender y utilizar. Los datos se envían y reciben como JSON o XML, lo que permite que la API sea compatible con una amplia variedad de aplicaciones. Esto significa que podemos crear una API que haga literalmente cualquier cosa, desde dar clima hasta un catálogo completo de una tienda en línea.
En general, una API RESTful tiene dos componentes principales: recursos y verbos HTTP. Los recursos son los datos o información que se pueden acceder a través de la API. Los verbos HTTP son las operaciones que se pueden realizar en esos recursos, como obtener un recurso, crear un recurso, actualizar un recurso o eliminar un recurso.
En Python, Flask proporciona una forma sencilla de crear una API RESTful. Podemos crear un recurso usando una clase de Python y luego agregar métodos para los verbos HTTP que queramos implementar. Por ejemplo, si queremos crear una API para acceder a una lista de tareas pendientes, podemos crear un recurso Task que tenga métodos GET, POST, PUT y DELETE.
class Task(Resource):
def get(self):
# Obtener todas las tareas
def post(self):
# Crear una nueva tarea
def put(self, task_id):
# Actualizar una tarea existente
def delete(self, task_id):
# Eliminar una tarea existente
Para crear una API RESTful completa con Flask, necesitamos definir los recursos y los verbos HTTP que queremos utilizar. Luego, creamos una aplicación Flask y agregamos nuestros recursos a la aplicación. Después de eso, podemos ejecutar la aplicación y acceder a la API a través de las URLs que hemos definido para cada recurso.
Flask es una excelente opción para crear una API RESTful en Python debido a su simplicidad y flexibilidad. Al usar Flask, podemos crear una API que puede realizar cualquier tarea que necesitemos. Y al seguir las mejores prácticas para crear una API RESTful, podemos garantizar que nuestra API sea fácil de entender, documentar y utilizar para cualquier aplicacion que la necesite.
Instalación de Flask y creación de un entorno virtual para el desarrollo de la API REST
Para comenzar con el desarrollo de nuestra API REST con Flask en Python, es necesario instalar Flask y crear un entorno virtual para trabajar en el proyecto de manera aislada. En este artículo explicaremos cómo hacerlo paso a paso.
Lo primero que debemos hacer es instalar Flask. Para ello, abrimos una terminal y ejecutamos el siguiente comando:
pip install flask
Esto instalará Flask y sus dependencias en nuestro sistema. Una vez instalado, podemos verificar que Flask esté correctamente instalado con el siguiente comando:
flask --version
Con esto, deberíamos recibir una respuesta que nos indique la versión de Flask que tenemos instalada, lo que confirmaría que todo está funcionando correctamente.
Ahora, el siguiente paso es crear un entorno virtual para nuestro proyecto. Esto nos permitirá tener un ambiente aislado en el que podamos instalar y mantener las versiones específicas de las bibliotecas y paquetes que necesitamos para nuestro proyecto, sin interferir con otras aplicaciones en nuestro sistema.
Para crear un entorno virtual, utilizaremos la biblioteca venv de Python. Para ello, ejecutamos el siguiente comando en nuestra terminal:
python -m venv mi_entorno_virtual
Donde “mi_entorno_virtual” es el nombre que queramos darle a nuestro entorno virtual. Una vez creado el entorno virtual, debemos activarlo con el siguiente comando:
source mi_entorno_virtual/bin/activate
Con esto, veremos el nombre de nuestro entorno virtual en nuestra terminal, lo que significa que ha sido activado correctamente.
Ahora, para confirmar que estamos trabajando en un entorno virtual, podemos ejecutar el siguiente comando:
which python
Esto debería responder con la ruta a la versión de Python que se está utilizando dentro del entorno virtual.
Con todos estos pasos completados, estamos listos para seguir adelante con el desarrollo de nuestra API REST utilizando Flask en Python. En el próximo artículo, explicaremos cómo crear una ruta básica para nuestra API.
Creación de endpoints y definición de los métodos HTTP
Una vez que tenemos nuestro proyecto de API REST estructurado y configurado en Flask, el siguiente paso es definir los endpoints y los métodos HTTP que estarán disponibles para que los usuarios interactúen con nuestra aplicación.
En simples palabras, los endpoints son las diferentes rutas que los usuarios pueden utilizar para interactuar con nuestra API. Estos endpoints pueden ser definidos a través de funciones específicas en nuestro código, utilizando la siguiente estructura:
@app.route('/ruta', methods=['GET', 'POST'])
En este ejemplo, se define la dirección /ruta como un endpoint válido en nuestra API, y se le indican los métodos HTTP que están permitidos para interactuar con esta ruta, los cuales en este caso son solo GET y POST.
Dentro de estas funciones, podemos definir la lógica específica que será ejecutada cuando un usuario interactúa con este endpoint y este método HTTP en particular. Por ejemplo, si quisieramos definir una respuesta básica cuando un usuario utiliza el método GET en el endpoint /ruta, podríamos utilizar el siguiente código:
@app.route('/ruta', methods=['GET'])
def obtener_data():
return 'Estas obteniendo informacion'
De esta forma, cualquier usuario que utilice el método GET para interactuar con el endpoint /ruta recibirá la respuesta “Estas obteniendo informacion”.
Además de la definición de endpoints y métodos HTTP básicos, también podemos utilizar parámetros adicionales para nuestras funciones que nos permitan obtener información adicional acerca de la petición que está siendo realizada. Por ejemplo, podemos utilizar el siguiente código en nuestra API para obtener el ID específico de un objeto solicitado por el usuario:
@app.route('/ruta/<int:id>', methods=['GET'])
def obtener_data(id):
return 'Este es el objeto con ID : {}'.format(id)
En este caso, estamos definiendo un endpoint /ruta que acepta el parámetro id en su URL y utilizando este parámetro en nuestra función para generar una respuesta personalizada al usuario.
De esta forma, utilizando la definición de endpoints y métodos HTTP en Flask, podemos crear API RESTful robustas y personalizadas que faciliten la interacción entre nuestros usuarios y nuestra aplicación.
Implementación de la autenticación y autorización en la API REST con Flask-JWT
Durante el proceso de diseño y desarrollo de nuestras API REST con Flask en Python, nos encontramos con un tema importante a considerar y es la seguridad de nuestros sistemas y datos. Para ello, una herramienta muy útil que podemos utilizar es Flask-JWT, un paquete de extensión de Flask que nos permite implementar fácilmente autenticación y autorización en nuestra API.
Autenticación y autorización
Antes de profundizar en Flask-JWT, es importante entender la diferencia entre autenticación y autorización. La autenticación es el proceso de verificar que el usuario es quien dice ser. Por otro lado, la autorización es el proceso de determinar si el usuario autenticado tiene acceso a los recursos solicitados. En resumen, la autenticación asegura que el usuario es quien dice ser, mientras que la autorización asegura que el usuario tiene el permiso necesario para realizar una acción.
Implementando autenticación y autorización con Flask-JWT
Flask-JWT utiliza tokens JSON web para implementar autenticación y autorización. Un token JWT es un objeto JSON que contiene información sobre el usuario autenticado, así como cualquier permiso que se le haya concedido. Este token se envía con cada solicitud a la API y se verifica en el servidor antes de procesar cualquier petición. Para implementar la autenticación y autorización en nuestra API Flask en Python, debemos seguir los siguientes pasos:
1. Instalar Flask-JWT
Primero, debemos instalar Flask-JWT en nuestro proyecto. Esto se hace fácilmente con pip utilizando el siguiente comando en la terminal:
pip install flask-jwt
2. Configurar la clave secreta
El siguiente paso es definir una clave secreta que se usará para cifrar y descifrar los tokens JWT. Esta clave secreta debe ser única y segura. Por ejemplo, podemos definir una clave secreta en nuestra aplicación Flask de la siguiente manera:
import os
app.config['SECRET_KEY'] = os.environ.get('SECRET_KEY') or 'clavesecreta'
Aquí estamos definiendo la clave secreta como una variable de entorno o una cadena simple “clave secreta”.
3. Implementar la autenticación
El siguiente paso es implementar la autenticación. Flask-JWT proporciona una forma fácil de hacerlo con el decorador @jwt_required, que se puede aplicar a cualquier ruta que requiera autenticación. Por ejemplo, podemos implementar la autenticación en nuestra API Flask Python de la siguiente manera:
from flask_jwt import jwt_required
@app.route('/protegido')
@jwt_required()
def protegido():
return 'Esta es una ruta protegida que requiere autenticación mediante JWT!'
Aquí estamos definiendo una ruta “protegida” que sólo se puede acceder si se proporciona un token JWT válido en la solicitud.
4. Implementar la autorización
Finalmente, podemos implementar la autorización en nuestra API Flask Python utilizando Flask-JWT de la misma manera que la autenticación. En lugar del decorador @jwt_required, podemos utilizar @jwt_required junto con un decorador @roles_required para definir los roles que tienen acceso a una determinada ruta. Por ejemplo:
from flask_jwt import roles_required
@app.route('/admin')
@jwt_required()
@roles_required('admin')
def admin():
return 'Esta es una ruta solo para usuarios con rol de administrador'
Aquí estamos definiendo una ruta “admin” que sólo puede ser accedida por usuarios con rol de administrador.
La implementación de autenticación y autorización es esencial para garantizar la seguridad de nuestras API REST construidas con Flask Python. Flask-JWT es una herramienta muy útil que nos ayuda a implementar fácilmente esta seguridad en nuestras aplicaciones. Siguiendo los pasos descritos en este articulo, podemos implementar autenticación y autorización en nuestra API Flask en Python.
Manejo de errores y excepciones en la API REST con Flask
A medida que desarrollamos nuestra API REST con Flask en Python, es importante considerar los posibles errores y excepciones que pueden ocurrir durante el procesamiento de las solicitudes. Es fundamental proporcionar una respuesta adecuada al usuario que solicita nuestros servicios, incluso cuando se producen errores.
Existen numerosos tipos de errores que pueden ocurrir en una API REST, entre los cuales se incluyen errores en el formato de las solicitudes, acceso no autorizado, solicitudes a recursos inexistentes, etc. Los errores pueden verse como excepciones que surgen en la aplicación y deben manejarse con cuidado.
Flask proporciona un mecanismo para manejar errores y excepciones en la API REST. La solución para manejar estas excepciones es utilizando decoradores en los métodos de manejo de excepciones. Un decorador es una función que toma otra función y extiende el comportamiento de la función original de formas distintas.
La forma más común de manejar las excepciones en Flask es usando el decorador app.errorhandler(). Este decorador se utiliza para registrar una función de manejo de errores para un determinado tipo de excepción.
Por ejemplo, si deseamos manejar errores HTTP 404, podemos definir una función de manejo de errores personalizada que devuelve una respuesta adecuada:
from flask import jsonify, make_response
@app.errorhandler(404)
def not_found(error):
return make_response(jsonify({'error': 'No se encontró el recurso solicitado'}), 404)
En este ejemplo, la función not_found es nuestro método de manejo de excepciones para un error HTTP 404. La función toma el objeto de error como parámetro y devuelve una respuesta JSON con el mensaje de error correspondiente.
Es importante tener en cuenta que también podemos agregar excepciones personalizadas a nuestra aplicación. Por ejemplo, si queremos definir una excepción personalizada para un recurso no encontrado, podemos definir nuestra propia excepción y manejarla con el decorador app.errorhandler(). De esta forma, tendremos un mayor control sobre cómo manejamos nuestras excepciones personalizadas.
Es importante manejar adecuadamente los errores y excepciones en nuestra API REST con Flask. El uso de decoradores para manejar excepciones es una forma efectiva de garantizar que nuestras respuestas sean claras e inequívocas para los usuarios. Al proporcionar respuestas precisas y adecuadas a las solicitudes de los usuarios, podemos mejorar la experiencia del usuario y la calidad de nuestra aplicación en general.
Documentación de la API REST con Swagger y Flask-RESTPlus
Después de haber desarrollado nuestra API REST con Flask en Python, llegó el momento de documentarla para que los desarrolladores externos puedan utilizarla de manera eficiente. En este sentido, existen distintas herramientas que podemos usar para llevar a cabo esta tarea, pero en esta ocasión vamos a centrarnos en dos de las más populares: Swagger y Flask-RESTPlus.
Swagger es una herramienta que nos permite documentar APIs REST de manera sencilla y visual. Su principal ventaja es que genera documentación a partir de nuestro código, lo que lo hace muy útil para mantener la documentación actualizada. Por su parte, Flask-RESTPlus es una extensión de Flask que nos brinda una serie de herramientas para construir APIs REST de manera más eficiente. Entre estas herramientas se encuentra la generación de documentación utilizando Swagger.
Para comenzar a trabajar con Swagger y Flask-RESTPlus necesitamos instalarlos en nuestro entorno de desarrollo. Para ello, podemos utilizar los siguientes comandos:
pip install flask-restplus
pip install flask-restplus[swagger]
Una vez instaladas las dependencias, podemos comenzar a generar la documentación de nuestra API REST utilizando Swagger y Flask-RESTPlus. Para ello, debemos agregar las siguientes líneas de código en nuestro archivo de aplicación:
from flask_restplus import Api
api = Api(version='1.0', title='Mi API', description='Descripción de mi API')
En estas líneas de código definimos algunos metadatos necesarios para nuestra documentación. La versión, el título y la descripción son los más importantes, pero también podemos definir otros parámetros opcionales como por ejemplo información de contacto del desarrollador y otros detalles relevantes.
Una vez que hemos definido nuestros metadatos, podemos agregar nuestras rutas utilizando los decoradores de Flask-RESTPlus. Por ejemplo, una ruta para obtener un usuario podría verse así:
@api.route('/users/<int:user_id>')
class User(Resource):
def get(self, user_id):
return {'id': user_id, 'name': 'John Doe'}
En este ejemplo estamos definiendo una ruta para obtener un usuario por su ID. La URL de la ruta es /users/<int:user_id>, donde user_id es un parámetro entero. La clase User extiende Resource de Flask-RESTPlus y define el método get, que es el que se ejecuta cuando se realiza una petición GET a esta ruta.
Finalmente, podemos generar nuestra documentación de Swagger utilizando el siguiente código:
from flask import Flask
from flask_restplus import Resource, Api
app = Flask(__name__)
api = Api(app, version='1.0', title='Mi API', description='Descripción de mi API')
@api.route('/users/<int:user_id>')
class User(Resource):
def get(self, user_id):
return {'id': user_id, 'name': 'John Doe'}
if __name__ == '__main__':
app.run(debug=True)
En este ejemplo estamos creando una aplicación de Flask y estamos agregando nuestra ruta de ejemplo utilizando Flask-RESTPlus. Luego, simplemente ejecutamos la aplicación en modo debug y accedemos a nuestra documentación de Swagger en la ruta /swagger.json.
Documentar nuestra API REST con Swagger y Flask-RESTPlus es muy sencillo y nos permite mantener nuestra documentación actualizada a medida que nuestro código evoluciona. Además, nos brinda una interfaz visual útil para los desarrolladores externos que quieren utilizar nuestra API, lo que facilita la integración con sus aplicaciones.
Pruebas unitarias y de integración para garantizar el correcto funcionamiento de la API REST
Una vez que se ha desarrollado una API REST con Flask en Python, es muy importante realizar pruebas unitarias y de integración para garantizar su correcto funcionamiento. Las pruebas unitarias consisten en probar cada una de las funciones o métodos que forman parte de la aplicación por separado, con el fin de detectar posibles errores en su implementación. Por otro lado, las pruebas de integración se encargan de comprobar que todas las partes de la aplicación funcionan correctamente en conjunto y que las diferentes funcionalidades se integran de manera adecuada.
Para llevar a cabo estas pruebas, Flask cuenta con un paquete llamado unittest, que ofrece una serie de herramientas para la realización de pruebas unitarias. Por ejemplo, podemos crear una clase que contenga una serie de métodos que prueben diferentes características de nuestra API. Cada uno de estos métodos se encargará de realizar una serie de peticiones HTTP a la API y comprobar que se obtienen los resultados esperados.
Por ejemplo, si nuestra API tiene un endpoint para obtener una lista de usuarios, podríamos crear un método que realice una petición GET a esa ruta y compruebe que se reciben los datos esperados en formato JSON. En caso de que esto no suceda, el método lanzará una excepción indicando el error.
import unittest
from app import app
class TestAPI(unittest.TestCase):
def test_get_users(self):
with app.test_client() as client:
response = client.get('/users')
data = response.get_json()
self.assertEqual(response.status_code, 200)
self.assertIsInstance(data, list)
Este método crea un cliente de prueba para nuestra aplicación utilizando el método test_client() de Flask. Luego, realiza una petición GET a la ruta /users y comprueba que el código de estado de la respuesta es 200 y que el cuerpo de la respuesta es una lista.
Las pruebas unitarias son una herramienta fundamental en el desarrollo de aplicaciones. Además de detectar posibles errores en el código, también ayudan a mantener la calidad del mismo a medida que se van realizando cambios y mejoras.
En cuanto a las pruebas de integración, Flask también cuenta con herramientas para su realización. Por ejemplo, podemos utilizar la librería requests para realizar peticiones HTTP a nuestra API desde una aplicación externa y comprobar que se obtienen los resultados esperados.
import requests
def test_integration():
response = requests.get('http://localhost:5000/users')
data = response.json()
assert response.status_code == 200
assert isinstance(data, list)
Este código realiza una petición GET a la ruta /users de nuestra API y comprueba que se recibe una respuesta con código de estado 200 y que el cuerpo de la respuesta es una lista.
Las pruebas unitarias y de integración son herramientas fundamentales para garantizar el correcto funcionamiento de una API REST desarrollada con Flask en Python. Estas pruebas no sólo nos permiten detectar errores en nuestro código, sino que también nos ayudan a mantener la calidad del mismo en el tiempo y a garantizar que las diferentes funcionalidades de nuestra aplicación se integren de manera adecuada.
Implementación de paginación y ordenamiento en la respuesta de la API REST con Flask
Nuestra API RESTful tiene una gran cantidad de datos para ofrecer y es probable que nuestros usuarios necesiten filtrarlos, paginarlos o ordenarlos. Por lo tanto, es importante saber cómo implementar estos requisitos en nuestra API utilizando Flask.
Paginación
Cuando se manejan grandes cantidades de datos, es importante dividirlos en pequeñas partes para que el usuario pueda manipularlos de manera eficiente. Esto se logra mediante la paginación.
En Flask, podemos implementar la paginación en nuestra API utilizando el paquete “Flask-Paginate”. Este paquete proporciona una clase de paginación que se puede usar para dividir nuestros datos en varias páginas.
from flask_paginate import Pagination, get_page_parameter
@app.route('/users')
def users():
# Obtener todos los usuarios
users = User.query.all()
# Configurar la paginación
page = request.args.get(get_page_parameter(), type=int, default=1)
per_page = 10
offset = (page - 1) * per_page
pagination = Pagination(page=page, total=len(users), per_page=per_page)
# Dividir los usuarios en páginas
users_page = users[offset: offset + per_page]
# Devolver los datos paginados
return jsonify({'users': users_page, 'pagination': pagination})
En este ejemplo, estamos obteniendo todos los usuarios de nuestra base de datos y luego configurando la paginación para mostrar solo 10 usuarios por página. Luego, dividimos los usuarios en páginas y devolvemos los datos paginados junto con el objeto de paginación.
Ordenamiento
La capacidad de ordenar los datos es esencial en cualquier aplicación que maneje numerosos datos. En Flask, podemos implementar la ordenación utilizando las funciones de Python sorted() y lambda.
@app.route('/users')
def users():
# Obtener todos los usuarios
users = User.query.all()
# Ordenar los usuarios por apellido ascendente
sorted_users = sorted(users, key=lambda x: x.last_name)
# Devolver los datos ordenados
return jsonify({'users': sorted_users})
En este ejemplo, estamos obteniendo todos los usuarios y ordenándolos en orden ascendente según su apellido utilizando la función sorted() y la función lambda que apunta al atributo last_name de cada usuario.
Implementar paginación y ordenamiento en nuestra API RESTful es una buena práctica que mejora la experiencia del usuario al manipular un gran volumen de datos. Con estos ejemplos simples, ya estamos listos para implementar paginación y ordenamiento en nuestra API utilizando Flask.
Conexión de la API REST con una base de datos utilizando SQLAlchemy
En el desarrollo de una API REST con Flask en Python, uno de los aspectos fundamentales es la conexión de la aplicación con una base de datos. Para lograr esto, se pueden utilizar diversas herramientas, entre las que destaca SQLAlchemy.
En mi experiencia, la utilización de SQLAlchemy ha sido crucial para construir una API REST robusta y escalable. Esta herramienta permite definir y manipular estructuras de base de datos de manera sencilla y eficiente, además de que ofrece una gran cantidad de funcionalidades avanzadas para trabajar con bases de datos complejas.
Para conectar la API REST con una base de datos utilizando SQLAlchemy, primero es necesario definir la estructura de la base de datos. Esto se puede hacer utilizando el lenguaje SQL o mediante el uso de ORM (Object-Relational Mapping) de SQLAlchemy. Personalmente, opté por el segundo método, ya que simplifica bastante la creación y manipulación de la estructura de la base de datos.
Una vez que se ha definido la estructura de la base de datos, es necesario crear la conexión entre la API REST y la base de datos. En SQLAlchemy, esto se hace mediante la creación de un objeto “engine”, que contiene la información necesaria para conectarse con la base de datos.
from flask import Flask
from sqlalchemy import create_engine
app = Flask(__name__)
engine = create_engine('mysql://usuario:contraseña@servidor/basedatos')
# Resto del código de la API REST
En este ejemplo, se ha creado un objeto “engine” que se conecta a una base de datos MySQL, utilizando un usuario y contraseña específicos. Es importante tener en cuenta que los detalles de conexión pueden variar dependiendo del tipo de base de datos y las configuraciones específicas.
Una vez que se ha creado la conexión, es posible utilizar SQLAlchemy para realizar consultas y manipulaciones en la base de datos. Por ejemplo, se puede crear un objeto “Session” que permita realizar consultas y modificaciones de manera más inteligente y eficiente:
from sqlalchemy.orm import sessionmaker
Session = sessionmaker(bind=engine)
session = Session()
result = session.query(User).filter_by(name='John').first()
En este ejemplo, se ha creado un objeto “Session” que utiliza el objeto “engine” previamente creado. Luego, se ha realizado una consulta para obtener el primer registro de la tabla “User” que tenga el nombre “John”. La respuesta de la consulta se guarda en la variable “result”.
La conexión de una API REST con una base de datos utilizando SQLAlchemy es algo fundamental para asegurar el correcto funcionamiento y escalabilidad de la aplicación. La herramienta ofrece una gran cantidad de funcionalidades avanzadas para trabajar con bases de datos complejas, lo que la convierte en una excelente opción para el desarrollo de aplicaciones web.
Despliegue de la API REST en un servidor de producción utilizando Docker y gunicorn
Una vez que hemos construido nuestra API REST con Flask en Python, el siguiente paso es desplegarla en un servidor de producción. En este caso, utilizaremos Docker y gunicorn para realizar el despliegue de nuestra aplicación.
Docker nos permite crear un contenedor con todas las dependencias necesarias para que nuestra aplicación funcione de forma aislada. De esta manera, podemos asegurarnos de que nuestra API REST funcione de manera estable y consistente en cualquier entorno en el que se despliegue.
Por otro lado, utilizaremos gunicorn como servidor web para nuestra aplicación Flask. Gunicorn es un servidor web que está diseñado específicamente para aplicaciones Python. Este servidor proporciona una forma rápida y fiable de manejar peticiones web entrantes y procesarlas con nuestra aplicación Flask.
Lo primero que necesitamos hacer es crear un archivo llamado Dockerfile en la raíz de nuestro proyecto. Este archivo contiene las instrucciones necesarias para que Docker cree un contenedor con nuestra aplicación. El contenido del file sería algo como esto:
FROM python:3.9-slim-buster
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
CMD ["gunicorn", "--bind", "0.0.0.0:8000", "app:app"]
En el archivo Dockerfile, estamos definiendo la imagen base de nuestro contenedor, instalar las dependencias necesarias, agregar nuestro código de la aplicación, y finalmente, iniciar el servidor con gunicorn.
Para construir el contenedor, ejecutamos el siguiente comando en nuestra terminal:
docker build -t my-api:latest .
Este comando construye la imagen de Docker utilizando el Dockerfile en la raíz de nuestro proyecto y lo etiqueta como my-api:latest. A continuación, podemos ejecutar el contenedor utilizando el siguiente comando:
docker run -p 8000:8000 my-api:latest
El comando anterior iniciará una instancia del contenedor y expondrá el puerto 8000 que está configurado en nuestro servidor web. Después de ejecutar el comando, deberíamos poder acceder a nuestra API REST a través del navegador utilizando la dirección IP del servidor y el puerto 8000.
En general, desplegar una aplicación Flask en un servidor de producción es una tarea que puede llevar tiempo y esfuerzo. Sin embargo, con herramientas como Docker y gunicorn, es posible crear un entorno totalmente aislado y seguro para nuestra aplicación, lo que garantiza que se ejecute de manera confiable y sin problemas. Por lo tanto, recomendamos a cualquier desarrollador utilizar estas herramientas para desplegar su próxima aplicación Flask.