Slack-Kommunikation in Echtzeit mit deiner Kinsta Hosted Python-Anwendung

Im Bereich des Hochleistungshostings und der vielseitigen Entwicklungstools sticht Kinsta als führende Plattform für WordPress, Anwendungen, Datenbanken und sogar kostenloses Statische-Website-Hosting hervor.

Slack, das für seine Slash Commands bekannt ist, lässt sich nahtlos in die von Kinsta gehosteten Anwendungen und Dienste integrieren und ermöglicht es den Nutzern, Aufgaben zu automatisieren und die Effizienz deutlich zu steigern.

In diesem Leitfaden wird erklärt, wie du die Echtzeitkommunikation zwischen Slack und einer auf Kinsta gehosteten Python-Anwendung einrichtest. Durch die Nutzung von Slash Commands können die Nutzer der Anwendung schnell Produkte erstellen, abfragen und löschen.

Diese Integration ermöglicht es ihnen, ihren Produktbestand dynamisch zu aktualisieren und so schnell auf Kundenwünsche zu reagieren.

Die Slash-Befehle von Slack verstehen

Slack Slash-Befehle sind textbasierte Abkürzungen. Sie beginnen mit einem Schrägstrich (/), gefolgt von einem bestimmten Schlüsselwort und einem optionalen Parameter.

Slash-Befehle lösen Aktionen aus oder interagieren direkt mit Integrationen innerhalb der Slack-Oberfläche. Mit /remind kannst du zum Beispiel direkt über Slack-Benachrichtigungen Erinnerungen einstellen.

Mit Slack-Integrationen kannst du maßgeschneiderte Befehle für deine Anwendungen konfigurieren. In diesem Leitfaden kann dein Team mit dem /check_inventory Slash Command und anderen Befehlen mühelos das Inventar unserer Produkt-Anwendung abfragen.

Die Integration von Slack in deine Anwendungen fördert die nahtlose Interaktion und optimierte Arbeitsabläufe an einem modernen Arbeitsplatz. Es verbessert die Kommunikation und Produktivität über:

• Ein zentraler Kommunikationsknotenpunkt – Slack fungiert als einheitlicher Raum für Teams. Durch die Integration von Anwendungen in Slack werden die Kanäle konsolidiert, sodass Unterhaltungen und Informationen an einem Ort stattfinden und die Effizienz gesteigert wird.
• Aktualisierungen in Echtzeit – Integrierte Anwendungen informieren sofort über wichtige Ereignisse, damit alle informiert bleiben und schnell auf Änderungen oder Aktualisierungen reagieren können.
• Optimierte Arbeitsabläufe – Integrationen automatisieren Aufgaben wie Benachrichtigungen von Projektmanagement-Tools oder das Auslösen von Aktionen in CRM-Software und reduzieren so die manuelle Arbeit.
• Verbesserte Zusammenarbeit – Wenn Teammitglieder direkt von Slack aus auf Anwendungen zugreifen, fördert das die nahtlose Zusammenarbeit. Sie können ganz einfach Dateien austauschen, bearbeiten und Projekte besprechen, was die Teamarbeit über alle Funktionen hinweg fördert.

Wie man eine Python-Anwendung auf Kinsta erstellt

Lass uns eine Produktmanagement-Anwendung auf Kinsta erstellen und bereitstellen. Dann integrierst du sie in Slack, um die Slash-Befehle zu erkunden. Die Benutzer können die Produkte des Inventars über Slash Commands in Slack hinzufügen, löschen und abfragen.

Voraussetzungen

Um diesem Leitfaden zu folgen, setzen wir voraus, dass du Folgendes hast

• Grundkenntnisse in Python
• Ein Slack-Konto

Als Erstes wollen wir ein Python-Projekt auf Kinsta einrichten. Befolge dazu die unten stehenden Schritte:

1. Besuche die Python-Vorlage von Kinsta auf GitHub.
2. Wähle Diese Vorlage verwenden > Neues Repository erstellen, um den Startcode in ein Repository in deinem GitHub-Konto zu kopieren.
3. Sobald dein Repository fertig ist, logge dich ein oder erstelle ein Konto, um dein MyKinsta-Dashboard zu sehen.
4. Autorisiere Kinsta bei deinem Git-Anbieter (Bitbucket, GitHub oder GitLab).
5. Klicke in der linken Seitenleiste auf Anwendungen und dann auf Anwendung hinzufügen.
6. Wähle das Repository und den Zweig aus, von dem aus du die Anwendung bereitstellen möchtest.
7. Gib deiner Anwendung einen eindeutigen Namen und wähle den Standort deines Rechenzentrums.
8. Als Nächstes konfigurierst du deine Build-Umgebung. Wähle die Standard-Build-Maschinen-Konfiguration mit der für diese Demo empfohlenen Nixpacks-Option.
9. Verwende alle Standardkonfigurationen und klicke dann auf Anwendung erstellen.

Die Bereitstellung dauert in der Regel ein paar Minuten. Wenn sie erfolgreich war, erhältst du einen Link zu deiner Anwendung und ein Dashboard mit Informationen zur Bereitstellung.

So richtest du die Slack-Integration in deiner Python-Anwendung ein

Beginnen wir mit der Erstellung einer Slack-Anwendung und konfigurieren dann die Slack-Befehle, die über einige Token mit deiner Python-Anwendung verbunden werden sollen. Konfigurieren wir eine Slack-Anwendung:

1. Rufe das Slack API Dashboard auf.
2. Klicke auf Neue Anwendung erstellen und wähle From Scratch.
3. Gib deiner Slack-Anwendung einen Namen (z. B. product-inventory).
4. Wähle den Arbeitsbereich aus und klicke auf Anwendung erstellen.

Nun zur Authentifizierung:

1. Aktiviere den Socket-Modus in der Seitenleiste deines Slack Dashboards.
2. Erstelle ein Token auf Anwendung-Ebene, indem du einen Token-Namen eingibst und auf Generieren klickst.
3. Speichere dieses Anwendung-Level-Token, um später Umgebungsvariablen zu konfigurieren.

So konfigurierst du Slash-Befehle

So richtest du die Slash-Befehle für deine Anwendung  ein:

1. Navigiere im Slack API Dashboard unter Basisinformationen zum Abschnitt Funktionen. Wähle Slash-Befehle.

   

2. Klicke auf Neuen Befehl erstellen, um einen neuen Befehl zu konfigurieren.

   

3. Auf der Seite „Neuen Befehl erstellen “ gibst du die Details für deinen neuen Slash-Befehl ein. Gib zum Beispiel /hi in das Feld Befehl ein. Füge optional eine kurze Beschreibung hinzu, z.B. „Sagt Hallo!“, und gib einen Hinweis auf die Verwendung. Klicke auf Speichern.
4. Klicke im Abschnitt Anwendung installieren in der Seitenleiste auf In Arbeitsbereich installieren.
5. Rufe das OAuth-Token des Bot-Benutzers auf, indem du in der Seitenleiste auf OAuth & Permissions gehst. Speichere dieses Token für spätere Zwecke.

So fügst du Token zur Anwendungsbereitstellung von Kinsta hinzu

1. Gehe zum Abschnitt Umgebungsvariablen unter Einstellungen deiner Anwendungsbereitstellung in MyKinsta.
2. Klicke auf Umgebungsvariable hinzufügen.

   

3. Füge für Schlüssel 1, SLACK_BOT_TOKEN, das OAuth-Token des Bot-Benutzers in Wert 1 ein. Für Schlüssel 2, SLACK_APP_TOKEN, füge den Anwendungs-Level-Token in Wert 2 ein.
4. Vergewissere dich, dass beide Optionen markiert sind, und klicke auf Jetzt bereitstellen, damit Kinsta deine Anwendung mit den Umgebungsvariablen neu bereitstellen kann.

