El mejor framework para construir una API en Python

Este es el segundo artículo de una serie dedicada al tema de las API.

Cada artículo cubre un tema diferente. Si está empezando a comprender cómo escribir su propia API, le resultará útil leerlo todo en orden. Si ya lo conoce y está interesado en un tema concreto, vaya directamente a él.

1. Explicación sencilla de la API
2. El mejor marco de trabajo para API (este artículo 👇)
3. Construir API con FastAPI (próximamente)
4. Construir API con ChatGPT (próximamente)
5. Herramientas para probar API (próximamente)
6. Gane dinero con la API (próximamente)

Vamos…

API frameworks

En el artículo anterior averiguamos qué es una API y cómo funciona, así que ahora vamos a ver cómo elegir el mejor marco de trabajo para APIs en Python. Para elegir una herramienta que le permita escribir APIs en Python de forma rápida y eficaz, debe tener en cuenta los siguientes aspectos:

• Tamaño del proyecto. Si su API formará parte de una aplicación web completa, lo mejor es elegir un marco de trabajo que le permita crear tanto la propia aplicación web como su parte API. Si todo lo que necesita es la API, cualquiera de los micro frameworks le servirá.

• Carga de trabajo. Suele estar directamente determinada por los requisitos de CPU y memoria del servidor. El parámetro más obvio es el número de peticiones cliente-servidor que el servidor puede manejar.

• Tiempo de asimilación. Por regla general, cuanto más potente es un marco de trabajo, más tiempo se necesita para aprenderlo. Si ya domina una herramienta, por supuesto, puede prescindir de este parámetro.

Un caso especial es uno sencillo, cuando todo lo que necesita es un cliente para recuperar datos de una API existente. Para crearlo puede utilizar embedded module o cualquiera de las bibliotecas populares, como httplib2 o la favorita de todos requests. Aunque no está directamente relacionado con el tema, les echaremos un vistazo para completar el cuadro.

Veamos ahora los mejores frameworks de API REST en Python que cuentan con soporte y desarrollo activos, además de ser populares entre los desarrolladores y ampliamente utilizados en la actualidad. Para su comodidad, los he dividido en tres categorías condicionales:

• Bibliotecas cliente
• Micro frameworks (conjunto mínimo de características)
• Full-stack frameworks (conjunto completo de funciones)

Empecemos por uno sencillo…

Bibliotecas cliente

Requests

Site: https://github.com/psf/requests

Type: Biblioteca de clientes

Requests es una biblioteca cliente HTTP muy popular en Python. Incluso la documentación oficial de Python la recomienda. Como su nombre indica, se utiliza para realizar peticiones a la API. La librería soporta todos los métodos HTTP y características avanzadas como autenticación, cookies de sesión, trabajo con SSL y muchas otras.

Trabajar con Requests es muy sencillo. He aquí un ejemplo de llamada a la API de Python cuando se utiliza el método GET para autorizarse en un sitio:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

>>> import requests
>>> URL = 'https://httpbin.org/basic-auth/user/pass'
>>> r = requests.get(URL, auth=('user', 'pass'))
>>> r.status_code
200
>>> r.headers['content-type']
'application/json; charset=utf8'
>>> r.encoding
'utf-8'
>>> r.text
'{"authenticated": true, ...'
>>> r.json()
{'authenticated': True, ...}

Aquí encontrará documentación sobre la biblioteca Requests detallada.

Faster Than Requests

Site: https://github.com/juancarlospaco/faster-than-requests/

Type: BibliotEca de clientes

Un paquete bastante interesante, que se está desarrollando activamente. Según el desarrollador, funciona más rápido que Requests :) Quizá se deba a que utiliza principalmente el lenguaje Nim. Hay una comparación de rendimiento en la página principal repository de GitHub. También se afirma que la biblioteca es mucho más compacta en términos de número de líneas de código.

