Comunicación en Tiempo Real de Slack con tu Aplicación Python Alojada en Kinsta

En el ámbito del alojamiento de alto rendimiento y las herramientas de desarrollo versátiles, Kinsta destaca como plataforma líder que ofrece WordPress, aplicaciones, bases de datos e incluso Alojamiento gratuito de Sitios Estáticos.

Slack, conocido por sus Comandos Slash, se integra perfectamente con las aplicaciones y servicios alojados en Kinsta, permitiendo a los usuarios automatizar tareas y mejorar significativamente la eficiencia.

Esta guía explica cómo configurar la comunicación en tiempo real entre Slack y una aplicación Python alojada en Kinsta. Al aprovechar los Comandos Slash (Slash Commands) , los usuarios de la aplicación adquieren la capacidad de crear, consultar y eliminar productos rápidamente.

Esta integración les permite actualizar dinámicamente su inventario de productos, garantizando respuestas rápidas a las necesidades de los clientes.

Entender los Comandos Slash de Slack

Los Comandos Slash de Slack son atajos basados en texto. Comienzan con una barra inclinada (/) seguida de una palabra clave específica y un parámetro opcional.

Los Comandos Slash desencadenan acciones o interactúan directamente con integraciones dentro de la interfaz de Slack. Por ejemplo, /remind permite establecer recordatorios directamente a través de las notificaciones de Slack.

Con las integraciones de Slack, puedes configurar comandos a medida para tus aplicaciones. En este tutorial, tu equipo puede consultar sin esfuerzo el inventario de nuestra aplicación de productos utilizando el comando Slash /check_inventory y otros comandos.

Integrar Slack con tus aplicaciones fomenta una interacción fluida y flujos de trabajo optimizados en un lugar de trabajo moderno. Mejora la comunicación y la productividad mediante:

• Un centro de comunicación centralizado — Slack actúa como un espacio unificado para los equipos. La integración de aplicaciones en Slack consolida los canales, manteniendo las conversaciones y la información en un solo lugar, e impulsando la eficiencia.
• Actualizaciones en tiempo real — Las aplicaciones integradas proporcionan alertas instantáneas sobre eventos clave, garantizando que todos estén informados y reaccionen rápidamente a los cambios o actualizaciones.
• Flujos de trabajo racionalizados — Las integraciones automatizan tareas como las notificaciones de las herramientas de gestión de proyectos o la activación de acciones en el software CRM, reduciendo el trabajo manual.
• Colaboración mejorada — Los miembros del equipo que acceden a las aplicaciones directamente desde Slack fomentan una colaboración sin fisuras. Pueden compartir, editar archivos y discutir proyectos fácilmente, fomentando el trabajo en equipo en todas las funciones.

Cómo Construir una Aplicación Python en Kinsta

Vamos a construir y desplegar una aplicación de gestión de productos en Kinsta. Después, intégrala con Slack para explorar los Comandos Slash. Los usuarios pueden añadir, eliminar y consultar los productos del inventario mediante Comandos Slash en Slack.

Requisitos Previos

Para seguir esta guía, asumimos que tienes:

• Conocimientos básicos de Python
• Una cuenta de Slack

En primer lugar, vamos a configurar un proyecto Python en Kinsta. Para ello, sigue los pasos que se indican a continuación:

1. Visita la plantilla Python de Kinsta en GitHub.
2. Selecciona Usar esta plantilla > Crear un nuevo repositorio para copiar el código de inicio en un repositorio dentro de tu cuenta de GitHub.
3. Una vez que tu repositorio esté listo, inicia sesión o crea una cuenta para ver tu panel MyKinsta.
4. Autoriza a Kinsta con tu proveedor de Git (Bitbucket, GitHub o GitLab).
5. Haz clic en Aplicaciones en la barra lateral izquierda, y luego en Añadir aplicación.
6. Selecciona el repositorio y la rama desde la que deseas desplegar.
7. Asigna un nombre único a tu aplicación y elige una ubicación para el centro de datos.
8. A continuación, configura tu entorno de construcción. Selecciona la configuración Estándar de la máquina de construcción con la opción Nixpacks recomendada para esta demo.
9. Utiliza todas las configuraciones por defecto y luego haz clic en Crear aplicación.

