In the realm of high-performance hosting and versatile development tools, Kinsta stands out as a leading platform catering to WordPress, applications, databases, and even free Static Site Hosting.
Slack, renowned for its Slash Commands, seamlessly integrates with Kinsta-hosted apps and services, enabling users to automate tasks and significantly enhance efficiency.
This guide explains how to set up real-time communication between Slack and a Python application hosted on Kinsta. By harnessing Slash Commands, users of the application gain the ability to swiftly create, query, and delete products.
This integration empowers them to dynamically update their product inventory dynamically, ensuring prompt responses to customer needs.
Understanding Slack’s Slash Commands
Slack Slash Commands are text-based shortcuts. They begin with a forward slash (/) followed by a specific keyword and optional parameter.
Slash Commands trigger actions or directly interact with integrations within the Slack interface. For example, /remind enables setting reminders directly through Slack notifications.
With Slack integrations, you can configure tailored commands for your applications. In this tutorial, your team can effortlessly query our product app’s inventory using the /check_inventory Slash Command and other commands.
Integrating Slack with your apps fosters seamless interaction and streamlined workflows within a modern workplace. It enhances communication and productivity via:
- A centralized communication hub — Slack acts as a unified space for teams. Integrating apps into Slack consolidates channels, keeping conversations and info in one place, and boosting efficiency.
- Real-time updates — Integrated apps provide instant alerts about key events, ensuring everyone stays informed and reacts quickly to changes or updates.
- Streamlined workflows — Integrations automate tasks like notifications from project management tools or triggering actions in CRM software, cutting down on manual work.
- Enhanced collaboration — Team members accessing apps directly from Slack fosters seamless collaboration. They can easily share, edit files, and discuss projects, promoting teamwork across functions.
How To Build a Python Application on Kinsta
Let’s build and deploy a product management application on Kinsta. Then, integrate it with Slack to explore Slash Commands. Users can add, delete, and query the inventory’s products via Slash Commands in Slack.
Prerequisites
To follow along with this guide, we assume you have:
First, let’s set up a Python project on Kinsta. To do this, follow the steps below:
- Visit the Kinsta’s Python template on GitHub.
- Select Use this template > Create a new repository to copy the starter code into a repository within your GitHub account.
- Once your repository is ready, log in or create an account to view your MyKinsta dashboard.
- Authorize Kinsta with your Git provider (Bitbucket, GitHub, or GitLab).
- Click Applications on the left sidebar, then click Add application.
- Select the repository and the branch you wish to deploy from.
- Assign a unique name to your application and choose a data center location.
- Configure your build environment next. Select the Standard build machine config with the recommended Nixpacks option for this demo.
- Use all default configurations and then click Create application.
Deployment typically takes a few minutes, and upon success, you’ll receive a link to your application along with a dashboard containing deployment information.
How To Set Up Slack Integration In Python Application
Let’s get started by creating a Slack application and then configure Slash commands which would be connected to your Python application via some tokens. Let’s configure a Slack app:
- Access the Slack API dashboard.
- Click Create New App and choose From Scratch.
- Name your Slack app (e.g., product-inventory).
- Select the workspace and click Create App.
Now, for authentication:
- Enable Socket Mode in your Slack dashboard’s sidebar.
- Generate an app-level token by typing a token name and clicking Generate.
- Save this app-level token for configuring environmental variables later.
How To Configure Slash Commands
To set up your app’s Slash Commands:
- Navigate to the Features section under Basic Information in the Slack API dashboard. Choose Slash Commands.
Slack API dashboard with options for adding features and functions. - Click Create New Command to configure a new command.
Create New Command page on Slack. - On the Create New Command page, fill in the details for your new Slash Command. For instance, type
/hiin the Command field. Optionally, add a brief description like “Says hello!” and provide a usage hint. Click Save. - In the Install App section of the sidebar, click Install to Workspace.
- Access the bot user OAuth token by heading to OAuth & Permissions on the sidebar. Save this token for future reference.
How To Add Tokens to Kinsta’s Application Deployment
- Go to the Environment Variables section under Settings of your application deployment in MyKinsta.
- Click Add environment variable.
Slack Add environment variable popup. - For Key 1, SLACK_BOT_TOKEN, paste the bot user OAuth token in Value 1. For Key 2, SLACK_APP_TOKEN, paste the app-level token in Value 2.
- Ensure both options are checked and click Deploy now so Kinsta can redeploy your application with the environment variables.
How To Implement Real-Time Communication
For this demo, you use the Kinsta’s Python template, which contains the following files:
- Procfile — Specifies the commands to run your application.
- requirements.txt — Lists the dependencies required for the Python application.
- server.py — The main file of the Python application, handling server-side functionality or operations.
Kinsta automatically creates a process based on the Procfile in the repository root when deploying an application. The Procfile contains the following code.
web: python server.pyThis command runs the code that server.py contains. Kinsta also installs the Python dependencies in requirements.txt during deployment and redeployment.
Now, let’s use the Bolt framework to set up real-time communication with your application. Add the following lines to your requirements.txt file to automatically install Bolt on your Python application when you update the repository.
slack-bolt==1.18.0
slack-sdk==3.23.0Also, add the psycopg2 library to the requirements.txt file. This will be used to connect to a Postgres database.
psycopg2-binary==2.9.9How To Implement a Postgres Database With Kinsta
The product inventory app needs a way to persist product data that Slash Commands add to the database. To create persistent data storage, you can use Kinsta’s hosted database.
- First, deploy a Postgres database on your Kinsta dashboard by navigating to the Databases section on the sidebar of MyKinsta’s dashboard.
- Click Create a database. Configure your database details by entering a name and selecting the database type. Select the PostgreSQL option and configure your desired size. A Database username and password is automatically generated:
Form for creating a database. - Click Continue to finish setting up your database. Wait for the PostgreSQL database to be created.
Once successful, to get your connection string for external access to your database, navigate to the External connections section of your deployed database dashboard and copy the External connection string.Database external connection information. Now, you can use this connection string to connect to the database from your Python application.
- In your Python project, create a db.py file within your project directory for database initialization functions. Add the following code:
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()When the
get_conn()function is called, it creates and returns a connection to the deployed Kinsta database using your external connection string.The
init_db()function gets a database connection, defines the database schema, and creates the table while also committing the changes. You should only call theinit_db()function once when initially setting up the application server. Use theget_conn()function in subsequent calls to get a connection to the database.
How To Implement the Slash Command Handlers
Now, build the application server code.
- Delete the server.py file’s contents and import the following libraries:
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 DatabaseErrorThese are required for Slack app functionality, database connections, and error handling.
- Add the following code to the server.py file after the import statements:
# Initialize your app with your bot token app = App( token=os.environ.get("SLACK_BOT_TOKEN"), )The
Appclass fromslack_boltis used to create an instance of the Slack app. It initializes the app with the bot user OAuth token retrieved from the environment variableSLACK_BOT_TOKEN. - Next, deploy a handler for the
/hiSlash Command you added to your Slack application earlier. Add the following lines to the server.py file.# The hi command simply sends back a greeting @app.command("/hi") def send_hello(ack, respond, command): # Acknowledge command request ack() respond(f"Hello!")The
@app.command()creates a listener for the command string passed as an argument and maps the following function for that Slash Command’s requests. Thesend_hello()function handles the request logic.The code also passes the request variables
ack,respond, andcommandfor the function to use. Callackto acknowledge the Slash Command request, as this is the first step before continuing processing, and callrespondto send back a text response.When the user types the Slash Command
/hiin your Slack workspace, they get the response, “Hello!” - Return to your Slack application dashboard and add the following commands.
Command Short Description Usage Hint /add_productAdd a product to the inventory. product_id, product_name, product_quantity /check_inventoryCheck for a product with a matching ID in inventory. product_id /delete_productDelete product with matching ID from inventory. product_id Now, your Slash Commands page should look like the following screenshot containing a list of commands and their details.
Slack API Slash Commands page. - Add the
/add_producthandler to the server.py file.# 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.bodyaccesses the full request payload Slack sends during the handling process.When a user types the
/add_productSlash Command, the application sends the following sample JSON payload as a POST request.{ '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': }The
commandandtextfields are included.commandcontains the triggered Slash Command whiletextcontains its additional text. For example, if the user types the command/add_product 1, notebook, 5,textcontains “1, notebook, 5”.The
add_producthandler extracts the product’s ID, name, and quantity from the user’s request and connects to the database using theget_conn()helper function. It also executes an insert SQL operation to add the product to the database. If the product ID already exists in the database, the code handles the error and responds that the ID already exists. - Now, add the rest of the command handlers to the server.py file.
# 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()These two command handlers query and delete the matching product ID in the inventory, respectively.
How To Run the Server
- To bring the database initialization and socket connection together, add the following lines to your server.py file.
# Start your app if __name__ == "__main__": # Initialize database on start init_db() # Connect socket handler = SocketModeHandler(app, os.environ["SLACK_APP_TOKEN"]) handler.start()You must initialize
SocketModeHandlerwith your app-level token. Use theSLACK_APP_TOKENto access the environment variable deployed in the Kinsta application. - Commit the changes to your remote repository to deploy them to Kinsta automatically. Now, server.py initializes the database and establishes the socket connection. Kinsta will trigger an automatic re-deployment of your Python application.
Test and Troubleshoot Your Application
You can test your application on Slack using the configured Slash Commands.
- Go to the workspace associated with your app. Type the slash (‘/’) character to view the app’s commands:
The kinsta-demo channel. - Test each Slash Command. For example, type
/hi. You get the response “Hello!”Response to Hi command. - Test what happens when you add the same product twice. Run the slash command
/add_product 1, notepad, 2two times.Adding a product twice. As the screenshot above shows, the first command worked. It added a new product. The second command prompted the response that the ID already exists.
- Try querying for the product ID we just added. Type
/check_inventory 1.Checking the inventory. The query returned the product with the matching ID.
- Finally, try deleting the product you added. Type
/delete_product 1.Deleting a product.
- Go to the workspace associated with your app. Type the slash (‘/’) character to view the app’s commands:
How To Troubleshoot
When configuring and deploying your application, you might encounter errors to resolve for your application to function correctly. Try the following methods to detect and fix typical errors.
- Verify your tokens: Ensure you configure your app-level token correctly with the
connections:writescope to enable access using Socket Mode. Also, use the correct tokens for the app class. The bot user token begins withxoxb-<...>. Use the app-level token (xapp-<...>) for theSocketModeHandlerclass. - Verify your slash commands: Ensure you’ve configured the Slash Commands on your Slack app’s dashboard and configured the correct handlers in your application server code.
- Employ better error handling: Ensure your application logic correctly handles errors, for example, when executing database operations.
- Verify your tokens: Ensure you configure your app-level token correctly with the
Summary
In this guide, you learned how to build a Python application with real-time communication via Slack’s Slash commands. You also learned how to deploy the application to Kinsta.
Integrating a Kinsta-hosted application with Slack enables users to quickly make changes using Slash Commands, enhancing interactivity and workflow efficiency while offering immediate access to real-time data. Staff can now seamlessly add, delete, or check product inventory without leaving their communications platform, boosting productivity during a busy work day.
Kinsta’s PaaS offers even more possibilities—you can connect applications and databases, deploying full-stack solutions for companies and businesses. And the best part? Your first $20 is covered by us!
Jeremy Holcombe
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 ;).