Lo más práctico de esta biblioteca son las numerosas funciones de ayuda que van más allá de los métodos HTTP habituales. Dispone de varias funciones útiles para tareas como la búsqueda de URL, la descarga de recursos como archivos de imagen, o la fusión de peticiones a varias URL y la devolución de una única respuesta.

He aquí algunos ejemplos de peticiones estándar de la API de Python:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

import faster_than_requests as requests

# GET
requests.get("http://httpbin.org/get")

# POST
requests.post("http://httpbin.org/post", "Some Data Here")

# Download a file
requests.download("http://example.com/foo.jpg", "out.jpg")

# Multi-Threaded Web Scraper
requests.scraper(["http://foo.io", "http://bar.io"], threads=True)

# URL-to-SQLite Web Scraper
requests.scraper5("http://foo.io", sqlite_file_path="database.db")

# Regex-powered Web Scraper
requests.scraper6("http://python.org", "(www|http:|https:)+[^s]+[w]")

# CSS Selector Web Scraper
requests.scraper7("http://python.org", "body > div.someclass a#someid")

# WebSockets Binary/Text
requests.websocket_send("ws://echo.websocket.org", "data here")

PycURL

Site: http://pycurl.io/

Type: BibliotEca de clientes

PycURL no es más que un complemento de Python para la biblioteca libcurl, que se utiliza para transferir archivos a través de varios protocolos. Soporta HTTP, FTP, SMTP y muchos otros. Si le gustan las bibliotecas cURL o libcurl, puede que también le guste esta interfaz Python para la biblioteca nativa libcurl, escrita en C/C++.

Encontrará muchas cosas interesantes en el repositorio PycURL oficial en GitHub. Para más detalles sobre la biblioteca, lea también la documentación oficial.

A continuación se muestra un ejemplo de cómo realizar una llamada HTTP GET con PycURL.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

import pycurl
from io import BytesIO

buffer = BytesIO()
c = pycurl.Curl()
c.setopt(c.URL, 'http://pycurl.io/')
c.setopt(c.WRITEDATA, buffer)
c.perform()
c.close()
body = buffer.getvalue()
# El cuerpo es una cadena de bytes.
# Necesita conocer la codificación para poder enviarlo a un archivo de texto,
# por ejemplo, en la salida estándar.
print(body.decode('iso-8859-1'))

urllib3

Site: https://urllib3.readthedocs.io/

Type: BibliotEca de clientes

Esta biblioteca de Python tiene una clase especial para gestionar pools de conexiones con soporte para multihilo, carga de archivos, formularios, manejo de excepciones y mucho más. Tiene una interfaz amigable, buena documentación e incluso soporte incorporado para bibliotecas de terceros.

urllib3 es un cliente HTTP potente y fácil de usar para Python. La funcionalidad de la biblioteca permite organizar un trabajo rápido y fiable con casi cualquier fuente de información en Internet.

La mayor parte del ecosistema Python ya utiliza urllib3, por lo que quizá también le interese echar un vistazo a esta biblioteca.

Ejemplos de llamadas a la API de Python en la biblioteca urllib3:

1
2
3
4
5
6
7
8
9

>>> import urllib3
>>> http = urllib3.PoolManager(num_pools=2)
>>> resp = http.request('GET', 'http://yahoo.com/')
>>> resp = http.request('GET', 'http://google.com/')
>>> resp = http.request('GET', 'http://httpbin.org/robots.txt')
>>> resp.status
200
>>> resp.data
b"User-agent: *\nDisallow: /deny\n"

Micro frameworks

Flask

Site: https://flask.palletsprojects.com/

Type: Micro framework

El proyecto comenzó como una simple envoltura alrededor de Werkzeug y Jinja, y hoy se ha convertido en uno de los marcos más populares para el desarrollo de aplicaciones web en Python, incluyendo la creación de API. El repositorio del proyecto en GitHub cuenta ya con más de 60.000 estrellas. Flask hace que sea fácil empezar, obtiene sus primeros resultados rápidamente, y gradualmente escala su aplicación a cualquier nivel.

