antonino, Autor em Área de Trampo

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.

– 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

O backend é a parte invisível de um sistema web. Ele processa dados, gerencia usuários e responde a requisições. Primeiramente, o backend não exibe telas diretamente. Em vez disso, ele fornece APIs ou renderiza HTML no servidor. Por exemplo, quando você faz login, o backend verifica sua senha. Além disso, ele consulta bancos de dados e aplica regras de negócio. A voz passiva é usada aqui: “as decisões críticas são tomadas no backend”. Quando utilizar um servidor Python? Em praticamente toda aplicação web moderna. Python é famoso por sua clareza e ecossistema maduro. Frameworks como Django, Flask e FastAPI dominam o mercado. Cada um tem características específicas para diferentes necessidades. Neste guia, exploraremos os conceitos fundamentais do backend. Vamos desde o servidor HTTP até a lógica de negócio. Preparado? Então comece sua jornada nos bastidores da web.

Servidores wsgi e asgi: a base do backend python

Um servidor web Python precisa de uma interface padronizada. WSGI (Web Server Gateway Interface) é o padrão clássico. Ele conecta o servidor (como Nginx) à sua aplicação Flask ou Django. Exemplos de servidores WSGI são Gunicorn e uWSGI. Por outro lado, ASGI (Asynchronous Server Gateway Interface) é mais novo. Ele suporta requisições assíncronas e WebSockets. FastAPI e Django 3+ rodam sobre ASGI com eficiência. Quando usar WSGI? Em aplicações síncronas tradicionais. Já o ASGI é melhor para chat, notificações ou streaming. A escolha impacta a performance e a complexidade do código. Servidores WSGI tratam uma requisição por vez por processo. Servidores ASGI podem lidar com muitas conexões simultâneas. Portanto, avalie seu caso antes de decidir. Um exemplo de execução com Gunicorn seria:

# Arquivo: app.py (Flask)
from flask import Flask
app = Flask(__name__)

@app.route('/')
def home():
    return "Backend funcionando!"

# Para rodar com Gunicorn (terminal):
# gunicorn -w 4 app:app

# Para Uvicorn (ASGI com FastAPI):
# uvicorn main:app --reload

# Arquivo: app.py (Flask)

from flask import Flask

app = Flask(__name__)

@app.route('/')

def home():

return "Backend funcionando!"

# Para rodar com Gunicorn (terminal):

# gunicorn -w 4 app:app

# Para Uvicorn (ASGI com FastAPI):

# uvicorn main:app --reload

No comando, -w 4 significa quatro processos de trabalho. Isso melhora a capacidade de resposta sob carga. Nunca use o servidor embutido do Flask em produção. Ele é inseguro e lento para múltiplos usuários simultâneos.

Rotas, middlewares e injeção de dependências

Rotas definem quais URLs ativam quais funções. Um middleware intercepta requisições antes da lógica principal. Por exemplo, autenticação, logging ou compressão de resposta. Em Flask, middlewares são criados com decoradores ou funções específicas. Em Django, eles são classes configuráveis no settings.py. Já a injeção de dependências facilita o teste de componentes isolados. FastAPI tem suporte nativo a dependências via Depends(). Isso evita acoplamento rígido entre partes do sistema. Quando usar middlewares? Sempre que houver lógica transversal. Log de requisições, cache e cabeçalhos de segurança são exemplos. A voz passiva é aplicada: “as dependências são resolvidas automaticamente”. Um exemplo prático com middleware simples em Flask:

from flask import Flask, request, g
import time

app = Flask(__name__)

@app.before_request
def antes_de_cada_requisicao():
    g.inicio = time.time()
    print(f"Requisição recebida: {request.path}")

@app.after_request
def depois_de_cada_resposta(resposta):
    duracao = time.time() - g.inicio
    print(f"Tempo de resposta: {duracao:.4f}s")
    return resposta

@app.route('/demo')
def demo():
    return "Middleware executado com sucesso!"

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

from flask import Flask, request, g

