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

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

AWS supports a few different runtime environments for python, so if we ever need a particular version, we will need to check that it’s supported by lambda first. A full list of  supported runtime versions is available on the AWS Documentation page for 

Check for already installed python versions

If we are using an operating system like Linux or Mac OS - we may already have some version of python installed on our local development machine. This version of python, commonly referred to as the 

 python, is rarely the latest version that we need for development. We can confirm if we have a 

 python version installed and see what version it is with the command 

 version of python installed is much older than 3.7. In other cases, the command above could fail completely, indicting that python is not installed at all. In cases where older are versions present,

 python directly. Updating it can break certain tools that our operating system needs for essential tasks, including dependency management software

 that will allow us to safely install the latest python version - regardless of whether we have a 

 is an open-source tool used for managing multiple python environments. It allows developers to define which version of python to use on a per-project basis. It's similar to the better-known tool that is commonly used in ruby development - 

 becoming popular, many python developers used 

 is still widely used - but it lacks some crucial features that 

 provides for standardized installation methods.

We will walk through the most common installation scenarios here, but if you encounter issues, consult the full installation instructions for the project: 

https://github.com/pyenv/pyenv#installation

Different operating systems have different dependency needs, the latest of which are documented here: 

https://github.com/pyenv/pyenv/wiki/Common-build-problems

Installing pyenv on Mac OS using homebrew

 installed. It's a widely used dependency manager for Mac OS that provides installation packages for many open-source software projects. The commands to install 

 configured then skip down to instructions for 

. The instructions underneath the “install by zip” instructions in the 

The following commands will install the required 

sudo yum -y update
sudo yum -y install git tmux
sudo yum -y install @development zlib-devel bzip2 bzip2-devel readline-devel sqlite \
sqlite-devel openssl-devel xz xz-devel libffi-devel findutils

Once dependencies are installed, use the 

sudo apt update
sudo apt install -y make build-essential libssl-dev zlib1g-dev libbz2-dev \
libreadline-dev libsqlite3-dev wget curl llvm libncurses5-dev libncursesw5-dev \
xz-utils tk-dev libffi-dev liblzma-dev python-openssl git

 helpful for completing the installation, as shown below.

$ curl -L https://github.com/pyenv/pyenv-installer/raw/master/bin/pyenv-installer | bash
...
WARNING: seems you still have not added 'pyenv' to the load path.

# Load pyenv automatically by adding
# the following to ~/.bashrc:

export PATH="/home/user/.pyenv/bin:$PATH"
eval "$(pyenv init -)"
eval "$(pyenv virtualenv-init -)"

Copy the last 3 lines from the output into your local clipboard from your terminal, and paste those into bottom of the file at 

Don’t paste from this book directly - the exported 

 variable will be specific to your install.

Use pyenv to install python 3.7 (All Operating Systems)

 can be used to fetch a list of all versions of python which are available to be installed with 

The output from command above can be extremely long though! Since we're using Amazon Linux 2 for examples, we have 

 already installed, which will allow us to filter out everything that isn't 3.7.

$ pyenv install --list | grep 3.7.
  3.7.0
  3.7.1
  3.7.2
  3.7.3
  3.7.4

That's a much more manageable output. In this case, it looks like 

 is the latest release, so we will install that.

We can install install any number of versions of python side-by-side using the 

 command. Each version gets installed into its own local directory, which ensures it will not conflict with our 

 has to compile each new version of python it installs, it can take 5-10 minutes to complete an install this way.

So to install python 3.7.4 specifically, we use:

Once the install completes, we can check which versions of python are now available for use with the 

$ pyenv versions
* system (set by /home/ec2-user/.pyenv/version)
  3.7.4

 version listed is the default 2.7 version we detected when running 

 is  currently selected as default python.

Since we want to use the new 3.7 version for development, we are going to need to set it as the 

 python version so it is used by default in this shell, and future ones we launch. We can change the 

 at any time by specifying the version of python we wish to use (it must be one we currently have installed).

 again, we can verify that 3.7.4 is in use because it has 