So implementierst du die Kommunikation in Echtzeit

Für diese Demo verwendest du das Python-Template von Kinsta, das die folgenden Dateien enthält:

• Procfile – Legt die Befehle fest, mit denen deine Anwendung ausgeführt wird.
• requirements.txt – Listet die Abhängigkeiten auf, die für die Python-Anwendung benötigt werden.
• server.py – Die Hauptdatei der Python-Anwendung, die die serverseitigen Funktionen und Vorgänge verwaltet.

Kinsta erstellt beim Deployment einer Anwendung automatisch einen Prozess, der auf dem Procfile im Stammverzeichnis des Repository basiert. Das Procfile enthält den folgenden Code.

web: python server.py

Dieser Befehl führt den Code aus, den server.py enthält. Kinsta installiert auch die Python-Abhängigkeiten in der Datei requirements.txt während der Bereitstellung und des Redeployments.

Nun wollen wir das Bolt-Framework verwenden, um die Echtzeitkommunikation mit deiner Anwendung einzurichten. Füge die folgenden Zeilen in die Datei requirements.txt ein, um Bolt automatisch auf deiner Python-Anwendung zu installieren, wenn du das Repository aktualisierst.

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

Füge außerdem die Bibliothek psycopg2 in die Datei requirements.txt ein. Diese wird für die Verbindung mit einer Postgres-Datenbank verwendet.

psycopg2-binary==2.9.9

So implementierst du eine Postgres-Datenbank mit Kinsta

Die Produktinventarisierungs-Anwendung braucht eine Möglichkeit, die Produktdaten, die Slash Commands der Datenbank hinzufügt, dauerhaft zu speichern. Um die Daten dauerhaft zu speichern, kannst du die gehostete Datenbank von Kinsta nutzen.

1. Richte zunächst eine Postgres-Datenbank in deinem Kinsta-Dashboard ein, indem du zum Abschnitt Datenbanken in der Seitenleiste des MyKinsta-Dashboards navigierst.
2. Klicke auf Datenbank erstellen. Konfiguriere die Details deiner Datenbank, indem du einen Namen eingibst und den Datenbanktyp auswählst. Wähle die Option PostgreSQL und gib die gewünschte Größe an. Ein Datenbank-Benutzername und ein Passwort werden automatisch generiert:

   

3. Klicke auf Weiter, um die Einrichtung deiner Datenbank abzuschließen. Warte, bis die PostgreSQL-Datenbank erstellt wurde.
   Wenn die Erstellung erfolgreich war, kannst du den Verbindungsstring für den externen Zugriff auf deine Datenbank abrufen, indem du zum Abschnitt Externe Verbindungen im Dashboard deiner eingerichteten Datenbank navigierst und den externen Verbindungsstring kopierst.

   

   Jetzt kannst du diesen Verbindungsstring verwenden, um dich von deiner Python-Anwendung aus mit der Datenbank zu verbinden.

4. Erstelle in deinem Python-Projekt eine Datei db.py in deinem Projektverzeichnis für die Datenbankinitialisierungsfunktionen. Füge den folgenden Code ein:

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

   Wenn die Funktion get_conn() aufgerufen wird, erstellt sie eine Verbindung zu der bereitgestellten Kinsta-Datenbank und gibt sie mit deinem externen Verbindungsstring zurück.

   Die Funktion init_db() ruft eine Datenbankverbindung ab, definiert das Datenbankschema und erstellt die Tabelle, während sie gleichzeitig die Änderungen festschreibt. Du solltest die Funktion init_db() nur einmal aufrufen, wenn du den Anwendungsserver einrichtest. Verwende die Funktion get_conn() bei späteren Aufrufen, um eine Verbindung zur Datenbank herzustellen.

So implementierst du die Slash Command Handler

Erstelle nun den Code des Anwendungsservers.

1. Lösche den Inhalt der Datei server.py und importiere die folgenden Bibliotheken:

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

   Diese werden für die Funktionalität der Slack-Anwendung, die Datenbankverbindungen und die Fehlerbehandlung benötigt.

