DEV Community: PauloSouza.info

Tipos de Sockets em TCP e UDP: Escolhendo o Caminho Adequado

PauloSouza.info — Tue, 28 Nov 2023 11:48:45 +0000

Seguindo o pontapé inicial, depois de uma rápida apresentação sobre Sockets com Python, vamos falar sobre protocolos TCP e UDP.

Nas comunicações de rede, a escolha do tipo de socket desempenha um papel fundamental na transmissão eficiente de dados. Vou tentar falar um pouco sobre os tipos de sockets com o uso de protocolos TCP (Transmission Control Protocol) e UDP (User Datagram Protocol), buscando de forma clara explicar suas características e fornecendo insights sobre as situações ideais para cada um.

Basicamente, as abreviações de cada protocolo já respondem ao que cada um se propõe, sendo:

O TCP é um Protocolo de Controle de Transmissão
O UDP é um Protocolo de Datagrama de Usuário

O termo "controle de transmissão" refere-se à transmissão de dados em uma rede de computadores, onde o TCP é um protocolo de comunicação confiável e orientado à conexão, e seu controle de transmissão atua na entrega confiável e ordenada dos dados.

O "datagrama de usuário" refere-se à um modelo de comunicação sem conexão. Ao contrário do TCP, o UDP não estabelece uma conexão antes de enviar dados e não fornece garantias de entrega, ordem ou verificação de integridade dos dados.

Um datagrama é uma unidade de informação que é transmitida através de uma rede de computadores. Assim sendo, cada datagrama é tratado como uma entidade independente, e não há um acordo prévio de uma conexão antes da transmissão.

TCP: Uma Dança Coreografada de Confiança

O TCP opera sob um paradigma de comunicação orientada à conexão. Este tipo de socket é como uma dança coreografada, onde cada passo é cuidadosamente planejado e verificado para garantir a entrega precisa e confiável dos dados.

Imagine uma conversa formal entre dois interlocutores onde cada palavra é cuidadosamente ouvida e confirmada. É basicamente isso.

Abaixo, segue o exemplo de um servidor TCP em Python com acesso apenas em localhost na porta 8080.

import socket

# Configuração do servidor TCP
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server_socket.bind(('localhost', 8080))
server_socket.listen()

# Aguardando conexão
client_socket, client_address = server_socket.accept()

# Recebendo dados
data = client_socket.recv(1024)
print(f'Dados recebidos via TCP: {data.decode()}')

# Fechando a conexão
client_socket.close()
server_socket.close()

Confiabilidade:

O TCP é altamente confiável, garantindo que os dados sejam entregues sem erros e na ordem correta. Ele emprega mecanismos como ACK (acknowledgment) e retransmissões para assegurar que nenhum dado seja perdido.

Controle de Fluxo:

Um dos pontos fortes do TCP é o seu controle de fluxo que gerencia a taxa de transferência de dados entre emissor e receptor, evitando congestionamentos e garantindo uma transmissão suave.

Sincronização:

A comunicação orientada à conexão do TCP requer um aperto de mão (handshake) inicial entre as partes envolvidas. Esse processo sincronizado estabelece a base para uma comunicação segura e eficiente.

Quando Escolher TCP:

O TCP é a escolha preferencial em cenários onde a integridade dos dados é crucial, como transferência de arquivos, transmissão de áudio e vídeo, e aplicações que demandam comunicação confiável.

UDP: Velocidade e Simplicidade em uma autoestrada digital, mas sem pedágios :)

Diferentemente do TCP, o UDP opera em um modo de comunicação sem conexão. Imagine uma autoestrada digital onde os dados viajam rapidamente, mas sem a necessidade de verificações constantes de velocidade.

Agora, imagine a mesma conversa entre dois interlocutores só que de forma mais rápida e direta, onde não há tempo para confirmações constantes e os dois falam sem parar de assuntos diferentes e, ao mesmo tempo. Você como ouvinte só capta o que você entendeu e continua andando.

