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

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.

    Slack API Dashboard mit Optionen zum Hinzufügen von Features und Funktionen
    Slack API Dashboard mit Optionen zum Hinzufügen von Features und Funktionen

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

    Slack-Seite "Neuen Befehl erstellen" mit Optionen für den Befehl, einer kurzen Beschreibung und einem Hinweis auf die Verwendung. Außerdem gibt es Details zu Escape-Kanälen, Nutzern und Links, die an deine Anwendung gesendet werden, sowie eine Vorschau auf einen Autovervollständigungseintrag
    Seite „Neuen Befehl erstellen“ auf Slack

  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.

    Slack Umgebungsvariable hinzufügen Popup mit Schlüsseln, Werten und der Option, sie zu entfernen oder eine weitere hinzuzufügen
    Slack Umgebungsvariable hinzufügen Popup

  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:

    Formular zur Erstellung einer Datenbank. Zu den Feldern gehören der Datenbankname, der Anzeigename, der Datenbanktyp und die Version, der Benutzername und das Passwort für die Datenbank, der Standort des Rechenzentrums und die Größe. Am unteren Rand des Formulars befinden sich zwei Schaltflächen: Abbrechen und Weiter
    Formular zum Erstellen einer Datenbank

  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.
    Die Infoseite für das eingesetzte Datenbank-Dashboard. Zu den Details gehören Ressourcen, Standort, Version, Erstellungsdatum, eine Liste der internen Verbindungen und Informationen zu den internen Verbindungen, einschließlich des Verbindungsstrings
    Informationen zur externen Verbindung der Datenbank

    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.

    Schrägstrich-Befehlsseite, die den Namen und die Beschreibung jedes Befehls mit Optionen zum Bearbeiten oder Löschen auflistet, sowie eine Schaltfläche "Neuen Befehl erstellen"
    Slack API Slash-Befehlsseite

  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. Gehe zu dem Arbeitsbereich, der mit deiner Anwendung verknüpft ist. Gib den Schrägstrich (‚/‘) ein, um die Befehle der Anwendung anzuzeigen:

      Kinsta-Demo-Kanal mit einer Liste von Befehlen, darunter Produkt-ID im Bestand prüfen, Produkt-ID, Name oder Menge hinzufügen, Produkt-ID löschen
      Der kinsta-demo Kanal

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

      Antwort auf den Hi-Befehl
      Antwort auf den Hi-Befehl

    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.
      Ergebnis der zweimaligen Ausführung des Befehls "Produkt hinzufügen". Es wird eine Menge von 2 angezeigt
      Ein Produkt zweimal hinzufügen

      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.
      Abfrage einer Produkt-ID mit dem Befehl Bestandsprüfung. Er listet die ID, den Namen und die Menge.
      Überprüfe den Bestand

      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.

      Nach dem Löschen des Produkts wird die Meldung angezeigt: Produkt mit ID 1 aus dem Bestand gelöscht!
      Ein Produkt löschen

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.

      • Ü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 at Kinsta, WordPress Web Developer, and Content Writer. Outside of all things WordPress, I enjoy the beach, golf, and movies. I also have tall people problems ;).