Nel regno dell’hosting ad alte prestazioni e degli strumenti di sviluppo versatili, Kinsta si distingue come piattaforma leader per WordPress, applicazioni, database e persino per l’hosting gratuito di siti statici.

Slack, famoso per i suoi comandi Slash, si integra perfettamente con le app e i servizi ospitati da Kinsta, consentendo agli utenti di automatizzare le attività e di migliorare notevolmente l’efficienza.

Questa guida spiega come impostare la comunicazione in tempo reale tra Slack e un’applicazione Python ospitata su Kinsta. Sfruttando i comandi Slash, gli utenti dell’applicazione hanno la possibilità di creare, interrogare ed eliminare rapidamente i prodotti.

Questa integrazione consente di aggiornare dinamicamente l’inventario dei prodotti, garantendo risposte tempestive alle esigenze dei clienti.

Come funzionano i comandi slash di Slack

I comandi Slack Slash sono scorciatoie basate sul testo. Iniziano con una barra in avanti (/) seguita da una parola chiave specifica e da un parametro opzionale.

I comandi Slash attivano azioni o interagiscono direttamente con le integrazioni all’interno dell’interfaccia Slack. Ad esempio, /remind permette di impostare i promemoria direttamente attraverso le notifiche di Slack.

Con le integrazioni di Slack, si possono configurare comandi su misura per le proprie applicazioni. In questo tutorial, il team potrà interrogare senza problemi l’inventario della nostra applicazione utilizzando il comando Slash /check_inventory e altri comandi.

L’integrazione di Slack con le applicazioni favorisce un’interazione perfetta e flussi di lavoro semplificati in un ambiente di lavoro moderno. Migliora la comunicazione e la produttività attraverso:

  • Un hub di comunicazione centralizzato: Slack funge da spazio unificato per i team. L’integrazione delle app in Slack consolida i canali, mantenendo le conversazioni e le informazioni in un unico luogo e aumentando l’efficienza.
  • Aggiornamenti in tempo reale: le app integrate forniscono avvisi istantanei sugli eventi chiave, assicurando che tutti siano informati e reagiscano rapidamente ai cambiamenti o agli aggiornamenti.
  • Flussi di lavoro semplificati: le integrazioni automatizzano attività come le notifiche dagli strumenti di gestione dei progetti o l’attivazione di azioni nel software CRM, riducendo il lavoro manuale.
  • Collaborazione migliorata: i membri del team che accedono alle app direttamente da Slack favoriscono una collaborazione perfetta. Possono facilmente condividere, modificare file e discutere di progetti, promuovendo il lavoro di squadra tra le varie funzioni.

Come creare un’applicazione Python su Kinsta

In questo articolo, costruiremo e distribuiremo un’applicazione per la gestione dei prodotti su Kinsta. Poi, la integreremo con Slack per esplorare i comandi Slash. Gli utenti potranno aggiungere, eliminare e interrogare i prodotti dell’inventario tramite i comandi Slash in Slack.

Prerequisiti

Per seguire questa guida, partiamo dal presupposto di avere:

Per prima cosa, configuriamo un progetto Python su Kinsta. Per farlo, seguiamo questi passi:

  1. Andiamo al template Python di Kinsta su GitHub.
  2. Selezioniamo Use this template > Create a new repository per copiare il codice iniziale in un repository del nostro account GitHub.
  3. Quando il repository sarà pronto, accediamo o creiamo un account per visualizzare la dashboard MyKinsta.
  4. Autorizziamo Kinsta con il nostro provider Git (Bitbucket, GitHub o GitLab).
  5. Clicchiamo su Applicazioni nella barra laterale di sinistra e poi su Aggiungi applicazione.
  6. Selezioniamo il repository e il branch da cui desideriamo effettuare il deploy.
  7. Assegniamo un nome univoco all’applicazione e scegliamo la posizione del centro dati.
  8. Configuriamo poi l’ambiente di build. Selezioniamo la configurazione della build machine standard con l’opzione Nixpacks consigliata per questa demo.
  9. Usiamo tutte le configurazioni predefinite e poi clicchiamo su Crea applicazione.

La distribuzione richiede in genere pochi minuti e, una volta completata, riceveremo un link all’applicazione e una dashboard contenente le informazioni sulla distribuzione.

Come impostare l’integrazione di Slack in un’applicazione Python

Iniziamo creando un’applicazione Slack e poi configurando i comandi Slash che saranno collegati all’applicazione Python tramite alcuni token. Configuriamo un’applicazione Slack:

  1. Accediamo alla dashboard delle API di Slack.
  2. Clicchiamo su New app e scegliamo From scratch.
  3. Diamo un nome all’app Slack (ad esempio, product-inventory).
  4. Selezioniamo l’area di lavoro e clicchiamo su Create app.