A lo largo de los años, Flask ha añadido muchas características que lo sitúan casi a la par de los frameworks full stack. Sin embargo, es su enfoque minimalista de la creación de aplicaciones web lo que lo convierte en la opción preferida de muchos desarrolladores.

Flask ofrece una gran variedad de opciones para lograr su objetivo y no le obliga a utilizar bibliotecas específicas ni a seguir una estructura de proyecto estrictamente definida. Usted mismo puede elegir las herramientas y bibliotecas que desea utilizar.

Hay muchas extensiones útiles desarrolladas y soportadas por la comunidad, lo que facilita añadir funcionalidad a su aplicación.

Así es como puede escribir una sencilla aplicación web “Hola Mundo” en Flask:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

from flask import Flask

app = Flask(__name__)

@app.route('/')
def hello_world():
    return 'Hello, World!'

if __name__ == '__main__':
    app.run()

Encontrará más información y documentación sobre Flask en la página web del proyecto, y una lista de recursos y plugins adicionales en este repositorio en GitHub.

También le recomiendo el tutorial oficial del propio Miguel Grinberg, la excelente serie de artículos en Hackers and Slackers, y la comunidad de usuarios en Reddit.

Tornado

Site: https://www.tornadoweb.org/

Type: Micro framework

Tornado es un framework y una biblioteca de redes asíncronas. También incluye un servidor HTTP y una interfaz de cliente, así como una interfaz WebSocket para la comunicación bidireccional con servidores que soporten WebSocket.

Tornado soporta todas las características básicas de middleware necesarias para manejar peticiones y respuestas HTTP, plantillas y enrutamiento.

También admite coroutines (rutas cooperativas), lo que lo convierte en una gran herramienta para crear backends de servidor con ciclos largos de recuperación de datos y conexiones persistentes, especialmente para WebSockets.

Un simple backend para la API en Tornado puede hacerse como sigue:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

import asyncio
import tornado.web

class MainHandler(tornado.web.RequestHandler):
    def get(self):
        self.write("Hello, world")

def make_app():
    return tornado.web.Application([
        (r"/", MainHandler),
    ])

async def main():
    app = make_app()
    app.listen(8888)
    await asyncio.Event().wait()

if __name__ == "__main__":
    asyncio.run(main())

Tornado existe desde hace mucho tiempo, pero algunas de sus características son un poco anticuadas en comparación con los marcos REST modernos. No obstante, es muy popular, ya que repository en GitHub tiene casi 21 mil estrellas.

FastAPI

Site: https://fastapi.tiangolo.com/

Type: Micro framework

FastAPI es uno de los marcos más recientes de Python. Según sus desarrolladores, es muy rápido, de alto rendimiento y admite una estructura de codificación compacta, lo que conduce a un desarrollo de aplicaciones muy rápido.

FastAPI se basa en las capacidades asyncio de Python, que se han estandarizado como una especificación ASGI para crear aplicaciones web asíncronas. FastAPI es casi tan potente como Flask y admite procedimientos incorporados para integrarse con bases de datos, realizar tareas en segundo plano, conectar middleware personalizado y mucho más.

Con más de 50.000 estrellas en repository en GitHub, FastAPI está ganando popularidad en la comunidad Python y está siendo desarrollado constantemente por un grupo de profesionales activos de más de 100 personas.

A continuación le mostramos cómo puede crear una API REST sencilla utilizando FastAPI:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
def read_root():
    return {"Hello": "World"}

@app.get("/items/{item_id}")
def read_item(item_id: int, q: str = None):
    return {"item_id": item_id, "q": q}

Documentación oficial: https://fastapi.tiangolo.com

Repositorio GitHub: https://github.com/tiangolo/fastapi

Sanic

Site: https://sanic.dev/en/

Type: Micro framework

Sanic es otro framework web Python basado en asyncio. Se trata de un marco muy ligero con soporte para todas las funciones básicas de aplicaciones HTTP y middleware.

