Microservice using serverless Application Model + Couchbase

Amazon Web Services introduced Modelo de aplicación sin servidor, or SAM, a couple of months ago. It defines simplified syntax for expressing
serverless resources. SAM extends AWS CloudFormation to add support for API Gateway, AWS Lambda and Amazon DynamoDB. This blog will show how to create a simple microservice using
SAM. Of course, we’ll use Couchbase instead of DynamoDB! This blog will also use the basic concepts explained in Microservice using AWS API Gateway, AWS Lambda and Couchbase. SAM
will show the ease with which the entire stack for microservice can be deployed and managed.

As a refresher, here are key components in the architecture:

Client could be curl, AWS CLI/Console, Postman client or any other tool/API that can invoke a REST endpoint.
AWS API Gateway is used to provision APIs. The top level resource is available at path /libros. HTTP GET y POST para el recurso.
Cada API activa una función Lambda. Se crean dos funciones Lambda, lista de libros para listar todos los libros disponibles y libro-crear para crear un nuevo libro.
Couchbase se utiliza como almacén de persistencia en EC2. Todos los documentos JSON se almacenan y recuperan de esta base de datos.

Other blogs on serverless:

Empecemos.

Serverless Application Model (SAM) Template

An AWS CloudFormation template with serverless resources conforming to the AWS SAM model is referred to as a SAM file or template. It is deployed
as a CloudFormation stack. Let’s take a look at our SAM template: This template is available at github.com/arun-gupta/serverless/blob/master/aws/microservice/template.yml.

AWSTemplateFormatVersion : '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Description: Microservice using API Gateway, Lambda and Couchbase
Resources:
  MicroserviceGetAllGateway:
    Type: AWS::Serverless::Function
    Properties:
      Handler: org.sample.serverless.aws.couchbase.gateway.BucketGetAll
      Runtime: java8
      CodeUri: s3://serverless-microservice/microservice-http-endpoint-1.0-SNAPSHOT.jar
      Timeout: 30
      MemorySize: 1024
      Environment:
        Variables:
          COUCHBASE_HOST: ec2-35-163-21-104.us-west-2.compute.amazonaws.com
      Role: arn:aws:iam::598307997273:role/microserviceRole
      Events:
        GetResource:
          Type: Api
          Properties:
            Path: /books
            Method: get
  MicroservicePostGateway:
    Type: AWS::Serverless::Function
    Properties:
      Handler: org.sample.serverless.aws.couchbase.gateway.BucketPost
      Runtime: java8
      CodeUri: s3://serverless-microservice/microservice-http-endpoint-1.0-SNAPSHOT.jar
      Timeout: 30
      MemorySize: 1024
      Environment:
        Variables:
          COUCHBASE_HOST: ec2-35-163-21-104.us-west-2.compute.amazonaws.com
      Role: arn:aws:iam::598307997273:role/microserviceRole
      Events:
        GetResource:
          Type: Api
          Properties:
            Path: /books
            Method: post

AWSTemplateFormatVersion : '2010-09-09'

Transformar: AWS::Serverless-2016-10-31

Descripción: Microservice using API Gateway, Lambda y Couchbase

Recursos:

MicroserviceGetAllGateway:

Tipo: AWS::Serverless::Function

Propiedades:

Manipulador: org.sample.serverless.aws.couchbase.gateway.BucketGetAll

Tiempo de ejecución: java8

CódigoUri: s3://serverless-microservice/microservice-http-endpoint-1.0-SNAPSHOT.jar

Tiempo de espera: 30

TamañoMemoria: 1024

Medio ambiente:

Variables:

COUCHBASE_HOST: ec2-35-163-21-104.us-west-2.compute.amazonaws.com

Papel: arn:aws:iam::598307997273:role/microserviceRole

Eventos:

GetResource:

Tipo: Api

Propiedades:

Ruta: /books

Método: get

MicroservicePostGateway:

Tipo: AWS::Serverless::Function

Propiedades:

Manipulador: org.sample.serverless.aws.couchbase.gateway.BucketPost

Tiempo de ejecución: java8

CódigoUri: s3://serverless-microservice/microservice-http-endpoint-1.0-SNAPSHOT.jar

Tiempo de espera: 30

TamañoMemoria: 1024

Medio ambiente:

Variables:

COUCHBASE_HOST: ec2-35-163-21-104.us-west-2.compute.amazonaws.com

Papel: arn:aws:iam::598307997273:role/microserviceRole

Eventos:

GetResource:

Tipo: Api

Propiedades:

Ruta: /books

Método: post

SAM template Specification provide complete details about contents in the template. The key parts of the template are:

Defines two resources, both of Lambda Function type identified by AWS::Serverless::Function attribute. Name of the Lambda function is defined by Resources..
Class for each handler is defined by the value of Resources..Properties.Handler atributo
Java 8 runtime is used to run the Function defined by Resources..Properties.Runtime atributo
Code for the class is uploaded to an S3 bucket, in our case to s3://serverless-microservice/microservice-http-endpoint-1.0-SNAPSHOT.jar
Resources..Properties.Environment.Variables.COUCHBASE_HOST attribute value defines the host where Couchbase is running. This can be easily deployed on EC2 as explained at Setup Couchbase.
Each Lambda function is triggered by an API. It is deployed using AWS API Gateway. The path is defined by Events.GetResource.Properties.Path. HTTP method is defined using Events.GetResource.Properties.Method atributo.

Java Application

