Set up the Openflow Connector for Slack¶

Prerequisites¶

1. Ensure that you have reviewed Openflow Connector for Slack.

2. Ensure that you have set up Openflow.

Set up a Slack App¶

Set up a Slack App in your Slack workspace. A Slack Admin is needed to set up access to the Slack Workspace. This is done by creating or supplying credentials to a Slack App and installing the App to the Slack workspace and channels. You can create a Slack App by using the JSON configuration:

1. Update the JSON manifest. Copy the JSON manifest text below. Change the name and display name properties from EXAMPLE_NAME_CHANGE_THIS to the desired name of your Slack App. It is recommended to use the same name and display name for your App.

   {
       "display_information": {
           "name": "EXAMPLE_NAME_CHANGE_THIS"
       },
       "features": {
           "bot_user": {
               "display_name": "EXAMPLE_NAME_CHANGE_THIS",
               "always_online": false
           }
       },
       "oauth_config": {
           "scopes": {
               "bot": [
                   "channels:history",
                   "channels:read",
                   "groups:history",
                   "groups:read",
                   "im:history",
                   "im:read",
                   "mpim:history",
                   "mpim:read",
                   "users.profile:read",
                   "users:read",
                   "users:read.email"
               ]
           }
       },
       "settings": {
           "event_subscriptions": {
               "bot_events": [
                   "message.channels",
                   "message.groups",
                   "message.im",
                   "message.mpim"
               ]
           },
           "interactivity": {
               "is_enabled": true
           },
           "org_deploy_enabled": false,
           "socket_mode_enabled": true,
           "token_rotation_enabled": false
       }
   }
   

   Copy

2. Create a Slack app through the Apps page.

   1. On the Your Apps page, select Create New App.

   2. Select From a manifest.

   3. Select the Workspace where you’ll be developing your app. You’ll be able to [distribute your app](https://api.slack.com/distribution) to other workspaces later if you choose.

   4. Copy the updated manifest JSON from step 1.

3. Generate an app-level token. You need to create an app-level token even after using the JSON manifest. Under Basic Information, scroll to the App-level tokens section and click the button to generate an [app-level token](https://api.slack.com/concepts/token-types#app). Include the connections:write scope to the token.

4. Install and authorize the app.

   1. Return to the Basic Information section of the app management page.

   2. Install your app by selecting the Install to Workspace button.

   3. You’ll now be sent through the Slack OAuth flow. Select Allow on the following screen.

   If you want to add your app to a different workspace besides your own, these steps would need to be performed by a user from that workspace. After installation, navigate back to the OAuth & Permissions page. You’ll see an access token under OAuth Tokens. Access tokens represent the permissions delegated to your app by the installing user. Keep it safe and secure. Avoid checking them into public version control. Instead, access them through an environment variable.

5. Adding the App to channels. Your app isn’t a member of any channels yet, so pick a channel to add some test messages in and /invite your app. For example, /invite @Grocery Reminders.

Setup necessary ingress rules¶

A Snowflake Admin should follow the egress guide to apply egress rules to the endpoint https://slack.com/api and enable WebSocket egress on wss://wss.slack.com. This is easiest done by adding a rule to enable egress on the “slack.com” domain.

Set up Snowflake account¶

As a Snowflake account administrator, perform the following tasks:

1. Create a new role or use an existing role and grant the Database privileges.

2. Create a new Snowflake service user with the type as SERVICE.

3. Grant the Snowflake service user the role you created in the previous steps.

4. Configure with key-pair auth for the Snowflake SERVICE user from step 2.

5. Snowflake strongly recommends this step. Configure a secrets manager supported by Openflow, for example, AWS, Azure, and Hashicorp, and store the public and private keys in the secret store.

   Note

   If for any reason, you do not wish to use a secrets manager, then you are responsible for safeguarding the public key and private key files used for key-pair authentication according to the security policies of your organization.

   1. Once the secrets manager is configured, determine how you will authenticate to it. On AWS, it’s recommended that you the EC2 instance role associated with Openflow as this way no other secrets have to be persisted.

   2. In Openflow, configure a Parameter Provider associated with this Secrets Manager, from the hamburger menu in the upper right. Navigate to Controller Settings » Parameter Provider and then fetch your parameter values.

   3. At this point all credentials can be referenced with the associated parameter paths and no sensitive values need to be persisted within Openflow.

6. If any other Snowflake users require access to the raw ingested documents and tables ingested by the connector (for example, for custom processing in Snowflake), then grant those users the role created in step 1.

7. Designate a warehouse for the connector to use. Start with the smallest warehouse size, then experiment with size depending on the number of tables being replicated, and the amount of data transferred. Large table numbers typically scale better with multi-cluster warehouses, rather than larger warehouse sizes.

Configure the connector¶

As a data engineer, perform the following tasks to configure a connector:

1. Create a database and schema in Snowflake for the connector to store ingested data.

2. Download the connector definition file.

3. Import the connector definition into Openflow:

   1. Open the Snowflake Openflow canvas.

   2. Add a process group. To do this, drag and drop the Process Group icon from the tool palette at the top of the page onto the canvas. Once you release your pointer, a Create Process Group dialog appears.

   3. On the Create Process Group dialog, select the connector definition file to import.

4. Right-click on the imported process group and select Parameters.

5. Populate the required parameter values as described in Flow parameters.

6. Right-click on the plane and select Enable all Controller Services.

7. Right-click on the imported process group and select Start. The connector starts the data ingestion.

8. Query the Cortex Search service.

SELECT PARSE_JSON(
  SNOWFLAKE.CORTEX.SEARCH_PREVIEW(
    '<cortex_db>.<cortex_schema>.<cortex_search_service_name>',
      '{
        "query": "<your_question>",
         "columns": ["text", "channel", "ts","username"],
         "filter": {"@contains": {"memberemails": "<user_emailID>"} },
         "limit": <number_of_results>
       }'
   )
)['results'] AS results

SELECT PARSE_JSON(
     SNOWFLAKE.CORTEX.SEARCH_PREVIEW(
          '<cortex_db>.<cortex_schema>.<cortex_search_service_name>',
          '{
             "query": "What is my vacation carry over policy?",
             "columns": ["text", "channel", “ts”,”username”],
             "filter": {"@contains": {"memberemails": "<user_emailID>"} },
             "limit": 1
          }'
     )
 )['results'] AS results

import snowflake.snowpark as snowpark
from snowflake.snowpark import Session
from snowflake.core import Root

def main(session: snowpark.Session):

   root = Root(session)

   # fetch service
   my_service = (root
     .databases["<cortex_db>"]
     .schemas["<cortex_schema>"]
     .cortex_search_services["<cortex_search_service_name>"]
   )

   # query service
   resp = my_service.search(
     query="What is my vacation carry over policy?",
     columns = ["text", "channel", "ts","username"],
     filter = {"@contains": {"memberemails": "<user_emailID>"} },
     limit=1
     )
   return (resp.to_json())

curl --location "https://<account_url>/api/v2/databases/<cortex_db>/schemas/<cortex_schema>/cortex-search-services/<cortex_search_service_name>" \
     --header 'Content-Type: application/json' \
     --header 'Accept: application/json' \
     --header "Authorization: Bearer <CORTEX_SEARCH_JWT>" \
     --data '{
         "query": "What is my vacation carry over policy?",
         "columns": ["text", "channel"],
         "limit": 1
     }'

{
  "results" : [ {
  "channel" : "dev notes",
  "text" : "Answer to the question asked."
  } ]
}