Python Academy · Aula

Injeção de dependências e autenticação

Use o sistema de DI do FastAPI para lógica compartilhada e autenticação baseada em JWT.

Injeção de dependências e autenticação é uma aula grátis de Python Academy no CoddyKit. Esta é a aula 3 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 é injeção de dependência?

O Depends() do FastAPI permite declarar lógica compartilhada (sessões de banco de dados, verificações de autenticação, configuração) que é injetada automaticamente nos manipuladores de rotas.

from fastapi import FastAPI, Depends
app = FastAPI()

def get_db():
    db = connect_db()
    try: yield db
    finally: db.close()

@app.get("/users")
def list_users(db = Depends(get_db)):
    return db.query_all("users")

Funções de dependência

Uma dependência pode ser qualquer objeto chamável. Ela pode ser uma função, uma classe ou outra função que use dependências.

from fastapi import Depends, FastAPI
app = FastAPI()

def common_params(skip: int = 0, limit: int = 10):
    return {"skip": skip, "limit": limit}

@app.get("/items")
def list_items(params: dict = Depends(common_params)):
    return params

@app.get("/users")
def list_users(params: dict = Depends(common_params)):
    return params

Dependências de classe

Use uma classe como dependência para agrupar configurações relacionadas. A classe é chamada com os argumentos de seu __init__ injetados.

from fastapi import Depends, FastAPI, Query
app = FastAPI()

class Pagination:
    def __init__(self, page: int = Query(1,ge=1), size: int = Query(10,ge=1,le=100)):
        self.page = page
        self.size = size
        self.offset = (page - 1) * size

@app.get("/items")
def list_items(pag: Pagination = Depends()):
    return {"offset": pag.offset, "size": pag.size}

OAuth2 Password Bearer

Use OAuth2PasswordBearer para ler um token Bearer do cabeçalho Authorization.

from fastapi import FastAPI, Depends
from fastapi.security import OAuth2PasswordBearer
app = FastAPI()

oauth2 = OAuth2PasswordBearer(tokenUrl="/token")

@app.get("/me")
def me(token: str = Depends(oauth2)):
    return {"token": token}   # validate token here

Tokens JWT

Crie e verifique tokens JWT com python-jose (ou pyjwt). Retorne um token no login e verifique-o em todas as rotas protegidas.

# pip install python-jose passlib
from jose import jwt, JWTError

SECRET_KEY = "change-me"
ALGORITHM = "HS256"

def create_token(data: dict) -> str:
    return jwt.encode(data, SECRET_KEY, algorithm=ALGORITHM)

def verify_token(token: str) -> dict:
    return jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])

Dependência do usuário atual

Crie uma dependência get_current_user que verifica o JWT e retorna o usuário autenticado.

from fastapi import Depends, HTTPException
from fastapi.security import OAuth2PasswordBearer
from jose import jwt, JWTError

oauth2 = OAuth2PasswordBearer(tokenUrl="/token")

def get_current_user(token: str = Depends(oauth2)):
    try:
        payload = jwt.decode(token, SECRET_KEY, algorithms=["HS256"])
        return payload["sub"]
    except JWTError:
        raise HTTPException(status_code=401, detail="Invalid token")

# @app.get("/me")
# def me(user=Depends(get_current_user)): return user

Hash de senhas

Nunca armazene senhas em texto simples. Use passlib para gerar o hash com bcrypt.

from passlib.context import CryptContext

pwd_ctx = CryptContext(schemes=["bcrypt"], deprecated="auto")

def hash_pw(plain: str) -> str:
    return pwd_ctx.hash(plain)

def verify_pw(plain: str, hashed: str) -> bool:
    return pwd_ctx.verify(plain, hashed)

Ponto de acesso de token

Implemente POST /token para aceitar credenciais de formulário, verificar a senha e retornar um JWT.

from fastapi import FastAPI, Depends, HTTPException
from fastapi.security import OAuth2PasswordRequestForm
app = FastAPI()

@app.post("/token")
def login(form: OAuth2PasswordRequestForm = Depends()):
    user = get_user_by_username(form.username)
    if not user or not verify_pw(form.password, user.hashed_pw):
        raise HTTPException(status_code=401, detail="Bad credentials")
    token = create_token({"sub": form.username})
    return {"access_token": token, "token_type": "bearer"}

Autenticação com chave de API

Em casos mais simples, valide uma chave de API de um cabeçalho ou parâmetro de consulta.

from fastapi import Depends, HTTPException, Security
from fastapi.security import APIKeyHeader

API_KEY_HEADER = APIKeyHeader(name="X-API-Key")

def require_api_key(key: str = Security(API_KEY_HEADER)):
    if key != "secret-key":
        raise HTTPException(status_code=403, detail="Forbidden")
    return key

Controle de acesso baseado em funções

Adicione permissões à autenticação incluindo verificações de função nas dependências.

from fastapi import Depends, HTTPException

def require_admin(user=Depends(get_current_user)):
    if user.get("role") != "admin":
        raise HTTPException(status_code=403, detail="Admins only")
    return user

# @app.delete("/users/{uid}")
# def delete_user(uid: int, admin=Depends(require_admin)):

Cache de dependências

Por padrão, uma dependência é chamada uma vez por solicitação e seu resultado é compartilhado entre todas as rotas que a utilizam nessa solicitação.

# The same db session object is shared:
@app.get("/summary")
def summary(
    db = Depends(get_db),      # db resolved once
    stats = Depends(get_stats) # get_stats also uses get_db — same db instance
): ...

Verificação rápida

O que Depends() faz no FastAPI?

Revisão

Use Depends(func) para injetar lógica compartilhada. Implemente a autenticação com OAuth2PasswordBearer, tokens JWT e uma dependência get_current_user. Calcule o resumo criptográfico das senhas com passlib/bcrypt. Adicione verificações de permissões como dependências adicionais.

Perguntas Frequentes

A aula “Injeção de dependências e autenticação” é grátis?

Sim — o texto completo de “Injeção de dependências e autenticação” é 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 “Injeção de dependências e autenticação”?

Use o sistema de DI do FastAPI para lógica compartilhada e autenticação baseada em JWT. 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 3 de 4.

Quanto tempo leva a aula “Injeção de dependências e autenticação”?

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