Ora, per l’autenticazione:

  1. Abilitiamo Socket Mode nella barra laterale della dashboard Slack.
  2. Generiamo un token a livello di app digitando il nome del token e Clicchiamondo su Generate.
  3. Salviamo questo token a livello di app per configurare le variabili ambientali in seguito.

Come configurare i comandi Slash

Per configurare i comandi Slash dell’app:

  1. Andiamo alla sezione Features sotto Basic information nella dashboard di Slack API. Scegliamo Slash Commands.

    Dashboard dell'API di Slack con opzioni per l'aggiunta di caratteristiche e funzioni
    La dashboard di Slack API con le opzioni per aggiungere caratteristiche e funzioni.

  2. Clicchiamo su Create New Command per configurare un nuovo comando.

    Pagina di creazione di un nuovo comando Slack con opzioni per il comando, una breve descrizione e un suggerimento d'uso. Presenta anche dettagli per i canali di fuga, gli utenti e i link inviati alla vostra app e un'anteprima di una voce di completamento automatico.
    Pagina Crea nuovo comando su Slack.

  3. Nella pagina Create New Command, inseriamo i dettagli del nostro nuovo comando Slash. Ad esempio, digitiamo /hi nel campo Command. Aggiungiamo facoltativamente una breve descrizione come “Dice ciao!” e forniamo un suggerimento d’uso. Clicchiamo su Save.
  4. Nella sezione Install App della barra laterale, clicchiamo su Install to Workspace.
  5. Accediamo al token OAuth dell’utente del bot andando su OAuth & Permissions nella barra laterale. Salviamo questo token per riferimenti futuri.

Come aggiungere i token al deployment delle applicazioni di Kinsta

  1. Andiamo alla sezione Variabili d’ambiente sotto Impostazioni dell’applicazione in MyKinsta.
  2. Clicchiamo su Aggiungi variabile d’ambiente.

    Slack Aggiunta di una variabile d'ambiente con chiavi, valori e la possibilità di rimuoverli o aggiungerne altri
    Il popup di Slack Add environment variable.

  3. Per la chiave 1, SLACK_BOT_TOKEN, incolliamo il token OAuth dell’utente del bot nel valore 1. Per la Chiave 2, SLACK_APP_TOKEN, incolliamo il token a livello di app nel Valore 2.
  4. Assicuriamoci che entrambe le opzioni siano selezionate e clicchiamo su Deploy now in modo che Kinsta possa distribuire nuovamente l’applicazione con le variabili d’ambiente.

Come implementare la comunicazione in tempo reale

Per questa demo si utilizza il modello Python di Kinsta, che contiene i seguenti file:

  • Procfile: specifichiamo i comandi per eseguire l’applicazione.
  • requirements.txt: elenca le dipendenze necessarie per l’applicazione Python.
  • server.py: il file principale dell’applicazione Python, che gestisce le funzionalità o le operazioni lato server.

Kinsta crea automaticamente un processo basato sul Procfile nella root del repository quando distribuisce un’applicazione. Il Procfile contiene il seguente codice.

web: python server.py

Questo comando esegue il codice contenuto in server.py. Kinsta installa anche le dipendenze Python contenute nel file requirements.txt durante la distribuzione e la ridistribuzione.

Ora utilizziamo il framework Bolt per impostare la comunicazione in tempo reale con l’applicazione. Aggiungiamo le seguenti righe al file requirements.txt per installare automaticamente Bolt sull’applicazione Python quando aggiorniamo il repository.

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

Inoltre, aggiungiamo la libreria psycopg2 al file requirements.txt. Questa verrà utilizzata per connettersi a un database Postgres.

psycopg2-binary==2.9.9

Come implementare un database Postgres con Kinsta