El despliegue suele tardar unos minutos y, si se realiza correctamente, recibirás un enlace a tu aplicación junto con un panel de control que contiene información sobre el despliegue.

Cómo Configurar la Integración de Slack en una Aplicación Python

Empecemos creando una aplicación Slack y luego configuremos los comandos Slash que se conectarían a tu aplicación Python a través de algunos tokens. Vamos a configurar una aplicación Slack:

1. Accede al panel de la API de Slack.
2. Haz clic en Crear Nueva App y elige Desde Cero.
3. Ponle un nombre a tu app Slack (por ejemplo, producto-inventario).
4. Selecciona el espacio de trabajo y haz clic en Crear Aplicación.

Ahora, para la autenticación:

1. Activa el Modo Socket en la barra lateral de tu panel de control de Slack.
2. Genera un token a nivel de aplicación escribiendo un nombre de token y haciendo clic en Generar.
3. Guarda este código de nivel de aplicación para configurar las variables de entorno más adelante.

Cómo Configurar los Comandos Slash

Para configurar los Comandos Slash de tu app:

1. Ve a la sección Características en Información Básica en el panel de control de la API de Slack. Selecciona Comandos Slash.

   

2. Haz clic en Crear Nuevo Comando para configurar un nuevo comando.

   

3. En la página Crear Nuevo Comando, rellena los detalles de tu nuevo Comando Slash. Por ejemplo, escribe /hi en el campo Comando. Opcionalmente, añade una breve descripción como «¡Saluda!» y proporciona una sugerencia de uso. Haz clic en Guardar.
4. En la sección Instalar Aplicación de la barra lateral, haz clic en Instalar en el Espacio de Trabajo.
5. Accede al token OAuth del usuario bot dirigiéndote a OAuth y Permisos en la barra lateral. Guarda este token para futuras consultas.

Cómo Añadir Tokens al Despliegue de Aplicaciones de Kinsta

1. Ve a la sección Variables de Entorno en Configuración del despliegue de tu aplicación en MyKinsta.
2. Haz clic en Añadir variable de entorno.

   

3. Para la Clave 1, SLACK_BOT_TOKEN, pega el token OAuth del usuario bot en el Valor 1. Para la Clave 2, SLACK_APP_TOKEN, pega el token a nivel de aplicación en el Valor 2.
4. Asegúrate de que ambas opciones están marcadas y haz clic en Desplegar ahora para que Kinsta pueda volver a desplegar tu aplicación con las variables de entorno.

Cómo Implementar la Comunicación en Tiempo Real

Para esta demo, utilizas la plantilla Python de Kinsta, que contiene los siguientes archivos:

• Procfile — Especifica los comandos para ejecutar tu aplicación.
• requirements.txt — Enumera las dependencias necesarias para la aplicación Python.
• server.py — El archivo principal de la aplicación Python, que maneja las funcionalidades u operaciones del lado del servidor.

Kinsta crea automáticamente un proceso basado en el Procfile en la raíz del repositorio al desplegar una aplicación. El Procfile contiene el siguiente código.

web: python server.py

Este comando ejecuta el código que contiene server.py. Kinsta también instala las dependencias de Python en requirements.txt durante el despliegue y el redespliegue.

Ahora, vamos a utilizar el framework Bolt para establecer una comunicación en tiempo real con tu aplicación. Añade las siguientes líneas a tu archivo requirements.txt para instalar automáticamente Bolt en tu aplicación Python cuando actualices el repositorio.

slack-bolt==1.18.0
slack-sdk==3.23.0

Añade también la biblioteca psycopg2 al archivo requirements.txt. Se utilizará para conectar con una base de datos Postgres.

psycopg2-binary==2.9.9

Cómo Implementar una Base de Datos Postgres con Kinsta

La aplicación de inventario de productos necesita una forma de persistir los datos de los productos que Slash Commands añade a la base de datos. Para crear un almacenamiento de datos persistente, puedes utilizar la base de datos alojada de Kinsta.

