antonino, Autor em Área de Trampo

Servidor Assíncrono em Python

22/04/202622/04/2026 Por antonino

– Web
1 – Backend (servidor)
1.1 – Sincrono (Django, Flask, FastAPI)
1.2 – Assincrono (FastAPI, Sanic, Aiohttp)
1.3 – WebSockets (Socket.IO, WebSockets)

LEGENDA

Nivel_1

Nivel_2

Nivel_3

Programação assíncrona permite múltiplas tarefas simultâneas. Ela não espera uma operação terminar para iniciar outra. Primeiramente, isso é excelente para operações de I/O. Por exemplo, chamadas de rede, acesso a banco ou leitura de arquivos. Em vez de bloquear, o código cede a vez para outra tarefa. Quando o resultado chega, a execução retorna ao ponto original. A voz passiva é usada aqui: “um event loop é usado para gerenciar as tarefas”. Quando utilizar frameworks assíncronos? Em aplicações com muitas conexões simultâneas. Chats, dashboards em tempo real ou proxies são exemplos perfeitos. Três frameworks se destacam: FastAPI, Sanic e Aiohttp. Cada um tem características e níveis de maturidade diferentes. Vamos explorar cada um em detalhes. Ao final, você saberá qual escolher para seu projeto.

FastAPI: o mais popular e completo

FastAPI é assíncrono por padrão, mas aceita funções síncronas. Ele é construído sobre o Starlette e usa Pydantic para validação. Sua maior força é a documentação automática (Swagger e ReDoc). Além disso, é extremamente rápido, comparável ao Node.js e Go. Quando usar FastAPI? Em APIs REST, microsserviços e projetos novos. Ele tem suporte nativo a WebSockets e background tasks. A curva de aprendizado é suave para quem conhece Flask. A voz passiva é aplicada: “as dependências são resolvidas de forma assíncrona”. Um exemplo simples de endpoint assíncrono:

from fastapi import FastAPI
import httpx
import asyncio

app = FastAPI()

@app.get('/dados-assincronos')
async def buscar_dados():
    async with httpx.AsyncClient() as cliente:
        # Chamada assíncrona: não bloqueia
        resposta1 = await cliente.get('https://api1.example.com/dados')
        resposta2 = await cliente.get('https://api2.example.com/status')
    
    return {
        'api1': resposta1.json(),
        'api2': resposta2.json()
    }

# Rode com: uvicorn main:app --reload

from fastapi import FastAPI

import httpx

import asyncio

app = FastAPI()

@app.get('/dados-assincronos')

async def buscar_dados():

async with httpx.AsyncClient() as cliente:

# Chamada assíncrona: não bloqueia

resposta1 = await cliente.get('https://api1.example.com/dados')

resposta2 = await cliente.get('https://api2.example.com/status')

return {

'api1': resposta1.json(),

'api2': resposta2.json()

}

# Rode com: uvicorn main:app --reload

As duas chamadas rodam de forma concorrente? Não exatamente. Elas ainda são sequenciais (uma após a outra). Para paralelismo real, use asyncio.gather(). FastAPI lida com milhares de conexões simultâneas facilmente.

Sanic: o veterano da velocidade

Sanic foi criado especificamente para ser rápido e assíncrono. Ele lembra o Flask na sintaxe, mas roda sobre asyncio. Quando usar Sanic? Em projetos que exigem máxima performance bruta. Por exemplo, servidores de jogos ou streaming de dados. Sanic suporta workers múltiplos e é estável há anos. Porém, sua comunidade é menor que a do FastAPI. A documentação é boa, mas menos abrangente. Uma vantagem é o servidor embutido pronto para produção. Não precisa de Gunicorn ou Uvicorn separados. Veja um exemplo de Sanic assíncrono:

from sanic import Sanic
from sanic.response import json
import asyncio

app = Sanic("MeuAppAssincrono")

@app.route("/slow")
async def endpoint_lento(request):
    await asyncio.sleep(2)  # Simula I/O
    return json({"mensagem": "Processado após 2 segundos"})

@app.route("/fast")
async def endpoint_rapido(request):
    return json({"mensagem": "Resposta imediata"})

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

from sanic import Sanic

from sanic.response import json

import asyncio

app = Sanic("MeuAppAssincrono")

@app.route("/slow")

async def endpoint_lento(request):

await asyncio.sleep(2) # Simula I/O

return json({"mensagem": "Processado após 2 segundos"})

@app.route("/fast")

async def endpoint_rapido(request):

return json({"mensagem": "Resposta imediata"})

if __name__ == "__main__":

app.run(host="0.0.0.0", port=8000, workers=4)

Enquanto /slow dorme, outras requisições são atendidas. O event loop do Sanic gerencia isso automaticamente. Isso é o poder do assíncrono: nenhum bloqueio desnecessário.

Aiohttp: o framework minimalista e direto