Abaixo, segue um exemplo de um servidor UDP em Python com acesso apenas em localhost na porta 8081.

import socket

# Configuração do servidor UDP
server_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
server_socket.bind(('localhost', 8081))

# Recebendo dados
data, client_address = server_socket.recvfrom(1024)
print(f'Dados recebidos via UDP: {data.decode()}')

# Fechando a conexão
server_socket.close()

Velocidade:

O UDP é mais rápido e eficiente do que o TCP, pois não carrega o fardo de estabelecer e manter uma conexão constante. Isso o torna ideal para aplicações que priorizam a velocidade sobre a confiabilidade.

Comunicação Sem Conexão:

Sem a necessidade de handshakes e verificações rigorosas, o UDP é adequado para situações onde uma comunicação rápida e simples é suficiente.

Broadcasting:

O UDP é frequentemente usado em cenários de broadcasting, onde a mesma mensagem é enviada para vários destinatários simultaneamente.

Quando Escolher UDP:

O UDP é a escolha acertada quando a velocidade é mais importante, como em jogos online, transmissões ao vivo e aplicações de VoIP, onde a perda ocasional de pacotes é tolerável.

Finalização

Se considerarmos a comunicação digital como uma sinfonia, o TCP seria a partitura meticulosamente seguida por uma orquestra, enquanto o UDP seria o improviso de um DJ tocando músicas escolhidas aleatoriamente e sem parar.

Com isso em mente, você já pode escolher o melhor caminho seguir.

* A lot o thanks for this great article and image in Privacy Canada in helping me to compose this article.

Introdução aos Sockets em Python

PauloSouza.info — Wed, 22 Nov 2023 10:53:00 +0000

A Magia dos Sockets com o Python

Em meio ao vasto território da programação em Python, os Sockets emergem como ferramentas essenciais para a construção de aplicações eficientes de comunicação entre dispositivos. Enquanto a abordagem tradicional de requisição e resposta HTTP tem suas vantagens, a versatilidade dos Sockets oferece uma alternativa dinâmica e poderosa.

Os Sockets, parte integrante da biblioteca padrão do Python, proporcionam uma maneira direta e flexível de estabelecer conexões entre diferentes sistemas. Nesta breve jornada, exploraremos os conceitos fundamentais por trás dos Sockets em Python, na criação de conexões à troca ágil de dados entre cliente e servidor.

Ao desvendar a magia dos Sockets em Python, os desenvolvedores serão capacitados a criar aplicações que transcendem as limitações das comunicações convencionais. Este é um convite para mergulhar no universo da comunicação de baixo nível, onde os Sockets se tornam as ferramentas essenciais para conectar e impulsionar aplicações de forma eficaz.

O que são Sockets

Considerados como ferramentas essenciais para facilitar a comunicação entre processos em uma rede, eles agem como pontos de extremidade, permitindo que diferentes programas troquem dados de maneira eficiente.

Um processo pode criar um socket, associá-lo a um endereço e porta específicos, e então aguardar por conexões (modo servidor) ou iniciar uma conexão com outro socket (modo cliente).

A comunicação bidirecional é estabelecida, possibilitando a troca de dados entre os processos, e a conexão pode ser encerrada quando a comunicação é concluída.

Pensando em um fluxo bem simples, você vai entender que a base para a construção de qualquer aplicação baseia-se nos três pontos abaixo:

O processo servidor cria um socket, o associa a um endereço e porta específicos, e entra em modo de escuta por conexões;
O cliente, por sua vez, cria um socket para se conectar ao servidor;
A comunicação bidirecional é então estabelecida, permitindo a troca eficiente de dados.

Os sockets são como canais de comunicação que permitem que programas conversem pela internet ou em uma rede local. Você pode pensar neles como tubos virtuais que enviam e recebem mensagens entre computadores, e assim, esses dois computadores podem trocar informações como textos ou até mesmo dados mais complexos, de forma rápida e eficiente.

