AWS Chalice এবং Upstash Redis সহ সার্ভারহীন জন্মদিন স্ল্যাকবট

কখনও কখনও আপনার বার্ষিক ইভেন্টগুলির জন্য অনুস্মারক তৈরি করা সর্বোত্তম হয় যাতে আপনি সেই বিশেষ তারিখগুলি ভুলে না যান এবং মিস না করেন৷

আপনি এবং আপনার দল/বন্ধুরা যদি স্ল্যাক ব্যবহার করে থাকেন, তাহলে এটি একটি ভাল ধারণা যে আপনি স্ল্যাকবটগুলির মাধ্যমে এই অনুস্মারকগুলি স্বয়ংক্রিয়ভাবে ব্যবহার করেন৷

এটি করার সময়, আপনি যদি চান যে আপনার স্ল্যাকবটটি একটি কম রক্ষণাবেক্ষণ করা হোক; উত্সের সাথে একযোগে মিথস্ক্রিয়া করার জন্য সার্ভারহীন প্রযুক্তি ব্যবহার করা সর্বোত্তম হতে পারে, অনুভূমিক মাপযোগ্যতাও সক্ষম করে৷

আমরা কী তৈরি করছি

আমরা একটি ইভেন্ট রিমাইন্ডার স্ল্যাকবট তৈরি করছি হোস্টিং এর জন্য পাইথন, AWS Chalice, AWS Lambda এবং API গেটওয়ে ব্যবহার করে। এটি ব্যবহারকারীদের সক্ষম করবে:

ব্যবহারকারীদের জন্য জন্মদিন সেট করুন।
ব্যবহারকারীদের জন্য বার্ষিকী সেট করুন।
ব্যবহারকারী বা সাধারণ চ্যানেলের জন্য কাস্টম ইভেন্ট সেট করুন

ইভেন্ট সেট হয়ে গেলে:

লোকদের মনে করিয়ে দেয় যে একটি নির্দিষ্ট ইভেন্ট আসছে, ইভেন্টের কেন্দ্রে থাকা ব্যক্তি ব্যতীত (ইভেন্ট সেট করার সময় উল্লেখ করা হয়েছে)।
ইভেন্টের বার্ষিকী আসার পরে সাধারণ চ্যানেলে পোস্ট করা, ইভেন্টের কেন্দ্রে থাকা ব্যক্তিকে (বা চ্যানেলের প্রত্যেকে) উল্লেখ করে।

কমান্ড

সেট

৷

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

ব্যবহারকারীর জন্মদিন সেট করে।
/event set anniversary <YYYY-MM-DD> <user>

ব্যবহারকারীর জন্য বার্ষিকী সেট করে, যখন তারা সেখানে কাজ শুরু করে।
/event set custom <YYYY-MM-DD> <user> <any kind of message with whitespaces>

প্রদত্ত বার্তা ব্যবহার করে একটি কাস্টম অনুস্মারক সেট করে৷

গেট-অল

৷

/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>(can be found with get-all) :

প্রদত্ত বার্তা ব্যবহার করে কাস্টম ইভেন্টের বিবরণ দেখায়৷
৷

সরান

৷

/event remove birthday <user> :

ব্যবহারকারীর জন্মদিন সরিয়ে দেয়।
/event remove anniversary <user> :

ব্যবহারকারীর জন্য বার্ষিকী সরিয়ে দেয়, যখন তারা সেখানে কাজ শুরু করে।
/event remove custom <event_name>(can be found with get-all) :

প্রদত্ত বার্তা ব্যবহার করে কাস্টম ইভেন্ট সরিয়ে দেয়৷

নির্ধারিত অনুস্মারক

৷

সাধারণ চ্যানেল মনে করিয়ে দিন

যখন সময় আসবে, স্ল্যাকবট নির্দিষ্ট চ্যানেলে অনুস্মারক বার্তা পাঠাবে।
বট থেকে ব্যক্তিগত বার্তা

সময় ঘনিয়ে এলে, স্ল্যাকবট ব্যক্তিগত অনুস্মারক বার্তা পাঠাবে।

সুতরাং, এই টুলটি দলের সদস্যদের জন্য বিশেষ তারিখ ট্র্যাক রাখতে ব্যবহার করা যেতে পারে। এইভাবে, সম্পর্ক এবং আন্তঃযোগাযোগ সুস্থভাবে বজায় রাখা যায়।

শুরু করা

ডেটাবেস প্রস্তুত করুন

আমরা Upstash কনসোলে আমাদের Redis ডাটাবেস তৈরি করতে পারি। UPSTASH_REDIS_REST_URL এবং UPSTASH_REDIS_REST_TOKEN নোট করুন যেহেতু তারা AWS এর জন্য পরিবেশ পরিবর্তনশীল হবে।

AWS শংসাপত্র কনফিগার করা

(অফিসিয়াল চ্যালিস রেপো থেকে নেওয়া। আপনি সেখানে আরও তথ্যের জন্য উল্লেখ করতে পারেন।)