2. Füge den folgenden Code in die Datei server.py nach den import-Anweisungen ein:

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

   Die Klasse App von slack_bolt wird verwendet, um eine Instanz der Slack-Anwendung zu erstellen. Sie initialisiert die Anwendung mit dem OAuth-Token des Bot-Benutzers, der aus der Umgebungsvariablen SLACK_BOT_TOKEN abgerufen wird.

3. Als Nächstes implementierst du einen Handler für den /hi Slash-Befehl, den du zuvor zu deiner Slack-Anwendung hinzugefügt hast. Füge die folgenden Zeilen in die Datei server.py ein.

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

   @app.command() erstellt einen Listener für den als Argument übergebenen Befehlsstring und bildet die folgende Funktion für die Anfragen dieses Slash Command ab. Die Funktion send_hello() verwaltet die Anfragelogik.

   Der Code übergibt außerdem die Anforderungsvariablen ack, respond und command, die die Funktion verwenden soll. Rufe ack auf, um die Slash Command-Anfrage zu bestätigen, da dies der erste Schritt vor der weiteren Verarbeitung ist, und rufe respond auf, um eine Textantwort zurückzusenden.

   Wenn der Nutzer den Slash Command /hi in deinem Slack-Arbeitsbereich eingibt, erhält er die Antwort „Hallo!“

4. Kehre zum Dashboard deiner Slack-Anwendung zurück und füge die folgenden Befehle hinzu.
   

   Befehl	Kurzbeschreibung	Hinweis zur Verwendung
   /add_product	Füge ein Produkt zum Inventar hinzu.	product_id, product_name, product_quantity
   /check_inventory	Suche nach einem Produkt mit einer passenden ID im Bestand.	produkt_id
   /delete_product	Produkt mit passender ID aus dem Bestand löschen.	product_id

   Jetzt sollte deine Slash-Befehlsseite wie der folgende Screenshot aussehen und eine Liste der Befehle und ihrer Details enthalten.

   

5. Füge den /add_product Handler in die Datei server.py ein.

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

   request.body greift auf den vollständigen Request Payload zu, den Slack während des Bearbeitungsprozesses sendet.

   Wenn ein Nutzer den /add_product Slash-Befehl eingibt, sendet die Anwendung die folgende JSON-Nutzdaten als POST-Anfrage.

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

   Die Felder command und text sind enthalten. command enthält den ausgelösten Slash Command, während text den zusätzlichen Text enthält. Wenn der Benutzer zum Beispiel den Befehl /add_product 1, notebook, 5 eingibt, enthält text „1, notebook, 5“.

   Der add_product Handler extrahiert die ID, den Namen und die Menge des Produkts aus der Anfrage des Benutzers und stellt mit der Hilfsfunktion get_conn() eine Verbindung zur Datenbank her. Außerdem führt er eine SQL-Operation zum Einfügen des Produkts in die Datenbank aus. Wenn die Produkt-ID bereits in der Datenbank existiert, behandelt der Code den Fehler und antwortet, dass die ID bereits existiert.

6. Füge nun den Rest der Befehlshandler in die Datei server.py ein.

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

   Diese beiden Befehlshandler fragen die passende Produkt-ID im Inventar ab bzw. löschen sie.

Wie man den Server ausführt

1. Um die Datenbankinitialisierung und die Socket-Verbindung zusammenzubringen, füge die folgenden Zeilen in deine Datei server.py ein.

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

   Du musst SocketModeHandler mit deinem Anwendungs-Level-Token initialisieren. Verwende SLACK_APP_TOKEN, um auf die Umgebungsvariable zuzugreifen, die in der Kinsta-Anwendung eingesetzt wird.

2. Übertrage die Änderungen in dein Remote-Repository, damit sie automatisch in Kinsta bereitgestellt werden. Jetzt initialisiert server.py die Datenbank und stellt die Socket-Verbindung her. Kinsta wird eine automatische Neuverteilung deiner Python-Anwendung auslösen.

