In true newline-fashion, we'll get *rolling* with a practical application right away. We're creating a fully functional, dice-rolling chat bot for Slack!

Create a Serverless Slack Bot with AWS Lambda and Python

Introduction

There's no `AWS Lambda` without `AWS`. That means we'll need a few AWS resources created and configured on the AWS side of things to develop and effectively.

How to Setup a Free AWS Developer Environment

Here, we'll configure an `AWS Workspace` or `AWS EC2 Instance` as the development environment to use for developing for AWS Lambda.

How to Configure EC2 and AWS Workspaces Local Credentials

Configuring Your AWS Environment

We can comfortably develop for AWS Lambda with python on any modern Operating System

Setup a Local Python AWS Lambda Development Environment

We will be using the AWS Lambda runtime for the latest stable version of Python 3 - `python3.7`.

Installing Python 3 and Pyenv on MacOS, Windows, and Linux

The easiest way to configure our local development with our credentials is to run the command `aws configure`

How to Login to AWS CLI and Configure Default Region

Configuring Your Local Machine

How Our Slack Bot "Dicebot" Will Work

How to Create an AWS S3 Bucket for Lambda Artifacts

How to Code a Lambda Hello World Function with AWS SAM

How to Test AWS Lambda Functions Locally With Docker

The Beginner Guide to AWS Lambda Deployment

Creating Hello-world Lambda

How to Create a Slack Bot

How to Code a Python Dice Rolling Simulator Program

How to Turn Serverless Python Lambda Code Into a Slack Bot

Testing Our Serverless Slack Dicebot with Docker Locally

Cleaning Up Our Serverless Dicebot Deployment

Creating Dicebot Lambda

*Serverless Computing* may sound like a scary topic, but with the rise of AWS Lambda and mature tools supporting it - it's more approachable than ever. In this newline course, we're going to learn what serverless technology is and isn't, and why it belongs in your developer toolbox. We'll see that for certain common projects - like custom chat bot creation - AWS Lambda really shines for it's simplicity, affordability, and ability to integrate with the wider AWS ecosystem. 

Some developers love using serverless tech because it helps them save money, scale quickly, and deliver on reliability goals. While all of those things are possible with Lambda (especially cost savings which are common - but certainly not guaranteed), it's the development agility and reduction of operations overhead that drives my love for the service. It's a relief to be able to get right into the code, without worrying about configuring operating systems, deploying containers, or scaling clusters. Serverless on Lambda gives developers the resources needed to write, deploy, and _maintain_ production-ready software - all without significant operational overhead.

In true newline-fashion, we'll get *rolling* with a practical application right away. RPG players rejoice - we're creating a fully functional, dice-rolling chat bot for Slack! While the example bot will be for Slack, the same idea can be easily adapted to create a bot for Telegram, Discord, or nearly any other chat service with a bot API. 

We will be using Python 3 for this project, but it's worth noting that [AWS Lambda works with other common languages and runtimes](https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html), including NodeJS, Java, ruby, go, and .NET. The basic mechanisms of creating, testing, and deploying your Lambda do not vary significantly based on your runtime choice.

By the end of this course you'll:

* Deploy a Slack Bot that runs on AWS Lambda
* Understand how to keep your AWS account secure
* Be able to deploy custom Lambda functions
* Understand serverless architecture and how it works

In this course we'll build and deploy a Serverless Slack Bot using AWS Lambda and Python. Along the way you'll learn about proper security, how lambda works, and how to deploy your service.

Create a Serverless Slackbot with AWS Lambda and Python

How to deploy a serverless bot into production

Dicebot code explained - non-Lambda portion

To get the dice rolling, we've provided the core "dicebot" library code below. We'll talk through some of the details, but to get oriented, here's the full listing:

# dicebot.py
# !/usr/bin/env python3
"""Library for the dice-rolling chat bot used in chapter1 of
   Fullstack Serverless - Python on AWS Lambda

Logic for interpreting text as a command to roll one or more dice.
Includes functionality to format roll output for slack.

Available functions:
- parse_text: Determine if a String value is a valid dice roll command
- roll_dice: Simulate the rolling of one or more dice with an arbitrary number of sides
- format_slack_response: Turn the result of a roll_dice into a slack compatible output dict
"""
# imports
from random import randint

# globals
DEFAULT_NUM_DICE = 1  # Default to rolling 1 dice when not specified
DEFAULT_DICE_SIDES = 20  # Role-playing game enthusiasts unite!
DEFAULT_DIVIDER_STR = "d"  # string to divide num_dice and dice_sides