$ pyenv versions
  system
* 3.7.4 (set by /home/ec2-user/.pyenv/version)

, we should see that the installed version matches up.

 is configured to use the latest version of python, we will setup 

 to handle dependency management in python projects. 

 provides features that are missing from the older dependency management tool - 

 will ensure we can keep each project's dependency needs installed into virtual environments, and defined in lockfiles.

Let's upgrade pip to the latest version first

$ pip install --upgrade pip
Successfully installed pip-19.2.3

We can now install pipenv with the --user flag

$ pip install --user pipenv
...
Installing collected packages: virtualenv-clone, certifi, virtualenv, pipenv
Successfully installed certifi-2019.9.11 pipenv-2018.11.26 virtualenv-16.7.5 virtualenv-clone-0.5.3

 with pip. In most cases, simply using the 

 will ensure the package gets installed correctly and can be used without resorting to running with 

, there are a few other modules that we'll want to go ahead and install with 

 to install modules that are used across all projects for development purposes - but use 

 for project-specific modules that are imported by our lambdas.

The packages we'll want to install across the dev env - 

 can be installed with the command below:

pip install --user awscli aws-sam-cli pylint cookiecutter

To define and install project-specific dependencies, we will need to create a project folder and navigate to it. Remember to always check your current directory before invoking 

 - it must always be invoked from within a project's directory to work correctly. We can confirm current terminal location with the command 

$ mkdir chap1
$ cd chap1/
$ pwd
/home/ec2-user/Development/chap1

. This command creates a blank file that 

 uses to store project dependencies, and the 

 populates a configuration setting in that 

 which locks the environment to python 3.7. Output is shown below:

$ pipenv --python 3.7
Creating a virtualenv for this project…
Pipfile: /home/ec2-user/chap1/Pipfile
Using /home/ec2-user/.pyenv/versions/3.7.4/bin/python3.7m (3.7.4) to create virtualenv…
⠴ Creating virtual environment...Already using interpreter /home/ec2-user/.pyenv/versions/3.7.4/bin/python3.7m
Using base prefix '/home/ec2-user/.pyenv/versions/3.7.4'
New python executable in /home/ec2-user/.local/share/virtualenvs/chap1-rs-3yCsf/bin/python3.7m
Also creating executable in /home/ec2-user/.local/share/virtualenvs/chap1-rs-3yCsf/bin/python
Installing setuptools, pip, wheel...
done.
Running virtualenv with interpreter /home/ec2-user/.pyenv/versions/3.7.4/bin/python3.7m

✔ Successfully created virtual environment!
Virtualenv location: /home/ec2-user/.local/share/virtualenvs/chap1-rs-3yCsf
Creating a Pipfile for this project…

 now exists in our project directory. Let's check out its contents.

$ cat Pipfile
[[source]]
name = "pypi"
url = "https://pypi.org/simple"
verify_ssl = true

[dev-packages]

[packages]

[requires]
python_version = "3.7"

 directly, it's better practice to just allow 

 to make those changes on our behalf. So let's go ahead and install a commonly used library, 

 for use in this new project. We can install it with the command 

 is widely used for interacting with the AWS API via python. In fact, it's used so frequently that all python Lambdas come with 

 already packaged! That said, installing it here will not cause any issues - so it's a safe example to practice with.

If we cat the Pipfile again, we should see a new line under 

$ cat Pipfile
[[source]]
name = "pypi"
url = "https://pypi.org/simple"
verify_ssl = true

[dev-packages]

[packages]
boto3 = "*"

[requires]
python_version = "3.7"

Additionally, we should see a new file in our directory called 

. This is the file that contains the full information about which version of the 

 module is installed, as well as information about any modules that were installed as dependencies of 

---
title: Installing Python 3 and Pyenv on MacOS, Windows, and Linux
isPublicLesson: true
description: "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

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

