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:

• Einen Slack Workspace, in dem Sie Anwendungen installieren können. Wenn Sie den Arbeitsbereich erstellt haben, haben Sie diese Fähigkeit. Wenn Sie nicht bereits über einen solchen verfügen, können Sie einen auf der Slack Website erstellen.

• (Optional) Einen Server oder einen Computer mit einer öffentlichen IP-Adresse für die Entwicklung. Wir empfehlen eine Neuinstallation von Ubuntu 20.04, einen Nicht-Root-Benutzer mit Sudo-Berechtigungen und aktiviertem SSH. Sie können diesem Leitfaden folgen, um Ihren Server zu initialisieren und diese Schritte durchzuführen.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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:

mkdir ~/.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....\n\n"
         }
      },
      {
         "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:

touch coinbot.py

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

nano coinbot.py

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:

# 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:

...
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:

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

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:

...
    # 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:

...
    # 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:

...
    # 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:

# 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....\n\n"
            ),
        },
    }

    # 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:

nano 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:

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:

python coinbot_test.py

Ü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.

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.

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

sudo ufw allow 3000

Überprüfen Sie nun den Status von ufw:

sudo ufw status

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:

touch app.py

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

nano app.py

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:

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:

...
# 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:

...
# 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:

...
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:

# 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:

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:

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.

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:

python3 app.py

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.

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.

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.

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.

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.

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.

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!

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:

• Bereitstellen Ihrer Flask-Anwendung unter Ubuntu 20.04 mit Gunicorn und Nginx
• Bereitstellen Ihrer Flask-Anwendung unter Ubuntu 20.04 mit uWSGI und Nginx
• Bereitstellen Ihrer Flask-Anwendung unter Ubuntu 18.04 mit Docker

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.