AWS Chalice और Upstash Redis का उपयोग करके Slack के लिए लो-मेंटेनेंस बर्थडे रिमाइंडर बॉट बनाएं

कभी-कभी अपने वार्षिक आयोजनों के लिए रिमाइंडर बनाना सबसे अच्छा होता है ताकि आप उन विशेष तिथियों को न भूलें और उन्हें मिस न करें।

यदि आप और आपकी टीम/दोस्त Slack का उपयोग कर रहे हैं, तो इन रिमाइंडर्स को स्लैकबॉट्स के माध्यम से स्वचालित करना एक अच्छा विचार है।

ऐसा करते समय, यदि आप चाहते हैं कि आपका स्लैकबॉट कम रखरखाव वाला हो, जिसमें यह स्रोत के साथ समवर्ती इंटरैक्शन के लिए सर्वरलेस तकनीकों का उपयोग करे, साथ ही क्षैतिज स्केलेबिलिटी को सक्षम करे।

हम क्या बना रहे हैं

हम Python, AWS Chalice, AWS Lambda और होस्टिंग के लिए API Gateway का उपयोग करके एक इवेंट रिमाइंडर स्लैकबॉट बना रहे हैं। यह यूज़र्स को सक्षम करेगा:

यूज़र्स के लिए बर्थडे सेट करें।
यूज़र्स के लिए वर्षगांठ सेट करें।
यूज़र्स या सामान्य चैनल के लिए कस्टम इवेंट सेट करें

एक बार इवेंट सेट हो जाने पर:

लोगों को याद दिलाता है कि एक विशिष्ट इवेंट आने वाला है, उस व्यक्ति को छोड़कर जो इवेंट का केंद्र है (इवेंट सेट करते समय उल्लिखित व्यक्ति)।
इवेंट की वर्षगांठ आने पर सामान्य चैनल पर पोस्ट करता है, इवेंट के केंद्र व्यक्ति का उल्लेख करता है (या चैनल में सभी को)।

कमांड्स

सेट

/event set birthday <YYYY-MM-DD> <user>

यूज़र का बर्थडे सेट करता है।
/event set anniversary <YYYY-MM-DD> <user>

यूज़र के लिए वर्षगांठ सेट करता है, जब उन्होंने वहां काम करना शुरू किया।
/event set custom <YYYY-MM-DD> <user> <व्हाइटस्पेस के साथ किसी भी प्रकार का संदेश>

प्रदान किए गए संदेश का उपयोग करके कस्टम रिमाइंडर सेट करता है।

सभी प्राप्त करें

/event get-all :

सभी सेट इवेंट दिखाता है।
/event get-all birthday :

सभी सेट बर्थडे दिखाता है।
/event get-all anniversary :

सभी सेट वर्षगांठ दिखाता है।
/event get-all custom :

सभी सेट कस्टम इवेंट दिखाता है।

प्राप्त करें

/event get birthday <user> :

यूज़र के बर्थडे विवरण दिखाता है।
/event get anniversary <user> :

यूज़र के लिए वर्षगांठ विवरण दिखाता है, जब उन्होंने वहां काम करना शुरू किया।
/event get custom <event_name>(get-all के साथ पाया जा सकता है) :

प्रदान किए गए संदेश का उपयोग करके कस्टम इवेंट विवरण दिखाता है।

हटाएं

/event remove birthday <user> :

यूज़र का बर्थडे हटाता है।
/event remove anniversary <user> :

यूज़र के लिए वर्षगांठ हटाता है, जब उन्होंने वहां काम करना शुरू किया।
/event remove custom <event_name>(get-all के साथ पाया जा सकता है) :

प्रदान किए गए संदेश का उपयोग करके कस्टम इवेंट हटाता है।

शेड्यूल्ड रिमाइंडर

सामान्य चैनल को याद दिलाएं

जब समय आता है, तो स्लैकबॉट निर्दिष्ट चैनल पर रिमाइंडर संदेश भेजेगा।
बॉट से निजी संदेश

जब समय नजदीक आता है, तो स्लैकबॉट निजी रिमाइंडर संदेश भेजेगा।

तो, इस टूल का उपयोग टीम के सदस्यों की विशेष तिथियों को ट्रैक करने के लिए किया जा सकता है। इस तरह, संबंधों और अंतर्संचार को स्वस्थ तरीके से बनाए रखा जा सकता है।

