Dependências globais e subdependências
Aplique dependências a toda uma aplicação ou roteador, encadeie subdependências e armazene em cache os resultados das dependências dentro de uma solicitação para criar aplicações FastAPI limpas e em camadas.
Dependências globais e subdependências é uma aula grátis de FastAPI Backend Development Bootcamp no CoddyKit. Esta é a aula 4 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 FastAPI Backend Development Bootcamp, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de FastAPI Backend Development Bootcamp inclui 4 aulas no total.
Partes desta aula ainda não foram traduzidas e aparecem em inglês.
Scaling Up Dependencies
You can attach a dependency to a single route, but real apps need to apply checks broadly. FastAPI supports dependencies at the app, router, and route levels, plus dependencies that depend on other dependencies.
App-Level Dependencies
Pass dependencies=[...] to the FastAPI constructor to run them for every request. Useful for global logging or API-key checks.
from fastapi import FastAPI, Depends
async def verify_key():
...
app = FastAPI(dependencies=[Depends(verify_key)])Router-Level Dependencies
Attach dependencies to an APIRouter so they apply to every route in that router but not the whole app.
from fastapi import APIRouter, Depends
admin = APIRouter(
prefix='/admin',
dependencies=[Depends(verify_admin)],
)Dependencies Without a Return
When you only need a side effect (like raising on failure), put the dependency in the dependencies list rather than a parameter. Its return value is ignored.
@app.get('/secure', dependencies=[Depends(verify_key)])
async def secure():
return {'ok': True}Sub-Dependencies
A dependency can itself depend on another dependency. FastAPI resolves the whole chain automatically.
def get_token(authorization: str = Header(None)):
return authorization
def get_user(token: str = Depends(get_token)):
return lookup_user(token)
@app.get('/me')
async def me(user = Depends(get_user)):
return userWhy Layer Dependencies
Sub-dependencies let you compose small, single-purpose pieces: parse the token, then resolve the user, then check permissions. Each layer is reusable and independently testable.
Dependency Caching
Within a single request, FastAPI caches each dependency by default. If two dependencies both need get_user, it runs only once. Disable with Depends(fn, use_cache=False).
@app.get('/data')
async def data(
a = Depends(get_user),
b = Depends(get_user), # reuses cached result
):
return a is bModeling the Resolution Chain
The resolver walks dependencies depth-first and caches by function. Here is a simplified version in plain Python.
cache = {}
calls = []
def resolve(name):
if name in cache:
return cache[name]
calls.append(name)
cache[name] = name + '_value'
return cache[name]
resolve('get_user'); resolve('get_user'); resolve('get_token')
print(calls)Combining Levels
Precedence flows from broad to narrow: app dependencies run first, then router, then route. A request to a router route runs all three layers in order.
Overriding for Tests
Swap any dependency in tests with app.dependency_overrides to inject fakes without touching production code.
app.dependency_overrides[get_user] = lambda: {'id': 1, 'name': 'Test'}Best Practices
Keep dependencies focused:
- One responsibility per dependency.
- Use app/router level for cross-cutting concerns.
- Rely on caching; only disable it when you truly need fresh evaluation.
Quick Check
Two parameters in the same route both use Depends(get_user) with default settings. How many times does get_user run for one request?
Recap
You leveled up dependency injection:
- Applied dependencies at app, router, and route scope.
- Used side-effect-only dependencies in the
dependencieslist. - Chained sub-dependencies and relied on per-request caching.
- Overrode dependencies for testing.
Perguntas Frequentes
A aula “Dependências globais e subdependências” é grátis?
Sim — o texto completo de “Dependências globais e subdependências” é 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 FastAPI Backend Development Bootcamp, atualize para CoddyKit PRO. O curso de FastAPI Backend Development Bootcamp inclui 4 aulas no total.
O que vou aprender em “Dependências globais e subdependências”?
Aplique dependências a toda uma aplicação ou roteador, encadeie subdependências e armazene em cache os resultados das dependências dentro de uma solicitação para criar aplicações FastAPI limpas e em… Você pratica FastAPI Backend Development Bootcamp 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 FastAPI Backend Development Bootcamp?
Nenhuma experiência prévia é necessária. FastAPI Backend Development Bootcamp 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 4 de 4.
Quanto tempo leva a aula “Dependências globais e subdependências”?
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 FastAPI Backend Development Bootcamp?
Sim. Cada aula de FastAPI Backend Development Bootcamp 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
- Compreendendo as dependências no FastAPI
- Injetando dependências comuns
- Dependências baseadas em classes e com yield
- Dependências globais e subdependências