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:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
# 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:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
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:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 |
# 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.