शुरुआत करना

डेटाबेस तैयार करें

हम Upstash कंसोल पर अपना Redis डेटाबेस बना सकते हैं। UPSTASH_REDIS_REST_URL और UPSTASH_REDIS_REST_TOKEN को नोट करें क्योंकि वे AWS के लिए एनवायरनमेंट वेरिएबल्स होंगे।

AWS क्रेडेंशियल्स कॉन्फ़िगर करना

(आधिकारिक Chalice रिपो से लिया गया। अधिक जानकारी के लिए वहां देखें।)

$ mkdir ~/.aws $ cat >> ~/.aws/config [default] aws_access_key_id=YOUR_ACCESS_KEY_HERE aws_secret_access_key=YOUR_SECRET_ACCESS_KEY region=YOUR_REGION (such as us-west-2, us-west-1, etc)

कुछ कन्वेंशन

सभी .py फ़ाइलें जो app.py के बाहर हैं, उन्हें chalicelib डायरेक्टरी के अंतर्गत रखा जाना चाहिए, अन्यथा इम्पोर्ट स्टेटमेंट्स समस्या पैदा कर सकते हैं।
सभी एनवायरनमेंट वेरिएबल्स को .chalice डायरेक्टरी के अंदर config.json फ़ाइल में कॉन्फ़िगर किया जाना चाहिए।

प्रोजेक्ट सोर्स डेवलपमेंट

सबसे पहले, चूंकि हम AWS Chalice का उपयोग कर रहे हैं, Chalice इंस्टॉल करने के लिए:

pip install chalice

Chalice प्रोजेक्ट शुरू करें

chalice new-project <project_name> AWS Chalice और Upstash Redis का उपयोग करके Slack के लिए लो-मेंटेनेंस बर्थडे रिमाइंडर बॉट बनाएं फिर, प्रोजेक्ट फोल्डर में जाएं। प्रोजेक्ट पहले से ही एक टेम्पलेट के साथ आता है।

चलाएं: chalice local यह देखने के लिए कि प्रोजेक्ट काम करता है।

app.py

समग्र प्रोजेक्ट संरचना और Slack रिक्वेस्ट को संभालने के लिए मुख्य फ़ाइल।

इसके साथ, हम अपनी प्रोजेक्ट संरचना और एंडपॉइंट्स बनाते हैं। हम तय करते हैं कि इवेंट को कैसे संभालना है, रिमाइंडर के लिए क्या शेड्यूल करना है।