1. En primer lugar, despliega una base de datos Postgres en tu panel de control de Kinsta accediendo a la sección Bases de datos en la barra lateral del panel de control de MyKinsta.
2. Haz clic en Crear una base de datos. Configura los detalles de tu base de datos introduciendo un nombre y seleccionando el tipo de base de datos. Selecciona la opción PostgreSQL y configura el tamaño deseado. Se generará automáticamente un nombre de usuario y una contraseña para la base de datos:

   

3. Haz clic en Continuar para terminar de configurar la base de datos. Espera a que se cree la base de datos PostgreSQL.
   Una vez creada, para obtener la cadena de conexión para el acceso externo a tu base de datos, ve a la sección Conexiones externas del panel de control de tu base de datos desplegada y copia la Cadena de conexión externa.

   

   Ahora, puedes utilizar esta cadena de conexión para conectarte a la base de datos desde tu aplicación Python.

4. En tu proyecto Python, crea un archivo db.py dentro del directorio de tu proyecto para las funciones de inicialización de la base de datos. Añade el siguiente código:

   import psycopg2
   import os
   
   # get connection string from environment variable
   connection_string = os.environ.get("DATABASE_CONNECTION_STRING")
    
   def get_conn():
      # create connection
      conn = psycopg2.connect(connection_string)
   
      # Return connection to the database
      return conn
        
   def init_db():
      # get connection
      conn = get_conn()
   
      # get cursor
      cur = conn.cursor()
   
      cur.execute("""
          DROP TABLE IF EXISTS products;
                      
          CREATE TABLE products (
              id INTEGER PRIMARY KEY,
              name TEXT UNIQUE NOT NULL,
              quantity INTEGER NOT NULL
          );
      """)
   
      cur.close()
      conn.commit()
      conn.close()

   Cuando se llama a la función get_conn(), crea y devuelve una conexión a la base de datos Kinsta desplegada utilizando tu cadena de conexión externa.

   La función init_db() obtiene una conexión a la base de datos, define el esquema de la base de datos y crea la tabla, a la vez que consigna los cambios. Sólo debes llamar a la función init_db() una vez al configurar inicialmente el servidor de aplicaciones. Utiliza la función get_conn() en llamadas posteriores para obtener una conexión a la base de datos.

Cómo Implementar los Manejadores de Comandos Slash

Ahora, crea el código del servidor de aplicaciones.

1. Elimina el contenido del archivo server.py e importa las siguientes bibliotecas:

   import os
   from slack_bolt import App
   from slack_bolt.adapter.socket_mode import SocketModeHandler
   from db import get_conn, init_db
   from psycopg2 import DatabaseError

   Éstas son necesarias para la funcionalidad de la aplicación Slack, las conexiones a la base de datos y la gestión de errores.

2. Añade el siguiente código al archivo server.py después de las sentencias import:

   # Initialize your app with your bot token
   app = App(
     token=os.environ.get("SLACK_BOT_TOKEN"),
   )

   La clase App de slack_bolt se utiliza para crear una instancia de la aplicación Slack. Inicializa la aplicación con el token OAuth del usuario bot recuperado de la variable de entorno SLACK_BOT_TOKEN.

3. A continuación, despliega un manejador para el comando /hi Slash que añadiste antes a tu aplicación Slack. Añade las siguientes líneas al archivo server.py.

   # The hi command simply sends back a greeting
   @app.command("/hi")
   def send_hello(ack, respond, command):
     # Acknowledge command request
     ack()
     respond(f"Hello!")

   @app.command() crea una escucha para la cadena de comandos pasada como argumento y asigna la siguiente función para las peticiones de ese Comando Slash. La función send_hello() se encarga de la lógica de las solicitudes.

   El código también pasa las variables de solicitud ack, respond y command para que las utilice la función. Llama a ack para reconocer la solicitud del Comando Slash, ya que es el primer paso antes de continuar el procesamiento, y llama a respond para devolver una respuesta de texto.

   Cuando el usuario escriba el comando Slash /hi en tu espacio de trabajo Slack, obtendrá la respuesta «¡Hola!»

4. Vuelve al panel de control de tu aplicación Slack y añade los siguientes comandos.
   

   Comando	Descripción breve	Uso Sugerencia
   /add_product	Añade un producto al inventario.	id_producto, nombre_producto, cantidad_producto
   /check_inventory	Buscar un producto con un ID coincidente en el inventario.	producto_id
   /delete_product	Eliminar del inventario un producto con un ID coincidente.	producto_id

   Ahora, tu página de Comandos de Slash debería parecerse a la siguiente captura de pantalla, que contiene una lista de comandos y sus detalles.

   