História rápida sobre Sockets em Python

A biblioteca existe desde os primeiros dias da linguagem. Ela foi desenvolvida para tornar a comunicação entre computadores mais fácil. Hoje, é amplamente utilizada em diversos tipos de aplicativos, desde jogos online até transferência de arquivos. Entender como usar sockets é como aprender a linguagem universal dos computadores para que eles possam se entender melhor e mais rápido.

Cliente e Servidor de comunicação

A facilidade de trabalhar com sockets em Python atrai tanto iniciantes quanto desenvolvedores experientes.

Com apenas algumas linhas de código, é possível criar servidores e clientes capazes de trocar informações de maneira rápida e concisa.

A clara abordagem da linguagem Python em relação aos sockets torna o desenvolvimento de aplicações distribuídas acessível a programadores de todos os níveis, promovendo uma experiência de codificação fluida e eficaz.

Exemplo de um Socket como servidor que aguarda conexões

import socket

# Configurações do servidor
host = '0.0.0.0'  # Aceita conexões em todos os endereços disponíveis
porta = 12345      # Porta para conexão

# Criação do socket do servidor
servidor_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# Associa o socket ao endereço e à porta
servidor_socket.bind((host, porta))

# Coloca o servidor em modo de escuta
servidor_socket.listen()

print(f"Servidor esperando por conexões em {host}:{porta}")

# Aceita uma conexão quando solicitado por um cliente
cliente_socket, cliente_endereco = servidor_socket.accept()

# Lê dados enviados pelo cliente
dados_recebidos = cliente_socket.recv(1024)
print(f"Recebido do cliente: {dados_recebidos.decode('utf-8')}")

# Encerra a conexão
cliente_socket.close()
servidor_socket.close()

Exemplo de um Socket como cliente para conexão a um servidor

import socket

# Configurações do cliente
host = 'localhost'  # Endereço do servidor
porta = 12345        # Porta do servidor

# Criação do socket do cliente
cliente_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# Conecta ao servidor
cliente_socket.connect((host, porta))

# Envia dados ao servidor
mensagem = "Olá, servidor!"
cliente_socket.send(mensagem.encode('utf-8'))

# Encerra a conexão
cliente_socket.close()

Finalizando...

Desvendar o potencial dos sockets em Python é abrir as portas para uma comunicação fluida e eficiente entre processos. E, à medida que exploramos mais a fundo, surgem oportunidades infinitas para criar aplicações distribuídas robustas e interativas, revelando o verdadeiro poder da conectividade em tempo real.

A abordagem dos próximos tópicos como uma pequena série sobre Sockets com exemplos de códigos, como:

TCP e UDP
Binds
Listens
Accepts
Sockets e Threads
Transferência de Arquivos
Tratamento de Erros
Segurança

Redis PubSub com Python

PauloSouza.info — Thu, 23 Jun 2022 14:36:18 +0000

Atualmente, quando falamos de PubSub, temos inúmeras opções para discutir quando falamos de clientes e servidores.

Basicamente, temos um publicador de um lado e um ouvinte do outro aguardando um dado. De forma simplificada — caso você ainda não tenha lido sobre isso, é como o professor lá na frente explicando uma matéria e do outro lado, 40 alunos na mesma sala anotando tudo aquilo que escutam.

Bem fácil, né?

Sistemas já conhecidos de mensageiros como RabbitMQ, ZeroMQ, Kafka e Nats.io promovem para cada solução, uma forma de implantar isso no seu código onde a distribuição dos dados mesmo que em ambientes diferentes, possa ser propagado com segurança.

No navegador, para uma comunicação através de um Websocket ou EventSource, também temos um publicador e múltiplos ouvintes como em uma sala de bate-papo, mas de formas distintas. O Websocket é um sistema de 2 vias onde ele pode ser o publicador e ouvinte, enquanto no EventSource uma única via é utilizada na comunicação do servidor com os clientes.

