Empezaremos con las características clave de FastAPI y sus casos de uso principales. Luego ejecutaremos nuestra primera aplicación y la probaremos. Por último, veremos en detalle cómo dar soporte a operaciones GET y POST que incluyen parámetros de solicitud, y construiremos y probaremos esos endpoints.

¿Por qué FastAPI?

Primera aplicación

FastAPI vs. Django

Operaciones GET

Hola mundo

¿Hola quién?

Operaciones POST

Modelo Pydantic

Operación POST en acción

Conceptos básicos de FastAPI

Comenzaremos aprendiendo a dar soporte a las operaciones PUT y DELETE con FastAPI. Después veremos cómo manejar distintos tipos de errores y devolver siempre un código de estado apropiado en la respuesta. Por último, aprenderemos a usar async para habilitar solicitudes concurrentes que soporten mayores cargas de trabajo.

Operaciones PUT y DELETE

Operación PUT en acción

Operación DELETE en acción

Gestión de errores

Clasificación de códigos de estado

Gestionar un error del cliente

Usar async para trabajo concurrente

¿Cuándo deberíamos usar async?

Operación DELETE asíncrona

Temas avanzados de FastAPI

Empezaremos aprendiendo a escribir pruebas de sistema para validar endpoints individuales de FastAPI. Después construiremos una API JSON CRUD completa para gestionar ciclos de vida de objetos sobre HTTP. Por último, aprenderemos a probar distintos endpoints de la aplicación trabajando juntos mediante pruebas funcionales manuales.

Pruebas automatizadas con FastAPI

Opciones

Pruebas unitarias

Pruebas de sistema

Pruebas unitarias vs. pruebas de sistema

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from typing import Optional

# define model Item
class Item(BaseModel):
    name: str
    quantity: Optional[int] = 0

app = FastAPI()

items = {"scissors": Item(name="scissors", quantity=100)}


@app.get("/items")
def read(name: str):
    if name not in items:
        raise HTTPException(status_code=404, detail="Item not found")
    return items[name]

# Import TestClient
from fastapi.testclient import ____
from main import app

# Create test client with application context
client = TestClient(____)

def test_main():
    response = client.get("/items?name=scissors")
    assert response.status_code == 200
    assert response.json() == {"name": "scissors",
                               "quantity": ____}

# Import TestClient
from fastapi.testclient import TestClient
from main import app

# Create test client with application context
client = TestClient(app)

def test_main():
    response = client.get("/items?name=scissors")
    assert response.status_code == 200
    assert response.json() == {"name": "scissors",
                               "quantity": 100}

Prueba de sistema

Crear una API JSON CRUD

Create

Read

Update

Operaciones HTTP y pasos CRUD

Respuesta a la operación DELETE

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from typing import Optional

# define model Item
class Item(BaseModel):
    name: str
    quantity: Optional[int] = 0

app = FastAPI()

items = {}


@app.____("/items")
def create(item: Item):
    name = item.name
    if name in items:
        raise HTTPException(status_code=409, detail="Item exists")
    items[name] = item
    return {"message": f"Added {name} to items."}
  
@app.____("/items")
def read(name: str):
    if name not in items:
        raise HTTPException(status_code=____, detail="Item not found")
    return items[name]  
  
@app.____("/items")
def update(item: Item):
    name = item.name
    if name not in items:
        raise HTTPException(status_code=____, detail="Item not found")
    items[name] = item
    return {"message": f"Updated {name}."}
  
@app.delete("/items")
def delete(item: Item):
    name = item.name
    if name not in items:
        raise HTTPException(status_code=____, detail="Item not found")
    del items[name]
    return {"message": f"Deleted {name}."}

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from typing import Optional

# define model Item
class Item(BaseModel):
    name: str
    quantity: Optional[int] = 0

app = FastAPI()

items = {}


@app.post("/items")
def create(item: Item):
    name = item.name
    if name in items:
        raise HTTPException(status_code=409, detail="Item exists")
    items[name] = item
    return {"message": f"Added {name} to items."}
  
@app.get("/items")
def read(name: str):
    if name not in items:
        raise HTTPException(status_code=404, detail="Item not found")
    return items[name]  
  
@app.put("/items")
def update(item: Item):
    name = item.name
    if name not in items:
        raise HTTPException(status_code=404, detail="Item not found")
    items[name] = item
    return {"message": f"Updated {name}."}
  
@app.delete("/items")
def delete(item: Item):
    name = item.name
    if name not in items:
        raise HTTPException(status_code=404, detail="Item not found")
    del items[name]
    return {"message": f"Deleted {name}."}

API JSON CRUD completa

Escribir una prueba funcional manual

Pruebas funcionales

Pruebas de sistema vs. pruebas funcionales

import requests

