
![[posts/img/going-serverless-offline/cover.jpeg]]

In this post, we are going to setup an environment with API Gateway, Lambda and DynamoDB using serverless framework which can be deployed to AWS directly or run fully local.

What are the advantages of using offline:

- Develop stress free without unexpected fees
- No need to wait for the deployment to finish to test every single change.
- Easier local debugging.
- When you’re ready, it takes just one command to deploy everything to AWS

You can also check the repositories of the individual plugins for more detailed information: [serverless](https://github.com/serverless/serverless), [serverless-offline](https://github.com/dherault/serverless-offline) and [serverless-dynamodb-local](https://github.com/99xt/serverless-dynamodb-local).

## Setting up serverless framework

Start with installing serverless framework if you have not already

```
npm install -g serverless
```

and setup your AWS credentials. You can create your key and secret from AWS Console

```
sls config credentials --provider aws --key \<KEY\> --secret \<SECRET\>
```

We’re all set to create our serverless project

```
serverless create --template aws-nodejs --path test-serverless
```

This will create a serverless.yml file which contains the definition of our resources and example lambda function in handler.js

At this point, you can deploy it to AWS using the below command in the project’s root folder

```
cd test-serverless
serverless deploy
```

As simple as that. But we’ll continue with setting up a local development environment.

## Setting up the local development environment

We need two plugins here;

- serverless-offline which emulates AWS Lambda and API Gateway
- serverless-dynamodb-local which runs a local DynamoDB.

```
npm install serverless-offline serverless-dynamodb-local --save-dev
```

Next step is updating our serverless.yml file. We changed runtime to nodejs8.10 to use the latest features, added a trigger for our lambda function and also added plugins section. Note that order is important in the plugins section.

```
service: test-serverless
provider:
  name: aws
  runtime: nodejs8.10
functions:
  hello:
    handler: handler.hello
    events:
      - http:
          path: ''
          method: get
plugins:
  - serverless-dynamodb-local
  - serverless-offline
```

after adding plugins, we need to install DynamoDB local in the project folder

```
serverless dynamodb install
```

now it’s time to run our local serverless. If you see a similar output, it means your setup was successful. You have your local DynamoDB instance running at localhost:8000, your local server is running at localhost:3000 and you have one endpoint at the root.

```
> serverless offline start
Dynamodb Local Started, Visit: [http://localhost:8000/shell](http://localhost:8000/shell)
Serverless: Starting Offline: dev/us-east-1.

Serverless: Routes for hello:
Serverless: GET /

Serverless: Offline listening on [http://localhost:3000](http://localhost:3000)
```

Try hitting [http://localhost:3000](http://localhost:3000), you should see the output of the lambda function.

## Integrating with local DynamoDB

We need to make the following changes to our serverless.yml file.

1. add an environment variable for the table name which we’ll use it in the template as well as in our nodejs code.
2. Replace functions section with two new functions; one for getting the users from dynamo and other for creating new users.
3. Add resources section which has the definition of our table
4. Set some flags in custom section for our local DynamoDB. Setting migrate to true will create the tables on start.

```
service: test-serverless
provider:
  name: aws
  runtime: nodejs8.10
  stage: dev
  environment:
    DYNAMODB_USER_TABLE: ${self:service}-${opt:stage, self:provider.stage}-Users
functions:
  usersGet:
    handler: handler.usersGet
    events:
      - http:
          path: ''
          method: get
  usersCreate:
    handler: handler.usersCreate
    events:
      - http:
          path: '/create'
          method: get # setting the method to GET for testing
resources:
  Resources:
    UsersTable:
      Type: AWS::DynamoDB::Table
      Properties:
        TableName: ${self:service}-${opt:stage, self:provider.stage}-Users
        AttributeDefinitions:
          - AttributeName: email
            AttributeType: S
        KeySchema:
          - AttributeName: email
            KeyType: HASH
        ProvisionedThroughput:
          ReadCapacityUnits: 1
          WriteCapacityUnits: 1
plugins:
  - serverless-dynamodb-local
  - serverless-offline
custom:
  dynamodb:
    start:
      port: 8000
      inMemory: true
      migrate: true # create tables on start
```

## Updating lambda functions

Let’s update our lambda functions to read/write to the table we defined above.

serverless-offline plugin sets IS\_OFFLINE environment variable to true. We’ll use it to decide if we want to connect to the local dynamo instance or the one in AWS. In other words, if we run serverless offline start, it will connect to the local DynamoDB, but once we deploy it to AWS, it will use the actual DynamoDB table.

Then we have our lambda functions: usersGet will return all entries in the table while usersCreate will add new entries.

If you’re not familiar with async/await, you can quickly check it [here](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/async_function). Since we changed our runtime to nodejs8.10 in serverless.yml, we can use this cool feature.

```
const AWS = require('aws-sdk');
const bluebird = require('bluebird');
AWS.config.setPromisesDependency(bluebird);

// use local dynamodb if running offline
const dbClient = new AWS.DynamoDB.DocumentClient(
  process.env.IS_OFFLINE ? {region: 'localhost', endpoint: 'http://localhost:8000'} : {}
);

module.exports.usersGet = async (event, context, callback) => {
  const params = {
    TableName: process.env.DYNAMODB_USER_TABLE
  };
  let result;
  try {
    result = await dbClient.scan(params).promise();
  } catch(error) {
    callback(null, {
      statusCode: error.statusCode || 501,
      headers: { 'Content-Type': 'text/plain' },
      body: 'Failed to get users'
    });
    return;
  }

  callback(null, {
    statusCode: 200,
    body: JSON.stringify(result.Items)
  });
};

module.exports.usersCreate = async (event, context, callback) => {
  const params = {
    TableName: process.env.DYNAMODB_USER_TABLE,
    Item: {
      email: `${Math.random().toString(36).substring(7)}@test.com`
    }
  };

  let result;
  try {
    result = await dbClient.put(params).promise();
  } catch (error) {
    callback(null, {
      statusCode: error.statusCode || 501,
      headers: {'Content-Type': 'text/plain'},
      body: 'Failed to create user'
    });
    return;
  }

  callback(null, {
    statusCode: 200,
    body: JSON.stringify(params.Item)
  });
};
```

It’s time to restart the offline server. This time, it should create the table and show two endpoints / and /create

```
> serverless offline start
Dynamodb Local Started, Visit: [http://localhost:8000/shell](http://localhost:8000/shell)
Serverless: DynamoDB - created table test-serverless-dev-Users
Serverless: Starting Offline: dev/us-east-1.

Serverless: Routes for usersGet:
Serverless: GET /

Serverless: Routes for usersCreate:
Serverless: GET /create

Serverless: Offline listening on [http://localhost:3000](http://localhost:3000)
```

We’re all set. Let’s open [http://localhost:3000/create](http://localhost:3000/create) and refresh a couple of times to create new users. And now hit [http://localhost:3000/](http://localhost:3000/) and see all the create users.

You can also deploy it to AWS with serverless deploy, but don’t forget to add necessary IAM roles for your lambda functions to access DynamoDB.

We are going to create a single component that supports text, textarea, select, radio, and checkbox. It will absorb all implementation differences for different inputs and will allow us using a unified component in our Formik forms.

Creating a unified Formik input field to support all input types seamlessly

In this post, we are going to setup an environment with API Gateway, Lambda and DynamoDB using serverless framework which can be deployed to AWS directly or run fully local.

Going Serverless Offline

Multitasking is the source of all evil. Until recently, I also liked having multiple screens and multi-tasking like many others. It was great to code on one screen while reading the slack messages and emails on the other screen. But, it was so easy to get distracted by continuous incoming notifications while trying to read, write or code something. Often, I was feeling tired in the middle of the day because continuous context switching was draining my energy and destroying my focus on the task I was working on. 

5 Tips To Stop Multitasking and Double Your Productivity

Although what react is doing looks quite complex, underlying logic is very simple. And the easiest way to understand is just running some simple examples. We’ll dive into how react renders components and updates the actual DOM.

How React Rendering Works - A Step by Step Guide

Maybe you’re just getting started with distributed systems and system design, or you just need a quick recap for your upcoming interview. In either case, in this post, you’ll find the most common concepts of system design and the most important aspects of them. Let’s get started.

Recap of System Design Interview Concepts

You solved 60 LeetCode hard and 300 LeetCode medium questions, you were a rockstar in your coding round and provided the most efficient solution in the world, but you couldn’t get the offer. Sounds familiar? Either case, keep reading, you might find some useful tips.

How to Succeed in Your Coding Interview

Attacks like CSRF or XSS are still not clear to many of us. It is not because they are super hard to understand, but it requires some basic understanding of concepts like SOP, CORS, CSP, HTTPS. Let's start with what's Same-origin Policy

Web security unknowns: Same-origin Policy

DynamoDB is Amazon’s NoSQL database which offers single-digit milliseconds latency. It is great for variety of use cases, but when you need to run complex search queries on your dataset, you quickly realise it is not designed for it.

Indexing DynamoDB Items to ElasticSearch using AWS Lambda

While making a simple request to https://google.com to see that simple search page, there are a lot of things going on behind the scenes to keep you secure. Understanding this flow will give you a lot of confidence in various topics like Digital Certificates and Signatures, Symmetric/Asymmetric key encryptions, Certificate Authorities and how they all work together to help you have secure communication.

What happens when you hit google.com using HTTPS

System design questions can be asked for any level with different expectations from the candidate, but to get a Senior offer, you have to rock this round. Practice makes perfect - like for anything else, it applies for system design interview too. So, keep practicing without taking shortcuts, practice as if it’s the real interview and always follow the same steps to make it perfect.