Implemente un carrito de compras en Python con una base de datos Redis administrada por Vultr

Introducción

El servidor Redis es una de las soluciones de bases de datos de código abierto más utilizadas. Redis almacena todos los datos en la memoria para permitir una baja latencia y un alto rendimiento. Estos beneficios hacen que Redis sea adecuado para almacenar datos de carritos de compras para sitios web ocupados, especialmente durante las temporadas altas.

Al realizar pedidos desde un sitio web de comercio electrónico, un cliente generalmente selecciona artículos de una lista de compras y luego los agrega a un carrito de compras. Debajo del capó, el carrito de compras reside en una base de datos. Si bien es práctico usar bases de datos relacionales para manejar los datos del carrito de compras, es posible que dichas bases de datos no funcionen de manera óptima con una gran cantidad de usuarios y su lentitud puede afectar negativamente la experiencia de los usuarios.

Redis tiene varias funciones que puede usar para acelerar el proceso de agregar, eliminar y mostrar datos del carrito de compras en su sitio web. Puedes usar Redis hset , hincrby , hdel y hget comandos en combinación con un hash de Redis (una colección de pares de valores de campo) para lograr todas las funcionalidades del carrito de compras.

Esta guía le muestra cómo implementar una aplicación de carrito de compras con Python y una base de datos Redis administrada en el servidor Ubuntu 20.04.

requisitos previos

Para seguir junto con esta guía:

  • Implemente un servidor Ubuntu 20.04.

  • Crear un no root sudo usuario.

  • Aprovisione una base de datos Vultr Redis administrada. Luego, navegue a su instancia de base de datos de Redis y haga clic en el Visión general pestaña para recuperar su base de datos Detalles de conexión . Esta guía utiliza los siguientes detalles de conexión de muestra:

    • nombre de usuario : default

    • clave : EXAMPLE_PASSWORD

    • anfitrión : SAMPLE_DB_HOST_STRING.vultrdb.com

    • Puerto : 16752

1. Crear una clase central de Redis

Cuando se diseñan aplicaciones de Python, es convencional configurar clases separadas para funciones básicas para promover la reutilización del código y reducir la repetición. Esta guía utiliza una clase central de Redis que maneja diferentes funciones para agregar, quitar, eliminar y enumerar elementos del carrito de compras del servidor de Redis. Siga los pasos a continuación para crear la clase:

  1. Comience por crear un project directorio para separar su código fuente de Python del resto de los archivos de Linux.

                              
                                $ mkdir project
    
                              
                            
  2. Cambiar a lo nuevo project directorio.

                              
                                $ cd project
    
                              
                            
  3. abrir un nuevo redis_gateway.py archivo en un editor de texto.

                              
                                $ nano redis_gateway.py
    
                              
                            
  4. Enter la siguiente información en el redis_gateway.py expediente. Reemplace la db_host , db_port y db_pass valores con la información de base de datos correcta de su base de datos de Redis administrada.

                              
                                import redis
    
    
    
    class RedisGateway:
    
    
    
        def __init__(self):
    
    
    
            db_host="SAMPLE_DB_HOST_STRING.vultrdb.com"
    
            db_port = 16752
    
            db_pass="EXAMPLE_PASSWORD"   
    
    
    
            self.redisClient = redis.Redis(host = db_host, port = db_port, password = db_pass, ssl="true")
    
    
    
        def add_to_cart(self, json_payload):
    
    
    
            cart_id = json_payload["cart_id"]
    
            product_name = json_payload["product_name"]
    
            quantity = json_payload["quantity"]
    
    
    
            if self.redisClient.hexists(cart_id , product_name):
    
    
    
                self.redisClient.hincrby(cart_id , product_name, quantity)
    
    
    
            else:   
    
    
    
                self.redisClient.hset(cart_id, product_name, quantity)                   
    
    
    
            return "Item added to cart successfully."
    
    
    
        def remove_from_cart(self, json_payload):
    
    
    
            cart_id = json_payload["cart_id"]
    
            product_name = json_payload["product_name"]
    
    
    
    
    
            if self.redisClient.hexists(cart_id, product_name):
    
    
    
                self.redisClient.hdel(cart_id, product_name)
    
    
    
                return "Item removed from cart."
    
    
    
            else:   
    
    
    
                return "Item not found from cart."
    
    
    
        def get_cart(self, cart_id):
    
    
    
            result = self.redisClient.hgetall(cart_id)        
    
    
    
            return result
    
                              
                            
  5. Guardar y close la redis_gateway.py expediente.

