WebSockets em Python - Área de Trampo

– 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

WebSockets mantêm uma conexão aberta entre cliente e servidor. Diferente do HTTP, os dados trafegam nas duas direções livremente. Primeiramente, isso permite atualizações instantâneas sem recarregar a página. Por exemplo, chats, notificações ou jogos online usam essa tecnologia. O servidor pode enviar mensagens ao cliente a qualquer momento. Além disso, a latência é muito menor que requisições HTTP tradicionais. A voz passiva é usada aqui: “uma única conexão TCP é estabelecida e mantida”. Quando utilizar WebSockets? Em aplicações que exigem tempo real. Dashboards de monitoramento, colaboração simultânea ou streaming de dados. Duas abordagens principais existem no ecossistema Python. WebSockets puros (RFC 6455) e Socket.IO (biblioteca com fallbacks). Vamos explorar ambas com exemplos práticos. Escolha a que melhor se adapta ao seu projeto.

Websockets puros: leve e nativo

WebSockets puros seguem o padrão oficial da web. Eles são suportados por todos os navegadores modernos. Em Python, a biblioteca websockets é a mais madura. Quando usar WebSockets puros? Em projetos que exigem baixo overhead. Também quando você controla tanto cliente quanto servidor. A desvantagem é a falta de fallback para conexões antigas. Além disso, não há reconexão automática ou salas prontas. A voz passiva é aplicada: “os eventos são tratados com funções assíncronas”. Um exemplo de servidor WebSocket puro com websockets:

import asyncio
import websockets
from datetime import datetime

async def enviar_horario(websocket, path):
    """Envia a hora atual a cada segundo."""
    try:
        while True:
            mensagem = f"Horário: {datetime.now().strftime('%H:%M:%S')}"
            await websocket.send(mensagem)
            await asyncio.sleep(1)
    except websockets.exceptions.ConnectionClosed:
        print("Cliente desconectado")

async def main():
    async with websockets.serve(enviar_horario, "localhost", 8765):
        print("Servidor WebSocket rodando em ws://localhost:8765")
        await asyncio.Future()  # Roda para sempre

if __name__ == "__main__":
    asyncio.run(main())

import asyncio

import websockets

from datetime import datetime

async def enviar_horario(websocket, path):

"""Envia a hora atual a cada segundo."""

try:

while True:

mensagem = f"Horário: {datetime.now().strftime('%H:%M:%S')}"

await websocket.send(mensagem)

await asyncio.sleep(1)

except websockets.exceptions.ConnectionClosed:

print("Cliente desconectado")

async def main():

async with websockets.serve(enviar_horario, "localhost", 8765):

print("Servidor WebSocket rodando em ws://localhost:8765")

await asyncio.Future() # Roda para sempre

if __name__ == "__main__":

asyncio.run(main())

Para testar, abra o console do navegador e digite: let ws = new WebSocket("ws://localhost:8765"); ws.onmessage = (e) => console.log(e.data); O servidor enviará a hora atualizada a cada segundo. Isso é WebSocket puro: simples, rápido e eficiente.

Socket.IO: alto nível e robusto

Socket.IO é uma biblioteca que emula WebSockets com fallbacks. Se WebSocket não estiver disponível, usa polling HTTP ou outras técnicas. Além disso, oferece reconexão automática e salas de conversa. Quando usar Socket.IO? Em aplicações que precisam de confiabilidade máxima. Também quando você quer funcionalidades prontas como broadcasts. A desvantagem é o overhead extra e a necessidade de cliente específico. O servidor Python python-socketio é fácil de integrar com Flask ou FastAPI. Exemplo de servidor Socket.IO com Flask:

from flask import Flask, render_template
from flask_socketio import SocketIO, emit, send
import time

app = Flask(__name__)
app.config['SECRET_KEY'] = 'segredo!'
socketio = SocketIO(app, cors_allowed_origins="*")

@socketio.on('mensagem_cliente')
def handle_mensagem(data):
    print(f"Recebido: {data}")
    # Envia para todos os clientes conectados
    emit('resposta_servidor', f"Eco: {data}", broadcast=True)

@socketio.on('ping')
def handle_ping():
    emit('pong', {'timestamp': time.time()})

if __name__ == '__main__':
    socketio.run(app, host='0.0.0.0', port=5000, debug=True)

from flask import Flask, render_template

from flask_socketio import SocketIO, emit, send

import time

app = Flask(__name__)

app.config['SECRET_KEY'] = 'segredo!'

socketio = SocketIO(app, cors_allowed_origins="*")

@socketio.on('mensagem_cliente')

def handle_mensagem(data):

print(f"Recebido: {data}")

# Envia para todos os clientes conectados

emit('resposta_servidor', f"Eco: {data}", broadcast=True)

@socketio.on('ping')

def handle_ping():

emit('pong', {'timestamp': time.time()})

if __name__ == '__main__':

socketio.run(app, host='0.0.0.0', port=5000, debug=True)

No lado cliente, você precisa incluir a biblioteca socket.io.js. Depois, conecte com io.connect('http://localhost:5000'). Socket.IO gerencia automaticamente a reconexão se o servidor cair. Isso é excelente para aplicações móveis ou redes instáveis.

Comparação direta e critérios de escolha

WebSockets puros são melhores para desempenho máximo. Eles têm menor latência e menos tráfego de controle. Socket.IO é superior em confiabilidade e facilidade de uso. A fórmula da taxa de sucesso em redes ruins: \(S = \frac{C_{\text{sucesso}}}{C_{\text{total}}} \times 100\%\) Socket.IO atinge valores maiores em conexões instáveis. Portanto, para intranet ou redes controladas, prefira WebSockets puros. Para aplicações públicas na internet, Socket.IO é mais seguro. Ambos são assíncronos e integram bem com FastAPI ou Aiohttp. Um exemplo de cliente WebSocket puro em Python:

import asyncio
import websockets

async def cliente():
    uri = "ws://localhost:8765"
    async with websockets.connect(uri) as websocket:
        await websocket.send("Olá servidor!")
        resposta = await websocket.recv()
        print(f"Resposta: {resposta}")

asyncio.run(cliente())

import asyncio

import websockets

async def cliente():

uri = "ws://localhost:8765"

async with websockets.connect(uri) as websocket:

await websocket.send("Olá servidor!")

resposta = await websocket.recv()

print(f"Resposta: {resposta}")

asyncio.run(cliente())

Já para Socket.IO cliente em Python, use python-socketio[client]. A escolha final depende da sua tolerância a complexidade. Comece com WebSockets puros se você controla o ambiente. Migre para Socket.IO se encontrar problemas de conectividade. Ambos são ferramentas poderosas para o arsenal do desenvolvedor. Implemente seu primeiro chat em tempo real ainda hoje!

Indice

Websockets puros: leve e nativo

Socket.IO: alto nível e robusto

Comparação direta e critérios de escolha

Deixe um comentário Cancelar resposta