O Básico: Um Servidor HTTP com Socket

Para entender o funcionamento de frameworks como o Django, é útil construir um servidor web simples usando sockets. O exemplo abaixo demonstra um loop de servidor que aceita conexões, lê a requisição HTTP bruta e envia uma resposta simples de volta ao cliente (navegador).

import socket

# Cria um objeto socket TCP/IP
socket_server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# Associa o socket ao endereço e porta local
socket_server.bind(("0.0.0.0", 8080))
# Coloca o socket em modo de escuta para conexões entrantes
socket_server.listen(5)
print("Servidor escutando na porta 8080...")

while True:
    # Aceita uma nova conexão de cliente
    client_conn, client_addr = socket_server.accept()
    # Recebe os dados da requisição (até 1024 bytes)
    request_data = client_conn.recv(1024)
    print(f"Requisição recebida de {client_addr}")

    # Envia a resposta HTTP básica
    http_response = (
        "HTTP/1.1 200 OK\r\n"
        "Content-Type: text/html; charset=utf-8\r\n"
        "\r\n"  # Linha em branco separa cabeçalho do corpo
        "<h1>Olá, Mundo do Socket!</h1>"
    )
    client_conn.sendall(http_response.encode('utf-8'))
    # Fecha a conexão com este cliente
    client_conn.close()

Roteamento Básico por URL

Ao inspecionar os dados brutos recebidos, podemos extrair a URL da requisição. Com isso, implementamos um roteador simples que retorna conteúdo diferente com base no caminho solicitado. A estrutura de dicionário é mais eficiente para este mapeamento do que múltiplos condicionais.

import socket

def handle_home(path):
    return "<h1>Página Inicial</h1>"

def handle_about(path):
    return "<h1>Sobre Nós</h1>"

def handle_not_found(path):
    return "<h1>404 - Não Encontrado</h1>"

# Mapeamento de rotas para funções tratadoras
routes = {
    "/home": handle_home,
    "/about": handle_about,
}

socket_server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
socket_server.bind(("0.0.0.0", 8080))
socket_server.listen(5)

while True:
    client_conn, _ = socket_server.accept()
    request_bytes = client_conn.recv(1024)
    request_str = request_bytes.decode('utf-8')
    
    # Extrai a linha de requisição e o caminho (segundo elemento)
    request_lines = request_str.split('\r\n')
    if request_lines:
        first_line = request_lines[0]
        parts = first_line.split(' ')
        if len(parts) >= 2:
            path = parts[1]
        else:
            path = "/"
    else:
        path = "/"
    
    # Encontra a função tratadora correspondente ou usa o 404
    handler_func = routes.get(path, handle_not_found)
    response_body = handler_func(path)
    
    http_response = f"HTTP/1.1 200 OK\r\nContent-Type: text/html; charset=utf-8\r\n\r\n{response_body}"
    client_conn.sendall(http_response.encode('utf-8'))
    client_conn.close()

Renderização de Templates Dinâmicos

Para gerar páginas com dados dinâmicos (como a hora atual), podemos ler um arquivo HTML e substituir marcadores especiais. Esta é uma forma primitiva do que frameworks chamam de "renderização de template".

import socket
from datetime import datetime

def handle_time(path):
    # Carrega o template HTML de um arquivo
    with open("time_template.html", "r", encoding="utf-8") as file:
        template_content = file.read()
    
    # Gera a hora atual no formato desejado
    current_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    
    # Substitui o marcador pelo valor dinâmico
    rendered_html = template_content.replace("{{current_time}}", current_time)
    return rendered_html

# O arquivo "time_template.html" conteria algo como:
# <h1>A hora atual é: {{current_time}}</h1>

Introdução ao Protocolo HTTP

As interações acima se baseiam no protocolo HTTP (Hypertext Transfer Protocol). É essencial entender sua estrutura:

• Requisição: Enviada pelo cliente (navegador) ao servidor. Contém:
  • Linha de Requisição: Método (GET, POST, etc.), caminho do recurso e versão do protocolo.
  • Cabeçalhos: Metadados como Host, User-Agent, Accept.
  • Corpo (opcional): Dados enviados, comuns em requisições POST/PUT.
• Resposta: Enviada pelo servidor ao cliente. Contém:
  • Linha de Status: Versão do protocolo, código de status (ex: 200 OK, 404 Not Found) e frase de status.
  • Cabeçalhos: Metadados como Content-Type, Content-Length.
  • Corpo: O conteúdo solicitado (HTML, JSON, imagem, etc.).

Códigos de status comuns incluem: 200 (Sucesso), 301 (Redirecionamento Permanente), 400 (Requisição Inválida), 403 (Proiibdo), 404 (Não Encontrado), 500 (Erro Interno do Servidor).

Por que Precisamos de um Framework?

Construir um servidor web do zero, como mostrado, é didático mas imprático para aplicações reais. Um framework como o Django abstrai tarefas complexas e fornece uma estrutura robusta, resolvendo problemas como:

1. Tratamento de Socket e HTTP: Gerenciamento eficiente de conexões e parsing de requisições/respostas. Django utiliza interfaces WSGI (como gunicorn ou uwsgi) para isso.
2. Roteamento Avançado: Mapeamento de URLs complexas, com parâmetros e namespaces, para funções visuais ou classes.
3. Renderização de Templates: Motor de templates poderoso (Jinja2 ou Django Template Language) com herança, filtros e tags.
4. Gerenciamento de Dados: ORM (Object-Relational Mapping) para interagir com bancos de dados de forma orientada a objetos.
5. Recursos de Segurança: Proteção contra CSRF, XSS, SQL injection, autenticação e autorização.
6. Middleware: Camadas de processamento de requisição/resposta para funcionalidades transversais.

Configuração de Projeto e Arquivos no Django

Ao criar um projeto Django com django-admin startproject, uma estrutura de diretórios e arquivos essenciais é gerada. Os mais importantes para a configuração inicial são:

• settings.py: O coração da configuração. Define banco de dados, aplicações instaladas, middleware, caminhos de templates, configurações de arquivos estáticos, idioma, fuso horário, etc.
• urls.py: O mapeamento principal de URLs do projeto. Redireciona as requisições para as URLs das aplicões específicas.
• wsgi.py: Ponto de entrada para servidores WSGI compatíveis, necessário para deploy em produção.

Dentro de uma aplicação Django, a configuração de rotas (URLs) e a lógica de tratamento (views) são definidas em seus próprios módulos, promovendo modularidade. O Django também gerencia automaticamente o servir de arquivos estáticos (CSS, JavaScript, imagens) durante o desenvolvimento, bastando configurar a lista STATICFILES_DIRS em settings.py e usar a template tag {% static 'caminho/do/arquivo' %}.