Sockets em Python: guia completo para iniciantes e experts

O que são sockets em Python e como funcionam

Um socket é uma interface de software que permite a comunicação bidirecional entre dispositivos em uma rede de computadores. É como um conector virtual através do qual aplicações podem enviar e receber dados pela rede.

As aplicações de rede modernas utilizam sockets Python para criar diversos sistemas. Desde mensageiros instantâneos até jogos online e serviços de troca de dados — a comunicação em rede via sockets está presente em todos esses casos.

Conceitos fundamentais da programação de rede

Para trabalhar com sockets em Python, é essencial compreender os seguintes conceitos:

• Endereço IP — endereço único de um dispositivo na rede
• Porta — identificador numérico de um serviço no dispositivo
• TCP (Transmission Control Protocol) — protocolo confiável de transmissão de dados
• UDP (User Datagram Protocol) — protocolo rápido sem confirmação de entrega

O TCP garante a entrega dos dados com controle de erros. O UDP é mais rápido, mas não assegura a entrega das mensagens.

Configuração e importação da biblioteca socket

O módulo socket faz parte da biblioteca padrão do Python. Para começar a usar sockets, basta fazer uma importação simples:

import socket

Não é necessário instalar nada adicional. A biblioteca socket está disponível em todas as versões do Python por padrão.

Criando um servidor TCP em Python

Implementação básica do servidor

Um servidor TCP aceita conexões de clientes e processa suas requisições. Veja uma implementação simples:

import socket

# Criação do socket TCP
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# Associação ao endereço e porta
server_socket.bind(('localhost', 12345))

# Início da escuta (máximo 5 conexões na fila)
server_socket.listen(5)

print("Servidor iniciado. Aguardando conexões...")

while True:
    # Aceitação da conexão
    client_socket, address = server_socket.accept()
    print(f"Conexão de {address}")
    
    # Recebimento da mensagem
    message = client_socket.recv(1024).decode('utf-8')
    print(f"Mensagem recebida: {message}")
    
    # Envio da resposta
    client_socket.send("Olá do servidor!".encode('utf-8'))
    
    # Fechamento da conexão com o cliente
    client_socket.close()

Entendendo o processo de funcionamento do servidor

No código acima, as seguintes operações ocorrem:

1. Um socket é criado usando o protocolo TCP
2. O servidor é associado ao endereço localhost e porta 12345
3. Inicia-se a espera por conexões de clientes
4. Quando um cliente se conecta, sua mensagem é recebida
5. O servidor envia uma resposta e fecha a conexão

O método socket.AF_INET indica o uso de IPv4, enquanto socket.SOCK_STREAM refere-se ao protocolo TCP.

Desenvolvendo um cliente TCP

Um cliente TCP conecta-se ao servidor e troca dados com ele. Exemplo de implementação do cliente:

import socket

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

# Conexão ao servidor
client_socket.connect(('localhost', 12345))

# Envio da mensagem
client_socket.send("Olá, servidor!".encode('utf-8'))

# Recebimento da resposta
response = client_socket.recv(1024).decode('utf-8')
print(f"Resposta do servidor: {response}")

# Fechamento da conexão
client_socket.close()

O cliente executa uma sequência de ações: conexão, envio de dados, recebimento da resposta e fechamento da conexão.

Trabalhando com o protocolo UDP

O UDP oferece uma forma mais rápida de transmissão de dados, sem garantias de entrega. Isso o torna adequado para aplicações em tempo real.

Servidor UDP

                    

                        Blogs                    
                    

                                                    
                                

                                    

                                        
                                    
                                    
Observabilidade em Go: tracing, métricas e logs para profissionais
                                
                            
                                                    
                                

                                    

                                        
                                    
                                    
Por que &String, &Vec e &Box são más práticas em Rust?