One place for hosting & domains

      Erstellen eines Slackbot in Python unter Ubuntu 20.04


      Der Autor wählte den Tech Education Fund, um im Rahmen des Programms Write for DOnations eine Spende zu erhalten.

      Einführung

      Slack ist eine Kommunikationsplattform, die für die Produktivität am Arbeitsplatz ausgelegt ist. Es enthält Funktionen wie Direktnachrichten, öffentliche und private Kanäle, Sprach- und Videoanrufe und Bot-Integrationen. Ein Slackbot ist ein automatisiertes Programm, das eine Vielzahl von Funktionen in Slack ausführen kann, von dem Senden von Nachrichten über das Auslösen von Aufgaben bis hin zu Warnungen bei bestimmten Ereignissen.

      In diesem Tutorial erstellen Sie in der Programmiersprache Python einen Slackbot. Python ist eine beliebte Sprache, die sich durch Einfachheit und Lesbarkeit auszeichnet. Slack bietet eine reichhaltige Python Slack API zur Integration mit Slack, um allgemeine Aufgaben wie das Senden von Nachrichten, das Hinzufügen von Emojis zu Nachrichten und vieles mehr durchzuführen. Slack bietet auch eine Python Slack Events API zur Integration mit Ereignissen in Slack, sodass Sie Aktionen für Ereignisse wie Nachrichten und Erwähnungen ausführen können.

      Als spaßigen Proof-of-Concept, der die Leistungsfähigkeit von Python und seinen Slack-APIs demonstriert, erstellen Sie einen CoinBot— einen Slackbot, der einen Kanal überwacht und, wenn er ausgelöst wird, eine Münze für Sie wirft. Sie können Ihren CoinBot dann so modifizieren, dass er eine beliebige Anzahl von etwas praktischeren Anwendungen erfüllt.

      Beachten Sie, dass dieses Tutorial Python 3 verwendet und nicht mit Python 2 kompatibel ist.

      Voraussetzungen

      Um diesen Leitfaden auszuführen, benötigen Sie:

      Sie möchten dieses Tutorial möglicherweise auf einem Server testen, der eine öffentliche IP-Adresse hat. Slack muss in der Lage sein, Ereignisse wie Nachrichten an Ihren Bot zu senden. Wenn Sie auf einem lokalen Rechner testen, müssen Sie Datenverkehr über Ihre Firewall auf Ihr lokales System portieren. Wenn Sie nach einer Möglichkeit suchen, auf einem Cloud-Server zu entwickeln, sehen Sie sich dieses Tutorial zur Verwendung des Visual Studio Code für die Remote-Entwicklung über das Remote-SSH-Plugin an.

      Schritt 1 — Erstellen des Slackbots in der Slack-Benutzeroberfläche

      Erstellen Sie zunächst Ihre Slack Anwendung in dem Slack API Bedienfeld. Melden Sie sich über einen Webbrowser bei Ihrem Arbeitsbereich in Slack an und navigieren Sie zum API Bedienfeld. Klicken Sie nun auf die Schaltfläche Create an App.

      Erstellen Sie Ihre Slack-Anwendung

      Als Nächstes werden Sie aufgefordert, den Namen Ihrer Anwendung einzugeben und einen Slack-Arbeitsbereich für die Entwicklung auszuwählen. Benennen Sie für dieses Tutorial Ihre Anwendung CoinBot und wählen Sie einen Arbeitsbereich, auf den Sie Admin-Zugriff haben. Sobald Sie dies getan haben, klicken Sie auf die Schaltfläche Create App.

      Benennen Sie Ihre Slack-App und wählen Sie einen Arbeitsbereich aus

      Sobald Ihre Anwendung erstellt ist, wird Ihnen das folgende Standard-Dashboard der Anwendung angezeigt. In diesem Dashboard verwalten Sie Anwendung, indem Sie Berechtigungen festlegen, Ereignisse abonnieren, die Anwendung in Arbeitsbereichen installieren, und vieles mehr.

      Standard Slack-Anwendungsbereich

      Damit Ihre Anwendung Nachrichten an einen Kanal senden kann, müssen Sie der Anwendung Berechtigungen zum Senden von Nachrichten erteilen. Klicken Sie dazu auf die Schaltfläche Permissions im Bedienfeld.

      Wählen Sie die Schaltfläche „Permissions“ im Bedienfeld

      Wenn Sie auf der Seite OAuth & Permissions ankommen, scrollen Sie nach unten, bis Sie den Abschnitt Scopes der Seite finden. Suchen Sie dann in dem Bereich den Unterabschnitt Bot Token Scopes und klicken Sie auf die Schaltfläche Add an OAuth Scope.

      Wählen Sie die Schaltfläche „Add an OAuth Scope“

      Klicken Sie auf diese Schaltfläche und geben Sie dann chat:write ein. Wählen Sie diese Berechtigung aus, um sie zu Ihrem Bot hinzuzufügen. Dadurch kann die Anwendung Nachrichten an Kanäle senden, auf die sie zugreifen kann. Weitere Informationen zu den verfügbaren Berechtigungen finden Sie in der Dokumentation von Slack.

      Fügen Sie die Berechtigung chat:write hinzu

      Nachdem Sie die entsprechende Berechtigung hinzugefügt haben, ist es an der Zeit, Ihre Anwendung in Ihren Slack-Arbeitsbereich zu installieren. Scrollen Sie auf der Seite OAuth & Permissions nach oben und klicken Sie oben auf die Schaltfläche Install App to Workspace.

      Installieren der Anwendung in den Arbeitsbereich

      Klicken Sie auf diese Schaltfläche und überprüfen Sie die Aktionen, die die Anwendung im Kanal ausführen kann. Sobald Sie zufrieden sind, klicken Sie auf die Schaltfläche Allow, um die Installation zu beenden.

      Installieren der Anwendung in den Arbeitsbereich

      Sobald der Bot installiert ist, erhalten Sie ein Bot User OAuth Access Token für Ihre Anwendung, das Sie verwenden können, wenn Sie das Ausführen von Aktionen im Arbeitsbereich versuchen möchten. Kopieren Sie dieses Token, da Sie es später benötigen.

      Speichern Sie das Access Token

      Fügen Sie Ihren neu installierten Bot abschließend in einen Kanal in Ihrem Arbeitsbereich hinzu. Wenn Sie noch keinen Kanal erstellt haben, können Sie den Kanal #general verwenden, der standardmäßig in Ihrem Slack-Arbeitsbereich erstellt wird. Suchen Sie die Anwendung im Abschnitt Apps der Navigationsleiste in Ihrem Slack-Client und klicken Sie darauf. Öffnen Sie anschließend das Menü Details oben rechts. Wenn Ihr Slack-Client nicht vollständig angezeigt wird, sieht er wie ein i in einem Kreis aus.

      Klicken Sie auf das Detailsymbol der Anwendung

      Um das Hinzufügen Ihrer Anwendung zu einem Kanal abzuschließen, klicken Sie auf die Schaltfläche More, die durch drei Punkte auf der Detailseite dargestellt wird, und wählen Sie Add this app to a channel…. Geben Sie Ihren Kanal in das angezeigte Modal ein und klicken Sie auf Add.

      Fügen Sie die Anwendung einem Kanal hinzu

      Sie haben Ihre Anwendung nun erfolgreich erstellt und sie zu einem Kanal in Ihrem Slack-Arbeitsbereich hinzugefügt. Nachdem Sie den Code für Ihre Anwendung geschrieben haben, kann sie Nachrichten in diesem Kanal posten. Im nächsten Abschnitt beginnen Sie das Schreiben des Python-Codes, der CoinBot betreiben wird.

      Schritt 2 — Einrichten Ihrer Python-Entwicklerumgebung

      Erstellen Sie zunächst Ihre Python-Umgebung, damit Sie den Slackbot entwickeln können.

      Öffnen Sie ein Terminal und installieren Sie python3 und die entsprechenden Tools auf Ihrem System:

      • sudo apt install python3 python3-venv

      Als Nächstes erstellen Sie eine virtuelle Umgebung, um Ihre Python-Pakete von der Systeminstallation von Python zu isolieren. Erstellen Sie dazu zunächst ein Verzeichnis, in dem Sie Ihre virtuelle Umgebung erstellen werden. Erstellen Sie ein neues Verzeichnis unter ~/.venvs:

      Erstellen Sie nun Ihre virtuelle Python-Umgebung:

      • python3 -m venv ~/.venvs/slackbot

      Aktivieren Sie als Nächstes Ihre virtuelle Umgebung, damit Sie die Python-Installation verwenden und Pakete installieren können:

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

      Ihre Shell-Eingabeaufforderung zeigt die virtuelle Umgebung nun in Klammern an. Dies sollte ungefähr so aussehen:

      Verwenden Sie nun pip zum Installieren der erforderlichen Python-Pakete in Ihre virtuelle Umgebung:

      • pip install slackclient slackeventsapi Flask

      slackclient und slackeventsapi erleichtern die Interaktion von Python mit den APIs von Slack. Flask ist ein beliebtes Mikro-Web-Framework, das Sie für die Bereitstellung Ihrer Anwendung verwenden werden:

      Nachdem Sie Ihre Entwicklungsumgebung eingerichtet haben, können Sie nun mit dem Schreiben Ihres Python Slackbots beginnen:

      Schritt 3 — Erstellen der Slackbot-Nachrichtenklasse in Python

      Nachrichten in Slack werden über eine speziell formatierte JSON-Nutzlast gesendet. Dies ist ein Beispiel für die JSON, die Ihr Slackbot erstellen und als Nachricht senden wird:

      {
         "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."
               }
            }
         ]
      }
      

      Sie könnten diese JSON manuell erstellen und senden, aber stattdessen erstellen wir eine Python-Klasse, die nicht nur diese Nutzlast erstellt, sondern auch einen Münzwurf simuliert.

      Verwenden Sie zunächst den Befehl touch zum Erstellen einer Datei namens coinbot.py:

      Öffnen Sie als Nächstes die Datei mit nano oder Ihrem bevorzugten Texteditor:

      Fügen Sie nun die folgenden Codezeilen hinzu, um die entsprechenden Bibliotheken für Ihre Anwendung zu importieren. Die einzige Bibliothek, die Sie für diese Klasse benötigen, ist die Bibliothek random aus der Python-Standardbibliothek. Diese Bibliothek ermöglicht es uns, einen Münzwurf zu simulieren.

      Fügen Sie die folgenden Zeilen zu coinbot.py hinzu, um alle erforderlichen Bibliotheken zu importieren:

      coinbot.py

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

      Erstellen Sie als Nächstes Ihre Klasse CoinBot und eine Instanz dieser Klasse, um die Nachrichten-Nutzlast zu erstellen. Fügen Sie die folgenden Zeilen zu coinbot.py hinzu, um die Klasse CoinBot zu erstellen:

      coinbot.py

      ...
      class CoinBot:
      

      Rücken Sie nun um eins ein und erstellen Sie die für Ihre Klasse erforderlichen Konstanten, Konstruktoren und Methoden. Erstellen Sie zunächst die Konstante, die die Basis Ihrer Nachrichten-Nutzlast enthält. Dieser Abschnitt gibt an, dass diese Konstante vom Abschnitt-Typ ist und der Text über Markdown formatiert wird. Außerdem gibt er an, welchen Text Sie anzeigen möchten. Weitere Informationen zu den verschiedenen Nutzlast-Optionen finden Sie in der offiziellen Slack-Dokumentation zur Nachrichten-Nutzlast.

      Fügen Sie die folgenden Zeilen an coinbot.py an, um die Grundvorlage für die Nutzlast zu erstellen:

      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"
                  ),
              },
          }
      

      Erstellen Sie als Nächstes einen Konstruktor für Ihre Klasse, damit Sie für jede Anfrage eine separate Instanz Ihres Bots erstellen können. Machen Sie sich hier keine Sorgen über den Speicher-Overhead. Der Python Garbage Collector wird diese Instanzen bereinigen, sobald sie nicht mehr benötigt werden. Dieser Code setzt den Empfängerkanal basierend auf einem Parameter, der an den Konstruktor übergeben wird.

      Fügen Sie die folgenden Zeilen an coinbot.py an, um den Konstruktor zu erstellen:

      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
      

      Schreiben Sie nun den Code, der das Werfen einer Münze simuliert. Wir erzeugen nach dem Zufallsprinzip eine Eins oder eine Null, die Kopf bzw. Zahl darstellen.

      Fügen Sie die folgenden Zeilen an coinbot.py an, um den Münzwurf zu simulieren und die erstellte Nutzlast zurückzugeben:

      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}},
      

      Erstellen Sie schließlich eine Methode, die die gesamte Nachrichten-Nutzlast, einschließlich der Daten aus Ihrem Konstruktor, handhabt und zurückgibt, indem Sie Ihre Methode _flip_coin aufrufen.

      Fügen Sie die folgenden Zeilen an coinbot.py an, um die Methode zu erstellen, die die fertige Nutzlast generiert:

      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(),
                  ],
              }
      

      Sie sind nun mit der Klasse CoinBot fertig und sie ist zum Testen bereit. Bevor Sie fortfahren, überprüfen Sie, ob Ihre fertige Datei, coinbot.py, Folgendes enthält:

      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(),
                  ],
              }
      

      Speichern und schließen Sie die Datei.

      Nachdem Sie nun eine Python-Klasse haben, die bereit ist, die Arbeit für Ihren Slackbot zu erledigen, stellen wir sicher, dass diese Klasse eine nützliche Nachrichten-Nutzlast erzeugt und dass Sie diese an Ihren Arbeitsbereich senden können.

      Schritt 4 — Testen Ihrer Nachricht

      Jetzt testen wir, ob diese Klasse eine angemessene Nutzlast erzeugt. Erstellen Sie eine Datei namens coinbot_test.py:

      Fügen Sie jetzt den folgenden Code hinzu. Achten Sie darauf, den Namen des Kanals in der Instanziierung der Coinbot-Klasse coin_bot = coinbot("#YOUR_CHANNEL_HERE") zu ändern. Dieser Code erstellt einen Slack-Client in Python, der eine Nachricht an den von Ihnen angegebenen Kanal sendet, in dem Sie die Anwendung bereits installiert haben:

      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)
      

      Speichern und schließen Sie die Datei.

      Bevor Sie diese Datei ausführen können, müssen Sie das Slack-Token, das Sie in Schritt 1 als Umgebungsvariablen gespeichert haben, exportieren:

      • export SLACK_TOKEN="your_bot_user_token"

      Testen Sie nun diese Datei und überprüfen Sie, ob die Nutzlast erzeugt und gesendet wird, indem Sie das folgende Skript in Ihrem Terminal ausführen. Stellen Sie sicher, dass Ihre virtuelle Umgebung aktiviert ist. Sie können dies überprüfen, indem Sie den Text (slackbot) am Anfang Ihrer Bash-Eingabeaufforderung sehen. Wenn Sie diesen Befehl ausführen, erhalten Sie eine Nachricht von Ihrem Slackbot mit den Ergebnissen eines Münzwurfs:

      Überprüfen Sie den Kanal, in dem Sie Ihre Anwendung installiert haben und vergewissen Sie sich, dass Ihr Bot die Münzwurf-Nachricht tatsächlich gesendet hat. Ihr Ergebnis werden Köpfe oder Zahlen sein.

      Münzwurftest

      Nachdem Sie nun bestätigt haben, dass Ihr Slackbot eine Münze werfen, eine Nachricht erstellen und die Nachricht übermitteln kann, erstellen wir einen Flask, um diese Anwendung ständig auszuführen und sie einen Münzwurf simulieren und die Ergebnisse teilen zu lassen, wenn sie einen bestimmten Text in den im Kanal gesendeten Nachrichten sieht.

      Schritt 5 — Erstellen einer Flask-Anwendung zum Ausführen Ihres Slackbots

      Nachdem Sie nun über eine funktionierende Anwendung verfügen, die Nachrichten an Ihren Slack-Arbeitsbereich senden kann, müssen Sie einen lang laufenden Prozess erstellen, damit Ihr Bot die im Kanal gesendeten Nachrichten abhören und darauf antworten kann, wenn der Text bestimmte Kriterien erfüllt. Sie verwenden das Python-Web-Framework Flask, um diesen Prozess auszuführen nach Ergebnissen in Ihrem Kanal zu lauschen.

      In diesem Abschnitt führen Sie Ihre Flask-Anwendung von einem Server mit einer öffentlichen IP-Adresse aus, damit die Slack-API Ihnen Ereignisse senden kann. Wenn Sie dies lokal auf Ihrer persönlichen Workstation ausführen, müssen Sie den Port von Ihrer persönlichen Firewall an den Port weiterleiten, der auf Ihrer Workstation ausgeführt wird. Diese Ports können die gleichen sein und dieses Tutorial wird so eingerichtet, dass Port 3000 verwendet wird.

      Passen Sie zunächst Ihre Firewall-Einstellungen so an, dass der Verkehr über Port 3000 zugelassen wird:

      Überprüfen Sie nun den Status von ufw:

      Sie werden eine Ausgabe wie diese sehen:

      Output

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

      Erstellen Sie nun die Datei für Ihre Flask-Anwendung. Benennen Sie diese Datei app.py:

      Öffnen Sie als Nächstes diese Datei in Ihrem bevorzugten Texteditor:

      Fügen Sie nun die folgenden Import-statements hinzu. Sie werden die folgenden Bibliotheken aus folgenden Gründen importieren:

      • import os – um auf Umgebungsvariablen zuzugreifen
      • import logging – um die Ereignisse der Anwendung zu protokollieren
      • from flask import Flask – um eine Flask-Anwendung zu erstellen
      • from slack import WebClient – um Nachrichten über Slack zu senden
      • from slackeventsapi import SlackEventAdapter – um Ereignisse von Slack zu empfangen und sie zu verarbeiten
      • from coinbot import CoinBot – um eine Instanz Ihres CoinBot zu erstellen und die Nachrichten-Nutzlast zu generieren.

      Fügen Sie die folgenden Zeilen zu app.py hinzu, um alle erforderlichen Bibliotheken zu importieren:

      app.py

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

      Erstellen Sie nun Ihre Flask-Anwendung und registrieren Sie einen Slack Ereignisadapter für Ihre Slack-Anwendung am Endpunkt /slack/events. Dadurch wird eine Route in Ihrer Slack-Anwendung erstellt, über die Slack-Ereignisse gesendet und aufgenommen werden. Dazu müssen Sie ein weiteres Token von Ihrer Slack-Anwendung erhalten, was Sie später im Tutorial tun werden. Sobald Sie diese Variable erhalten, exportieren Sie sie als Umgebungsvariable namens SLACK_EVENTS_TOKEN. Fahren Sie fort und schreiben Sie Ihren Code, um ihn beim Erstellen des SlackEventAdapters einzulesen, auch wenn Sie das Token noch nicht gesetzt haben.

      Fügen Sie die folgenden Zeilen zu app.py hinzu, um die Flask-Anwendung zu erstellen und den Ereignisadapter in dieser Anwendung zu registrieren:

      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)
      

      Erstellen Sie als Nächstes ein Web-Client-Objekt, mit dem Ihre Anwendung Aktionen im Arbeitsbereich ausführen kann, insbesondere um Nachrichten zu senden. Dies ist vergleichbar mit dem, was Sie getan haben, als Sie zuvor Ihre Datei coinbot.py getestet haben.

      Fügen Sie die folgende Zeile an app.py an, um diesen slack_web_client zu erstellen:

      app.py

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

      Erstellen Sie nun eine aufrufbare Funktion, die eine Instanz von CoinBot erzeugt, und verwenden Sie dann diese Instanz, um eine Nachrichten-Nutzlast zu erstellen und die Nachrichten-Nutzlast an den Slack Web-Client zur Zustellung zu übergeben. Diese Funktion nimmt einen einzigen Parameter, channel, auf, der angibt, welcher Kanal die Nachricht empfängt.

      Fügen Sie die folgenden Zeilen an app.py an, um diese Funktion zu erstellen:

      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)
      

      Nachdem Sie nun eine Funktion zur Behandlung der Nachrichten-Aspekte Ihrer Anwendung erstellt haben, erstellen Sie eine Funktion, die Slack-Ereignisse für eine bestimmte Aktion überwacht und dann Ihren Bot ausführt. Sie werden Ihre Anwendung so konfigurieren, dass sie mit den Ergebnissen eines simulierten Münzwurfs reagiert, wenn sie den Satz „Hey Sammy, Flip a coin“ (Hey Sammy, wirf eine Münze) sieht. Sie werden jede Version dieses Falls akzeptieren – was die Anwendung nicht daran hindert, zu reagieren.

      Dekorieren Sie zunächst Ihre Funktion mit der Syntax @slack_events_adapter.on, die es Ihrer Funktion ermöglicht, Ereignisse zu empfangen. Geben Sie an, dass Sie nur die Nachrichten-Ereignisse empfangen wollen, und lassen Sie Ihre Funktion einen Nutzlastparameter akzeptieren, der alle erforderlichen Slack-Informationen enthält. Sobald Sie diese Nutzlast haben, parsen Sie den Text aus und analysieren ihn. Wenn er dann die Aktivierungs-Phrase erhält, sendet Ihre Anwendung die Ergebnisse eines simulierten Münzwurfs.

      Fügen Sie den folgenden Code an app.py an, um eingehende Nachrichten zu empfangen, zu analysieren und darauf zu reagieren:

      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)
      

      Erstellen Sie schließlich einen Hauptabschnitt, der einen Logger erstellt, damit Sie die Interna Ihrer Anwendung sehen und die Anwendung auf Ihrer externen IP-Adresse auf Port 3000 starten können. Um die Ereignisse von Slack aufzunehmen, z. B. wenn eine neue Nachricht gesendet wird, müssen Sie Ihre Anwendung auf einer öffentlich zugänglichen IP-Adresse testen.

      Fügen Sie die folgenden Zeilen an app.py an, um Ihren Hauptabschnitt einzurichten:

      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)
      

      Sie sind nun mit der Flask-Anwendung fertig und sie ist zum Testen bereit. Bevor Sie fortfahren, überprüfen Sie, dass Ihre fertige Datei app.py Folgendes enthält:

      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)
      

      Speichern und schließen Sie die Datei.

      Nachdem Ihre Flask-Anwendung nun bereit ist, Ihrer Anwendung zu bedienen, testen wir sie.

      Schritt 6 — Ausführen Ihrer Flask-Anwendung

      Bringen Sie abschließend alles zusammen und führen Sie Ihre Anwendung aus.

      Fügen Sie zunächst Ihre laufende Anwendung als autorisierten Handler für Ihren Slackbot hinzu.

      Navigieren Sie zum Abschnitt Basic Information Ihrer Anwendung in der Slack-Benutzeroberfläche. Scrollen Sie nach unten, bis Sie den Abschnitt App Credentials finden.

      Slack Signing Secret (Unterschriftengeheimnis)

      Kopieren Sie das Signing Secret und exportieren Sie es als Umgebungsvariable SLACK_EVENTS_TOKEN:

      • export SLACK_EVENTS_TOKEN="MY_SIGNING_SECRET_TOKEN"

      Damit haben Sie alle erforderlichen API-Token, um Ihre Anwendung auszuführen. Siehe Schritt 1, wenn Sie eine Auffrischung benötigen, wie Sie Ihre SLACK_TOKEN exportieren können. Jetzt können Sie Ihre Anwendung starten und überprüfen, ob sie tatsächlich ausgeführt wird. Stellen Sie sicher, dass Ihre virtuelle Umgebung aktiviert ist und führen Sie folgenden Befehl aus, um Ihre Flask-Anwendung zu starten:

      Sie werden eine Ausgabe wie diese sehen:

      (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)
      

      Um zu überprüfen, ob Ihre Anwendung aktiviert ist, öffnen Sie ein neues Terminal-Fenster und führen curl für die IP-Adresse Ihres Servers mit dem richtigen Port aus unter /slack/events:

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

      curl gibt Folgendes zurück:

      Output

      These are not the slackbots you're looking for.

      Der Empfang der Nachricht Theses are not the slackbots you're looking for (Dies sind nicht die Slackbots, nach denen Sie suchen) zeigt an, dass Ihre Anwendung aktiviert ist und ausgeführt wird.

      Lassen Sie diese Flask-Anwendung nun laufen, während Sie die Konfiguration Ihrer Anwendung in der Slack-Benutzeroberfläche beenden.

      Erteilen Sie Ihrer Anwendung zunächst die entsprechenden Berechtigungen, damit sie auf Nachrichten hören und entsprechend reagieren kann. Klicken Sie auf Event Subscriptions in der Seitenleiste der Benutzeroberfläche und schalten Sie die Optionsschaltfläche Enable Events um.

      Schaltfläche „Ereignisse aktivieren“

      Geben Sie anschließend Ihre IP-Adresse, den Port und /slack/events-Endpunkte in das Feld Request URL ein. Vergessen Sie nicht das HTTP-Protokoll-Präfix. Slack wird versuchen, sich mit Ihrem Endpunkt zu verbinden. Sobald dies erfolgreich abgeschlossen ist, sehen Sie ein grünes Häkchen mit dem Wort Verified daneben.

      Ereignis-Abonnements URL anfordern

      Erweitern Sie als Nächstes Subscribe to bot events und fügen Sie die Berechtigung message.channels zu Ihrer Anwendung hinzu. Dadurch kann Ihre Anwendung Nachrichten von Ihrem Kanal empfangen und verarbeiten.

      Berechtigung „Bot-Ereignisse abonnieren“

      Sobald Sie dies getan haben, sehen Sie das Ereignis in Ihrem Abschnitt Subscribe to bot events aufgelistet. Klicken Sie als Nächstes auf die grüne Schaltfläche Save Changes in der rechten unteren Ecke.

      Änderungen bestätigen und speichern

      Sobald Sie dies getan haben, sehen Sie oben auf dem Bildschirm ein gelbes Banner, das Sie darauf hinweist, dass Sie Ihre Anwendung neu installieren müssen, damit die folgenden Änderungen wirksam werden. Jedes Mal, wenn Sie Berechtigungen ändern, müssen Sie Ihre Anwendung neu installieren. Klicken Sie in diesem Banner auf den Link reinstall your app, um Ihre Anwendung neu zu installieren.

      Banner „Neuinstallation Ihrer Anwendung“

      Es wird ein Bestätigungsbildschirm angezeigt, der die Berechtigungen Ihres Bots zusammenfasst und Sie fragt, ob Sie die Installation zulassen möchten. Klicken Sie auf die grüne Schaltfläche Allow, um den Installationsvorgang abzuschließen.

      Bestätigung der Neuinstallation

      Danach sollte Ihre Anwendung bereit sein. Gehen Sie zurück zu dem Kanal, in dem Sie CoinBot installiert haben, und senden Sie eine Nachricht mit dem Inhalt Hey Sammy, Flip a coin. Ihr Bot wird eine Münze werfen und mit den Ergebnissen antworten. Herzlichen Glückwunsch! Sie haben einen Slackbot erstellt!

      Hey Sammy, wirf eine Münze

      Zusammenfassung

      Wenn Sie mit der Entwicklung Ihrer Anwendung fertig sind und sie in Produktion gehen kann, müssen Sie sie auf einem Server bereitstellen. Dies ist notwendig, da der Flask-Entwicklungsserver keine sichere Produktionsumgebung ist. Es ist besser, wenn Sie Ihre Anwendung über ein WSGI bereitstellen und eventuell sogar einen Domänennamen sichern und Ihrem Server einen DNS-Eintrag geben. Es gibt viele Optionen zum Bereitstellen von Flask-Anwendungen, von denen einige unten aufgeführt sind:

      Es gibt noch viele weitere Möglichkeiten, Ihre Anwendung bereitzustellen, als nur diese. Wie immer, wenn es um Bereitstellungen und Infrastruktur geht, tun Sie das, was für Sie am besten funktioniert.

      In jedem Fall verfügen Sie nun über einen Slackbot, mit dem Sie eine Münze werfen können, um Ihnen bei Entscheidungen zu helfen, wie zum Beispiel, was Sie zu Mittag essen möchten.

      Sie können diesen Basiscode auch nehmen und ihn an Ihre Bedürfnisse anpassen, sei es automatisierte Unterstützung, Ressourcenmanagement, Bilder von Katzen oder was immer Ihnen einfällt. Sie können die vollständigen Python Slack API-Dokumente hier einsehen.



      Source link