import time

app = Flask(__name__)

@app.before_request

def antes_de_cada_requisicao():

g.inicio = time.time()

print(f"Requisição recebida: {request.path}")

@app.after_request

def depois_de_cada_resposta(resposta):

duracao = time.time() - g.inicio

print(f"Tempo de resposta: {duracao:.4f}s")

return resposta

@app.route('/demo')

def demo():

return "Middleware executado com sucesso!"

if __name__ == '__main__':

app.run()

Esse código mede o tempo de cada requisição automaticamente. O middleware before_request roda antes da view. O after_request roda depois, podendo modificar a resposta. Isso é poderoso para monitoramento e auditoria.

Lógica de negócio e camada de serviços

A lógica de negócio é o coração do seu backend. Ela implementa regras como “usuário só pode comprar se tiver saldo”. Essa lógica não deve ficar dentro das rotas ou controladores. Em vez disso, crie uma camada de serviços separada. Cada serviço é uma classe ou conjunto de funções puras. Elas recebem dados, processam e retornam resultados. Isso facilita testes unitários e reutilização de código. Por exemplo, um serviço de cálculo de imposto pode ser usado em várias rotas. Quando usar essa separação? Em qualquer projeto com mais de dez rotas. A fórmula da complexidade ciclomática sugere: \(M = E – N + 2P\). Onde E são arestas, N nós, P componentes conexos. Manter a lógica isolada reduz esse número e a manutenção. Veja um exemplo de serviço financeiro simples:

# servicos.py - camada de serviços
class CalculadoraImposto:
    @staticmethod
    def calcular(valor, aliquota=0.1):
        """Calcula imposto sobre um valor."""
        if valor < 0:
            raise ValueError("Valor não pode ser negativo")
        return valor * aliquota

# app.py - rota usando o serviço
from flask import Flask, request, jsonify
from servicos import CalculadoraImposto

app = Flask(__name__)

@app.route('/imposto', methods=['POST'])
def calcular_imposto_route():
    dados = request.get_json()
    valor = dados.get('valor', 0)
    aliquota = dados.get('aliquota', 0.1)
    
    try:
        resultado = CalculadoraImposto.calcular(valor, aliquota)
        return jsonify({'imposto': resultado})
    except ValueError as e:
        return jsonify({'erro': str(e)}), 400

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

# servicos.py - camada de serviços

class CalculadoraImposto:

@staticmethod

def calcular(valor, aliquota=0.1):

"""Calcula imposto sobre um valor."""

if valor < 0:

raise ValueError("Valor não pode ser negativo")

return valor * aliquota

# app.py - rota usando o serviço

from flask import Flask, request, jsonify

from servicos import CalculadoraImposto

app = Flask(__name__)

@app.route('/imposto', methods=['POST'])

def calcular_imposto_route():

dados = request.get_json()

valor = dados.get('valor', 0)

aliquota = dados.get('aliquota', 0.1)

try:

resultado = CalculadoraImposto.calcular(valor, aliquota)

return jsonify({'imposto': resultado})

except ValueError as e:

return jsonify({'erro': str(e)}), 400

if __name__ == '__main__':

app.run()

Note como a lógica de negócio está isolada na classe. A rota apenas orquestra a chamada e trata erros. Isso permite testar o cálculo sem precisar do Flask. Para testar, basta assert CalculadoraImposto.calcular(100) == 10.0. Essa arquitetura é chamada de “service layer” ou camada de serviços. Ela escala bem para equipes grandes e código de longo prazo. Por fim, lembre-se: o backend Python é poderoso e flexível. Comece simples, adicione middlewares e serviços gradualmente. Seu sistema crescerá de forma organizada e sustentável.

Síncrono em Python

Django: o gigante síncrono e full-stack

Flask: flexibilidade síncrona com micro núcleo

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

Backend com Python

Servidores wsgi e asgi: a base do backend python

Rotas, middlewares e injeção de dependências

Lógica de negócio e camada de serviços