Python Academy · Aula

Configuração de projeto FastAPI e primeiro endpoint

Instale FastAPI, crie um projeto e escreva seu primeiro endpoint GET.

Configuração de projeto FastAPI e primeiro endpoint é uma aula grátis de Python Academy no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Python Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Python Academy inclui 4 aulas no total.

O que é FastAPI?

FastAPI é uma estrutura web moderna do Python para criar APIs REST. Ela fornece documentação OpenAPI automática, modelos de solicitação/resposta com verificação de tipos por meio do Pydantic e desempenho nativo assíncrono.

# pip install fastapi uvicorn
from fastapi import FastAPI

app = FastAPI()

@app.get("/")
def root():
    return {"message": "Hello, FastAPI"}

Execução do servidor

Execute com uvicorn. A opção --reload reinicia automaticamente quando o código é alterado durante o desenvolvimento.

# main.py
from fastapi import FastAPI
app = FastAPI()

@app.get("/health")
def health(): return {"status": "ok"}

# Terminal:
# uvicorn main:app --reload
# → http://127.0.0.1:8000
# → http://127.0.0.1:8000/docs  (Swagger UI)

Métodos HTTP

Decore as funções de rota com @app.get, @app.post, @app.put, @app.delete ou @app.patch.

from fastapi import FastAPI
app = FastAPI()

@app.get("/items")
def list_items(): return []

@app.post("/items")
def create_item(): return {"id": 1}

@app.delete("/items/{item_id}")
def delete_item(item_id: int): return {"deleted": item_id}

Parâmetros de caminho

Declare os parâmetros de caminho na cadeia da rota com {name} e como argumentos da função com anotações de tipo.

from fastapi import FastAPI
app = FastAPI()

@app.get("/users/{user_id}")
def get_user(user_id: int):
    return {"user_id": user_id, "name": "Alice"}

# GET /users/42  → {"user_id": 42, "name": "Alice"}

Parâmetros de consulta

Os parâmetros da função que não estão no caminho se tornam parâmetros de consulta.

from fastapi import FastAPI
app = FastAPI()

@app.get("/items")
def list_items(skip: int = 0, limit: int = 10, q: str | None = None):
    return {"skip": skip, "limit": limit, "q": q}

# GET /items?skip=5&limit=20&q=search

Corpo de solicitação com Pydantic

Use um BaseModel do Pydantic como tipo do parâmetro para declarar e validar um corpo de solicitação JSON.

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class Item(BaseModel):
    name: str
    price: float
    in_stock: bool = True

@app.post("/items")
def create_item(item: Item):
    return {"received": item.model_dump()}

Erros de validação do Pydantic

Se o corpo da solicitação não corresponder ao esquema, o FastAPI retornará automaticamente o erro 422 Entidade não processável com uma mensagem de erro detalhada.

# POST /items with body {"name": 123}
# → HTTP 422 Unprocessable Entity
# {
#   "detail": [
#     {
#       "type": "string_type",
#       "loc": ["body","name"],
#       "msg": "Input should be a valid string"
#     }
#   ]
# }

Modelos de resposta

Use response_model= para declarar o que o ponto de acesso retorna. O FastAPI valida a resposta e filtra os campos extras.

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class UserOut(BaseModel):
    id: int
    name: str

@app.get("/users/{uid}", response_model=UserOut)
def get_user(uid: int):
    return {"id": uid, "name": "Alice", "password": "secret"}  # password filtered out

Códigos de status

Defina o código de status de sucesso padrão com status_code=. Importe códigos comuns de fastapi.status.

from fastapi import FastAPI, status
app = FastAPI()

@app.post("/items", status_code=status.HTTP_201_CREATED)
def create_item():
    return {"id": 1}

# HTTP 201 Created is returned on success

HTTPException

Lance HTTPException para retornar uma resposta de erro com um código de status personalizado e uma mensagem detalhada.

from fastapi import FastAPI, HTTPException
app = FastAPI()

fake_db = {1: "Alice"}

@app.get("/users/{uid}")
def get_user(uid: int):
    if uid not in fake_db:
        raise HTTPException(status_code=404, detail="User not found")
    return {"name": fake_db[uid]}

Documentação automática

O FastAPI gera automaticamente a Swagger UI em /docs e a ReDoc em /redoc a partir das anotações das suas rotas.

# After starting with uvicorn:
# http://localhost:8000/docs     — Swagger UI (try the API live)
# http://localhost:8000/redoc    — ReDoc (clean docs view)
# http://localhost:8000/openapi.json  — raw OpenAPI schema

Verificação rápida

Como declarar um parâmetro obrigatório de corpo de solicitação JSON no FastAPI?

Recapitulação

As rotas do FastAPI são funções decoradas: parâmetros de caminho na URL, parâmetros de consulta como argumentos tipados e corpos de solicitação como modelos Pydantic. Lance HTTPException para erros. A Swagger UI é gerada automaticamente em /docs.

Perguntas Frequentes

A aula “Configuração de projeto FastAPI e primeiro endpoint” é grátis?

Sim — o texto completo de “Configuração de projeto FastAPI e primeiro endpoint” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Python Academy, atualize para CoddyKit PRO. O curso de Python Academy inclui 4 aulas no total.

O que vou aprender em “Configuração de projeto FastAPI e primeiro endpoint”?

Instale FastAPI, crie um projeto e escreva seu primeiro endpoint GET. Você pratica Python Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Python Academy?

Nenhuma experiência prévia é necessária. Python Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.

Quanto tempo leva a aula “Configuração de projeto FastAPI e primeiro endpoint”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Python Academy?

Sim. Cada aula de Python Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

Configuração de projeto FastAPI e primeiro endpoint
Parâmetros de caminho, parâmetros de consulta e corpos de requisição
Injeção de dependências e autenticação
Endpoints assíncronos e integração com banco de dados

← Voltar para Python Academy