from chalice import Chalice, Cron, Rate import os import random from datetime import date from chalicelib.utils import responseToDict, postToChannel, diffWithTodayFromString, allSlackUsers, sendDm, validateRequest, convertToCorrectMention from chalicelib.upstash import setHandler, getAllHandler, getEvent, getAllKeys, removeEvent app = Chalice(app_name='birthday-slackbot') NOTIFY_TIME_LIMIT = int(os.getenv("NOTIFY_TIME_LIMIT")) # GET रिक्वेस्ट के लिए सैंपल रूट। @app.route('/', methods=["GET"]) def something(): return { "Hello": "World" } # POST रिक्वेस्ट एंडपॉइंट कॉन्फ़िगर करना। # कमांड को पार्स किया जाता है और हैंडल/निर्देशित किया जाता है @app.route('/', methods=["POST"], content_types=["application/x-www-form-urlencoded"]) def index(): # उपयोग में आसानी के लिए बॉडी पार्स करें r = responseToDict(app.current_request.raw_body) headers = app.current_request.headers # रिक्वेस्ट की वैधता जांचें। if not validateRequest(headers, r): return {"Status": "Validation failed."} commandArray = r['text'].split() command = commandArray.pop(0) try: if command == "set": setHandler(commandArray) return { 'response_type': "ephemeral", 'text': "Set the event." } elif command == "get": eventType = commandArray[0] eventName = eventType + "-" + commandArray[1] resultDict = getEvent(eventName) return { 'response_type': "ephemeral", 'text': "`{}` Details:\n\n Date: {}\nRemaining: {} days!".format(eventName, resultDict[0], resultDict[1]) } elif command == "get-all": stringResult = getAllHandler(commandArray) return { 'response_type': "ephemeral", 'text': "{}".format(stringResult) } elif command == "remove": eventName = "{}-{}".format(commandArray[0], commandArray[1]) removeEvent(eventName) return { 'response_type': "ephemeral", 'text': "Removed the event." } else: return { 'response_type': "ephemeral", 'text': "Wrong usage of the command." } except: print("some stuff") return { 'response_type': "ephemeral", 'text': "Some problem occured. Please check your command." } # हर दिन 10:00 am (UTC) पर चलाएं। @app.schedule(Cron(0, 10, '*', '*', '?', '*')) def periodicCheck(event): allKeys = getAllKeys() for key in allKeys: handleEvent(key) # जेनेरिक इवेंट को पार्स किया जाता है और संबंधित हैंडलर्स को निर्देशित किया जाता है। def handleEvent(eventName): eventSplitted = eventName.split('-') eventType = eventSplitted[0] # पहले कैरेक्टर के रूप में @ या ! को डिस्कार्ड करें personName = eventSplitted[1][1:] personMention = convertToCorrectMention(personName) eventDict = getEvent(eventName) remainingDays = eventDict[1] totalTime = eventDict[2] if eventType == "birthday": birthdayHandler(personMention, personName, remainingDays) elif eventType == "anniversary": anniversaryHandler(personMention, personName, remainingDays, totalTime) elif eventType == "custom": eventMessage = "Not specified" if len(eventSplitted) == 3: eventMessage = eventSplitted[2] customHandler(eventMessage, personMention, personName, remainingDays) # बर्थडे इवेंट्स को संभालता है। def birthdayHandler(personMention, personName, remainingDays): if remainingDays == 0: sendRandomBirthdayToChannel('general', personMention) if remainingDays <= NOTIFY_TIME_LIMIT: dmEveryoneExcept("{} day(s) until {}'s birthday!".format(remainingDays, personMention), personName) # वर्षगांठ इवेंट्स को संभालता है। def anniversaryHandler(personMention, personName, remainingDays, totalTime): if remainingDays == 0: sendRandomAnniversaryToChannel('general', personMention, totalTime) if remainingDays <= NOTIFY_TIME_LIMIT: dmEveryoneExcept("{} day(s) until {}'s anniversary! It will be {} year(s) since they joined!".format(remainingDays, personMention, totalTime), personName) # कस्टम इवेंट्स को संभालता है। def customHandler(eventMessage, personMention, personName, remainingDays): if remainingDays == 0: postToChannel('general', "`{}` is here {}!".format(eventMessage, personMention)) elif remainingDays <= NOTIFY_TIME_LIMIT: dmEveryoneExcept("{} day(s) until {} `{}`!".format(remainingDays, personMention, eventMessage), personName) # दिए गए व्यक्ति को छोड़कर सभी को निजी संदेश भेजता है। def dmEveryoneExcept(message, person): usersAndIds = allSlackUsers() for user in usersAndIds: if user[0] != person: sendDm(user[1], message) # निर्दिष्ट चैनल पर यादृच्छिक रूप से चुना गया बर्थडे संदेश भेजता है। def sendRandomBirthdayToChannel(channel, personMention): messageList = [ "Happy Birthday {}! Wishing you the best!".format(personMention), "Happy Birthday {}! Wishing you a happy age!".format(personMention), "Happy Birthday {}! Wishing you a healthy, happy life!".format(personMention), ] message = random.choice(messageList) return postToChannel('general', message) # निर्दिष्ट चैनल पर यादृच्छिक रूप से चुना गया वर्षगांठ संदेश भेजता है। def sendRandomAnniversaryToChannel(channel, personMention, totalTime): messageList = [ "Today is the anniversary of {} joining! It has been {} years since they joined!".format(personMention, totalTime - 1), "Celebrating the anniversary of {} joining! It has been {} years!".format(personMention, totalTime - 1), "Congratulating {} for entering {}(th) year here!".format(personMention, totalTime), ] message = random.choice(messageList) return postToChannel('general', message) # जब प्रोजेक्ट डेप्लॉय/रीडिप्लॉय होता है तो हम अपने इवेंट हैंडलर्स चलाना चाहते हैं। allKeys = getAllKeys() for key in allKeys: handleEvent(key)

chalicelib/utils.py

हेल्पर फ़ंक्शन और एब्स्ट्रैक्शन के लिए मुख्य फ़ाइल।

हम मुख्य रूप से इस फ़ाइल का उपयोग एब्स्ट्रैक्शन के लिए करेंगे। ताकि हमारा सोर्स कोड अव्यवस्थित न हो और पठनीयता बनी रहे।