L’applicazione per l’inventario dei prodotti ha bisogno di un modo per conservare i dati dei prodotti che Slash Commands aggiunge al database. Per creare un’archiviazione persistente dei dati, possiamo utilizzare il database ospitato da Kinsta.

  1. Per prima cosa, distribuiamo un database Postgres sulla dashboard di Kinsta navigando nella sezione Database nella barra laterale della dashboard di MyKinsta.
  2. Clicchiamo su Crea un database. Configuriamo i dettagli del database inserendo un nome e selezionando il tipo di database. Selezioniamo l’opzione PostgreSQL e configuriamo la dimensione desiderata. Il nome utente e la password del database vengono generati automaticamente:

    Modulo per la creazione di un database. I campi includono il nome del database, il nome visualizzato, il tipo e la versione del database, il nome utente e la password del database, la posizione del centro dati e la dimensione. Nella parte inferiore del modulo sono presenti due pulsanti: Annulla e Continua
    Modulo per la creazione di un database.

  3. Clicchiamo su Continua per terminare la configurazione del database. Attendiamo che il database PostgreSQL venga creato.
    Una volta completata la creazione, per ottenere la stringa di connessione per l’accesso esterno al database, andiamo alla sezione Connessioni esterne della dashboard del database distribuito e copiamo la stringa di connessione esterna.
    La pagina informativa per il cruscotto del database distribuito. I dettagli includono le risorse, la posizione, la versione, la data di creazione, un elenco di connessioni interne e le informazioni sulle connessioni interne, compresa la stringa di connessione.
    Informazioni sulla connessione esterna del database.

    Ora possiamo utilizzare questa stringa di connessione per collegarci al database dall’applicazione Python.

  4. Nel progetto Python, creiamo un file db.py all’interno della cartella del progetto per le funzioni di inizializzazione del database. Aggiungiamo il seguente codice: 
    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()

    Quando la funzione get_conn() viene chiamata, crea e restituisce una connessione al database Kinsta distribuito utilizzando la stringa di connessione esterna.

    La funzione init_db() ottiene una connessione al database, definisce lo schema del database e crea la tabella, effettuando anche il commit delle modifiche. Dovremmo chiamare la funzione init_db() una sola volta durante la configurazione iniziale dell’application server, e utilizzare la funzione get_conn() nelle chiamate successive per ottenere una connessione al database.

Come implementare i gestori dei comandi Slash

Ora costruiamo il codice del server dell’applicazione.

  1. Cancelliamo il contenuto del file server.py e importiamo le seguenti librerie: 
    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

    Queste sono necessarie per le funzionalità dell’app Slack, le connessioni al database e la gestione degli errori.

  2. Aggiungiamo il seguente codice al file server.py dopo le dichiarazioni di importazione: 
    # Initialize your app with your bot token
app = App(
  token=os.environ.get("SLACK_BOT_TOKEN"),
)

    La classe App di slack_bolt viene utilizzata per creare un’istanza dell’app Slack. Inizializza l’app con il token OAuth dell’utente bot recuperato dalla variabile d’ambiente SLACK_BOT_TOKEN.

  3. Quindi, distribuiamo un gestore per il comando /hi Slash che abbiamo aggiunto all’applicazione Slack in precedenza. Aggiungiamo le seguenti righe al file server.py. 
    # 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() crea un ascoltatore per la stringa di comando passata come argomento e mappa la seguente funzione per le richieste del comando Slash. La funzione send_hello() gestisce la logica delle richieste.

    Il codice passa anche le variabili di richiesta ack, respond e command affinché la funzione le utilizzi. Chiamiamo ack per confermare la richiesta del comando Slash, in quanto questo è il primo passo prima di continuare l’elaborazione, e chiamiamo respond per inviare una risposta testuale.

    Quando l’utente digita il comando Slash /hi nel vostro spazio di lavoro Slack, riceve la risposta “Ciao!”

  4. Torniamo alla dashboard dell’applicazione Slack e aggiungiamo i seguenti comandi.
    Comando Descrizione breve Suggerimento d’uso
    /add_product Aggiunge un prodotto all’inventario. iD_prodotto, nome_prodotto, quantità_prodotto
    /check_inventory Controlla se nell’inventario c’è un prodotto con un ID corrispondente. prodotto_id
    /delete_product Elimina dall’inventario il prodotto con l’ID corrispondente. prodotto_id

    Ora la pagina dei comandi di Slash dovrebbe assomigliare alla seguente schermata contenente un elenco di comandi e i relativi dettagli.

    La pagina dei comandi Slash elenca il nome e la descrizione di ciascuno di essi, con le opzioni per modificarli o eliminarli e il pulsante Crea nuovo comando.
    Pagina dei comandi Slash dell’API di Slack.

  5. Aggiungiamo il gestore /add_product al file server.py. 
    # 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 accede al payload completo della richiesta che Slack invia durante il processo di gestione.

    Quando un utente digita il comando /add_product Slash, l’applicazione invia il seguente esempio di payload JSON come richiesta POST.

    {
    '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': 
}

    I campi command e text sono inclusi. command contiene il comando Slash attivato mentre text contiene il testo aggiuntivo. Ad esempio, se l’utente digita il comando /add_product 1, notebook, 5, text contiene “1, notebook, 5”.

    Il gestore add_product estrae l’ID, il nome e la quantità del prodotto dalla richiesta dell’utente e si connette al database utilizzando la funzione helper get_conn(). Esegue inoltre un’operazione SQL di inserimento per aggiungere il prodotto al database. Se l’ID del prodotto esiste già nel database, il codice gestisce l’errore e risponde che l’ID esiste già.

  6. Ora aggiungiamo il resto dei gestori di comandi al file server.py. 
    # 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()

    Questi due gestori di comandi interrogano ed eliminano rispettivamente l’ID del prodotto corrispondente nell’inventario.