Además, Sanic admite la posibilidad de escribir protocolos personalizados y componentes de middleware para personalizar el protocolo de solicitud y respuesta. Sanic tiene su propio servidor web incorporado para acelerar el desarrollo, y también se integra bien con Nginx para aplicaciones industriales.

A continuación le mostramos cómo escribir una API sencilla en Sanic:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

from sanic import Sanic
from sanic.response import json

app = Sanic()

@app.route('/')
async def test(request):
    return json({'hello': 'world'})

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=8000)

Para más información, consulte Repositorio Sanic en GitHub o Guía de inicio de Sanic.

Falcon

Site: https://falconframework.org/

Type: Micro framework

Falcon es un marco sencillo y robusto para construir backends de aplicaciones y microservicios a gran escala. Admite el estilo arquitectónico REST y funciona con servidores compatibles con WSGI o ASGI.

Falcon dispone de una interfaz orientada a objetos y basada en clases para definir los recursos de la API. Admite funciones básicas HTTP y de aplicaciones de middleware, incluido el procesamiento de protocolos HTTP, enrutamiento, gestión de medios, cookies y utilidades URI.

A continuación se explica cómo crear una API REST utilizando el enfoque orientado a objetos de Falcon:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

class QuoteResource:
    def on_get(self, req, resp):
        """Handles GET requests"""
        quote = {
            'quote': (
                "I've always been more interested in "
                "the future than in the past."
            ),
            'author': 'Grace Hopper'
        }
        resp.media = quote

api = falcon.API()
api.add_route('/quote', QuoteResource())

Puede encontrar más información en el repositorio de Falcon en GitHub. Para empezar a desarrollar en Falcon, se recomienda leer la documentación oficial del proyecto.

Bottle

Site: https://bottlepy.org/

Type: Micro framework

Bottle es un microframework muy ligero. Es muy pequeño en tamaño, se distribuye como sólo un archivo, y depende únicamente de la biblioteca estándar de Python.

Bottle es genial para:

• Prototipar ideas rápidamente
• Aprender cómo se construyen los frameworks
• Crear y ejecutar aplicaciones web personales sencillas

Al mismo tiempo, Bottle proporciona todos los componentes que necesita para crear un backend completo para una API REST que se base en enrutamiento y plantillas. Admite la mayoría de las funciones habituales relacionadas con HTTP, como cookies, cabeceras, metadatos y carga de archivos. También tiene un servidor HTTP incorporado.

Una aplicación rápida y sencilla en Bottle tiene este aspecto:

1
2
3
4
5
6
7

from bottle import route, run, template

@route('/hello/<name>')
def index(name):
    return template('<b>Hello {{name}}</b>!', name=name)

run(host='localhost', port=8080)

Para más información, consulte repositorio Botella en GitHub. En documentación oficial encontrará una guía de inicio rápido, detalles de configuración y una colección de artículos útiles.

Hug

Site: https://www.hug.rest/

Type: Micro framework

hug es en realidad un marco de trabajo API multi-interfaz. Ofrece una gran manera de crear API REST separando la lógica de negocio de la API de la propia interfaz, y asociando dependencias de versión.

Dado que hug se centra en la creación de API, sus capacidades se limitan estrictamente al procesamiento de E/S, el enrutamiento y las anotaciones de tipo. No obstante, admite la posibilidad de añadir extensiones.

Una de las características interesantes de hug es la capacidad de proporcionar la lógica de la API a través de CLI, HTTP, o una función local, lo que le permite utilizar hug como un módulo estándar de Python.

He aquí cómo escribir una API en hug:

1
2
3
4
5
6

import hug

@hug.get('/happy_birthday')
def happy_birthday(name, age:hug.types.number=1):
    """Says happy birthday to a user"""
    return "Happy {age} Birthday {name}!".format(**locals())

👉 Tenga en cuenta que al utilizar hug puede haber un problema si necesita preprocesar las peticiones que recibe. Dado que el cuerpo de la solicitud se pasa al hilo, sólo puede leerlo una vez.

