Contact Us
Search:

LocalStack: AWS On Your Laptop

LocalStack is a cloud application development tool that provides an easy-to-use test/mock system. It creates a testing environment on your local computer that emulates the AWS cloud environment in terms of functionality and APIs.

LocalStack: AWS On Your Laptop

LocalStack is a cloud application development tool that provides an easy-to-use test/mock system. It creates a testing environment on your local computer that emulates the AWS cloud environment in terms of functionality and APIs.

LocalStack's primary objective is to assist you in speeding up various procedures, simplifying testing, and saving money on development testing. For example, consider the time it takes to spin up an EC2 instance on Amazon Web Services (AWS). It can take a few minutes, but it can take 15 minutes or more to spin up an Elastic Kubernetes Service (EKS). That is acceptable for production environments, but this amount of time may be excessive when it comes to testing. Also, while you are just getting started and testing things out, these procedures can lead to high costs.

It is possible to run Lambda functions, create DynamoDB tables, ECS containers, and more, such as putting your application behind an API Gateway with LocalStack. All of these functionalities are powered by your local machine without ever talking to the cloud.

This blog post includes a Serverless Demo, and code samples can be found in this github repository.

LocalStack has three different customer usage tier options: Community Edition, Pro, and Enterprise. Each of the usage tiers has its available services and features. Pro and Enterprise options require payment, but the Community Edition option is free for personal usage. 

I am going to use the Community Edition option for this blog post. 

The diagram below depicts the various usage tiers (Open Source, Pro, and Enterprise) and the capabilities available in each. And also, you can check the complete list of features from this link here.

Screen Shot 2022-03-08 at 22.09.44

Integration with LocalStack

LocalStack is compatible with a wide range of cloud development tools. There are numerous aspects to cloud development, and there is a large ecosystem of tools to handle them all. LocalStack allows you to execute your process entirely on your local workstation, whether you're using Infrastructure-as-Code (IaC) to manage your AWS infrastructure or developing apps with AWS SDKs like boto. LocalStack is compatible with a wide range of cloud development tools. I am going to use the Serverless Framework for this blog post.

Screen Shot 2022-03-08 at 22.10.33

Get LocalStack Up and Running

In this section of this blog post, you will see how a simple serverless application can be deployed using LocalStack. 

There are a couple of ways you can install LocalStack. You can install it with a package manager, you can run it on docker with docker-compose, and it is also possible to run LocalStack in a Kubernetes cluster. 

I am going to install LocalStack using docker-compose. You can create different configurations based on your requirements with the docker-compose configuration provided in the LocalStack repository

Prerequisites:

Please make sure to install the following tools on your machine before moving on.

  • docker
  • docker-compose (version 1.9.0+)
  • npm

Docker-compose YAML file template


version: "3.8"
services:
  localstack:
    container_name: "localstack-test"
    image: localstack/localstack:latest
    network_mode: bridge
    privileged: true
    ports:
      - '4566:4566'
    environment:
      - SERVICES=${SERVICES- }
      - DATA_DIR=/tmp/localstack
      - LAMBDA_EXECUTOR=docker-reuse
      - DOCKER_HOST=unix:///var/run/docker.sock
      - AWS_EXECUTION_ENV=true
    volumes:
      - ".volume/tmp/localstack:/tmp/localstack"
      - "/var/run/docker.sock:/var/run/docker.sock"

After creating the `docker-compose.yml` file, get it up and running with the following command.


$ docker-compose up

localstack-test | LocalStack version: 0.13.0
localstack-test | LocalStack build date: 2021-11-23
localstack-test | LocalStack build git hash: b6046487
localstack-test | 
localstack-test | 2021-11-24 07:38:12,906 INFO success: infra entered RUNNING state, process has stayed up for > than 1 seconds (startsecs)
localstack-test | Starting edge router (https port 4566)...
localstack-test | Ready.

 

As there are no errors, LocalStack services are ready for usage.

Serverless Framework is a good option to integrate and use with LocalStack. Let’s install it with npm.


$ npm install -g serverless
$ npm install --save-dev serverless-localstack

Setting Up The App

I am going to create a simple backend that creates, deletes, lists, updates, and retrieves customers that can be used through a REST HTTP API using API Gateway, Lambda, and DynamoDB services.


Screen Shot 2022-03-08 at 22.11.15

The figure below provides an overview of the structure of the repository.


Screen Shot 2022-03-08 at 22.11.53

The code example below provides an overview of the `getCustomer.py` file. You can get the code at this GitHub Repository.


import os
import json
import boto3

if 'LOCALSTACK_HOSTNAME' in os.environ:
   dynamodb_endpoint = 'http://%s:4566'% os.environ['LOCALSTACK_HOSTNAME']
   dynamodb = boto3.resource('dynamodb',endpoint_url=dynamodb_endpoint)
else:
   dynamodb = boto3.resource('dynamodb')


def getCustomer(event, context):
   table = dynamodb.Table(os.environ['DYNAMODB_TABLE'])

   # fetch Customer from the database
   result = table.get_item(
       Key={
           'id': event['pathParameters']['id']
       }
   )

   # create a response
   response = {
       "statusCode": 200,
       "body": json.dumps(result['Item'])
   }

   return response

The code example below provides an overview of the `serverless.yml` file.

 


service: serverless-rest-api-with-dynamodb

frameworkVersion: ">=1.1.0 <=2.70.0"

provider:
 name: aws
 runtime: python3.8
 environment:
   DYNAMODB_TABLE: ${self:service}-${opt:stage, self:provider.stage}
 ...
functions:
 create:
   handler: customers/createCustomer.createCustomer
   events:
     - http:
         path: customers
         method: post
         cors: true
 ...
resources:
 Resources:
   CustomersDynamoDbTable:
     Type: 'AWS::DynamoDB::Table'
     DeletionPolicy: Retain
 ...

After these steps are complete, the following command will deploy my application to LocalStack.


$ serverless deploy --stage local

The result should be similar to:


Screen Shot 2022-03-08 at 22.12.59

I will use the given endpoint to create a customer with the following command.


$ curl -X POST http://localhost:4566/restapis/cfev9cngmk/local/_user_request_/customers --data '{"firstName":"Cem","lastName":"ALTUNER"}'
  

The expected output:

{"id": "4b19151b-51ad-11ec-8e88-fbb757305d9e", "firstName": "Cem", "lastName": "ALTUNER", "createdAt": "1638256527.26767", "updatedAt": "1638256527.26767"}

Serverless Framework is a good option to create and test serverless applications on your local computer with LocalStack. But if you want to test your whole infrastructure, the Infrastructure as a Code approach like Terraform would be a better option. For further information, you can check this link here. 

Conclusion

LocalStack makes it easier to test, save money, and get things done faster when developing your infrastructure. If you want to test your infrastructure on your local computer, LocalStack can be the right solution for you.

Cem Altuner

Cem is a cloud engineer at Kloia. He has studied Amazon Web Services and Kubernetes projects. He is also experimenting with serverless computing.