ENDPOINT = "http://localhost:8000/items"

# Create item "rock" without providing quantity
r = requests.post(ENDPOINT, json={"name": "rock"})
assert r.status_code == ____
assert r.json()["message"] == "Added rock to items."

# Verify that item "rock" has quantity 0
r = requests.get(ENDPOINT + "?____=____")
assert r.status_code == 200
assert r.json()["quantity"] == 0

# Update item "rock" with quantity 100
r = requests.put(ENDPOINT, json={"name": "rock", "quantity": 100})
assert r.status_code == 200
assert r.json()["message"] == "Updated rock."

# Verify that item "rock" has quantity 100
r = requests.get(ENDPOINT + "?name=rock")
assert r.status_code == 200
assert r.json()["quantity"] == ____

# Delete item "rock"
r = requests.delete(ENDPOINT, json={____: ____})
assert r.status_code == 200
assert r.json()["message"] == "Deleted rock."

# Verify that item "rock" does not exist
r = requests.get(ENDPOINT + "?name=rock")
assert r.status_code == ____

print("Test complete.")

import requests

ENDPOINT = "http://localhost:8000/items"

# Create item "rock" without providing quantity
r = requests.post(ENDPOINT, json={"name": "rock"})
assert r.status_code == 200
assert r.json()["message"] == "Added rock to items."

# Verify that item "rock" has quantity 0
r = requests.get(ENDPOINT + "?name=rock")
assert r.status_code == 200
assert r.json()["quantity"] == 0

# Update item "rock" with quantity 100
r = requests.put(ENDPOINT, json={"name": "rock", "quantity": 100})
assert r.status_code == 200
assert r.json()["message"] == "Updated rock."

# Verify that item "rock" has quantity 100
r = requests.get(ENDPOINT + "?name=rock")
assert r.status_code == 200
assert r.json()["quantity"] == 100

# Delete item "rock"
r = requests.delete(ENDPOINT, json={"name": "rock"})
assert r.status_code == 200
assert r.json()["message"] == "Deleted rock."

# Verify that item "rock" does not exist
r = requests.get(ENDPOINT + "?name=rock")
assert r.status_code == 404

print("Test complete.")

Prueba funcional

Resumen

Creación y prueba de una API JSON CRUD

Este curso te enseña a crear aplicaciones web listas para producción con FastAPI, un popular framework de Python para crear APIs. Aprenderás a manejar las cuatro operaciones HTTP, definir esquemas de solicitud y respuesta, validar peticiones a la API y devolver los códigos de estado HTTP adecuados. También verás cómo ejecutar código asíncrono para mejorar el rendimiento y, al final, desarrollarás una API CRUD y probarás flujos de trabajo con el módulo requests de Python. Diseñado para programadores con experiencia en Python, este curso te proporciona las habilidades para gestionar datos con FastAPI y te prepara para crear canalizaciones robustas de gestión de datos y despliegue de modelos de ML.

<h2>Introducción a FastAPI y sus aplicaciones</h2> Las API se utilizan habitualmente para gestionar datos en la web, y FastAPI es un nuevo y popular marco web para crear API con Python. Los ingenieros de datos y machine learning utilizan FastAPI para crear aplicaciones que sirven como transacciones y canalizaciones de datos sensibles al contexto en la web.<br><br> <h2>Creación de aplicaciones web de nivel profesional con FastAPI</h2> En este curso, aprenderás a crear aplicaciones web de nivel profesional aprovechando tus conocimientos de Python con el marco FastAPI. Al final, comprenderás los casos de uso principales de FastAPI en relación con otros marcos web de Python. Aprenderás a crear API utilizando los cuatro tipos de operaciones HTTP y a definir esquemas de solicitud y respuesta. Además, validarás las solicitudes de API, responderás con los códigos de estado HTTP y los mensajes adecuados, y ejecutarás código de forma asíncrona para mejorar el rendimiento de la aplicación. Un proyecto práctico te guiará a través de la creación de una API CRUD (Crear, Leer, Actualizar, Eliminar) clásica, probando flujos de trabajo utilizando el módulo de solicitudes de Python.<br><br> <h2>Objetivos del curso y público objetivo</h2> Este curso está diseñado para programadores Python con experiencia que desean crear aplicaciones web que gestionen datos utilizando FastAPI. Al completar este curso, tendrás los fundamentos necesarios para crear proyectos FastAPI adecuados para la gestión de datos de alto rendimiento y los procesos de servicio de modelos de aprendizaje automático.

Introduction to APIs in Python

Introduction to Object-Oriented Programming in Python

Crea APIs robustas con FastAPI, dominando operaciones HTTP, validación y ejecución asíncrona.

Operaciones HTTP y pasos CRUD

Introducción a FastAPI

ejercicio interactivo práctico