from urllib import request import urllib from urllib.parse import parse_qsl import json import os import hmac import hashlib from datetime import date SLACK_BOT_TOKEN = os.getenv("SLACK_BOT_TOKEN") SLACK_SIGNING_SECRET = os.getenv("SLACK_SIGNING_SECRET") # Slack यूज़र का वास्तविक नाम लौटाता है। def getRealName(slackUsers, username): for user in slackUsers: if user[0] == username: return user[2] return "Nameless" # वर्कस्पेस में सभी Slack यूज़र्स को लौटाता है। def allSlackUsers(): resultDict = sendPostRequest("https://slack.com/api/users.list", SLACK_BOT_TOKEN) members = resultDict['members'] userMembers = [] for member in members: if not member['deleted'] and not member['is_bot']: userMembers.append([member['name'], member['id'], member['real_name']]) return userMembers # दिए गए चैनल की आईडी लौटाता है। def channelNameToId(channelName) : resultDict = sendPostRequest("https://slack.com/api/conversations.list", SLACK_BOT_TOKEN) for channel in resultDict['channels']: if (channel['name'] == channelName): return channel['id'] return None # दिए गए चैनलआईडी पर दिए गए संदेश के साथ पोस्ट करता है। def postToSlack(channelId, messageText): data = { "channel": channelId, "text": messageText } data = json.dumps(data) data = str(data) data = data.encode('utf-8') resultDict = sendPostRequest("https://slack.com/api/chat.postMessage", SLACK_BOT_TOKEN, data) return resultDict # Slack चैनल पर पोस्ट करता है। def postToChannel(channel, messageText): channelId = channelNameToId(channel) return postToSlack(channelId, messageText) # userId वाले यूज़र को निजी संदेश भेजता है। def sendDm(userId, messageText): return postToSlack(userId, messageText) # जेनेरिक POST रिक्वेस्ट भेजता है और परिणाम लौटाता है। def sendPostRequest(requestURL, bearerToken, data={}): req = request.Request(requestURL, method="POST", data=data) req.add_header("Authorization", "Bearer {}".format(bearerToken)) req.add_header("Content-Type", "application/json; charset=utf-8") r = request.urlopen(req) resultDict = json.loads(r.read().decode()) return resultDict # रिस्पॉन्स को पार्स और डिक्ट में कन्वर्ट करता है। def responseToDict(res): return dict(parse_qsl(res.decode())) # तिथियां इस रूप में दी जाती हैं: YYYY-MM-DD # वर्तमान दिन और वर्षगांठ के बीच अंतर लौटाता है। def diffWithTodayFromString(dateString): now = date.today() currentYear = now.year dateTokens = dateString.split("-") month = int(dateTokens[1]) day = int(dateTokens[2]) if now > date(currentYear, month, day): return (date((currentYear + 1), month, day) - now).days return (date(currentYear, month, day) - now).days # तिथियां इस रूप में दी जाती हैं: YYYY-MM-DD # वर्तमान तिथि तक बीते कुल समय की गणना करता है। def totalTimefromString(dateString): now = date.today() dateTokens = dateString.split("-") year = int(dateTokens[0]) month = int(dateTokens[1]) day = int(dateTokens[2]) then = date(year, month, day) years = now.year - then.year return years + 1 # एंडपॉइंट पर आने वाली रिक्वेस्ट को मान्य करता है। # टाइमस्टैम्प और साइनिंग सीक्रेट के साथ रिक्वेस्ट बॉडी को हैश करता है। # फिर, उस हैश की तुलना Slack सिग्नेचर से करता है। def validateRequest(header, body): bodyAsString = urllib.parse.urlencode(body) timestamp = header['x-slack-request-timestamp'] slackSignature = header['x-slack-signature'] baseString = "v0:{}:{}".format(timestamp, bodyAsString) h = hmac.new(SLACK_SIGNING_SECRET.encode(), baseString.encode(), hashlib.sha256) hashResult = h.hexdigest() mySignature = "v0=" + hashResult return mySignature == slackSignature # दिए गए नाम को मेंशन स्ट्रिंग में कन्वर्ट करता है। def convertToCorrectMention(name): if name == "channel" or name == "here" or name == "everyone": return "".format(name) else: return "<@{}>".format(name)

chalicelib/upstash.py