Explicación del archivo redis_gateway.py

  • los redis_gateway.py el archivo tiene uno RedisGateway clase.

  • los RedisGateway La clase tiene cuatro métodos.

    1. los __init__() La función se activa cuando importa e inicializa la clase por primera vez.

    2. los add_to_cart(..., json_payload) función toma un json_payload que contiene el cart_id la product_name y el quantity que estás agregando al carrito. Bajo la add_to_cart() función, primero está verificando si existe un carrito en el servidor Redis ejecutando el self.redisClient.hexists función. Si el carrito existe, está utilizando el self.redisClient.hincrby... Comando para agregar la nueva cantidad al carrito. De lo contrario, si un carro con el definido cart_id no existe, lo estás creando desde cero. Entonces, estás usando el self.redisClient.hset(cart_id, product_name, quantity) Comando para agregar el nuevo nombre del producto y la cantidad.

    3. los remove_from_cart(self, json_payload) La función acepta una carga JSON con el nombre del producto que desea eliminar del carrito. Estás usando la lógica. if self.redisClient.hexists(cart_id, product_name): declaración para verificar si el producto existe en el servidor Redis antes de emitir el self.redisClient.hdel(cart_id, product_name) dominio.

    4. los get_cart(..., cart_id) la función toma la cart_id y consulta el servidor de Redis para enumerar todos los artículos en el carrito usando el self.redisClient.hgetall(cart_id) dominio.

  • los RedisGateway ahora está listo. Puede hacer referencia a él en otros archivos de código fuente y usar sus métodos usando la siguiente sintaxis:

                              
                                import redis_gateway  
    
    rg = redis_gateway.RedisGateway()
    
    
    
    resp = rg.add_to_cart(json_payload);
    
    resp = rg.remove_from_cart(json_payload);
    
    resp = rg.get_cart(cart_id);
    
                              
                            

Con una puerta de enlace Redis central lista, siga el siguiente paso para crear el archivo principal para su aplicación.

2. Crea el archivo principal de Python

Cada aplicación de Python debe tener un archivo principal que se activa cuando inicia la aplicación. Esta guía utiliza la main.py archivo como punto de partida. Cree el archivo siguiendo los pasos a continuación:

  1. abrir un nuevo main.py archivo en un editor de texto.

                              
                                $ nano main.py
    
                              
                            
  2. Enter la siguiente información en el main.py expediente.

                              
                                import http.server
    
    from http import HTTPStatus
    
    from urllib.parse import urlparse, parse_qs
    
    
    
    import socketserver
    
    import json
    
    
    
    import redis_gateway        
    
    
    
    class httpHandler(http.server.SimpleHTTPRequestHandler):
    
    
    
        def do_POST(self):
    
    
    
            content_length = int(self.headers['Content-Length'])
    
            post_data = self.rfile.read(content_length)
    
    
    
            json_payload = json.loads(post_data) 
    
    
    
            self.send_response(HTTPStatus.OK)
    
            self.end_headers()
    
    
    
            rg = redis_gateway.RedisGateway()
    
    
    
            resp = rg.add_to_cart(json_payload);                
    
    
    
            self.wfile.write(bytes(resp + 'rn', "utf8"))
    
    
    
        def do_DELETE(self):
    
    
    
            content_length = int(self.headers['Content-Length'])
    
            post_data = self.rfile.read(content_length)
    
    
    
            json_payload = json.loads(post_data) 
    
    
    
            self.send_response(HTTPStatus.OK)
    
            self.end_headers()
    
    
    
            rg = redis_gateway.RedisGateway()
    
    
    
            resp = rg.remove_from_cart(json_payload);                
    
    
    
            self.wfile.write(bytes(resp + 'rn', "utf8"))
    
    
    
        def do_GET(self):
    
    
    
            self.send_response(HTTPStatus.OK)
    
            self.end_headers()
    
    
    
            parsed_url = urlparse(self.path)
    
            params = parse_qs(parsed_url.query)
    
    
    
            cart_id = params['cart_id'][0]
    
    
    
            rg = redis_gateway.RedisGateway()  
    
    
    
            cart = rg.get_cart(cart_id)
    
    
    
            data = { y.decode('ascii'): cart.get(y).decode('ascii') for y in cart.keys() }
    
    
    
            resp = json.dumps(data, indent = 4, separators = (',', ': '))    
    
    
    
            self.wfile.write(bytes(resp + "rn", "utf8"))
    
    
    
    httpServer = socketserver.TCPServer(('', 8080), httpHandler)
    
    
    
    print("HTTP server started at port 8080...")
    
    
    
    try:
    
    
    
        httpServer.serve_forever()
    
    
    
    except KeyboardInterrupt:
    
    
    
        httpServer.server_close()
    
        print("The server is stopped.")
    
                              
                            
  3. Guardar y close la main.py expediente.