$ 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 এর অধীনে স্থাপন করা উচিত ডিরেক্টরি, অন্যথায় আমদানি বিবৃতি সমস্যা সৃষ্টি করতে পারে।
সমস্ত পরিবেশ ভেরিয়েবল config.json-এ কনফিগার করা উচিত .chalice-এর ভিতরে ফাইল ডিরেক্টরি।
- একটি json ফরম্যাটে, কী সহ:"environment_variables"

প্রকল্প উৎস উন্নয়ন

প্রথমত, যেহেতু আমরা AWS Chalice ব্যবহার করছি , চেলিস ইনস্টল করতে:

pip install chalice

চ্যালিস প্রকল্প শুরু করুন

chalice new-project <project_name> AWS Chalice এবং Upstash Redis সহ সার্ভারহীন জন্মদিন স্ল্যাকবট তারপর, প্রজেক্ট ফোল্ডারে সিডি করুন। প্রকল্পটি ইতিমধ্যেই একটি টেমপ্লেট নিয়ে এসেছে৷

৷

চালান:chalice local প্রজেক্ট কাজ করছে তা দেখতে।

app.py

সামগ্রিক প্রকল্প কাঠামোর জন্য এবং স্ল্যাক অনুরোধগুলি পরিচালনা করার জন্য প্রধান ফাইল৷

এটি দিয়ে, আমরা আমাদের প্রকল্প কাঠামো এবং শেষ পয়েন্ট তৈরি করি। আমরা কীভাবে ইভেন্টগুলি পরিচালনা করব, অনুস্মারক কাজ করার জন্য কী সময়সূচী করব তা নির্ধারণ করি৷

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"))


# Sample route for get requests.
@app.route('/', methods=["GET"])
def something():
    return {
        "Hello": "World"
        }

# Configuring POST request endpoint.
# Command is parsed and handled/directed to handler
@app.route('/', methods=["POST"], content_types=["application/x-www-form-urlencoded"])
def index():

    # Parse the body for ease of use
    r = responseToDict(app.current_request.raw_body)
    headers = app.current_request.headers

    # Check validity of the request.
    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."
        }


# Run at 10:00 am (UTC) every day.
@app.schedule(Cron(0, 10, '*', '*', '?', '*'))
def periodicCheck(event):
    allKeys = getAllKeys()
    for key in allKeys:
        handleEvent(key)


# Generic event is parsed and directed to relevant handlers.
def handleEvent(eventName):
    eventSplitted = eventName.split('-')

    eventType = eventSplitted[0]

    # discard @ or ! as a first character
    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)

# Handles birthday events.
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)

# Handles anniversary events.
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)

# Handles custom events.
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)


# Sends private message to everyone except for the person given.
def dmEveryoneExcept(message, person):
    usersAndIds = allSlackUsers()
    for user in usersAndIds:
        if user[0] != person:
            sendDm(user[1], message)


# Sends randomly chosen birthday message to specified channel.
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)

# Sends randomly chosen anniversary message to specified channel.
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)


# We want to run our event handlers when the project is deployed/redeployed.
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")

# Returns real name of the slack user.
def getRealName(slackUsers, username):
    for user in slackUsers:
        if user[0] == username:
            return user[2]
    return "Nameless"

# Returns all slack users in the workspace.
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

# Returns the id of the given channel.
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

# Posts to given slack channelId with given message.
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

# Posts to a slack channel.
def postToChannel(channel, messageText):
    channelId = channelNameToId(channel)
    return postToSlack(channelId, messageText)

# Sends a private message to a user with userId.
def sendDm(userId, messageText):
    return postToSlack(userId, messageText)

# Sends generic post request and returns the result.
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

# Parses and converts the res to dict.
def responseToDict(res):
    return dict(parse_qsl(res.decode()))


# Dates are given as: YYYY-MM-DD
# Returns difference between current day and the anniversary.
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


# Dates are given as: YYYY-MM-DD
# Calculates the total time that has passed until current date.
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

# Validate requests coming to endpoint.
# Hashes request body with timestamp and signing secret.
# Then, compares that hash with slack signature.
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

# Converts given name to mention string.
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")

# Posts to Upstash Rest Url with parameters given.
def postToUpstash(parameters):
    requestURL = UPSTASH_REST_URL
    for parameter in parameters:
        requestURL += ("/" + parameter)

    resultDict = sendPostRequest(requestURL, UPSTASH_TOKEN)
    return resultDict['result']


# Sets key-value pair for the event with given parameters.
def setEvent(parameterArray):

    postQueryParameters = ['SET']

    for parameter in parameterArray:
        parameter = parameter.split()
        for subparameter in parameter:
            postQueryParameters.append(subparameter)

    resultDict = postToUpstash(postQueryParameters)

    return resultDict


# Returns event details from the event given.
def getEvent(eventName):
    postQueryParameters = ['GET', eventName]
    date = postToUpstash(postQueryParameters)

    timeDiff = diffWithTodayFromString(date)
    totalTime = totalTimefromString(date)
    mergedDict = [date, timeDiff, totalTime]
    return mergedDict