def parse_text(text):
    """Take a roll definition string, checks if it's valid, and then returns
        a dict to be used as kwargs for the roll_dice function.

        Args:
            text: a String value defining a roll according to SRD standard (ie "2d10")

        Returns: a dict with the output required for roll_dice function
            num_dice: integer value for how many dice will be rolled
            dice_sides: integer value for sides on each dice. represents maximum roll value.
        ex: {"num_dice":1, "dice_sides":20}
    """
    num_dice = DEFAULT_NUM_DICE
    num_sides = DEFAULT_DICE_SIDES
    divider = DEFAULT_DIVIDER_STR.lower()

    if text:
        lower_text = str(text).lower()  # ex: convert "D" to "d"
        # if a divider is present, attempt to parse the values before and after it
        if divider in lower_text:
            # returns partitiioned tuple: (num_dice,"d",num_sides)
            parted_text = lower_text.partition(divider)
            # if num_dice is defined, convert to int and use it
            if parted_text[0]:
                num_dice = int(parted_text[0])  # throws ValueError
            # if num_sides is defined, convert to int and use it
            if parted_text[2]:
                num_sides = int(parted_text[2])  # throws ValueError
        else:
            # if no divider is present, as single int is accepted as num_dice
            num_dice = int(text)  # throws ValueError

    output = {"num_dice": num_dice, "dice_sides": num_sides}
    return output


def roll_dice(num_dice=DEFAULT_NUM_DICE, dice_sides=DEFAULT_DICE_SIDES):
    """Creates a dict with random roll values

    Args:
        num_dice: integer value for how many dice will be rolled
        dice_sides: integer value for sides on each dice. represents maximum roll value.

    Returns: dict with that contains the roll definition and results
        keys and values in the output inlcude:
        dice_roll: a string defining the dice roll (ie, "1d20")
        results: a list of ints representing rolled values (ie, [20])
        ex: {"dice_roll": "1d20", "results":[20]}
    """
    dice_results = [randint(1, dice_sides) for i in range(num_dice)]
    dice_result_dict = {"dice_roll": "{}d{}".format(num_dice, dice_sides), "results": dice_results}
    return dice_result_dict


def format_slack_response(dice_result):
    """Takes the output from the roll_dice function and creates a slack-formatted dict with output

    Args:
        dice_result: a dict with the output from roll_dice.
           expects keys and values for:
               dice_roll: a string defining the dice roll (ie, "1d20")
               results: a list of ints representing rolled values (ie, [20])
            ex: {"dice_roll": "1d20", "results":[20]}

    Returns: A dict with containing a result message as expected by the slack API
        ex:
    {
    "response_type": "in_channel",
    "text": "20",
    "attachments": [{
            "text":"rolled 1d20"
        }]
    }
    """
    sum_results = sum(dice_result["results"])
    output_dict = {"response_type": "in_channel"}
    output_dict["text"] = "{} = {}".format(dice_result["results"], str(sum_results))
    output_dict["attachments"] = [{"text": "rolled {}".format(dice_result["dice_roll"])}]
    return output_dict

 file shown here works totally separately of AWS Lambda. We can even invoke it from a local, interactive python terminal to play around with it and see how it works.

 directory, we will open an interactive python interpreter, as shown below.

$ cd first_function
$ python
Python 3.7.4 (default, Oct  8 2019, 13:59:00)
[GCC 7.4.0] on linux
Type "help", "copyright", "credits" or "license" for more information.

 is to import the dicebot code into our local interpreter. Since we invoked our python interpreter from the 

We can confirm that it is working and imported from our local directory with the command 

>>> import dicebot
>>> print(dicebot)
<module 'dicebot' from '/home/ec2-user/Development/dicebot/dicebot/first_function/dicebot.py'>

 just look at the source code, but let's use this opportunity to learn about a useful feature of python: the 

 has followed python best practices for documentation, the 

 comment from the module is accessible from our interactive python shell. 

>>> print(dicebot.__doc__)
"""
Library for the dice-rolling chat bot used in chapter1 of
   Fullstack Serverless - Python on AWS Lambda

Logic for interpreting text as a command to roll one or more dice.
Includes functionality to format roll output for slack.

Available functions:
- parse_text: Determine if a String value is a valid dice roll command
- roll_dice: Simulate the rolling of one or more dice with an arbitrary number of sides
- format_slack_response: Turn the result of a roll_dice into a slack compatible output dict
"""

Cool, now we know the functions that dicebot provides are called 

We can see the documentation for those specific functions the same way. To print the docs for a specific function in a module, use 

---
title: How to Code a Python Dice Rolling Simulator Program
isPublicLesson: false
code: https://gitlab.com/fullstackio/books/newline-course-apps/stephanie-prime-create-a-serverless-slack-bot-with-aws-lambda-and-python-app/-/tree/main/code/dicebot
---

# Exploring the Dicebot Core Code

## Dicebot code explained - non-Lambda portion

To get the dice rolling, we've provided the core "dicebot" library code below. We'll talk through some of the details, but to get oriented, here's the full listing:

```python { actualFilename=./protected/dicebot/first_function/dicebot.py endChar=4107 endLine=102 startChar=0 startLine=1 statedFilename=dicebot/first_function/dicebot.py url=https&#x3A;//gitlab.com/fullstackio/books/newline-course-template/module_05/lesson_05.02/protected/dicebot/first_function/dicebot.py }
# dicebot.py
# !/usr/bin/env python3
"""Library for the dice-rolling chat bot used in chapter1 of
   Fullstack Serverless - Python on AWS Lambda

Logic for interpreting text as a command to roll one or more dice.
Includes functionality to format roll output for slack.

Available functions:
- parse_text: Determine if a String value is a valid dice roll command
- roll_dice: Simulate the rolling of one or more dice with an arbitrary number of sides
- format_slack_response: Turn the result of a roll_dice into a slack compatible output dict
"""
# imports
from random import randint

# globals
DEFAULT_NUM_DICE = 1  # Default to rolling 1 dice when not specified
DEFAULT_DICE_SIDES = 20  # Role-playing game enthusiasts unite!
DEFAULT_DIVIDER_STR = "d"  # string to divide num_dice and dice_sides


def parse_text(text):
    """Take a roll definition string, checks if it's valid, and then returns
        a dict to be used as kwargs for the roll_dice function.

        Args:
            text: a String value defining a roll according to SRD standard (ie "2d10")

        Returns: a dict with the output required for roll_dice function
            num_dice: integer value for how many dice will be rolled
            dice_sides: integer value for sides on each dice. represents maximum roll value.
        ex: {"num_dice":1, "dice_sides":20}
    """
    num_dice = DEFAULT_NUM_DICE
    num_sides = DEFAULT_DICE_SIDES
    divider = DEFAULT_DIVIDER_STR.lower()

    if text:
        lower_text = str(text).lower()  # ex: convert "D" to "d"
        # if a divider is present, attempt to parse the values before and after it
        if divider in lower_text:
            # returns partitiioned tuple: (num_dice,"d",num_sides)
            parted_text = lower_text.partition(divider)
            # if num_dice is defined, convert to int and use it
            if parted_text[0]:
                num_dice = int(parted_text[0])  # throws ValueError
            # if num_sides is defined, convert to int and use it
            if parted_text[2]:
                num_sides = int(parted_text[2])  # throws ValueError
        else:
            # if no divider is present, as single int is accepted as num_dice
            num_dice = int(text)  # throws ValueError

    output = {"num_dice": num_dice, "dice_sides": num_sides}
    return output


def roll_dice(num_dice=DEFAULT_NUM_DICE, dice_sides=DEFAULT_DICE_SIDES):
    """Creates a dict with random roll values

    Args:
        num_dice: integer value for how many dice will be rolled
        dice_sides: integer value for sides on each dice. represents maximum roll value.

    Returns: dict with that contains the roll definition and results
        keys and values in the output inlcude:
        dice_roll: a string defining the dice roll (ie, "1d20")
        results: a list of ints representing rolled values (ie, [20])
        ex: {"dice_roll": "1d20", "results":[20]}
    """
    dice_results = [randint(1, dice_sides) for i in range(num_dice)]
    dice_result_dict = {"dice_roll": "{}d{}".format(num_dice, dice_sides), "results": dice_results}
    return dice_result_dict


def format_slack_response(dice_result):
    """Takes the output from the roll_dice function and creates a slack-formatted dict with output

    Args:
        dice_result: a dict with the output from roll_dice.
           expects keys and values for:
               dice_roll: a string defining the dice roll (ie, "1d20")
               results: a list of ints representing rolled values (ie, [20])
            ex: {"dice_roll": "1d20", "results":[20]}

    Returns: A dict with containing a result message as expected by the slack API
        ex:
    {
    "response_type": "in_channel",
    "text": "20",
    "attachments": [{
            "text":"rolled 1d20"
        }]
    }
    """
    sum_results = sum(dice_result["results"])
    output_dict = {"response_type": "in_channel"}
    output_dict["text"] = "{} = {}".format(dice_result["results"], str(sum_results))
    output_dict["attachments"] = [{"text": "rolled {}".format(dice_result["dice_roll"])}]
    return output_dict
```

The `dicebot.py` file shown here works totally separately of AWS Lambda. We can even invoke it from a local, interactive python terminal to play around with it and see how it works.

Let's go ahead and copy that `dicebot.py` code into a new file within the `first_function` directory. From that `first_function` directory, we will open an interactive python interpreter, as shown below.

```bash
$ cd first_function
$ python
Python 3.7.4 (default, Oct  8 2019, 13:59:00)
[GCC 7.4.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
```

Our first step towards using `dicebot.py` is to import the dicebot code into our local interpreter. Since we invoked our python interpreter from the `first_function` directory, we can use the command `import dicebot` to get access to that code.

We can confirm that it is working and imported from our local directory with the command `print(dicebot)`

```python
>>> import dicebot
>>> print(dicebot)
<module 'dicebot' from '/home/ec2-user/Development/dicebot/dicebot/first_function/dicebot.py'>
```

Now, sure we _could_ just look at the source code, but let's use this opportunity to learn about a useful feature of python: the `__doc__` attribute. Since the developer of `dicebot.py` has followed python best practices for documentation, the `docstring` comment from the module is accessible from our interactive python shell. 