Hola Mundo en FastAPI

▶

Finalmente, es momento de crear el "Hola Mundo" con FastApi; es decir, implementar lo mínimo necesario para poder ver algo por pantalla; quedamos en que, ya creamos nuestro ambiente virtual, instalar dependencias y proyecto en FastAPI.

Así que, creamos un archivo dentro del proyecto (la carpeta tasks):

api.py

Con el siguiente código:

api.py

from fastapi import FastAPI
app = FastAPI()
@app.get("/")
def hello_world():
    return {"hello": "world"}

En este primer ejemplo, lo primero que hacemos es cargar una clase que proporciona acceso al framework de FastAPI:

from fastapi import FastAPI

Con esta clase, creamos una instancia de FastApi:

app = FastAPI()

Lo cual nos da acceso a múltiples funcionalidades del framework, como lo es, crear las rutas de la aplicación.

Definimos una petición de tipo GET para la raíz y esto se hace mediante un decorador como el que podemos ver a continuación:

@app.get("/")

Por supuesto, podemos acceder a otros tipos de peticiones como POST, PUT, PATCH o DELETE indicando el método correspondiente el cual tiene su equivalente directo con el nombre de la petición a usar; es decir, para enviar una petición de tipo GET, usamos la función de get(), para enviar una petición de tipo POST, usamos la función de post().

Al igual que ocurre con otros frameworks web, cada petición es procesada mediante una función, en el ejemplo anterior, la petición de tipo GET para la raíz, es procesada mediante una función llamada hello_world() que lo único que hace es devolver un diccionario indicando el mensaje de "hola mundo":

@app.get("/")
def hello_world():
    return {"hello": "world"}

Con esto, tenemos nuestro primer ejemplo de hola mundo en FlastApi; pero, para poder ver este mensaje por pantalla, específicamente cualquier programa que permite procesar peticiones HTTP como lo es un navegador, tenemos que levantar el servidor asociado a la aplicación anterior y es aquí en donde usamos el servidor de uvicorn instalado anteriormente; para ello, desde la terminal y raíz del proyecto, usamos el siguiente comando:

$ uvicorn api:app --reload

Con el comando anterior, indicamos el nombre del archivo, que en este caso es el llamado api.py:

api:app

Y que el servidor se mantenga atento a los cambios; es decir, con la opción de:

--reload

El servidor se recargará cada vez que se realicen cambios en la aplicación.

Al ejecutar el comando anterior, veremos por la terminal:

INFO:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
INFO:     Started reloader process [15820] using StatReload
INFO:     Started server process [4024]
INFO:     Waiting for application startup.
INFO:     Application startup complete.
INFO:     127.0.0.1:58209 - "GET / HTTP/1.1" 200 OK
INFO:     127.0.0.1:58209 - "GET /favicon.ico HTTP/1.1" 404 Not Found
INFO:     127.0.0.1:58209 - "GET / HTTP/1.1" 200 OK

▶

Nos indica cual es la ruta en la cual la aplicación a sido levantada:

http://127.0.0.1:8000

Y desde esta ruta, que podemos ejecutar en el navegador, veremos en mensaje de:

http://127.0.0.1:8000

{
  "hello": "world"
}

En caso de que sea necesario, también puedes personalizar el puerto mediante la opción de port e indicas el puerto que quieras usar, en este ejemplo, el puerto 8001:

$ uvicorn api:app --port 8001

Y si quieres colocar también la opción de reload:

$ uvicorn api:app --port 8001 --reload

Y en la salida verás ahora que el servidor levando la aplicación en el puerto 8001

Uvicorn running on http://127.0.0.1:8001 (Press CTRL+C to quit)

Finalmente, la función anterior también puedes indicar el tipo de dato de retorno:

@app.get("/")
def hello_world() -> dict:
    return {"hello": "world"}

Es importante notar que se usa una petición de tipo GET, que es el típico tipo de petición empleada para consultar datos; y la única que podemos emplear directamente desde el navegador sin necesidad de emplear un formulario.

Parámetros en las rutas (path)

A nivel de las rutas también se pueden definir parámetros con los cuales interactúa el usuario final y lucen de la siguiente forma:

@app.get("/posts/{id}")

Como puedes ver, este esquema de rutas permite emplear parámetros dinámicos y con esto, poder suministrar datos a cada uno de los recursos de la API que estemos construyendo; en el ejemplo anterior, se indica que para la ruta se debe de suministrar un parámetro llamado id que luego es suministrado como un argumento a la función decorada; es decir:

@app.get("/posts/{id}")
def add(id: int):
    #TODO
    return {"POST ID": id}

En el ejemplo anterior, se debe de indicar un parámetro llamado "id" que debe ser de tipo entero el cual puede ser empleado (por ejemplo) para buscar por el identificador de un post que se quiere recuperar:

/post/123

Tipos de rutas

Existen distintos métodos HTTP que podemos usar para realizar peticiones al servidor; estos métodos no son más que un conjunto de verbos que se utilizan para realizar diferentes tipos de acciones; los métodos más comunes son GET, POST, PUT, PATCH y DELETE:

• GET: se utiliza para obtener información de un servidor web. La información se envía en la URL de la petición.
• POST: se utiliza para enviar información a un servidor web. La información se envía en el cuerpo de la petición.
• PUT: se utiliza para actualizar información en un servidor web. La información se envía en el cuerpo de la petición.
• PATCH: se utiliza para actualizar parcialmente información en un servidor web. La información se envía en el cuerpo de la petición.
• DELETE: se utiliza para eliminar información de un servidor web. La información se envía en la URL de la petición.

Todos estos métodos tienen su equivalente en FastApi; de momento hemos utilizado métodos de tipo GET, para obtener datos, pero, también es posible emplear otros:

@app.get(<URI>)
@app.post(<URI>)
@app.put(<URI>)
@app.patch(<URI>)
@app.delete(<URI>)

Como puedes ver, tenemos una función decoradora para cada tipo de método y tiene una relación directa con el tipo de petición HTTP; es decir, tenemos un método decorador put() para enviar peticiones de tipo PUT, y así para el resto.

Bibliotecas principales de FastApi

Para terminar esta introducción con FastAPI, es importante señalar que FastAPI se basa en dos bibliotecas principales de Python: Starlette, un framework web ASGI de bajo nivel (https://www.starlette.io/), y Pydantic, una biblioteca de validación (https://pydantic-docs.helpmanual.io/), del cual esta última biblioteca, la usaremos arduamente en las siguientes secciones.

Ambas librerías las puedes ver si haces un:

$ pip freeze

Sobre tu proyecto en FastApi.

El siguiente paso, aprende a generar datos de prueba desde la documentación de FastAPI.