Come eseguire il server

  1. Per unire l’inizializzazione del database e la connessione al socket, aggiungiamo le seguenti righe al file server.py. 
    # Start your app
if __name__ == "__main__":
    # Initialize database on start
    init_db()

    # Connect socket
    handler = SocketModeHandler(app, os.environ["SLACK_APP_TOKEN"])
    handler.start()

    Dobbiamo inizializzare SocketModeHandler con il token a livello di applicazione. Usiamo SLACK_APP_TOKEN per accedere alla variabile d’ambiente distribuita nell’applicazione Kinsta.

  2. Facciamo il commit delle modifiche al repository remoto per distribuirle automaticamente su Kinsta. Ora, server.py inizializza il database e stabilisce la connessione socket. Kinsta attiverà una nuova distribuzione automatica dell’applicazione Python.

Testare e risolvere i problemi dell’applicazione

Possiamo testare l’applicazione su Slack utilizzando i comandi Slash configurati.

    1. Andiamo all’area di lavoro associata all’applicazione. Digitiamo il carattere slash (‘/’) per visualizzare i comandi dell’applicazione:

      Il canale Kinsta-demo con un elenco di comandi, tra cui controllare l'ID del prodotto in inventario, aggiungere l'ID del prodotto, il nome o la quantità, eliminare l'ID del prodotto e Hi.
      Il canale kinsta-demo.

    2. Proviamo ogni comando Slash. Ad esempio, digitiamo /hi. Otterremo la risposta “Hi!”

      Risposta al comando Hi con il messaggio Hi!'
      Risposta al comando Hi.

    3. Verifichiamo cosa succede quando aggiungiamo lo stesso prodotto due volte. Eseguiamo il comando slash /add_product 1, notepad, 2 due volte.
      Risultato dell'esecuzione del comando add product due volte. Mostra una quantità di 2
      Aggiungere un prodotto due volte.

      Come mostra la schermata qui sopra, il primo comando ha funzionato. Ha aggiunto un nuovo prodotto. Il secondo comando ha dato come risposta che l’ID esiste già.

    4. Proviamo a cercare l’ID del prodotto appena aggiunto. Digitiamo /check_inventory 1.
      Interrogazione dell'ID di un prodotto con il comando check inventory. Vengono elencati l'ID, il nome e la quantità
      Controlla l’inventario.

      La query ha restituito il prodotto con l’ID corrispondente.

    5. Infine, proviamo a cancellare il prodotto che abbiamo aggiunto. Digitiamo /delete_product 1.

      Dopo aver eliminato il prodotto, il messaggio dice: Prodotto con ID 1 eliminato dall'inventario!
      Eliminare un prodotto.

Come risolvere i problemi

Durante la configurazione e la distribuzione dell’applicazione, potremmo incontrare degli errori da risolvere per far funzionare correttamente l’applicazione. Proviamo i seguenti metodi per individuare e risolvere gli errori tipici.

      • Verificare i token: assicuriamoci di configurare correttamente il token a livello di applicazione con l’ambito connections:write per abilitare l’accesso in modalità Socket. Inoltre, utilizziamo i token corretti per la classe dell’applicazione. Il token dell’utente bot inizia con xoxb-<...>. Usiamo il token di livello app (xapp-<...>) per la classe SocketModeHandler.
      • Verificare i comandi slash: assicuriamoci di aver configurato i comandi Slash nella dashboard dell’app Slack e di aver configurato i gestori corretti nel codice del server dell’applicazione.
      • Impiegare una migliore gestione degli errori: assicuriamoci che la logica dell’applicazione gestisca correttamente gli errori, ad esempio durante l’esecuzione di operazioni sul database.

Riepilogo

Con questa guida abbiamo imparato a costruire un’applicazione Python con comunicazione in tempo reale tramite i comandi Slash di Slack. Abbiamo anche imparato a distribuire l’applicazione su Kinsta.

L’integrazione di un’applicazione ospitata da Kinsta con Slack consente agli utenti di apportare rapidamente modifiche utilizzando i comandi Slash, migliorando l’interattività e l’efficienza del flusso di lavoro e offrendo un accesso immediato ai dati in tempo reale. Il personale può ora aggiungere, eliminare o controllare l’inventario dei prodotti senza lasciare la piattaforma di comunicazione, aumentando la produttività durante una giornata lavorativa intensa.

Il PaaS di Kinsta offre ancora più possibilità: potete collegare applicazioni e database, implementando soluzioni full-stack per aziende e imprese. E la parte migliore? I primi 20€ ve li regaliamo noi!

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 ;).