Teste und behebe Fehler in deiner Anwendung

Du kannst deine Anwendung auf Slack mit den konfigurierten Slash-Befehlen testen.

1. 1. Gehe zu dem Arbeitsbereich, der mit deiner Anwendung verknüpft ist. Gib den Schrägstrich (‚/‘) ein, um die Befehle der Anwendung anzuzeigen:

      

   2. Teste jeden Slash-Befehl. Gib zum Beispiel /hi ein. Du erhältst die Antwort „Hallo!“

      

   3. Teste, was passiert, wenn du das gleiche Produkt zweimal hinzufügst. Führe den Schrägstrich-Befehl /add_product 1, notepad, 2 zwei Mal aus.

      

      Wie der Screenshot oben zeigt, hat der erste Befehl funktioniert. Es wurde ein neues Produkt hinzugefügt. Der zweite Befehl führte zu der Antwort, dass die ID bereits existiert.

   4. Versuche, die Produkt-ID abzufragen, die wir gerade hinzugefügt haben. Gib /check_inventory 1 ein.

      

      Die Abfrage liefert das Produkt mit der passenden ID.

   5. Versuche schließlich, das hinzugefügte Produkt zu löschen. Gib /delete_product 1 ein.

      

Fehlersuche und -behebung

Bei der Konfiguration und Bereitstellung deiner Anwendung können Fehler auftreten, die du beheben musst, damit deine Anwendung richtig funktioniert. Probiere die folgenden Methoden aus, um typische Fehler zu erkennen und zu beheben.

1. 1. • Überprüfe deine Token: Vergewissere dich, dass du dein Token auf Anwendungs-Ebene mit dem Bereich connections:write richtig konfiguriert hast, um den Zugriff über den Socket-Modus zu ermöglichen. Verwende außerdem die richtigen Token für die Anwendungs-Klasse. Das Bot-Benutzer-Token beginnt mit xoxb-<...>. Verwende das Anwendungs-Level-Token (xapp-<...>) für die Klasse SocketModeHandler.
      • Überprüfe deine Slash-Befehle: Vergewissere dich, dass du die Slash-Befehle im Dashboard deiner Slack-Anwendung konfiguriert und die richtigen Handler im Code deines Anwendungsservers konfiguriert hast.
      • Setze eine bessere Fehlerbehandlung ein: Stelle sicher, dass deine Anwendungslogik Fehler richtig behandelt, z. B. bei der Ausführung von Datenbankoperationen.

Zusammenfassung

In diesem Leitfaden hast du gelernt, wie du eine Python-Anwendung mit Echtzeitkommunikation über die Slash-Befehle von Slack erstellst. Du hast auch gelernt, wie du die Anwendung auf Kinsta bereitstellst.

Die Integration einer von Kinsta gehosteten Anwendung mit Slack ermöglicht es den Nutzern, mit Slash-Befehlen schnell Änderungen vorzunehmen, was die Interaktivität und die Effizienz der Arbeitsabläufe verbessert und gleichzeitig einen sofortigen Zugriff auf Echtzeitdaten ermöglicht. Die Mitarbeiter können jetzt nahtlos Produktbestände hinzufügen, löschen oder überprüfen, ohne ihre Kommunikationsplattform zu verlassen, und so die Produktivität während eines arbeitsreichen Tages steigern.

Kinstas PaaS bietet noch mehr Möglichkeiten – du kannst Anwendungen und Datenbanken miteinander verbinden und so Komplettlösungen für Unternehmen und Betriebe bereitstellen. Und das Beste daran? Deine ersten 20 Dollar werden von uns übernommen!

Jeremy Holcombe Kinsta

Content & Marketing Editor bei Kinsta, WordPress Web Developer und Content Writer. Außerhalb von WordPress genieße ich den Strand, Golf und Filme. Außerdem habe ich Probleme mit großen Menschen ;).

• LinkedIn