5. Añade el manejador /add_product al archivo server.py.

   # command to add products
   @app.command("/add_product")
   def add_product(ack, respond, command, request):
    #Acknowledge command request
    ack()
   
    # Extract payload from request
    payload = request.body['text']
    id, name, quantity = [i.strip() for i in payload.split(",")]
     
    # conn object
    conn = None
   
    try:
      # get conn
      conn = get_conn()
   
      # get cursor
      cur = conn.cursor()
   
      # Insert product into the database
      cur.execute(
        "INSERT INTO products (id, name, quantity) VALUES (%s, %s, %s)",
          (int(id), name, int(quantity))
      )
      
      # close communication with postgresql
      cur.close()
      
      # commit changes
      conn.commit()
      
      # Response
      respond(f"""Added product to inventory:
        id - {id},
        name - {name},
        quantity - {quantity}
      """)
   
    except DatabaseError:
      # Send a response
      respond(f"Product with ID {id} exists in inventory!")
     
    finally:
      # close connection
      if conn is not None:
        conn.close()

   request.body accede al payload completo que Slack envía durante el proceso de manejo.

   Cuando un usuario escribe el comando /add_product Slash, la aplicación envía el siguiente payload JSON de muestra como una solicitud POST.

   {
       'token': , 
       'team_id': , 
       'team_domain': , 
       'channel_id': , 
       'channel_name': , 
       'user_id': , 
       'user_name': , 
       'command': '/add_product', 
       'text': '1, notebook, 5', 
       'api_app_id': , 
       'is_enterprise_install': , 
       'response_url': , 
       'trigger_id': 
   }

   Se incluyen los campos command y text. command contiene el Comando Slash activado, mientras que text contiene su texto adicional. Por ejemplo, si el usuario escribe el comando /add_product 1, notebook, 5, text contiene «1, cuaderno, 5».

   El manejador add_product extrae el ID, el nombre y la cantidad del producto de la solicitud del usuario y se conecta a la base de datos utilizando la función de ayuda get_conn(). También ejecuta una operación SQL de inserción para añadir el producto a la base de datos. Si el ID del producto ya existe en la base de datos, el código gestiona el error y responde que el ID ya existe.

6. Ahora, añade el resto de los manejadores de comandos al archivo server.py.

   # command to check inventory for a product_id
   @app.command("/check_inventory")
   def check_inventory(ack, respond, command, request):
      # Acknowledge command request
      ack()
   
      # Extract payload from request
      id = request.body['text'].strip()
   
      # Get a database connection
      conn = None
      try:
          # get conn
          conn = get_conn()
   
          # get cursor
          cur = conn.cursor()
    
          # Fetch matching product with ID from database
          cur.execute(
              "SELECT * FROM products WHERE id=%s",
              (int(id),)
          )
   
          product = cur.fetchone()
   
          # close comms
          cur.close()
   
          if product is None:
              respond(f"No product with matching ID {id} found.")
          else:
              # Deconstruct tuple if the product exists
              _, name, quantity = product
             
              respond(f"""Product with ID {id} found:
                         name - {name},
                         quantity - {quantity}
                     """)
            
      except Exception as e:
          print("Connection error: %s", e)
            
      finally:
          # close connection
          if conn is not None:
              conn.close()
   
   # command to delete the matching product_id from inventory
   @app.command("/delete_product")
   def delete_product(ack, respond, command, request):
       #Acknowledge command request
       ack()
   
       # Extract payload from request
       id = request.body['text'].strip()
       
       # Get connection
       conn = None
       try:
           # Get connection
           conn = get_conn()
      	 
           # get cursor
           cur = conn.cursor()
      	 
           # Insert the product into the database
           cur.execute(
           	"DELETE FROM products WHERE id = %s",
           	(int(id),)
           )
           cur.close()
           conn.commit()
      	 
           # Response
           respond(f"Product with ID {id} deleted from inventory!")
       except Exception as e:
           print("Connection error: %s", e)
       finally:
           # close connection
           if conn is not None:
               conn.close()
   

   Estos dos manejadores de comandos consultan y eliminan el ID de producto coincidente en el inventario, respectivamente.

Cómo Ejecutar el Servidor

1. Para unir la inicialización de la base de datos y la conexión al socket, añade las siguientes líneas a tu archivo server.py.

   # Start your app
   if __name__ == "__main__":
       # Initialize database on start
       init_db()
   
       # Connect socket
       handler = SocketModeHandler(app, os.environ["SLACK_APP_TOKEN"])
       handler.start()

   Debes inicializar SocketModeHandler con tu token a nivel de aplicación. Utiliza SLACK_APP_TOKEN para acceder a la variable de entorno desplegada en la aplicación Kinsta.

2. Confirma los cambios en tu repositorio remoto para desplegarlos en Kinsta automáticamente. Ahora, server.py inicializa la base de datos y establece la conexión socket. Kinsta activará un redespliegue automático de tu aplicación Python.

Probar y Solucionar Problemas de tu Aplicación

Puedes probar tu aplicación en Slack utilizando los Comandos Slash configurados.

1. 1. Ve al espacio de trabajo asociado a tu aplicación. Escribe el carácter barra (‘/’) para ver los comandos de la aplicación:

      

   2. Prueba cada uno de los comandos de la barra. Por ejemplo, escribe /hi. Obtendrás la respuesta «¡Hola!»

      

   3. Prueba qué ocurre cuando añades el mismo producto dos veces. Ejecuta el comando de barra /add_product 1, notepad, 2 dos veces.

      

      Como muestra la captura de pantalla anterior, el primer comando funcionó. Añadió un nuevo producto. El segundo comando dio como respuesta que el ID ya existe.

   4. Prueba a buscar el ID del producto que acabamos de añadir. Escribe /check_inventory 1.

      

      La consulta devuelve el producto con el ID coincidente.

   5. Por último, prueba a eliminar el producto que has añadido. Escribe /delete_product 1.

      

Cómo Solucionar Problemas

Al configurar y desplegar tu aplicación, es posible que encuentres errores que debes resolver para que tu aplicación funcione correctamente. Prueba los siguientes métodos para detectar y solucionar los errores típicos.

1. 1. • Verifica tus tokens: Asegúrate de que configuras correctamente tu token a nivel de aplicación con el alcance connections:write para permitir el acceso utilizando el Modo Socket. Además, utiliza los tokens correctos para la clase de app. El token de usuario del bot empieza por xoxb-<...>. Utiliza el token de nivel de aplicación (xapp-<...>) para la clase SocketModeHandler.
      • Verifica tus comandos slash: Asegúrate de haber configurado los Comandos Slash en el panel de control de tu app Slack y de haber configurado los manejadores correctos en el código de tu servidor de aplicaciones.
      • Emplea una mejor gestión de errores: Asegúrate de que la lógica de tu aplicación gestiona correctamente los errores, por ejemplo, al ejecutar operaciones de base de datos.

Resumen

En esta guía, has aprendido a crear una aplicación Python con comunicación en tiempo real a través de los comandos Slash de Slack. También has aprendido a desplegar la aplicación en Kinsta.

La integración de una aplicación alojada en Kinsta con Slack permite a los usuarios realizar cambios rápidamente mediante los comandos Slash, mejorando la interactividad y la eficiencia del flujo de trabajo al tiempo que ofrece acceso inmediato a datos en tiempo real. Ahora el personal puede añadir, eliminar o comprobar el inventario de productos sin salir de su plataforma de comunicaciones, lo que aumenta la productividad durante una ajetreada jornada laboral.

El PaaS de Kinsta ofrece aún más posibilidades — puedes conectar aplicaciones y bases de datos, desplegando soluciones full-stack para empresas y negocios. ¿Y lo mejor? ¡Nosotros nos hacemos cargo de tus primeros 20$!

Jeremy Holcombe Kinsta

Content & Marketing Editor at Kinsta, WordPress Web Developer, and Content Writer. Outside of all things WordPress, I enjoy the beach, golf, and movies. I also have tall people problems ;).

• Sitio web
• LinkedIn