El archivo main.py explicado

  • los import ... le permite importar todos los módulos de Python necesarios requeridos por su aplicación. los http.server , HTTPStatus , urlparse , parse_qs y socketserver Los módulos ofrecen funcionalidades HTTP a la aplicación. los json El módulo le permite dar formato a las respuestas en la respuesta JSON estándar. Luego, para conectarse al servidor Redis, está importando su personalizado redis_gateway módulo.

  • los httpHandler clase maneja todos los métodos HTTP. Estos son, POST , DELETE y GET . Estos métodos coinciden con las siguientes funciones del carrito de compras.

    • POST : rg.add_to_cart(...) . Agrega artículos al carrito.

    • DELETE : rg.remove_from_cart(...) . Elimina artículos del carrito.

    • GET : rg.get_cart(...) . Enumera todos los artículos del carrito.

  • los httpServer = socketserver.TCPServer(('', 8080), httpHandler) declaración inicia un servidor HTTP en el puerto 8080 y declara httpHandler como la clase de controlador.

Su aplicación ya está lista. Siga el siguiente paso para probar la aplicación.

3. Pruebe la aplicación del carrito de compras de Redis

El paso final es instalar los módulos de Python de terceros requeridos por su aplicación y ejecutar algunas pruebas para asegurarse de que todo funcione.

  1. Instalar el pitón pip paquete. Esta es una herramienta para descargar e instalar módulos de Python.

                              
                                $ sudo apt update
    
    $ sudo apt install -y python3-pip
    
                              
                            
  2. Utilizar el pip paquete para instalar el redis módulo para Python.

                              
                                $ pip install redis
    
                              
                            
  3. Ejecute la aplicación usando el python3 mando seguido de la puesta en marcha main.py expediente.

                              
                                $ python3 main.py
    
                              
                            

    Producción.

                              
                                HTTP server started at port 8080...
    
                              
                            
  4. Establezca otra conexión SSH al servidor y use Linux curl comando para enviar las siguientes solicitudes a la aplicación.

    • Agregue tres artículos a un carrito usando abc como el cart_id .

                                    
                                      $ curl -X POST https://localhost:8080/ -H 'Content-Type: application/json' -d '{"cart_id": "abc", "product_name": "SMART WATCH", "quantity": "4"}'
      
      
      
      $ curl -X POST https://localhost:8080/ -H 'Content-Type: application/json' -d '{"cart_id": "abc", "product_name": "4G WIRELESS ROUTER", "quantity": "7"}'
      
      
      
      $ curl -X POST https://localhost:8080/ -H 'Content-Type: application/json' -d '{"cart_id": "abc", "product_name": "500W JUICER", "quantity": "2"}'
      
                                    
                                  

      Producción.

                                    
                                      ...
      
      Item added to cart successfully.
      
                                    
                                  
    • Recupera artículos del carrito.

                                    
                                      $ curl -X GET 'https://localhost:8080?cart_id=abc'
      
                                    
                                  

      Producción.

                                    
                                      {
      
          "SMART WATCH": "4",
      
          "4G WIRELESS ROUTER": "7",
      
          "500W JUICER": "2"
      
      }
      
                                    
                                  
    • Eliminar un solo artículo del carrito.

                                    
                                      $ curl -X DELETE https://localhost:8080/ -H 'Content-Type: application/json' -d '{"cart_id": "abc", "product_name": "SMART WATCH"}'
      
                                    
                                  

      Producción.

                                    
                                      Item removed from cart.
      
                                    
                                  

Conclusión

Esta guía implementa una solución de carrito de compras con Python y una base de datos Redis administrada de Vultr en el servidor Ubuntu 20.04. Utilice el código fuente de muestra de esta guía cuando cree su próxima aplicación de carrito de compras. La implementación del carrito de compras de Redis mejora la experiencia de los usuarios al permitir que su aplicación maneje muchos pedidos durante el pico.

Lea los siguientes documentos para obtener más información sobre los casos de uso de Redis.

  • Cómo administrar datos de sesión de PHP con Redis en Ubuntu 20.04.

  • Caché de datos MySQL con Redis y PHP en Ubuntu 20.04.

  • Implemente transacciones y bloqueos de Redis con Golang y MySQL en un servidor Linux.

Título del artículo Nombre (opcional) Correo electrónico (opcional) Descripción

Enviar sugerencia

Related Posts