Por lo tanto, si lee el cuerpo de la petición en un método que preprocesa peticiones, el hilo permanecerá vacío y hug no podrá obtener parámetros de entrada de él. El problema se resuelve creando un hilo adicional antes de leer los parámetros.

Encontrará más información en hug repositorio en GitHub, así como en hug documentación oficial.

Eve

Site: https://python-eve.org/

Type: Micro framework

Eve es un microframework para APIs construido sobre Flask. El objetivo de Eve es hacer que el desarrollo de API REST sea extremadamente rápido y sencillo. Por eso está construido sobre los principios de Flask, dejando de lado todos los componentes de aplicación web de Flask.

Eve soporta todas las plantillas de API REST más utilizadas, como operaciones CRUD, puntos finales de API personalizables, filtrado, ordenación, multipágina, formatos JSON/XML/JSONP.

También admite funciones avanzadas como autenticación, CORS, almacenamiento en caché, limitación de velocidad y mucho más. Eve también soporta la integración con bases de datos MongoDB y SQL.

Eve puede utilizar archivo de configuración en formato Python para definir los recursos y los puntos finales de la API. Así, la API REST puede construirse utilizando la sintaxis declarativa JSON.

Para más información, lea la Guía de puesta en marcha de Eve o consulte el repositorio de Eve GitHub.

Fullstack frameworks

Django

Site: https://www.djangoproject.com/

Type: Fullstack framework

Django es un framework web Python de pila completa. Es uno de los frameworks web más antiguos y populares, repositorio Django tiene casi 67 mil estrellas en GitHub.

El framework Django tiene un montón de características para crear aplicaciones web completas. Además de soportar toda la funcionalidad HTTP necesaria, incluyendo aplicaciones middleware, sus características incluyen muestras MVC, vistas de datos, manejo de bases de datos, formularios, plantillas, seguridad, almacenamiento en caché y mucho más.

Por supuesto, utilizar Django sólo para crear un backend API REST es claramente exagerado. Es por eso que usted puede utilizar un marco especial Django REST, que es un proyecto apoyado por la comunidad, para este propósito. Utiliza Django como motor base, proporcionando una interfaz más sencilla específica para el desarrollo de API REST.

Consulte el repositorio oficial de Django y/o el repositorio oficial de Django REST para obtener más información sobre cómo trabajar con ellos. Y en este enlace encontrará la Guía de inicio rápido de Django REST.

TurboGears

Site: https://turbogears.org/

Type: Fullstack framework

TurboGears es otro framework full-stack. La idea principal en su desarrollo fue permitir escalar el proyecto desde una aplicación sencilla (en un único archivo) hasta una aplicación full-stack. De este modo, TurboGears puede dar la sensación de trabajar con un microframe, pero también proporciona todas las herramientas necesarias para desarrollar una aplicación web en toda regla.

TurboGears está construido con el esquema MVC (Modelo-Vista-Controlador) como otros frameworks completos. Admite plantillas, gestión de páginas, autenticación y autorización, almacenamiento en caché y compatibilidad con varias bases de datos y migración de esquemas.

La versión más básica se crea de forma muy sencilla. Cree un archivo tgapp.py y declare un controlador en él:

1
2
3
4
5
6
7
8

class RootController(TGController):
    @expose()
    def index(self):
        return 'Hello World'

    @expose()
    def hello(self, person):
        return 'Hello %s' % person

Para que el controlador funcione, es necesario crear una aplicación:

1
2
3
4
5
6
7
8

from tg import MinimalApplicationConfigurator

config = MinimalApplicationConfigurator()
config.update_blueprint({
    'root_controller': RootController()
})

application = config.make_wsgi_app()

Por último, dé la orden para ejecutar esta aplicación:

1
2
3
4
5

from wsgiref.simple_server import make_server

print("Serving on port 8080...")
httpd = make_server('', 8080, application)
httpd.serve_forever()