डेटाबेस से सीधे संबंधित फ़ंक्शन के लिए मुख्य फ़ाइल।

यहां, हम अपने डेटाबेस कॉल को संभालेंगे। हम डेटाबेस से फ़ेच करेंगे, की-वैल्यू पेयर सेट करेंगे आदि। यह फ़ाइल app.py से निम्न-स्तरीय विवरणों को एब्स्ट्रैक्ट करने में भी मदद करती है, जिससे पठनीयता और मॉड्यूलैरिटी बढ़ती है।

Upstash Redis डेटाबेस के बारे में एक बड़ी बात यह है कि यह RESTFUL API कॉल्स को सपोर्ट करता है। इस तरह, आप अपने डेटाबेस को लगातार कनेक्शन बनाने और बंद करने की आवश्यकता के बिना एक्सेस कर सकते हैं, जो सर्वरलेस एप्लिकेशन के लिए जाने का तरीका है।

from chalicelib.utils import sendPostRequest, getRealName, allSlackUsers, diffWithTodayFromString, totalTimefromString import os UPSTASH_REST_URL = os.getenv("UPSTASH_REST_URL") UPSTASH_TOKEN = os.getenv("UPSTASH_TOKEN") # दिए गए पैरामीटर्स के साथ Upstash Rest Url पर पोस्ट करता है। def postToUpstash(parameters): requestURL = UPSTASH_REST_URL for parameter in parameters: requestURL += ("/" + parameter) resultDict = sendPostRequest(requestURL, UPSTASH_TOKEN) return resultDict['result'] # दिए गए पैरामीटर्स के साथ इवेंट के लिए की-वैल्यू पेयर सेट करता है। def setEvent(parameterArray): postQueryParameters = ['SET'] for parameter in parameterArray: parameter = parameter.split() for subparameter in parameter: postQueryParameters.append(subparameter) resultDict = postToUpstash(postQueryParameters) return resultDict # दिए गए इवेंट से इवेंट विवरण लौटाता है। def getEvent(eventName): postQueryParameters = ['GET', eventName] date = postToUpstash(postQueryParameters) timeDiff = diffWithTodayFromString(date) totalTime = totalTimefromString(date) mergedDict = [date, timeDiff, totalTime] return mergedDict # डेटाबेस से सभी कीज़ (इवेंट्स) फ़ेच करता है def getAllKeys(): return postToUpstash(['KEYS', '*']) # दिए गए इवेंट को डेटाबेस से हटाता है। def removeEvent(eventName): postQueryParameters = ['DEL', eventName] resultDict = postToUpstash(postQueryParameters) return resultDict # सेट रिक्वेस्ट को पार्स करके और सेटइवेंट फ़ंक्शन पैरामीटर्स को कॉन्फ़िगर करके संभालता है। def setHandler(commandArray): eventType = commandArray.pop(0) date = commandArray.pop(0) user = commandArray.pop(0) if eventType == "birthday": listName = "birthday-" + user return setEvent( [listName, date] ) elif eventType == "anniversary": listName = "anniversary-" + user return setEvent( [listName, date] ) elif eventType == "custom": message = "" for string in commandArray: message += string + "_" listName = "custom-" + user + "-" + message user = commandArray[1] return setEvent( [listName, date] ) else: return # गेट-ऑल रिक्वेस्ट को संभालता है। def getAllHandler(commandArray): filterParameter = None if len(commandArray) == 1: filterParameter = commandArray[0] allKeys = getAllKeys() birthdays = [] anniversaries = [] customs = [] slackUsers = allSlackUsers() stringResult = "\n" for key in allKeys: if key[0] == 'b': birthdays.append(key) elif key[0] == 'a': anniversaries.append(key) elif key[0] == 'c': customs.append(key) if filterParameter is None or filterParameter == "birthday": stringResult += "Birthdays:\n" for bday in birthdays: tag = bday.split('-')[1] username = tag[1:] realName = getRealName(slackUsers, username) details = getEvent(bday) stringResult += "`{}` ({}): {} - `{} days` remaining!\n".format(tag, realName, details[0], details[1]) if filterParameter is None or filterParameter == "anniversary": stringResult += "\nAnniversaries:\n" for ann in anniversaries: tag = ann.split('-')[1] username = tag[1:] realName = getRealName(slackUsers, username) details = getEvent(ann) stringResult += "`{}` ({}): {} - `{} days` remaining!\n".format(tag, realName, details[0], details[1]) if filterParameter is None or filterParameter == "custom": stringResult += "\nCustom Reminders:\n" for cstm in customs: splitted = cstm.split('-') username = splitted[2] realName = getRealName(slackUsers, username) details = getEvent(cstm) stringResult += "`{}-{}` ({}): {}\n".format(splitted[1], splitted[2], getRealName(slackUsers, username), details[0]) return stringResult