The Java application that contains the Lambda functions is at github.com/arun-gupta/serverless/tree/master/aws/microservice/microservice-http-endpoint.
Lambda function that is triggered by HTTP GET method is shown:

public class BucketGetAll implements RequestHandler<GatewayRequest, GatewayResponse> {

    @Override
    public GatewayResponse handleRequest(GatewayRequest request, Context context) {
        try {
            N1qlQuery query = N1qlQuery
                    .simple(select("*")
                            .from(i(CouchbaseUtil.getBucketName()))
                            .limit(10));

            String result = CouchbaseUtil.getBucket().query(query).allRows().toString();

            return new GatewayResponse(200, result, GatewayResponse.HEADERS_JSON);
        } catch (ConfigurationException e) {
            return new GatewayResponse(400, e.getMessage(), GatewayResponse.HEADERS_TEXT);
        }
    }
}

público clase BucketGetAll implementa RequestHandler<GatewayRequest, GatewayResponse> {

@Anular

público GatewayResponse handleRequest(GatewayRequest solicitar, Contexto contexto) {

pruebe {

N1qlQuery consulta = N1qlQuery

.simple(seleccione("*")

.de(i(CouchbaseUtil.getBucketName()))

.límite(10));

Cadena resultado = CouchbaseUtil.getBucket().consulta(consulta).allRows().toString();

devolver nuevo GatewayResponse(200, resultado, GatewayResponse.HEADERS_JSON);

} captura (ConfigurationException e) {

devolver nuevo GatewayResponse(400, e.getMessage(), GatewayResponse.HEADERS_TEXT);

}

A little bit of explanation:

Each Lambda function needs to implement the interface com.amazonaws.services.lambda.runtime.RequestHandler.
API Gateway and Lambda integration require a specific input format y output format.
These formats are defined as GatewayRequest y GatewayResponse clases.
Function logic uses SDK Java de Couchbase to query the Couchbase database. N1QL query is used to query
the database. The results and exception are then wrapped in GatewayRequest y GatewayResponse.

Lambda function triggered by HTTP POST method is pretty straightforward as well:

public class BucketPost implements RequestHandler<GatewayRequest, GatewayResponse> {

    @Override
    public GatewayResponse handleRequest(GatewayRequest request, Context context) {

        try {
            JsonDocument document = CouchbaseUtil.getBucket().upsert(Book.fromStringToJson(request.getBody()));
            return new GatewayResponse(200, document.content().toString(), GatewayResponse.HEADERS_JSON);
        } catch (Exception ex) {
            return new GatewayResponse(400, ex.getMessage(), GatewayResponse.HEADERS_TEXT);
        }
    }
}

público clase BucketPost implementa RequestHandler<GatewayRequest, GatewayResponse> {

@Anular

público GatewayResponse handleRequest(GatewayRequest solicitar, Contexto contexto) {

pruebe {

JsonDocument documento = CouchbaseUtil.getBucket().upsert(Reserve.fromStringToJson(solicitar.getBody()));

devolver nuevo GatewayResponse(200, documento.contenido().toString(), GatewayResponse.HEADERS_JSON);

} captura (Excepción ex) {

devolver nuevo GatewayResponse(400, ex.getMessage(), GatewayResponse.HEADERS_TEXT);

}

A bit of explanation:

Incoming request payload is retrieved from GatewayRequest
Document inserted in Couchbase is returned as response.
Like the previous method, Function logic uses SDK Java de Couchbase to query the Couchbase database. The results and exception are then
wrapped in GatewayRequest y GatewayResponse.

Build the Java application as:

mvn -f microservice-http-endpoint/pom.xml clean package

1	mvn -f microservicio-http-punto final/pom.xml limpiar paquete

Upload Lambda Function to S3

SAM template reads the code from an S3 bucket. Let’s create a S3 bucket:

aws s3 mb s3://serverless-microservice --region us-west-2

1	aws s3 mb s3://serverless-microservice --region us-west-2

us-oeste-2 region is one of the supported regions for API Gateway. S3 bucket names are globally unique but their location is region specific. Upload
the code to S3 bucket:

aws s3 cp microservice-http-endpoint/target/microservice-http-endpoint-1.0-SNAPSHOT.jar s3://serverless-microservice/microservice-http-endpoint-1.0-SNAPSHOT.jar

1	aws s3 cp microservicio-http-punto final/objetivo/microservicio-http-punto final-1.0-SNAPSHOT.tarro s3://serverless-microservice/microservice-http-endpoint-1.0-SNAPSHOT.jar

The code is now uploaded to S3 bucket. SAM template is ready to be deployed!

Deploy SAM Template

Deploy the SAM template:

aws cloudformation deploy 
--template-file template.yml 
--stack-name microservice-gateway 
--region us-west-2

aws cloudformation despliegue

--plantilla-archivo plantilla.yml

--pila-nombre microservicio-pasarela

--región us-oeste-2

Muestra la salida:

Waiting for changeset to be created..
Waiting for stack create/update to complete
Successfully created/updated stack - microservice-gateway

En espera para changeset a sea creado..

En espera para pila crear/actualización a completa

Con éxito creado/actualizado pila - microservicio-pasarela

This one command deploys Lambda functions and REST Resource/APIs that trigger these Lambda functions.

Invoke the Microservice

API Gateway publishes a REST API that can be invoked by curl, wget, AWS CLI/Console, Postman or any other app that can call a REST API. This blog will use AWS Console to show the interaction. API Gateway home at us-west-2.console.aws.amazon.com/apigateway/home?region=us-west-2#/apis shows:

Click on the API to see all the APIs in this resource: