One place for hosting & domains

      Cómo crear un Slackbot en Python en Ubuntu 20.04


      El autor seleccionó el Tech Education Fund para recibir una donación como parte del programa Write for DOnations.

      Introducción

      Slack es una plataforma de comunicación diseñada para la productividad en el lugar de trabajo. Incluye características tales como mensajes directos, canales públicos y privados, llamadas de voz y de video e integraciones bot. Un Slackbot es un programa automatizado que puede realizar múltiples funciones en Slack, desde el envío de mensajes hasta la activación de tareas de alerta en ciertos eventos.

      En este tutorial, creará un Slackbot en el lenguaje de programación Python. Python es un lenguaje popular que se enorgullece de su simplicidad y legibilidad. Slack proporciona una Python Slack API amplia para integrarla con Slack y realizar tareas comunes como enviar mensajes, añadir emojis a los mensajes y mucho más. Slack también proporciona una Python Slack Events API para integrarla con eventos en Slack, lo que le permite realizar acciones en eventos como mensajes y menciones.

      Como una divertida demostración conceptual para ver el poder de Python y sus API de Slack, creará un CoinBot, un Slackbot que supervisa un canal, y, cuando se active, le lanzará una moneda. A continuación, puede modificar su CoinBot para que cumpla con cualquier número de aplicaciones un poco más prácticas.

      Tenga en cuenta que este tutorial utiliza Python 3 y no es compatible con Python 2.

      Requisitos previos

      Para completar los pasos de esta guía, necesitará lo siguiente:

      • Un espacio de trabajo de Slack en el que tiene la capacidad de instalar aplicaciones. Si creó el espacio de trabajo, tiene esta capacidad. Si aún no tiene uno, puede crearlo en el sitio web de Slack.

      • (Opcional) Un servidor o un equipo con una dirección IP pública para su desarrollo. Recomendamos una nueva instalación de Ubuntu 20.04, un usuario no root con privilegios sudo y SSH habilitado. Puede seguir esta guía para inicializar su servidor y completar estos pasos.

      Es posible que quiera probar este tutorial en un servidor que tenga una dirección IP pública. Slack deberá poder enviar eventos como mensajes a su bot. Si está probando en una máquina local, deberá transferir el tráfico por su firewall a su sistema local. Si está buscando una forma de desarrollar en un servidor en la nube, consulte este tutorial sobre Cómo usar Visual Studio Code para el desarrollo remoto a través del complemento Remote-SSH.

      Paso 1: Crear el Slackbot en la IU de Slack

      Primero, cree su aplicación Slack en el Panel de Control de API de Slack. Inicie sesión en su espacio de trabajo en Slack a través de un navegador web y diríjase al Panel de Control de API. Ahora haga clic en el botón Crear una aplicación.

      Crear su aplicación de Slack

      A continuación, se le solicitará el nombre de su aplicación y que seleccione un espacio de trabajo de Slack de desarrollo. Para este tutorial, nombre su aplicación como CoinBot y seleccione un espacio de trabajo al que tenga acceso de administrador. Una vez que haya hecho esto, haga clic en el botón Crear aplicación.

      Nombrar su aplicación de Slack y seleccionar un espacio de trabajo

      Una vez creada su aplicación, verá el siguiente panel de control de aplicación predeterminado. Este panel de control es donde gestiona su aplicación configurando permisos, suscribiéndose a eventos, instalando la aplicación en espacios de trabajo y mucho más.

      Panel de aplicación de Slack predeterminado

      Para que su aplicación pueda enviar mensajes a un canal, deberá conceder permisos de aplicación para ello. Para hacerlo, haga clic en el botón Permisos en el panel de control.

      Seleccionar el botón Permisos en el panel de control

      Cuando llegue a la página OAuth & Permisos, desplácese hacia abajo hasta que encuentre la sección Alcances de la página. A continuación, encuentre la subsección Alcance de token del bot y haga clic en el botón Añadir un alcance de OAuth.

      Seleccionar el botón Añadir un alcance de OAuth

      Haga clic en ese botón y escriba chat:write. Seleccione ese permiso para agregarlo a su bot. Esto permitirá que la aplicación publique mensajes en canales a los que puede acceder. Para obtener más información sobre los permisos disponibles, consulte la documentación de Slack.

      Añada el permiso chat:write

      Ahora que ha agregado el permiso apropiado, es el momento de instalar su aplicación en su espacio de trabajo de Slack. Vuelva a la página OAuth y permisos y haga clic en el botón Instalar aplicación en espacio de trabajo de la parte superior.

      Instalar aplicación en el espacio de trabajo

      Haga clic en este botón y revise las acciones que puede realizar la aplicación en el canal. Una vez que esté satisfecho, haga clic en el botón Permitir para finalizar la instalación.

      Instalar aplicación en el espacio de trabajo

      Una vez instalado el bot verá un Token de acceso OAuth de usuario de bot para que su aplicación lo utilice cuando intente realizar acciones en el espacio de trabajo. Siga y copie este token; lo necesitará más tarde.

      Guardar el Token de acceso

      Por último, añada el bot que acaba de instalar en un canal dentro de su espacio de trabajo. Si aún no ha creado un canal, puede usar el canal #general que se crea de forma predeterminada en su espacio de trabajo de Slack. Busque la aplicación en la sección Apps de la barra de navegación en su cliente Slack y haga clic en ella. Una vez hecho eso, abra el menú Detalles en el lado superior derecho. Si su cliente de Slack no aparece en pantalla completa, tendrá una i en un círculo.

      Hacer clic en el Icono de detalles de la aplicación

      Para terminar de agregar su aplicación a un canal, haga clic en el botón Más representado por tres puntos en la página de detalles y seleccione Añadir esta aplicación a un canal… Escriba su canal en el modal que aparece y haga clic en Añadir.

      Añadir una aplicación a un canal

      Ahora ha creado correctamente su aplicación y la ha añadido a un canal dentro de su espacio de trabajo de Slack. Tras escribir el código para su aplicación, podrá publicar mensajes en ese canal. En la siguiente sección, empezará a escribir el código Python que habilitará CoinBot.

      Paso 2: Configurar su entorno de desarrollo de Python

      Primero, configuraremos su entorno Python para que pueda desarrollar el Slackbot.

      Abra un terminal e instale python3 y las herramientas pertinentes en su sistema:

      • sudo apt install python3 python3-venv

      A continuación, creará un entorno virtual para aislar sus paquetes Python de la instalación del sistema Python. Para hacerlo, primero cree un directorio en el que creará su entorno virtual. Cree un nuevo directorio en ~/.venvs:

      Ahora cree su entorno virtual Python:

      • python3 -m venv ~/.venvs/slackbot

      A continuación, active su entorno virtual para que pueda usar su instalación Python e instale paquetes:

      • source ~/.venvs/slackbot/bin/activate

      Ahora su mensaje de shell mostrará el entorno virtual entre paréntesis. El aspecto será similar a este:

      Ahora utilice pip para instalar los paquetes Python necesarios en su entorno virtual:

      • pip install slackclient slackeventsapi Flask

      slackclient y slackeventsapi facilitan la interacción de Python con las API de Slack. Flask es un marco microweb popular que utilizará para implementar su aplicación:

      Ahora que tiene su entorno de desarrollo configurado, puede comenzar a escribir su Python Slackbot:

      Paso 3: Crear una clase de mensaje de Slackbot en Python

      Los mensajes en Slack se envían a través de una carga útil JSON de formato específico. Este es un ejemplo del JSON que su Slackbot creará y enviará como un mensaje:

      {
         "channel":"channel",
         "blocks":[
            {
               "type":"section",
               "text":{
                  "type":"mrkdwn",
                  "text":"Sure! Flipping a coin....nn"
               }
            },
            {
               "type":"section",
               "text":{
                  "type":"mrkdwn",
                  "text":"*flips coin* The result is Tails."
               }
            }
         ]
      }
      

      Podría crear manualmente este JSON y enviarlo, pero en vez de eso compilaremos una clase Python que no solo elabora esta carga útil sino que también simula el lanzar una moneda.

      Primero, utilice el comando touch para crear un archivo llamado coinbot.py:

      A continuación, abra el archivo con nano o su editor de texto favorito:

      Ahora añada las siguientes líneas de código para importar las bibliotecas pertinentes para su aplicación. La única biblioteca que necesita para esta clase es la biblioteca random de la Biblioteca Estándar Python. Esta biblioteca nos permitirá simular el lanzamiento de una moneda.

      Añada las siguientes líneas a coinbot.py para importar todas las bibliotecas necesarias:

      coinbot.py

      # import the random library to help us generate the random numbers
      import random
      

      A continuación, cree su clase CoinBot y una instancia de esta clase para crear la carga útil del mensaje. Añada las siguientes líneas a coinbot.py para crear la clase CoinBot:

      coinbot.py

      ...
      class CoinBot:
      

      Ahora ponga la sangría en uno y cree las constantes, los constructores y los métodos necesarios para su clase. Primero, crearemos la constante que mantendrá la base de su carga útil de mensaje. Esta sección especifica que esta constante es del tipo de sección y que el texto se formateará a través de marcado. También especifica el texto que desea mostrar. Puede leer más sobre las diferentes opciones de carga útil en la documentación oficial de carga útil del mensaje de Slack.

      Añada las siguientes líneas a coinbot.py para crear la plantilla base para la carga útil:

      coinbot.py

      ...
          # Create a constant that contains the default text for the message
          COIN_BLOCK = {
              "type": "section",
              "text": {
                  "type": "mrkdwn",
                  "text": (
                      "Sure! Flipping a coin....nn"
                  ),
              },
          }
      

      A continuación, cree un constructor para su clase para que pueda crear una instancia separada de su bot para cada solicitud. No se preocupe por la sobrecarga de memoria aquí; el recolector de basura Python limpiará estas instancias una vez que ya no se necesiten. Este código establece el canal receptor basado en un parámetro transmitido al constructor.

      Añada las siguientes líneas a coinbot.py para crear el constructor:

      coinbot.py

      ...
          # The constructor for the class. It takes the channel name as the a
          # parameter and sets it as an instance variable.
          def __init__(self, channel):
              self.channel = channel
      

      Ahora escriba el código que simula lanzar una moneda. Generaremos aleatoriamente un uno o un cero, lo que representa cara o cruz respectivamente.

      Añada las siguientes líneas a coinbot.py para simular el lanzamiento de una moneda y devolver la carga útil creada.

      coinbot.py

      ...
          # Generate a random number to simulate flipping a coin. Then return the
          # crafted slack payload with the coin flip message.
          def _flip_coin(self):
              rand_int =  random.randint(0,1)
              if rand_int == 0:
                  results = "Heads"
              else:
                  results = "Tails"
      
              text = f"The result is {results}"
      
              return {"type": "section", "text": {"type": "mrkdwn", "text": text}},
      

      Por último, cree un método que elabore y devuelva toda la carga útil del mensaje, incluidos los datos de su constructor, llamando a su método _flip_coin.

      Añada las siguientes líneas a coinbot.py para crear el método que generará la carga útil terminada:

      coinbot.py

      ...
          # Craft and return the entire message payload as a dictionary.
          def get_message_payload(self):
              return {
                  "channel": self.channel,
                  "blocks": [
                      self.COIN_BLOCK,
                      *self._flip_coin(),
                  ],
              }
      

      Ahora ha terminado con la clase CoinBot y está listo para probarlo. Antes de continuar, verifique que su archivo terminado, coinbot.py, contenga lo siguiente:

      coinbot.py

      # import the random library to help us generate the random numbers
      import random
      
      # Create the CoinBot Class
      class CoinBot:
      
          # Create a constant that contains the default text for the message
          COIN_BLOCK = {
              "type": "section",
              "text": {
                  "type": "mrkdwn",
                  "text": (
                      "Sure! Flipping a coin....nn"
                  ),
              },
          }
      
          # The constructor for the class. It takes the channel name as the a
          # parameter and then sets it as an instance variable
          def __init__(self, channel):
              self.channel = channel
      
          # Generate a random number to simulate flipping a coin. Then return the
          # crafted slack payload with the coin flip message.
          def _flip_coin(self):
              rand_int =  random.randint(0,1)
              if rand_int == 0:
                  results = "Heads"
              else:
                  results = "Tails"
      
              text = f"The result is {results}"
      
              return {"type": "section", "text": {"type": "mrkdwn", "text": text}},
      
          # Craft and return the entire message payload as a dictionary.
          def get_message_payload(self):
              return {
                  "channel": self.channel,
                  "blocks": [
                      self.COIN_BLOCK,
                      *self._flip_coin(),
                  ],
              }
      

      Guarde y cierre el archivo.

      Ahora que tiene una clase Python lista para hacer el trabajo para su Slackbot, asegurémonos de que esta clase produzca una carga útil de mensaje y que pueda enviarla a su espacio de trabajo.

      Paso 4: Probar su mensaje

      Ahora vamos a probar que esta clase produzca una carga útil adecuada. Cree un archivo llamado coinbot_test.py:

      Ahora agregue el siguiente código. Asegúrese de cambiar el nombre del canal en la instanciación de la clase coinbot coin_bot = coinbot("#YOUR_CHANNEL_HERE"). Este código creará un cliente Slack en Python que enviará un mensaje al canal en el que especifica que ya ha instalado la aplicación:

      coinbot_test.py

      from slack import WebClient
      from coinbot import CoinBot
      import os
      
      # Create a slack client
      slack_web_client = WebClient(token=os.environ.get("SLACK_TOKEN"))
      
      # Get a new CoinBot
      coin_bot = CoinBot("#YOUR_CHANNEL_HERE")
      
      # Get the onboarding message payload
      message = coin_bot.get_message_payload()
      
      # Post the onboarding message in Slack
      slack_web_client.chat_postMessage(**message)
      

      Guarde y cierre el archivo.

      Antes de ejecutar este archivo, deberá exportar el token de Slack que guardó en el paso 1 como variable de entorno:

      • export SLACK_TOKEN="your_bot_user_token"

      Ahora pruebe este archivo y verifique que la carga útil se produzca y se envíe ejecutando la siguiente secuencia de comandos en su terminal. Asegúrese de que su entorno virtual está activado. Puede verificarlo viendo el texto (slackbot) en la parte delantera de su instrucción bash. Ejecute este comando, recibirá un mensaje de su Slackbot con los resultados de lanzar una moneda:

      Compruebe el canal en el que instaló su aplicación y verifique que su bot de hecho envió el mensaje de lanzar una moneda. Su resultado será cara o cruz.

      Prueba de lanzar una moneda

      Ahora que ha verificado que su Slackbot puede lanzar una moneda, crear un mensaje y entregarlo, crearemos un Flask para ejecutar perpetuamente esta aplicación y hacer que simule el lanzamiento de una moneda y que comparta los resultados cuando vea determinado texto en mensajes enviados en el canal.

      Paso 5: Crear una aplicación Flask para ejecutar su Slackbot

      Ahora que tiene una aplicación que funciona y puede enviar mensajes a su espacio de trabajo de Slack, deberá crear un proceso de ejecución largo para que su bot pueda escuchar los mensajes enviados en el canal y responderles si el texto cumple determinados criterios. Usará el marco web Python Flask para ejecutar este proceso y escuchar eventos en su canal.

      En esta sección, ejecutará su aplicación Flask desde un servidor con una dirección IP pública para que la API de Slack pueda enviarle eventos. Si lo está ejecutando localmente en su estación de trabajo personal, deberá reenviar el puerto desde su firewall personal al puerto que se ejecutará en su estación de trabajo. Estos puertos pueden ser iguales, y este tutorial se configurará para usar el puerto 3000.

      Primero, configure su firewall para que permita el tráfico a través del puerto 3000:

      Ahora compruebe el estado de ufw:

      Verá un resultado similar a este:

      Output

      Status: active To Action From -- ------ ---- OpenSSH ALLOW Anywhere 3000 ALLOW Anywhere OpenSSH (v6) ALLOW Anywhere (v6) 3000 (v6) ALLOW Anywhere (v6)

      Ahora cree el archivo para su aplicación Flask. Llame a este archivo app.py:

      A continuación, abra este archivo en su editor de texto favorito:

      Ahora añada las siguientes statements de importación. Importará las siguientes bibliotecas por las siguientes razones:

      • import os: para acceder a variables de entorno
      • import logging: para registrar los eventos de la aplicación
      • from flask import Flask: para crear una aplicación Flask
      • from slack import WebClient: para enviar mensajes a través de Slack
      • from slackeventsapi import SlackEventAdapter: para recibir eventos de Slack y procesarlos
      • from coinbot import CoinBot: para crear una instancia de su CoinBot y generar la carga útil de mensaje.

      Añada las siguientes líneas a app.py para importar todas las bibliotecas necesarias:

      app.py

      import os
      import logging
      from flask import Flask
      from slack import WebClient
      from slackeventsapi import SlackEventAdapter
      from coinbot import CoinBot
      

      Ahora cree su aplicación Flask y registre un adaptador de evento de Slack a su aplicación Slack en el extremo /slack/events. Esto creará una ruta en su aplicación Slack donde se enviarán y consumirán los eventos de Slack. Para hacerlo, deberá obtener otra token desde su aplicación Slack, lo que hará más tarde en el tutorial. Una vez que obtenga esta variable, la exportará como una variable de entorno llamada SLACK_EVENTS_TOKEN. Siga y escriba su código para que lo lea cuando cree el SlackEventAdapter, a pesar de que aún no ha configurado el token.

      Añada las siguientes líneas a app.py para crear la aplicación Flask y registrar el adaptador de eventos en esta aplicación:

      app.py

      ...
      # Initialize a Flask app to host the events adapter
      app = Flask(__name__)
      
      # Create an events adapter and register it to an endpoint in the slack app for event ingestion.
      slack_events_adapter = SlackEventAdapter(os.environ.get("SLACK_EVENTS_TOKEN"), "/slack/events", app)
      

      A continuación, cree un objeto cliente web que permitirá a su aplicación realizar acciones en el espacio de trabajo, específicamente para enviar mensajes. Esto es similar a lo que hizo cuando probó su archivo coinbot.py previamente.

      Añada la siguiente línea a app.py para crear este slack_web_client:

      app.py

      ...
      # Initialize a Web API client
      slack_web_client = WebClient(token=os.environ.get("SLACK_TOKEN"))
      

      Ahora cree una función que puede invocarse y que creará una instancia de CoinBot y, luego, utilice esta instancia para crear una carga útil de mensaje y transmitirla al cliente web de Slack para su entrega. Esta función tendrá un solo parámetro, channel, que especificará qué canal recibe el mensaje.

      Añada las siguientes líneas a app.py para crear esta función:

      app.py

      ...
      def flip_coin(channel):
          """Craft the CoinBot, flip the coin and send the message to the channel
          """
          # Create a new CoinBot
          coin_bot = CoinBot(channel)
      
          # Get the onboarding message payload
          message = coin_bot.get_message_payload()
      
          # Post the onboarding message in Slack
          slack_web_client.chat_postMessage(**message)
      

      Ahora que ha creado una función para manejar los aspectos de mensajería de su aplicación, cree una que monitoree los eventos de Slack para cierta acción y ejecute su bot. Va a configurar su aplicación para que responda con los resultados del lanzamiento simulado de una moneda cuando vea la frase “Hola Sammy, lanza una moneda”. Aceptará cualquier versión; no impedirá que la aplicación responda.

      Primero, decore su función con la sintaxis @slack_events_adapter.on que permite a su función recibir eventos. Especifique que solo quiere los eventos message y que su función acepta un parámetro de carga útil que contiene toda la información necesaria de Slack. Una vez que tenga esta carga útil, analizará el texto. Luego, si recibe la frase de activación, su aplicación enviará los resultados de lanzar una moneda simulada.

      Añada el siguiente código a app.py para recibir, analizar y actuar en los mensajes entrantes:

      app.py

      # When a 'message' event is detected by the events adapter, forward that payload
      # to this function.
      @slack_events_adapter.on("message")
      def message(payload):
          """Parse the message event, and if the activation string is in the text,
          simulate a coin flip and send the result.
          """
      
          # Get the event data from the payload
          event = payload.get("event", {})
      
          # Get the text from the event that came through
          text = event.get("text")
      
          # Check and see if the activation phrase was in the text of the message.
          # If so, execute the code to flip a coin.
          if "hey sammy, flip a coin" in text.lower():
              # Since the activation phrase was met, get the channel ID that the event
              # was executed on
              channel_id = event.get("channel")
      
              # Execute the flip_coin function and send the results of
              # flipping a coin to the channel
              return flip_coin(channel_id)
      

      Por último, cree una sección main que creará un logger para que pueda ver la parte interna de su aplicación, así como lanzar la aplicación en su dirección IP externa en el puerto 3000. Para consumir los eventos desde Slack, como cuando se envía un nuevo mensaje, deberá probar su aplicación en una dirección IP orientada al público.

      Añada las siguientes líneas a app.py para configurar su sección principal:

      app.py

      if __name__ == "__main__":
          # Create the logging object
          logger = logging.getLogger()
      
          # Set the log level to DEBUG. This will increase verbosity of logging messages
          logger.setLevel(logging.DEBUG)
      
          # Add the StreamHandler as a logging handler
          logger.addHandler(logging.StreamHandler())
      
          # Run your app on your externally facing IP address on port 3000 instead of
          # running it on localhost, which is traditional for development.
          app.run(host="0.0.0.0", port=3000)
      

      Ahora ha terminado con la aplicación Flask y está listo para probarla. Antes de seguir verifique que su archivo terminado, app.py contiene lo siguiente:

      app.py

      import os
      import logging
      from flask import Flask
      from slack import WebClient
      from slackeventsapi import SlackEventAdapter
      from coinbot import CoinBot
      
      # Initialize a Flask app to host the events adapter
      app = Flask(__name__)
      # Create an events adapter and register it to an endpoint in the slack app for event injestion.
      slack_events_adapter = SlackEventAdapter(os.environ.get("SLACK_EVENTS_TOKEN"), "/slack/events", app)
      
      # Initialize a Web API client
      slack_web_client = WebClient(token=os.environ.get("SLACK_TOKEN"))
      
      def flip_coin(channel):
          """Craft the CoinBot, flip the coin and send the message to the channel
          """
          # Create a new CoinBot
          coin_bot = CoinBot(channel)
      
          # Get the onboarding message payload
          message = coin_bot.get_message_payload()
      
          # Post the onboarding message in Slack
          slack_web_client.chat_postMessage(**message)
      
      
      # When a 'message' event is detected by the events adapter, forward that payload
      # to this function.
      @slack_events_adapter.on("message")
      def message(payload):
          """Parse the message event, and if the activation string is in the text,
          simulate a coin flip and send the result.
          """
      
          # Get the event data from the payload
          event = payload.get("event", {})
      
          # Get the text from the event that came through
          text = event.get("text")
      
          # Check and see if the activation phrase was in the text of the message.
          # If so, execute the code to flip a coin.
          if "hey sammy, flip a coin" in text.lower():
              # Since the activation phrase was met, get the channel ID that the event
              # was executed on
              channel_id = event.get("channel")
      
              # Execute the flip_coin function and send the results of
              # flipping a coin to the channel
              return flip_coin(channel_id)
      
      if __name__ == "__main__":
          # Create the logging object
          logger = logging.getLogger()
      
          # Set the log level to DEBUG. This will increase verbosity of logging messages
          logger.setLevel(logging.DEBUG)
      
          # Add the StreamHandler as a logging handler
          logger.addHandler(logging.StreamHandler())
      
          # Run our app on our externally facing IP address on port 3000 instead of
          # running it on localhost, which is traditional for development.
          app.run(host="0.0.0.0", port=3000)
      

      Guarde y cierre el archivo.

      Ahora que su aplicación Flask está lista para servir a su aplicación, vamos a probarla.

      Paso 6: Ejecutar su aplicación Flask

      Por último, reúna todo y ejecute su aplicación.

      Primero, añada su aplicación en ejecución como un controlador autorizado para su Slackbot.

      Diríjase a la sección Información básica de su aplicación en la IU de Slack. Desplácese hasta que encuentre la sección Credenciales de la aplicación.

      Secreto de firma de Slack

      Copie el Secreto de firma y expórtelo como la variable de entorno SLACK_EVENTS_TOKEN:

      • export SLACK_EVENTS_TOKEN="MY_SIGNING_SECRET_TOKEN"

      Con esto, tiene todas las tokens de API necesarias para ejecutar su aplicación. Consulte el paso 1 si necesita un repaso sobre cómo exportar su SLACK_TOKEN. Ahora puede iniciar su aplicación y verificar que de hecho se está ejecutando. Asegúrese de que su entorno virtual está activado y ejecute el siguiente comando para iniciar su aplicación Flask:

      Verá un resultado similar a este:

      (slackbot) [20:04:03] sammy:coinbot$ python app.py
       * Serving Flask app "app" (lazy loading)
       * Environment: production
         WARNING: This is a development server. Do not use it in a production deployment.
         Use a production WSGI server instead.
       * Debug mode: off
       * Running on http://0.0.0.0:3000/ (Press CTRL+C to quit)
      

      Para verificar que su aplicación se ha completado, abra una nueva ventana de terminal y curl la dirección IP de su servidor con el puerto correcto en /slack/events:

      • curl http://YOUR_IP_ADDRESS:3000/slack/events

      Curl le mostrará lo siguiente:

      Output

      These are not the slackbots you're looking for.

      Recibiendo el mensaje Estos no son los slackbots que está buscando. indica que su aplicación está en ejecución.

      Ahora deje esta aplicación Flask en ejecución mientras termina de configurar su aplicación en la IU de Slack.

      Primero, conceda a su aplicación los permisos apropiados para que pueda escuchar los mensajes y responder de forma correcta. Haga clic en Suscripciones de eventos en la barra lateral de la IU y cambie el botón de radio Habilitar eventos.

      Botón de habilitar eventos

      Una vez que haya hecho eso, escriba su dirección IP, su puerto y su extremo /slack/events en el campo URL de solicitud. No olvide el prefijo de protocolo HTTP. Slack hará un intento de conectarse a su extremo. Una vez que haya hecho esto correctamente, verá una marca de verificación verde con la palabra Verificada junto a ella.

      URL de solicitud a suscripciones de eventos

      A continuación, amplíe el Suscribir a los eventos bot y añada el permiso message.channels a su aplicación. Esto permitirá a su aplicación recibir mensajes de su canal y procesarlos.

      Suscribirse a permisos de eventos bot

      Una vez que haya hecho esto, verá el evento que aparece en su sección Suscribirse a eventos bot. A continuación, haga clic en el botón verde Guardar cambios en la esquina inferior derecha.

      Confirmar y guardar los cambios

      Una vez hecho, verá un banner amarillo a lo largo de la parte superior de la pantalla, lo que le indica que debe reinstalar su aplicación para que se apliquen los siguientes cambios. Cada vez que cambie los permisos deberá reinstalar su aplicación. Haga clic en el enlace reinstalar su aplicación en este banner para reinstalar su aplicación.

      Banner que indica que debe reinstalar su aplicación

      Verá una pantalla de confirmación que resume los permisos que tendrá su bot y le solicitará si quiere permitir su instalación. Haga clic en el botón verde Permitir para terminar el proceso de instalación.

      Confirmación de reinstalación

      Ahora que ha hecho esto, su aplicación debería estar lista. Vuelva al canal en el que instaló CoinBot y envíe un mensaje que contenga la frase Hola Sammy, lanza una moneda. Su bot lanzará una moneda y responderá con los resultados. ¡Felicidades! ¡Ha creado un Slackbot!

      Hola Sammy, lanza una moneda

      Conclusión

      Una vez que haya terminado de desarrollar su aplicación y esté listo para moverla a producción, deberá implementarla en un servidor. Esto es necesario porque el servidor de desarrollo Flask no es un entorno de producción seguro. Será mejor si implementa su aplicación usando un WSGI e incluso asegurando un nombre de dominio y dando a su servidor un registro DNS. Existen muchas opciones para implementar aplicaciones Flask, algunas de las cuales se enumeran a continuación:

      Hay muchas otras formas de implementar su aplicación, no solo estas. Como siempre, cuando se trata de implementaciones e infraestructura, haga lo que mejor le funcione.

      En cualquier caso, ahora tiene un Slackbot que puede usar para lanzar una moneda para ayudarle a tomar decisiones, como lo que debe comer.

      También puede tomar este código base y modificarlo para que se ajuste a sus necesidades, ya sea soporte automatizado, gestión de recursos, imágenes de gatos o lo que se le ocurra. Aquí puede ver los documentos completos de Python Slack API.



      Source link

      Cómo crear un certificado SSL autofirmado para Apache en Ubuntu 20.04


      Introducción

      TLS, o “seguridad de capa de transporte”, y su predecesor SSL, son protocolos utilizados para envolver el tráfico normal en un envoltorio protegido y cifrado. Usando esta tecnología, los servidores pueden enviar de forma segura información a sus clientes sin que sus mensajes sean interceptados o leídos por una parte externa.

      En esta guía, le mostraremos cómo crear y usar un certificado SSL autofirmado con el servidor web Apache en Ubuntu 20.04.

      Nota: Un certificado autofirmado cifrará la comunicación entre su servidor y cualquier cliente. Sin embargo, dado que no está firmado por ninguna de las autoridades certificadoras de confianza incluidas con los navegadores web y los sistemas operativos, los usuarios no pueden usar el certificado para validar la identidad de su servidor de forma automática. Como resultado, sus usuarios verán un error de seguridad cuando visiten su sitio.

      Debido a esta limitación, los certificados autofirmados no son apropiados para un entorno de producción que sirve al público. Normalmente, se utilizan para probar o para asegurar servicios no críticos utilizados por un solo usuario o un pequeño grupo de usuarios que pueden confiar en la validez del certificado a través de canales de comunicación alternativos.

      Para obtener una solución de certificado más preparado para la producción, consulte Let’s Encrypt, una autoridad de certificado gratuita. Puede aprender a descargar y configurar un certificado Let’s Encrypt en nuestro tutorial Cómo proteger Apache con Let’s Encrypt en Ubuntu 20.04.

      Requisitos previos

      Antes de iniciar este tutorial, necesitará lo siguiente:

      • Acceso a un servidor Ubuntu 20.04 con un usuario no root sudo habilitado. Nuestra guía de configuración inicial de servidor con Ubuntu 20.04 puede mostrarle cómo crear esta cuenta.
      • También deberá tener Apache instalado. Puede instalar Apache usando apt. Primero, actualice el índice de paquetes locales de modo que se refleje cualquier cambio anterior:

      A continuación, instale el paquete apache2:

      Y, por último, si tiene un firewall ufw configurado, abra los puertos http y https:

      • sudo ufw allow "Apache Full"

      Una vez que haya completado estos pasos, asegúrese de haber iniciado sesión como usuario no root y continúe con el tutoria.

      Paso 1: Habilitar mod_ssl

      Antes de poder utilizar cualquiera de los certificados SSL,primero se debe habilitar mod_ssl, un módulo de Apache que proporciona soporte para el cifrado SSL.

      Habilite mod_ssl con el comando a2enmod:

      Reinicie Apache para activar el módulo:

      • sudo systemctl restart apache2

      Ahora está habilitado el módulo mod_ssl y listo para su uso.

      Paso 2: Crear el certificado SSL

      Ahora que Apache está listo para usar cifrado, podemos continuar y generar un nuevo certificado SSL. El certificado almacenará información básica sobre su sitio, y estará acompañado de un archivo de claves que permite al servidor manejar de forma segura datos cifrados.

      Podemos crear la clave SSL y los archivos de certificado con el comando openssl:

      • sudo openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout /etc/ssl/private/apache-selfsigned.key -out /etc/ssl/certs/apache-selfsigned.crt

      Tras introducir el comando, aparecerá un mensaje donde puede introducir información sobre su sitio web. Antes de abordar eso, observemos lo que sucede en el comando que emitimos:

      • openssl: es la herramienta de línea de comandos para crear y administrar certificados, claves y otros archivos de OpenSSL.
      • req -x509: especifica que deseamos usar la administración de la solicitud de firma de certificados (CSR) X.509. El “X.509” es un estándar de infraestructura de claves públicas al que se adhieren SSL y TLS para la administración de claves y certificados.
      • -nodes: indica a OpenSSL que omita la opción para proteger nuestro certificado con una frase de contraseña. Necesitamos que Apache pueda leer el archivo, sin intervención del usuario, cuando se inicie el servidor. Una frase de contraseña evitaría que esto suceda porque tendríamos que introducirla tras cada reinicio.
      • -days 365: esta opción establece el tiempo durante el cual el certificado se considerará válido. En este caso, lo configuramos por un año. Muchos navegadores modernos rechazarán cualquier certificado válido por más de un año.
      • -newkey rsa:2048: especifica que deseamos generar un nuevo certificado y una nueva clave al mismo tiempo. No creamos la clave que se requiere para firmar el certificado en un paso anterior, por lo que debemos crearla junto con el certificado. La parte rsa:2048 le indica que cree una clave RSA de 2048 bits de extensión.
      • -keyout: esta línea indica a OpenSSL dónde colocar el archivo de clave privada generado que estamos creando.
      • -out: indica a OpenSSL dónde colocar el certificado que creamos.

      Complete las solicitudes de forma adecuada. La línea más importante es la que solicita Common Name. Debe introducir el nombre de host que utilizará para acceder al servidor o a la IP pública del servidor. Es importante que este campo coincida con lo que pondrá en la barra de direcciones de su navegador para acceder al sitio, ya que un error de concordancia causará más errores de seguridad.

      La lista completa de las instrucciones tendrá un aspecto similar a este:

      Country Name (2 letter code) [XX]:US
      State or Province Name (full name) []:Example
      Locality Name (eg, city) [Default City]:Example 
      Organization Name (eg, company) [Default Company Ltd]:Example Inc
      Organizational Unit Name (eg, section) []:Example Dept
      Common Name (eg, your name or your server's hostname) []:your_domain_or_ip
      Email Address []:webmaster@example.com
      

      Los dos archivos que creó se ubicarán en los subdirectorios correspondientes en /etc/ssl.

      A continuación, actualizaremos nuestra configuración Apache para usar el nuevo certificado y la clave.

      Paso 3: Configurar Apache para usar SSL

      Ahora que tenemos nuestro certificado y la clave autofirmados disponibles, debemos actualizar nuestra configuración Apache para usarlos. En Ubuntu, puede colocar nuevos archivos de configuración de Apache (deben terminar en .conf) en /etc/apache2/sites-available/y se cargarán la próxima vez que se vuelva a cargar o reiniciar el proceso Apache.

      Para este tutorial, crearemos un nuevo archivo de configuración mínimo. (Si ya tiene un Apache <Virtualhost> configurado y solo necesita agregarle SSL, probablemente deberá copiar las líneas de configuración que comienzan con SSL, y cambiar el puerto VirtualHost de 80 a 443. Nos encargaremos del puerto 80 en el siguiente paso).

      Abra un nuevo archivo en el directorio /etc/apache2/sites-available:

      • sudo nano /etc/apache2/sites-available/your_domain_or_ip.conf

      Pegue la siguiente configuración mínima VirtualHost:

      /etc/apache2/sites-available/your_domain_or_ip.conf

      <VirtualHost *:443>
         ServerName your_domain_or_ip
         DocumentRoot /var/www/your_domain_or_ip
      
         SSLEngine on
         SSLCertificateFile /etc/ssl/certs/apache-selfsigned.crt
         SSLCertificateKeyFile /etc/ssl/private/apache-selfsigned.key
      </VirtualHost>
      
      

      Asegúrese de actualizar la línea ServerName a la que desea que se dirija su servidor. Puede ser un nombre de host, un nombre de dominio completo o una dirección IP. Asegúrese de que lo que elija coincida con Common Name que eligió al crear el certificado.

      Las líneas restantes especifican un directorio DocumentRoot para que sirva los archivos, y las opciones SSL necesarias para apuntar Apache a nuestro certificado y clave recién creados.

      Ahora vamos a crear nuestro DocumentRoot y ponemos un archivo HTML en él solo para fines de prueba:

      • sudo mkdir /var/www/your_domain_or_ip

      Abra un nuevo archivo index.html con su editor de texto:

      • sudo nano /var/www/your_domain_or_ip/index.html

      Pegue lo siguiente en el archivo en blanco:

      /var/www/your_domain_or_ip/index.html

      <h1>it worked!</h1>
      

      Esto no es un archivo HTML completo, por supuesto, pero los navegadores son indulgentes y bastará para verificar nuestra configuración.

      Guarde y cierre el archivo. A continuación, debemos habilitar el archivo de configuración con la herramienta a2ensite:

      • sudo a2ensite your_domain_or_ip.conf

      A continuación, realizaremos una prueba para ver que no haya errores de configuración:

      • sudo apache2ctl configtest

      Si la operación se completa de forma correcta, obtendrá un resultado similar a este:

      Output

      AH00558: apache2: Could not reliably determine the server's fully qualified domain name, using 127.0.1.1. Set the 'ServerName' directive globally to suppress this message Syntax OK

      La primera línea es un mensaje que le indica que la directiva ServerName no está configurada a nivel global. Si quiere deshacerse de ese mensaje, puede establecer ServerName en el nombre de dominio o la dirección IP de su servidor en /etc/apache2/apache2.conf. Esto es opcional, ya que el mensaje no causará problemas.

      Si el resultado contiene Syntax OK, en su archivo de configuración no habrá errores de sintaxis. Podemos volver a cargar Apache de forma segura para implementar nuestros cambios:

      • sudo systemctl reload apache2

      Ahora cargue su sitio en un navegador, asegurándose de usar https:// al principio.

      Debería ver un error. Esto es normal para un certificado autofirmado. El navegador le advierte que no puede verificar la identidad del servidor, porque nuestro certificado no está firmado por ninguna de sus autoridades de certificado conocidas. Para fines de prueba y uso personal, puede estar bien. Debería poder hacer clic en avanzada o más información y elegir continuar.

      Una vez que lo haga, su navegador cargará el mensaje it worked! (¡funcionó!).

      Nota: si su navegador no se conecta en absoluto al servidor, asegúrese de que su conexión no está siendo bloqueada por un firewall. Si utiliza ufw, los siguientes comandos abrirán los puertos 80 y 443:

      • sudo ufw allow "Apache Full"

      A continuación, añadiremos otra sección VirtualHost a nuestra configuración para que sirva las solicitudes HTTP sencillas y las redirija a HTTPS.

      Paso 4: Redirigir HTTP a HTTPS

      Actualmente, nuestra configuración solo responderá a las solicitudes HTTPS en el puerto 443. Es una buena práctica responder también en el puerto 80, incluso si quiere forzar que se cifre todo el tráfico. Configuraremos un VirtualHost para que responda a estas solicitudes no cifradas y las redireccione a HTTPS.

      Abra el mismo archivo de configuración Apache que iniciamos en pasos anteriores:

      • sudo nano /etc/apache2/sites-available/your_domain_or_ip.conf

      En la parte inferior, cree otro bloque VirtualHost para que coincida con las solicitudes en el puerto 80. Utilice la directiva ServerName para que coincida de nuevo con su nombre de dominio o su dirección IP. A continuación, utilice Redirect para que coincida con cualquier solicitud y las envíe al VirtualHost SSL. Asegúrese de incluir la barra de arrastre:

      /etc/apache2/sites-available/your_domain_or_ip.conf

      <VirtualHost *:80>
          ServerName your_domain_or_ip
          Redirect / https://your_domain_or_ip/
      </VirtualHost>
      

      Guarde y cierre este archivo cuando haya terminado, y vuelva a probar la sintaxis de configuración y a cargar Apache:

      • sudo apachectl configtest
      • sudo systemctl reload apache2

      Puede probar la nueva funcionalidad de redireccionamiento visitando su sitio con http:// simple delante de la dirección. Debería redireccionarse a https:// automáticamente.

      Conclusión

      Ahora ha configurado Apache para que sirva las solicitudes cifradas usando un certificado SSL autofirmado, y para redireccionar las solicitudes HTTP no cifradas a HTTPS.

      Si planea usar SSL para un sitio web público, debería pensar en comprar un nombre de dominio y usar una autoridad de certificado ampliamente compatible, como Let’s Encrypt.

      Para obtener más información sobre el uso de Let’s Encrypt con Apache, consulte nuestro tutorial Cómo proteger Apache con Let’s Encrypt en Ubuntu 20.04.



      Source link

      Libro electrónico “Cómo crear código en Go”


      Descargue todo el EBook

      Libro electrónico Cómo crear código en Go en formato EPUB

      Libro electrónico Cómo crear código en Go en formato PDF

      Introducción al libro electrónico

      Este libro está diseñado como una introducción a la escritura de programas con el lenguaje de programación Go. Aprenderá cómo escribir herramientas y aplicaciones útiles para el desarrollo que puedan ejecutarse en servidores remotos o en sistemas locales de Windows, macOS y Linux.

      Este libro toma como base la serie de tutoriales publicados por la comunidad de DigitalOcean sobre Cómo crear código en Go. Los temas que abarca incluyen:

      1. Instalar y establecer un entorno local de desarrollo de Go en sistemas Windows, macOS y Linux

      2. Diseñar los programas con lógica condicional, incluidas las instrucciones de conmutación para controlar el flujo del programa

      3. Definir estructuras de datos propias y crear interfaces a dichas estructuras para el código reutilizable

      4. Escribir funciones personalizadas para la gestión de errores

      5. Compilar e instalar los programas de Go para que puedan ejecutarse en diferentes sistemas operativos y arquitecturas de CPU

      6. Utilizar indicadores para pasar argumentos a los programas, a fin de anular las opciones predeterminadas

      Cada capítulo puede leerse de manera independiente o utilizarse como referencia, o bien puede leerlos en orden. A medida que aprenda a utilizar Go con este libro, no dude en ir directamente al capítulo o a los capítulos que mejor se adapten a su propósito.

      Descargar el libro electrónico

      Puede descargar el libro electrónico en formato EPUB o PDF siguiendo los enlaces que se muestran a continuación.

      Descargue todo el EBook

      Libro electrónico Cómo crear código en Go en formato EPUB

      Libro electrónico Cómo crear código en Go en formato PDF

      Una vez que haya terminado de leer el libro, si quiere obtener más información sobre cómo crear herramientas y aplicaciones con Go, visite la sección sobre Go de la comunidad de DigitalOcean.



      Source link