Vamos começar conhecendo os principais recursos do FastAPI e seus casos de uso. Depois, vamos executar nosso primeiro aplicativo e testá-lo! Por fim, vamos aprender os detalhes de como dar suporte às operações GET e POST que incluem parâmetros de requisição e vamos construir e testar esses endpoints.

Por que FastAPI?

Primeira aplicação

FastAPI vs. Django

Operações GET

Olá, mundo

Olá, quem?

Operações POST

Modelo Pydantic

Operação POST em ação

Noções básicas de FastAPI

Vamos começar aprendendo como dar suporte às operações PUT e DELETE usando FastAPI. Em seguida, vamos aprender a lidar com diferentes tipos de erros e sempre retornar um código de status apropriado na resposta. Por último, veremos como usar async para permitir requisições concorrentes que suportam cargas de trabalho maiores.

Operações PUT e DELETE

Operação PUT em ação

Operação DELETE em ação

Tratando erros

Classificação de status codes

Tratando um erro do cliente

Usando async para trabalho concorrente

Quando devemos usar async?

Operação DELETE assíncrona

Tópicos avançados de FastAPI

Vamos começar aprendendo a escrever testes de sistema para validar endpoints individuais do FastAPI. Depois, vamos construir uma API CRUD completa em JSON para gerenciar ciclos de vida de objetos via HTTP. Por fim, vamos aprender a testar diferentes endpoints do aplicativo funcionando em conjunto com testes funcionais manuais.

Testes automatizados com FastAPI

Opções

Testes de unidade

Testes de sistema

Testes de unidade vs. testes 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}

Teste de sistema

Construindo uma API CRUD em JSON

Create

Read

Update

Operações HTTP e etapas do CRUD

Resposta de operação 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

Escrevendo um teste funcional manual

Testes funcionais

Testes de sistema vs. testes funcionais

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.")

Teste funcional

Encerramento

Criando e testando uma API CRUD em JSON

Este curso ensina você a criar aplicações web em nível de produção usando FastAPI, um framework Python popular para criar APIs. Você vai aprender a lidar com as quatro operações HTTP, definir esquemas de requisição e resposta, validar requisições de API e retornar os códigos de status HTTP apropriados. Também verá execução assíncrona para aumentar o desempenho e, ao final, você vai desenvolver uma API CRUD e testar fluxos com o módulo requests do Python. Voltado para programadores Python experientes, este curso oferece as habilidades para gerenciar dados com FastAPI, preparando você para construir pipelines robustos de gerenciamento de dados e de serving de modelos de ML.

<h2>Introdução ao FastAPI e suas aplicações</h2> As APIs são muito usadas pra gerenciar dados na web, e o FastAPI é uma nova estrutura web popular pra criar APIs com Python. Os engenheiros de dados e machine learning usam o FastAPI pra criar aplicativos que funcionam como transações e pipelines de dados sensíveis ao contexto na web.<br><br> <h2>Criando aplicativos web de nível profissional com FastAPI</h2> Neste curso, você vai aprender a criar aplicativos web de nível profissional usando suas habilidades em Python com a estrutura FastAPI. No final, você vai entender os principais casos de uso do FastAPI em relação a outras estruturas web Python. Você vai aprender a criar APIs usando os quatro tipos de operações HTTP e definir esquemas de solicitação e resposta. Além disso, você vai validar solicitações de API, responder com códigos e mensagens de status HTTP apropriados e executar código de forma assíncrona para melhorar o desempenho do aplicativo. Um projeto prático vai te ajudar a criar uma API CRUD (Create, Read, Update, Delete) clássica, testando fluxos de trabalho usando o módulo requests do Python.<br><br> <h2>Objetivos do curso e público-alvo</h2> Esse curso é feito pra quem já tem experiência em programação Python e quer criar aplicativos web que gerenciem dados usando FastAPI. Ao concluir este curso, você terá a base necessária para criar projetos FastAPI adequados para gerenciamento de dados de alto rendimento e pipelines de serviço de modelos de ML.

Introduction to APIs in Python

Introduction to Object-Oriented Programming in Python

Crie APIs robustas com FastAPI, dominando operações HTTP, validação e execução assíncrona.

API JSON CRUD completa

Introdução ao FastAPI

exercicio interativo prático