# Fetches all keys (events) from the database
def getAllKeys():
    return postToUpstash(['KEYS', '*'])

# Deletes given event from the database.
def removeEvent(eventName):
    postQueryParameters = ['DEL', eventName]
    resultDict = postToUpstash(postQueryParameters)
    return resultDict


# Handles set request by parsing and configuring setEvent function parameters.
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

# Handles get-all requests.
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_REDIS_REST_URL>,
    "UPSTASH_TOKEN": <UPSTASH_REDIS_REST_TOKEN>,
    "SLACK_BOT_TOKEN": <SLACK_BOT_TOKEN>,
    "SLACK_SIGNING_SECRET": <SLACK_SIGNING_SECRET>,
    "NOTIFY_TIME_LIMIT": "<amount of days before getting notifications for events>"
    }
}

সব হয়ে গেলে

ফোল্ডার গঠন

আপনার ফোল্ডারের গঠনটি এইরকম হওয়া উচিত:

<project_name>:
    app.py

    chalicelib:
        utils.py
        upstash.py
        <Some other default files generated by chalice>

    .chalice:
        config.json
        <Some other default files generated by chalice>

স্থানীয়ভাবে চলছে

Chalice স্থানীয় স্থাপনার জন্য সক্ষম করে, যা উন্নয়ন প্রক্রিয়াকে সত্যিই দ্রুত করে তোলে।

চালান:chalice local AWS Chalice এবং Upstash Redis সহ সার্ভারহীন জন্মদিন স্ল্যাকবট

আপনার যদি একটি স্ট্যাটিক আইপি ঠিকানা না থাকে, তাহলে আপনাকে একটি টানেলিং পরিষেবা ব্যবহার করা উচিত যেমন ngrok যাতে আপনি স্ল্যাক:

-এ আপনার এন্ডপয়েন্ট দেখাতে পারেন

./ngrok http 8000 --> আপনার স্থানীয় হোস্ট টানেল:8000

Slack কনফিগার করুন

1. স্ল্যাক এপিআই অ্যাপস পৃষ্ঠাতে যান:

নতুন অ্যাপ তৈরি করুন
- স্ক্র্যাচ থেকে
- আপনার অ্যাপের নাম দিন এবং একটি ওয়ার্কস্পেস বেছে নিন
Oauth &Permissions এ যান
- নিম্নলিখিত স্কোপ যোগ করুন
  - চ্যানেল:পড়ুন
  - চ্যাট:লিখুন
  - chat:write.public
  - কমান্ড
  - গোষ্ঠী:পড়ুন
  - users:read
- ওয়ার্কস্পেসে অ্যাপ ইনস্টল করুন
  - মৌলিক তথ্য --> আপনার অ্যাপ ইনস্টল করুন --> ওয়ার্কস্পেসে ইনস্টল করুন

ভেরিয়েবলগুলি নোট করুন (এগুলি AWS স্থাপনার জন্য env ভেরিয়েবল হবে) :
- SLACK_SIGNING_SECRET :
  - বেসিক ইনফরমেশনে যান
    - অ্যাপ ক্রেডেনশিয়াল --> সাইনিং সিক্রেট
- SLACK_BOT_TOKEN :
  - OAuth এবং অনুমতিতে যান
    - বট ব্যবহারকারী OAuth টোকেন

3. স্ল্যাক এপিআই অ্যাপস পৃষ্ঠাতে যান এবং প্রাসঙ্গিক অ্যাপ বেছে নিন:

স্থাপনের পরে, আপনি REST_API_URL ব্যবহার করতে পারেন অথবা ngrok_domain <domain> হিসাবে .

Slack API অ্যাপস পৃষ্ঠাতে যান এবং প্রাসঙ্গিক অ্যাপ বেছে নিন:

স্ল্যাশ কমান্ডে যান:
- নতুন কমান্ড তৈরি করুন:
  - কমান্ড :event
  - অনুরোধ URL :<domain>
  - আপনি যেভাবে চান বাকিটা কনফিগার করুন।

এই পরিবর্তনের পরে, স্ল্যাকের জন্য অ্যাপটি পুনরায় ইনস্টল করার প্রয়োজন হতে পারে।

অভিনন্দন!

আপনার কাছে এখন একটি কার্যকরী সার্ভারহীন স্ল্যাকবট আছে! আপনি যা খুশি তা কাস্টমাইজ করতে দ্বিধা বোধ করুন৷

আপনি স্থানীয় হোস্টিং এবং ফলাফলের সাথে সন্তুষ্ট হওয়ার পরে, সহজভাবে:

chalice deploy AWS Lambda এবং API গেটওয়েতে চূড়ান্ত স্থাপনার জন্য।

আপনি এখন আপনার স্ল্যাক কনফিগারেশনে AWS Chalice দ্বারা প্রদত্ত REST_API_URL ব্যবহার করতে পারেন৷