Aiohttp é cliente e servidor HTTP assíncrono em um só pacote. Ele não tem validação de dados ou documentação automática. Por outro lado, oferece controle total e baixo overhead. Quando usar Aiohttp? Em projetos onde você quer mínimas abstrações. Também é excelente para proxies, crawlers ou servidores customizados. A curva de aprendizado é mais íngreme que a do FastAPI. Você precisa entender asyncio profundamente. A voz passiva é vista: “as rotas são registradas manualmente nas tabelas”. Exemplo de um servidor simples com Aiohttp:

from aiohttp import web
import asyncio

async def handle_requisicao(request):
    nome = request.match_info.get('nome', 'Anônimo')
    await asyncio.sleep(0.5)  # Simula I/O
    return web.Response(text=f"Olá, {nome}!")

async def iniciar_servidor():
    app = web.Application()
    app.router.add_get('/saudacao/{nome}', handle_requisicao)
    return app

if __name__ == '__main__':
    web.run_app(iniciar_servidor(), port=8080)

from aiohttp import web

import asyncio

async def handle_requisicao(request):

nome = request.match_info.get('nome', 'Anônimo')

await asyncio.sleep(0.5) # Simula I/O

return web.Response(text=f"Olá, {nome}!")

async def iniciar_servidor():

app = web.Application()

app.router.add_get('/saudacao/{nome}', handle_requisicao)

return app

if __name__ == '__main__':

web.run_app(iniciar_servidor(), port=8080)

Esse código é leve e eficiente. Não há validação automática de parâmetros. Você mesmo precisa extrair e verificar os dados. Aiohttp é ideal para quem quer entender profundamente o asyncio.

Comparação final e quando escolher cada um

FastAPI é a escolha para a maioria dos projetos novos. Ele oferece documentação, validação e performance excelentes. Sanic é uma alternativa quando você precisa de velocidade pura. Aiohttp é para cenários onde o controle absoluto é necessário. A fórmula de throughput pode ajudar na decisão: \(Throughput = \frac{N_{\text{conexões}}}{T_{\text{médio resposta}}}\) Em sistemas assíncronos, o throughput é muito maior para I/O. Porém, para CPU intensivo, o assíncrono não traz vantagem. Portanto, avalie seu tipo de operação dominante. Comece com FastAPI se tiver dúvidas. Ele é o mais equilibrado entre poder e simplicidade. Lembre-se: programação assíncrona exige cuidado com race conditions. Use locks e semáforos quando necessário. Com essas ferramentas, você construirá backends escaláveis e modernos.

Síncrono em Python

22/04/202622/04/2026 Por antonino

– Web
1 – Backend (servidor)
1.1 – Sincrono (Django, Flask, FastAPI)
1.2 – Assincrono (FastAPI, Sanic, Aiohttp)
1.3 – WebSockets (Socket.IO, WebSockets)

LEGENDA

Nivel_1

Nivel_2

Nivel_3

Processamento síncrono significa que as tarefas ocorrem em sequência. Cada requisição é tratada completamente antes da próxima começar. Primeiramente, Django e Flask são frameworks majoritariamente síncronos. FastAPI também suporta o modo síncrono, embora seja famoso pelo assíncrono. Por exemplo, um endpoint que consulta um banco de dados bloqueia a execução. O servidor não aceita novas conexões enquanto processa essa operação. A voz passiva é usada aqui: “cada linha de código é executada em ordem”. Quando utilizar código síncrono? Na maioria das aplicações web tradicionais. Blogs, sistemas administrativos e e-commerces funcionam bem assim. A simplicidade do síncrono reduz bugs e facilita a depuração. Além disso, o custo mental para desenvolvedores é menor. Portanto, não se sinta pressionado a usar async sem necessidade real. Vamos explorar como cada framework lida com o paradigma síncrono. Três subtítulos guiarão nossa análise comparativa.

Django: o gigante síncrono e full-stack

Django é totalmente síncrono por design e tradição. Cada requisição roda em um processo ou thread separada. O servidor WSGI (como Gunicorn) gerencia o paralelismo real. Dentro de uma view, o código executa linha após linha. Isso é previsível e fácil de testar. Django oferece ORM síncrono, cache e autenticação prontos. Quando usar Django síncrono? Em projetos grandes e monolíticos. Por exemplo, portais de notícias ou sistemas de gestão. A desvantagem é o bloqueio durante I/O (acesso a banco ou API externa). Contudo, para 95% dos casos, isso não é um problema. A fórmula do tempo total de resposta: \(T = \sum_{i=1}^{n} t_i\). Onde \(t_i\) é o tempo de cada operação sequencial. Um exemplo simples de view síncrona no Django:

# views.py no Django
from django.http import JsonResponse
from django.db import connection
import time

def consulta_demorada(request):
    # Operação síncrona que bloqueia
    with connection.cursor() as cursor:
        cursor.execute("SELECT COUNT(*) FROM usuarios")
        resultado = cursor.fetchone()
    
    time.sleep(1)  # Simula processamento pesado
    return JsonResponse({'total': resultado[0]})

# views.py no Django

from django.http import JsonResponse

from django.db import connection

import time

def consulta_demorada(request):

# Operação síncrona que bloqueia

with connection.cursor() as cursor:

cursor.execute("SELECT COUNT(*) FROM usuarios")

resultado = cursor.fetchone()

time.sleep(1) # Simula processamento pesado

return JsonResponse({'total': resultado[0]})

Essa view trava o processo por pelo menos um segundo. Outras requisições aguardam em fila se houver poucas threads. A solução é aumentar o número de processos ou threads no Gunicorn. Django síncrono é robusto e testado há mais de 15 anos.

Flask: flexibilidade síncrona com micro núcleo

Flask também opera no modo síncrono por padrão. Cada rota é uma função que bloqueia até retornar. Ele é mais leve e minimalista que o Django. Quando usar Flask síncrono? Em APIs pequenas e protótipos. Também é excelente para microsserviços simples. A falta de estrutura impõe decisões sobre ORM e autenticação. Por outro lado, você escolhe exatamente o que precisa. O servidor padrão do Flask não é para produção. Use Gunicorn ou Waitress com múltiplos workers. A voz passiva é aplicada: “as extensões são integradas conforme necessário”. Flask síncrono é perfeito para aprender conceitos de backend. Seu código é explícito e sem mágicas. Veja um exemplo de API síncrona com Flask:

from flask import Flask, request, jsonify
import requests

app = Flask(__name__)

@app.route('/clima', methods=['GET'])
def clima_sincrono():
    cidade = request.args.get('cidade', 'São Paulo')
    # Chamada síncrona para API externa (bloqueia)
    resposta = requests.get(f'https://api.exemplo.com/clima?q={cidade}')
    dados = resposta.json()
    return jsonify(dados)

if __name__ == '__main__':
    app.run()

from flask import Flask, request, jsonify

import requests

app = Flask(__name__)

@app.route('/clima', methods=['GET'])

def clima_sincrono():

cidade = request.args.get('cidade', 'São Paulo')

# Chamada síncrona para API externa (bloqueia)

resposta = requests.get(f'https://api.exemplo.com/clima?q={cidade}')

dados = resposta.json()

return jsonify(dados)

if __name__ == '__main__':

app.run()

Note que requests.get() bloqueia até a resposta voltar. Durante esse tempo, o servidor não atende outras requisições no mesmo worker. Para alta concorrência, aumente o número de workers. Flask síncrono é claro, direto e suficiente para muitas aplicações.

FastAPI no modo síncrono: o melhor de dois mundos

FastAPI suporta funções síncronas e assíncronas livremente. Você pode escrever def minha_rota(): (síncrono) ou async def. O framework gerencia automaticamente a execução correta. Quando usar FastAPI síncrono? Em operações com CPU intensiva. Cálculos pesados, processamento de imagens ou criptografia. Nesses casos, o modo assíncrono não traria ganhos reais. Porém, FastAPI foi construído para alta performance mesmo no síncrono. Ele utiliza o servidor Uvicorn (ASGI) com threads para funções síncronas. Isso evita bloqueio total do event loop. A documentação automática (Swagger) funciona perfeitamente. Uma vantagem adicional: migrar de síncrono para assíncrono é fácil. Basta adicionar async e trocar bibliotecas como httpx no lugar de requests. Exemplo de endpoint síncrono no FastAPI:

from fastapi import FastAPI
import hashlib
import time

app = FastAPI()

@app.get('/hash-sincrono')
def calcular_hash(texto: str):
    """Função síncrona com CPU-bound (hash)."""
    inicio = time.time()
    for _ in range(100000):
        resultado = hashlib.sha256(texto.encode()).hexdigest()
    fim = time.time()
    return {
        'hash': resultado,
        'tempo_segundos': round(fim - inicio, 2)
    }

# Rode com: uvicorn arquivo:app --reload

from fastapi import FastAPI

import hashlib

import time

app = FastAPI()

@app.get('/hash-sincrono')

def calcular_hash(texto: str):

"""Função síncrona com CPU-bound (hash)."""

inicio = time.time()

for _ in range(100000):

resultado = hashlib.sha256(texto.encode()).hexdigest()

fim = time.time()

return {

'hash': resultado,

'tempo_segundos': round(fim - inicio, 2)

}

# Rode com: uvicorn arquivo:app --reload

Esse código consome CPU pura, não I/O. O modo síncrono é ideal aqui, pois async não aceleraria. Portanto, escolha FastAPI quando quiser flexibilidade para o futuro. Resumo final: Django é completo e síncrono. Flask é simples e leve. FastAPI é rápido e híbrido. Todos os três servem bem para a maioria dos projetos. Comece com o que parece mais natural para seu time.