AWS supports a few different runtime environments for python, so if we ever need a particular version, we will need to check that it’s supported by lambda first. A full list of  supported runtime versions is available on the AWS Documentation page for [Lambda Runtimes](https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html).

## Check for already installed python versions

If we are using an operating system like Linux or Mac OS - we may already have some version of python installed on our local development machine. This version of python, commonly referred to as the `system` python, is rarely the latest version that we need for development. We can confirm if we have a `system` python version installed and see what version it is with the command `python --version`, as shown below.

```bash
$ python --version
Python 2.7.6
```

The output above indicates that the `system` version of python installed is much older than 3.7. In other cases, the command above could fail completely, indicting that python is not installed at all. In cases where older are versions present,**it is unsafe to update `system` python directly. Updating it can break certain tools that our operating system needs for essential tasks, including dependency management software**. Fortunately, there is a tool called `pyenv` that will allow us to safely install the latest python version - regardless of whether we have a `system` python version installed or not.

## Install Pyenv

[Pyenv](https://github.com/pyenv/pyenv) is an open-source tool used for managing multiple python environments. It allows developers to define which version of python to use on a per-project basis. It's similar to the better-known tool that is commonly used in ruby development - `rbenv`. Prior to `pyenv` becoming popular, many python developers used `virtualenv` to manage environment versions. `virtualenv` is still widely used - but it lacks some crucial features that `pyenv` provides for standardized installation methods.

We will walk through the most common installation scenarios here, but if you encounter issues, consult the full installation instructions for the project: <https://github.com/pyenv/pyenv#installation>

Different operating systems have different dependency needs, the latest of which are documented here: <https://github.com/pyenv/pyenv/wiki/Common-build-problems>

### Installing pyenv on Mac OS using homebrew

Many developers may already have [homebrew](https://brew.sh/) installed. It's a widely used dependency manager for Mac OS that provides installation packages for many open-source software projects. The commands to install `brew` are provided below.

-   Install dependencies for `brew`

    ```shell
    xcode-select --install
    ```
-   Install `brew`

    ```shell
    /usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"
    ```
-   Install dependencies pyenv requires

    ```bash
    brew update
    brew install openssl readline sqlite3 xz zlib
    ```
-   **If using Mojave or above**, use this command to install an additional required dependency:

    ```bash
    $ sudo installer -pkg /Library/Developer/CommandLineTools/Packages/macOS_SDK_headers_for_macOS_10.14.pkg -target /
    ```
-   Install pyenv

    ```bash
    brew install pyenv
    ```
-   Update the shell to ensure autocomplete for pyenv is functional

    ```bash
    echo -e 'if command -v pyenv 1>/dev/null 2>&1; then\n  eval "$(pyenv init -)"\nfi' >> ~/.bash_profile
    exec "$SHELL"
    ```

### Pyenv on Windows

If using a version of Windows with [Windows Subsystem for Linux](#windows-subsystem) configured then skip down to instructions for [Ubuntu 18.04](#install-pyenv-ubuntu)

 Otherwise - we will need to use a `pyenv` fork, `pyenv-win`. The instructions underneath the “install by zip” instructions in the [pyenv-win wiki](https://github.com/pyenv-win/pyenv-win#installation) provide instructions for `pyenv-win` installation.

### Pyenv on Amazon Linux 2

The following commands will install the required `pyenv` dependencies on Amazon Linux 2

```bash
sudo yum -y update
sudo yum -y install git tmux
sudo yum -y install @development zlib-devel bzip2 bzip2-devel readline-devel sqlite \
sqlite-devel openssl-devel xz xz-devel libffi-devel findutils
```

Once dependencies are installed, use the [pyenv-installer](#pyenv-installer) to finish installation.

### Pyenv on Ubuntu Linux 18.04 {id:install-pyenv-ubuntu}

The following commands will install the required `pyenv` dependencies on Ubuntu Linux 18.04

```bash
sudo apt update
sudo apt install -y make build-essential libssl-dev zlib1g-dev libbz2-dev \
libreadline-dev libsqlite3-dev wget curl llvm libncurses5-dev libncursesw5-dev \
xz-utils tk-dev libffi-dev liblzma-dev python-openssl git
```

Once dependencies are installed, use the [pyenv-installer](#pyenv-installer) to finish installation.

### Pyenv Installer (Linux)

Linux users will find the [pyenv-installer](https://github.com/pyenv/pyenv-installer) helpful for completing the installation, as shown below.

```bash
$ curl -L https://github.com/pyenv/pyenv-installer/raw/master/bin/pyenv-installer | bash
...
WARNING: seems you still have not added 'pyenv' to the load path.

# Load pyenv automatically by adding
# the following to ~/.bashrc:

export PATH="/home/user/.pyenv/bin:$PATH"
eval "$(pyenv init -)"
eval "$(pyenv virtualenv-init -)"
```

Copy the last 3 lines from the output into your local clipboard from your terminal, and paste those into bottom of the file at `~/.bashrc.` _Don’t paste from this book directly - the exported `PATH` variable will be specific to your install._

Steps to paste the output using `vim`:

-   Open `~/.bashrc` with `vim`

    ```bash
    vim ~/.bashrc
    ```
-   `vim` commands to modify `~/.bashrc`

    ```vim
    GG
    o
    (right-click to paste)
    :wq (enter)
    ```

## Use pyenv to install python 3.7 (All Operating Systems)

The command `pyenv install --list` can be used to fetch a list of all versions of python which are available to be installed with `pyenv`.

The output from command above can be extremely long though! Since we're using Amazon Linux 2 for examples, we have `grep` already installed, which will allow us to filter out everything that isn't 3.7.

```bash
$ pyenv install --list | grep 3.7.
  3.7.0
  3.7.1
  3.7.2
  3.7.3
  3.7.4
```

That's a much more manageable output. In this case, it looks like [3.7.4](https://www.python.org/downloads/release/python-374/) is the latest release, so we will install that.

We can install install any number of versions of python side-by-side using the `pyenv install` command. Each version gets installed into its own local directory, which ensures it will not conflict with our `system` python, or any other version. Since `pyenv` has to compile each new version of python it installs, it can take 5-10 minutes to complete an install this way.

So to install python 3.7.4 specifically, we use:

```bash
pyenv install 3.7.4
```

Once the install completes, we can check which versions of python are now available for use with the `pyenv versions` command.

```bash
$ pyenv versions
* system (set by /home/ec2-user/.pyenv/version)
  3.7.4
```

In the output above, the `system` version listed is the default 2.7 version we detected when running `python --version` earlier. The `*` next to `system` means that `system` is  currently selected as default python.

Since we want to use the new 3.7 version for development, we are going to need to set it as the `global` python version so it is used by default in this shell, and future ones we launch. We can change the `global` at any time by specifying the version of python we wish to use (it must be one we currently have installed).

The `pyenv global` command for 3.7.4 is shown below.

```bash
pyenv global 3.7.4
```

After that, when we run `pyenv versions` again, we can verify that 3.7.4 is in use because it has `*` next to it.

    $ pyenv versions
      system
    * 3.7.4 (set by /home/ec2-user/.pyenv/version)

Likewise, when we run `python --version`, we should see that the installed version matches up.

```bash
$ python --version
Python 3.7.4
```

## Install pipenv

Now that `pyenv` is configured to use the latest version of python, we will setup [pipenv](https://github.com/pypa/pipenv) to handle dependency management in python projects. `Pipenv` provides features that are missing from the older dependency management tool - `pip`. Using `pipenv` will ensure we can keep each project's dependency needs installed into virtual environments, and defined in lockfiles.

Let's upgrade pip to the latest version first

```bash
$ pip install --upgrade pip
Successfully installed pip-19.2.3
```

We can now install pipenv with the --user flag

```bash
$ pip install --user pipenv
...
Installing collected packages: virtualenv-clone, certifi, virtualenv, pipenv
Successfully installed certifi-2019.9.11 pipenv-2018.11.26 virtualenv-16.7.5 virtualenv-clone-0.5.3
```

W> Don't use `sudo` with pip, use `--user`
W>
W> It should not be necessary to use `sudo` with pip. In most cases, simply using the `--user` flag after `pip install` will ensure the package gets installed correctly and can be used without resorting to running with `sudo`.

## Install dev modules from pip

Besides `pipenv`, there are a few other modules that we'll want to go ahead and install with `pip`. In general, we'll use `pip install --user` to install modules that are used across all projects for development purposes - but use `pipenv install` for project-specific modules that are imported by our lambdas.

The packages we'll want to install across the dev env - `awscli`, `aws-sam-cli`, `pylint`, and `cookiecutter` can be installed with the command below:

```bash
pip install --user awscli aws-sam-cli pylint cookiecutter
```

## Install project modules with pipenv

To define and install project-specific dependencies, we will need to create a project folder and navigate to it. Remember to always check your current directory before invoking `pipenv` - it must always be invoked from within a project's directory to work correctly. We can confirm current terminal location with the command `pwd`, as shown below

```bash
$ mkdir chap1
$ cd chap1/
$ pwd
/home/ec2-user/Development/chap1
```

From this new directory, `pipenv --python 3.7` to initiate the creation of a `Pipfile`. This command creates a blank file that `pipenv` uses to store project dependencies, and the `--python 3.7` populates a configuration setting in that `Pipfile` which locks the environment to python 3.7. Output is shown below:

```bash
$ pipenv --python 3.7
Creating a virtualenv for this project…
Pipfile: /home/ec2-user/chap1/Pipfile
Using /home/ec2-user/.pyenv/versions/3.7.4/bin/python3.7m (3.7.4) to create virtualenv…
⠴ Creating virtual environment...Already using interpreter /home/ec2-user/.pyenv/versions/3.7.4/bin/python3.7m
Using base prefix '/home/ec2-user/.pyenv/versions/3.7.4'
New python executable in /home/ec2-user/.local/share/virtualenvs/chap1-rs-3yCsf/bin/python3.7m
Also creating executable in /home/ec2-user/.local/share/virtualenvs/chap1-rs-3yCsf/bin/python
Installing setuptools, pip, wheel...
done.
Running virtualenv with interpreter /home/ec2-user/.pyenv/versions/3.7.4/bin/python3.7m

✔ Successfully created virtual environment!
Virtualenv location: /home/ec2-user/.local/share/virtualenvs/chap1-rs-3yCsf
Creating a Pipfile for this project…
```

A file named `Pipfile` now exists in our project directory. Let's check out its contents.

```bash
$ cat Pipfile
[[source]]
name = "pypi"
url = "https://pypi.org/simple"
verify_ssl = true

[dev-packages]

[packages]

[requires]
python_version = "3.7"
```

While it's possible to modify this `Pipfile` directly, it's better practice to just allow `pipenv` to make those changes on our behalf. So let's go ahead and install a commonly used library, `boto3` for use in this new project. We can install it with the command `pipenv install boto3`

```bash
pipenv install boto3
```

I> A note on `boto3`
I>
I> The module `boto3` is widely used for interacting with the AWS API via python. In fact, it's used so frequently that all python Lambdas come with `boto3` already packaged! That said, installing it here will not cause any issues - so it's a safe example to practice with.

If we cat the Pipfile again, we should see a new line under `[packages]` that shows `boto3`.

```bash
$ cat Pipfile
[[source]]
name = "pypi"
url = "https://pypi.org/simple"
verify_ssl = true

[dev-packages]

[packages]
boto3 = "*"

[requires]
python_version = "3.7"
```

Additionally, we should see a new file in our directory called `Pipfile.lock`. This is the file that contains the full information about which version of the `boto3` module is installed, as well as information about any modules that were installed as dependencies of `boto3`
