FastAPI Backend Development Bootcamp · Aula

FastAPI e operações assíncronas

Compreenda como o FastAPI lida naturalmente com funções assíncronas e como escrever código eficiente e não bloqueante.

FastAPI e operações assíncronas é uma aula grátis de FastAPI Backend Development Bootcamp no CoddyKit. Esta é a aula 2 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.

FastAPI's Async Foundation

FastAPI is built for speed! It leverages Python's asynchronous features to handle many requests concurrently, especially I/O-bound tasks.

This means your API can stay responsive even when waiting for external resources like databases or other APIs.

Sync vs. Async Endpoints

In FastAPI, you can define two main types of endpoint functions:

Synchronous (def): These functions block the event loop while they run. If one request takes long, others might wait.
Asynchronous (async def): These functions can 'pause' and let other tasks run while they await an operation (like reading from a database), making your API non-blocking.

Simple Synchronous Endpoint

Here's a standard synchronous endpoint. While simple, if time.sleep() were a real, slow database call, it would block other requests until it completes.

Try running it and observe the delay if you try to make multiple requests quickly.

from fastapi import FastAPI
import uvicorn
import time

app = FastAPI()

@app.get("/sync_hello")
def sync_hello():
    time.sleep(2) # Simulate a blocking I/O operation
    return {"message": "Hello from sync endpoint!"}

if __name__ == "__main__":
    uvicorn.run(app, host="0.0.0.0", port=8000)

Defining Asynchronous Endpoints

To make your endpoint non-blocking, use async def. This tells FastAPI (and Python) that this function can be suspended and resumed.

Inside an async def function, you use the await keyword to wait for other asynchronous operations to complete without blocking the entire application.

Your First Async Endpoint

This example uses asyncio.sleep(), which is an asynchronous sleep function. Notice the await keyword before it.

This allows FastAPI to handle other requests while this one 'sleeps', making the server more responsive.

from fastapi import FastAPI
import uvicorn
import asyncio

app = FastAPI()

@app.get("/async_hello")
async def async_hello():
    await asyncio.sleep(2) # Simulate non-blocking I/O
    return {"message": "Hello from async endpoint!"}

if __name__ == "__main__":
    uvicorn.run(app, host="0.0.0.0", port=8000)

When to Go Async

async def shines for I/O-bound operations. These are tasks that spend most of their time waiting for something else to happen, such as:

Making requests to external APIs (e.g., httpx).
Querying a database (e.g., asyncpg, SQLModel).
Reading/writing files from disk.
Network communication.

For CPU-bound tasks (heavy calculations), async def doesn't speed up the task itself, but it can help keep the server responsive.

Interacting with Async Libraries

When your FastAPI async def endpoint needs to interact with another asynchronous library (like an async HTTP client or an async database driver), you must use await.

Failing to use await will result in the awaitable object being returned directly, not its resolved result, which is usually not what you want!

Conceptual Async API Call

Imagine fetching data from another service. An async HTTP client allows this without blocking. Here's how it conceptually looks within an async def endpoint:

We simulate network latency with asyncio.sleep to show the non-blocking nature.

from fastapi import FastAPI
import uvicorn
import asyncio

app = FastAPI()

@app.get("/fetch_data")
async def fetch_external_data():
    # In a real app, you'd use an async HTTP client like 'httpx'
    # async with httpx.AsyncClient() as client:
    #     response = await client.get("https://api.example.com/data")
    #     data = response.json()

    await asyncio.sleep(1) # Simulate network latency
    return {"data": "Fetched async data!"}

if __name__ == "__main__":
    uvicorn.run(app, host="0.0.0.0", port=8000)

Uvicorn: The Async Engine

FastAPI relies on an ASGI server like Uvicorn. Uvicorn is what actually runs your async def functions efficiently.

It manages the Python event loop, which orchestrates when different asynchronous tasks get to run.
When an await is encountered, Uvicorn can switch to another ready task, making your API highly concurrent.

This 'context switching' is what allows FastAPI to handle many requests without waiting for each one to finish entirely.

Quick Check: Async Use

You are building a FastAPI endpoint that needs to fetch data from a slow external API (an I/O-bound task). Which of the following is the best way to define this endpoint to ensure your FastAPI application remains responsive?

Recap: Async FastAPI

We've explored how FastAPI harnesses Python's asynchronous features:

Use async def for endpoint functions that perform I/O-bound operations.
Use await when calling other asynchronous functions or libraries within an async def.
This non-blocking approach, powered by Uvicorn and the event loop, allows your FastAPI application to handle many concurrent requests efficiently, leading to highly responsive APIs.

Next, we'll look at how to offload truly long-running or CPU-bound tasks to background processes!

Perguntas Frequentes

A aula “FastAPI e operações assíncronas” é grátis?

Sim — o texto completo de “FastAPI e operações assíncronas” é 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 “FastAPI e operações assíncronas”?

Compreenda como o FastAPI lida naturalmente com funções assíncronas e como escrever código eficiente e não bloqueante. 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 2 de 4.

Quanto tempo leva a aula “FastAPI e operações assíncronas”?

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

Revisão de Async/Await em Python
FastAPI e operações assíncronas
Executando tarefas em segundo plano
WebSockets para comunicação em tempo real

← Voltar para FastAPI Backend Development Bootcamp