.chalice/config.json

AWS पर प्रोजेक्ट के कॉन्फ़िगरेशन के लिए फ़ाइल।

यहां, हम अपने प्रोजेक्ट विवरण जैसे एनवायरनमेंट वेरिएबल्स और डेप्लॉयमेंट स्टेज को परिभाषित करते हैं। इसके लिए, हम केवल एनवायरनमेंट वेरिएबल्स को जोड़कर कॉन्फ़िगर करेंगे:

{ "environment_variables": { "UPSTASH_REST_URL": , "UPSTASH_TOKEN": , "SLACK_BOT_TOKEN": , "SLACK_SIGNING_SECRET": , "NOTIFY_TIME_LIMIT": "" } }

सब हो जाने के बाद

फोल्डर संरचना

आपकी फोल्डर संरचना कुछ इस तरह दिखनी चाहिए:

: app.py chalicelib: utils.py upstash.py  .chalice: config.json

स्थानीय रूप से चल रहा है

Chalice स्थानीय डेप्लॉयमेंट को सक्षम बनाता है, जो विकास प्रक्रिया को वास्तव में त्वरित बनाता है।

चलाएं: chalice local AWS Chalice और Upstash Redis का उपयोग करके Slack के लिए लो-मेंटेनेंस बर्थडे रिमाइंडर बॉट बनाएं

यदि आपके पास स्टेटिक आईपी एड्रेस नहीं है, तो आपको ngrok जैसी टनलिंग सेवा का उपयोग करना चाहिए ताकि आप अपने एंडपॉइंट को Slack को दिखा सकें:

./ngrok http 8000 --> आपके localhost:8000 को टनल करता है

Slack कॉन्फ़िगर करें

1. Slack API Apps पेज पर जाएं:

नया ऐप बनाएं
- स्क्रैच से
- अपने ऐप का नाम दें और वर्कस्पेस चुनें
Oauth & Permissions पर जाएं
- निम्नलिखित स्कोप जोड़ें
  - channels:read
  - chat:write
  - chat:write.public
  - commands
  - groups:read
  - users:read
- ऐप को वर्कस्पेस में इंस्टॉल करें
  - Basic Information --> Install Your App --> Install To Workspace

वेरिएबल्स नोट करें (ये AWS डेप्लॉयमेंट के लिए एनवायरनमेंट वेरिएबल्स होंगे) :
- SLACK_SIGNING_SECRET:
  - Basic Information पर जाएं
    - App Credentials --> Signing Secret
- SLACK_BOT_TOKEN:
  - OAuth & Permissions पर जाएं
    - Bot User OAuth Token

3. Slack API Apps पेज पर जाएं और संबंधित ऐप चुनें:

डेप्लॉयमेंट के बाद, आप REST_API_URL या ngrok_domain का उपयोग <domain> के रूप में कर सकते हैं।

Slack API Apps पेज पर जाएं और संबंधित ऐप चुनें:

Slash Commands पर जाएं:
- नया कमांड बनाएं:
  - कमांड : event
  - रिक्वेस्ट URL : <domain>
  - बाकी को अपनी पसंद के अनुसार कॉन्फ़िगर करें।

इन परिवर्तनों के बाद, Slack को ऐप को पुनः इंस्टॉल करने की आवश्यकता हो सकती है।

बधाई हो!

अब आपके पास एक कार्यशील सर्वरलेस स्लैकबॉट है! इसे अपनी इच्छानुसार कस्टमाइज़ करने के लिए स्वतंत्र महसूस करें।

जब आप स्थानीय होस्टिंग और परिणामों से संतुष्ट हों, तो बस:

chalice deploy AWS Lambda और API Gateway पर अंतिम डेप्लॉयमेंट के लिए।

अब आप AWS Chalice द्वारा प्रदान किए गए REST_API_URL का उपयोग अपने Slack कॉन्फ़िगरेशन पर कर सकते हैं।