O Redis, conhecido pela sua velocidade, já possui nativamente a funcionalidade para PubSub sem a necessidade de configurações adicionais, mas com suas limitações onde nas ferramentas citadas teremos soluções mais robustas, com persistência de dados, streaming e por aí vai... Mas estamos aqui para falar do Redis PubSub.

Botando o Redis pra funcionar

Para testes, você pode subir um container na sua máquina mesmo para o Redis utilizando o Docker.

docker run -ti --rm -p 6379:6379 --name pubsub redis:alpine

Como Redis ativo, abra uma nova aba/janela da sua linha de comando para testarmos o canal pythonpubsub como ouvinte.

docker exec -ti pubsub redis-cli subscribe pythonpubsub

Para testarmos a publicação no mesmo canal, abra uma nova aba/janela na sua linha de comando e vamos ver a máquina acontecer.

docker exec -ti pubsub redis-cli publish pythonpubsub "eu sou uma mensagem"

Divertido, né?... Mas aí você se pergunta sobre a velocidade e nesta aba/janela que você publicou a mensagem, vamos fazer um for simples para publicar 10000 mensagens.

for i in {1..10000}; do
    docker exec -ti pubsub redis-cli publish pythonpubsub "mensagem $i";
done

Agora que configuramos o ambiente como container Redis e testamos o PubSub, feche todas as janelas mantendo apenas a aba/janela da sua linha de comando onde o servidor Redis está rodando. Tá na hora de escrever um código bem simples em Python. Tão simples que é bem próximo do que fizemos até agora e isso vai ampliar seus horizontes.

Partindo para o código em Python

Mas... Python? Só Python? Não! O exemplo é em Python - por uma paixão pessoal e ser melhor na leitura do código, mas pode ser também com o uso de bibliotecas equivalentes para NodeJS, PHP, Golang, Java ou qualquer outra linguagem da sua preferência.

Aqui, na minha máquina local, eu estou usando o Python na versão 3.9.13, mas em testes recentes eu não tive problema de compatibilidade em versões 3.6+.

No caso do Python, é sempre importante ter o ambiente virtual ativo para que assim possamos isolar as dependências entre projetos.

python3 -m venv venv

Inicie o ambiente virtual para iniciar a instalação da única dependência que teremos com a biblioteca de conexão para o Redis.

. venv/bin/activate

Instale a biblioteca redis.

pip3 install redis

Crie um arquivo chamado app.py e nele, vamos inserir o nosso código de subscriber como um daemon que se manterá ativo até o encerramento do programa (o famoso ctrl+c).

from redis import StrictRedis

client = StrictRedis(host="localhost", port=6379)

pubsub = client.pubsub()
pubsub.subscribe('pythonpubsub')

while True:
    msg = pubsub.get_message()

    if msg:
        if not isinstance(msg['data'], int):
            channel, message = msg['channel'], msg['data']
            print('%s: %s' % (channel.decode('utf-8'), message.decode('utf-8')))

Rode o arquivo app.py.

python3 app.py

Junto com a aplicação já rodando, abra outra aba/janela na sua linha de comando e deixe o subscriber do Redis rodando do lado.

docker exec -ti pubsub redis-cli subscribe pythonpubsub

Sabe aquele for que criamos lá em cima? Abra uma nova aba/janela da sua linha de comando e vamos ver as mensagens sendo propagadas em ambas as janelas.

for i in {1..10000}; do
    docker exec -ti pubsub redis-cli publish pythonpubsub "mensagem $i";
done

Bem legal, né? Vou te falar que isso já me salvou algumas vezes para aumentar a velocidade de processamento paralelo em algumas aplicações sem grandes mudanças ou necessidade de refactoring.

Espero que você tenha curtido. Sigo aberto a sugestões e boas idéias.