Introducción a la programación de redes en Python

() translation by (you can also view the original English article)

Este tutorial te ofrecerá una introducción a los sockets en Python y cómo utilizar el módulo de socket para crear servidores y clientes HTTP en Python. También se incluirá a Tornado, una biblioteca de redes de Python que es ideal para sondeos largos, WebSockets y otras aplicaciones que requieren una conexión de larga duración para cada usuario.

¿Qué son los sockets?

Un socket es un enlace entre dos aplicaciones que pueden comunicarse entre sí (ya sea localmente en una sola máquina o a distancia entre dos máquinas en ubicaciones separadas).

Básicamente, los sockets actúan como un enlace de comunicación entre dos entidades, es decir, un servidor y un cliente. Un servidor dará la información solicitada por un cliente. Por ejemplo, cuando visitaste esta página, el navegador creó un socket y se conectó al servidor.

El módulo de socket

Para crear un socket, se utiliza la función socket.socket (), y la sintaxis es tan simple como:

1	import socket
2	s= socket.socket (socket_family, socket_type, protocol=0)

Aquí está la descripción de los argumentos:

socket_family: representa la familia de direcciones (y el protocolo). Puede ser AF_UNIX o AF_INET.
socket_type: representa el tipo de socket y puede ser SOCK_STREAM o SOCK_DGRAM.
protocol: este es un argumento opcional y, por lo general, su valor predeterminado es 0.

Después de obtener tu objeto del socket, puedes crear un servidor o un cliente según se desee usando los métodos disponibles en el módulo de socket.

Crea un cliente simple

Antes de iniciar, veamos los métodos de socket de cliente disponibles en Python.

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect(): Inicia una conexión con el servidor TCP.

Para crear un nuevo socket, primero importa el método de socket de la clase de socket.

1	import socket

Después, crearemos un socket de flujo (TCP) de la siguiente forma:

1	stream_socket = socket.socket( socket.AF_INET, socket.SOCK_STREAM )

El argumento AF_INET indica que estás solicitando un socket de Protocolo de Internet (IP), específicamente IPv4. El segundo argumento es el tipo de protocolo de transporte SOCK_STREAM para sockets TCP. Asimismo, también puedes crear un socket IPv6 especificando el argumento del socket AF_INET6.

Especifica el servidor.

1	server = "localhost"

Especifica el puerto con el que nos queremos comunicar.

port =80

Conecta el socket al puerto donde el servidor está escuchando.

1	server_address = ((host, port))
2	stream_socket.connect(server_address)
3

Es importante tener en cuenta que el host y el puerto deben ser una tupla.

Envía una solicitud de datos al servidor:

1	message = 'message'
2	stream_socket.sendall(message)

Obtén la respuesta del servidor:

1	data = sock.recv(10)
2	print data

Para cerrar un socket conectado, se utiliza el método de cierre:

1	stream_socket.close()

A continuación se muestra el código completo para el cliente/servidor.

import socket
import sys

# Create a TCP/IP socket
stream_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# Define host
host = 'localhost'

# define the communication port
port = 8080

# Connect the socket to the port where the server is listening
server_address = ((host, port))

print "connecting"

stream_socket.connect(server_address)


# Send data
message = 'message'
stream_socket.sendall(message)

# response
data = stream_socket.recv(10)
print data


print 'socket closed'
stream_socket.close()

Crea un servidor simple

Ahora veamos un simple servidor Python. Los siguientes son los métodos de servidor con socket disponibles en Python.

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind(): enlaza la dirección (nombre del host, número de puerto) al socket.
s.listen (): configura e inicia TCP listener.
s.accept (): acepta la conexión del cliente TCP.

Seguiremos los siguientes pasos:

Crea un socket.
Enlaza el socket a un puerto
Empieza a aceptar conexiones en el socket.

Aquí está el programa del servidor.

import socket
import sys

# Create a TCP/IP socket
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# Define host
host = 'localhost'

# define the communication port
port = 8080

# Bind the socket to the port
sock.bind((host, port))
# Listen for incoming connections
sock.listen(1)

# Wait for a connection
print 'waiting for a connection'
connection, client = sock.accept()

print client, 'connected'

# Receive the data in small chunks and retransmit it

data = connection.recv(16)
print 'received "%s"' % data
if data:

    connection.sendall(data)
else:
    print 'no data from', client


# Close the connection
connection.close()

El servidor ahora está listo para las conexiones entrantes.

Ahora ejecuta los programas del cliente y del servidor en ventanas de terminal separadas, para que puedan comunicarse entre sí.

Salida del servidor

1	$ python server.py
2	waiting for a connection
3	('127.0.0.1', 47050) connected
4	received "message"

Salida del cliente

1	$ python client.py
2	connecting
3	message
4	socket closed

El framework Tornado

El framework Tornado es una de las bibliotecas disponibles para la programación de redes en Python. En esta sección, analizaremos esta biblioteca y mostraremos cómo utilizarla para crear WebSockets.

Tornado es un framework web para Python y una biblioteca de redes asincrónicas. Tornado utiliza la red de I/O (entrada/salida) sin bloqueo y, por consiguiente, es capaz de escalar hasta decenas de miles de conexiones abiertas. Este atributo lo hace ideal para sondeos largos, WebSockets y otras aplicaciones que requieran una conexión duradera con cada usuario.

Vamos a crear un simple WebSocket con Tornado:

import tornado.ioloop
import tornado.web


class ApplicationHandler(tornado.web.RequestHandler):

    def get(self):
        self.message = message = """<html>
<head>
    <title>Tornado Framework</title>

</head>
<body
    <h2>Welcome to the Tornado framework</h2>
</body>
</html>"""
        self.write(message)


if __name__ == "__main__":
    application = tornado.web.Application([
        (r"/", ApplicationHandler),
    ])
    application.listen(5001)
    tornado.ioloop.IOLoop.instance().start()

En el código anterior:

Definimos la clase ApplicationHandler que sirve como controlador para una solicitud y devuelve una respuesta usando el método write().
El método main es la entrada para el programa.
tornado.web.Application crea una base para la aplicación web y toma una colección de controladores, es decir, ApplicationHandler.
La aplicación escucha en el puerto 5000, y un cliente puede comunicarse con esta aplicación utilizando el mismo puerto.
tornado.ioloop.IOLoop.instance().start() crea un hilo sin bloqueo para una aplicación.

Si ejecutamos la aplicación, obtendremos el resultado como se muestra en la siguiente captura de pantalla.

Conclusión

A estas alturas, ya debes haber comprendido los fundamentos de la programación de sockets en Python y cómo puedes crear un servidor y un cliente simples. Siéntete libre de experimentar creando tu propio cliente de chat. Para obtener más información, visita la documentación oficial de Python.

Asimismo, no dudes en ver lo que tenemos disponible para la venta y para el estudio en Envato Market, y no dudes en hacer cualquier pregunta y aportar tu valiosa retroalimentación usando el feed de abajo.