A continuación, ejecute la aplicación con el comando python tgapp.py e iniciará el servidor en el puerto 8080. Abra su navegador, escriba la dirección http://localhost:8080 y verá el texto Hola, mundo.

Y si envía la consulta http://localhost:8080/hello?person=MyName, verá la respuesta Hola MiNombre.

Eso es todo.

Consulte el repositorio de TurboGears en GitHub para conocer mejor el framework. Y para empezar, estudie la documentación de TurgoGears.

web2py

Site: http://www.web2py.com/

Type: Fullstack framework

Web2py es un framework full-stack de código abierto escrito y programado en Python. Su principal objetivo es desarrollar aplicaciones web rápidas, escalables y seguras basadas en bases de datos.

En el núcleo de web2py se encuentran módulos para manejar HTTP y URLs. También tiene un programador incorporado para realizar tareas en segundo plano. Además, web2py tiene una capa de abstracción de base de datos que mapea objetos Python a objetos de base de datos como tablas, consultas y registros.

La capa de abstracción de la base de datos funciona conjuntamente con un conjunto de controladores que soportan muchas bases de datos populares, como SQLite, MySQL, PostgreSQL, Oracle, DB2, MSSQL, MongoDB y otras.

También tiene soporte completo para MVC, validación de formularios, seguridad, control de acceso y muchas otras utilidades.

web2py viene en paquetes binarios que usted ejecuta en su ordenador y luego, a través de la interfaz web, crea su aplicación o servicio web.

Para una mirada detallada en repositorio web2py en GitHub. El proyecto también cuenta con una excelente documentación en varios idiomas, tanto oficial como generada por la comunidad, con ejemplos y vídeos tutoriales.

Pyramid

Site: https://trypyramid.com/

Type: Fullstack framework

Pyramid es otro completo framework web de Python cuya idea básica es empezar con algo pequeño e ir creciendo hasta convertirse en un gran proyecto según las necesidades. Este enfoque permite a los desarrolladores comenzar con Pyramid como un micro-marco.

Además, Pyramid es lo suficientemente flexible como para expandirse y añadir nuevos componentes para manejar todas las tareas necesarias para construir una aplicación web a gran escala.

Pyramid incluye todas las características estándar del marco web, como el esquema MVC, el enrutamiento, las plantillas, la seguridad, las sesiones, las bases de datos y el registro. También tiene un servidor web incorporado llamado pserve, pero funciona perfectamente con Apache y Nginx para aplicaciones serias.

He aquí un ejemplo de un backend simple en Pyramid.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

from wsgiref.simple_server import make_server
from pyramid.config import Configurator
from pyramid.response import Response

def hello_world(request):
    return Response('Hello World!')

if __name__ == '__main__':
    with Configurator() as config:
        config.add_route('hello', '/')
        config.add_view(hello_world, route_name='hello')
        app = config.make_wsgi_app()
    server = make_server('0.0.0.0', 6543, app)
    server.serve_forever()

Como en casos anteriores, recomiendo leer el repositorio de Pyramid en GitHub, la Guía de inicio rápido de Pyramid y la documentación oficial de Pyramid.

Conclusión

El artículo es bastante largo y tiene que entender que es sólo un breve resumen de algunas de las soluciones más populares para desarrollar su API. Siempre puede consultar información más detallada y elegir el producto que más le guste para crear su propio proyecto único.

Y compartiré otro enlace que es bueno consultar. Se trata de una comparación de rendimiento de muchos frameworks para aplicaciones web que realizan tareas fundamentales como la serialización JSON, el acceso a bases de datos y el procesamiento de plantillas del lado del servidor.

Cada marco se ejecuta en una configuración realista. Los resultados se obtienen en instancias en la nube y en hardware físico. Las implementaciones de prueba fueron creadas en su mayoría por la comunidad, y todo el código fuente está disponible en repositorio GitHub.

En la próxima parte, veremos un ejemplo práctico de cómo escribir su API y luego documentarla adecuadamente.

Buena suerte 👍