Conceptos básicos de servidor de WebSocket en Python

Python servidor WebSocket : Aquí, vamos a aprender acerca de los conceptos básicos del servidor de WebSocket en Python como lo que es el servidor de WebSocket , dónde y cuándo usarlo , bibliotecas WebSocket pitón, etc.

Qué es un servidor de WebSocket?

En palabras sencillas, un servidor de WebSocket es una escucha aplicación en cualquier servidor de puerto TCP que sigue un protocolo WS llamada (o WSS).

A menudo, un proxy inverso, como un servidor HTTP se utiliza para detectar WebSocket apretones de manos, proceso de ellos, y enviar esos clientes al servidor WebSocket . El protocolo WebSocket fue diseñado para trabajar bien con la infraestructura web existente. Como parte de este principio de diseño, la conexión WebSocket comienza como una conexión HTTP, con la completa compatibilidad con el mundo pre-WebSocket. El cambio de protocolo de HTTP a WebSocket se conoce como apretón de manos.

El cliente envía una cabecera de actualización:

    --- request header ---
GET / HTTP/1.1
Upgrade: websocket
Connection: Upgrade
Host: localhost:4040
Origin: http://localhost:4040
Sec-WebSocket-Key: q0+vBfXgMvGGywjDaHZWiw==
Sec-WebSocket-Version: 13

Si el servidor entiende, el protocolo WebSocket, que está de acuerdo con el protocolo de class a través de la cabecera de actualización.

    -----------------------
--- response header ---
HTTP/1.1 101 Switching Protocols
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Accept: /YqMq5iNGOMjtELPGCZsnozMSlw=
Date: Sun, 15 Sep 2019 23:34:04 GMT
Server: Python/3.7 websockets/8.0.2
-----------------------

En este punto, se rompe la conexión HTTP hacia abajo y se sustituye por una conexión WebSocket través de la conexión TCP / IP subyacente. El WebSocket, similar a HTTP, utiliza HTTP (80) y HTTPS (443) por switch.

Dónde y Cuándo utilizar WebSockets?

  1. aplicaciones en tiempo real – cuando la interfaz de usuario necesita ser actualizada sin los datos default petición del cliente. Aquí WebSockets son más rápidas que con el sondeo de AJAX tradicional, que utiliza HTTP
  2. Gaming Aplicaciones
  3. aplicaciones de chat

Cuando no WebSockets uso? No se requieren

actualizaciones en tiempo real. Los WebSockets, ya que mantiene la conexión viva hasta que uno de los componentes se cierra la conexión. En cambio, los servicios REST son suficientes para obtener los datos desde el servidor.

El uso de bibliotecas de Python para implementar un servidor de WebSocket

Python proporciona muchas bibliotecas para implementar el servidor de WebSocket . Los siguientes son los pocos de muchos disponibles en el mercado. Estas bibliotecas se pueden instalar fácilmente a través de PyPI dentro del entorno virtual o en el entorno Anaconda .

Ejemplo for código de aplicación del servidor de WebSocket

1) el uso de la biblioteca WebSockets (ws_server.py)

import asyncio
import websockets
import time
import json
async def say_hello(websocket, path):
while True:
await websocket.send("hello world")
time.sleep(10)
# the server starts up in localhost and port 4040
start_server = websockets.serve(say_hello,'localhost',4040)
asyncio.get_event_loop().run_until_complete(start_server)
asyncio.get_event_loop().run_forever()

2) el uso de un tornado biblioteca (tornado_ws_server.py)

'''
    This module hosts a websocket server using tornado
    libraries
'''
import tornado.web
import tornado.httpserver
import tornado.ioloop
import tornado.websocket as ws
from tornado.options import define, options
import time
define('port', default=4041, help='port to listen on')
class web_socket_handler(ws.WebSocketHandler):
'''
    This class handles the websocket channel
    '''
@classmethod
def route_urls(cls):
return [(r'/',cls, {}),]
def simple_init(self):
self.last = time.time()
self.stop = False
def open(self):
'''
            client opens a connection
        '''
self.simple_init()
print("New client connected")
self.write_message("You are connected")
def on_message(self, message):
'''
            Message received on the handler
        '''
print("received message {}".format(message))
self.write_message("You said {}".format(message))
self.last = time.time()
def on_close(self):
'''
            Channel is closed
        '''
print("connection is closed")
def check_origin(self, origin):
return True
def initiate_server():
#create a tornado application and provide the urls
app = tornado.web.Application(web_socket_handler.route_urls())
#setup the server
server = tornado.httpserver.HTTPServer(app)
server.listen(options.port)
#start io/event loop
tornado.ioloop.IOLoop.instance().start()
if __name__ == '__main__':
initiate_server()

Configuración del entorno para implementar un WebSocket servidor

  • Crear un entorno virtual
    -bash-4,2 € python3 -m Venv Venv
  • fuente (o activar) el entorno virtual
    -bash-4,2 € fuente Venv / bin / Activar
  • Instalar la biblioteca deseada con pip
  • 	(venv) -bash-4.2$ pip3 install websockets
    Collecting websockets
    Downloading https://files.pythonhosted.org/packages/f0/4b/ad228451b1c071c5c52616b7d4298ebcfcac5ae8515ede959db19e4cd56d/websockets-8.0.2-cp36-cp36m-manylinux1_x86_64.whl (72kB)
    100% |████████████████████████████████| 81kB 2.1MB/s
    Installing collected packages: websockets
    Successfully installed websockets-8.0.2
    (venv) -bash-4.2$
    (venv) -bash-4.2$ pip3 install tornado
    Collecting tornado
    Using cached https://files.pythonhosted.org/packages/30/78/2d2823598496127b21423baffaa186b668f73cd91887fcef78b6eade136b/tornado-6.0.3.tar.gz
    Installing collected packages: tornado
    Running setup.py install for tornado ... done
    Successfully installed tornado-6.0.3
    (venv) -bash-4.2$
    Execute the sample websocket server
    Python3 tornado_ws_server.py
    Or
    Python3 ws_server.py

Wireshark traza de la interacción cliente-servidor

Basic concepts of WebSocket server in Python - 4

Referencias:


Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *