An application built using Serverless Architecture follows the event-driven approach. For example, an activity happened in the application such as a click. This is very different from a classical architecture where the application code is typically deployed in an application server such as Tomcat or WildFly. Scaling your application means starting additional instances of the application server or spinning up additional containers with the packaged application server. The Load Balancer need to be updated with the new IP addresses. Operating systems need to be patched, upgraded and maintained.<\/p>\n
![\"\"](\"https:\/\/martinfowler.com\/articles\/serverless\/ps.svg\")
<\/p>\n
Serverless Architectures<\/a> explain the difference between the classical programming model and this new serverless architecture. With a FaaS platform your application is divided into multiple functions. Each function is deployed in FaaS. The service spins up additional compute instances to meet the scalability demands of your application. FaaS platforms provides the execution environment and takes care of starting and tearing down\u00a0the containers to run your function.<\/p>\n Read Serverless Architectures<\/a> for more details about these images. One of the big advantages of FaaS is that you are only charged for the compute time, i.e. the time your code is running. There is no charge when your code is not running. How are Functions different from VMs and Containers? Note that Linux containers instead of Docker containers are used\u00a0as an implementation for AWS Lambda.<\/p>\n As quoted at Serverless Architectures<\/a>, a quick answer is provided by the following tweet:<\/p>\n If your PaaS can efficiently start instances in 20ms that run for half a second, then call it serverless. https:\/\/t.co\/S3YzvqFYLR<\/a><\/p>\n \u2014 adrian cockcroft (@adrianco) May 28, 2016<\/a><\/p><\/blockquote>\n In other words most PaaS applications are not geared towards bringing entire applications up and down for every request, whereas FaaS platforms do exactly this. Abstracting the Back-end with FaaS<\/a> explain the difference with different\u00a0*aaS offerings. The image from the blog is captured below: Serverless Architectures<\/a>\u00a0also provide great\u00a0details about what\u00a0FaaS is and is not. AWS Lambda<\/a>, Google Cloud Functions <\/a>and Azure Functions<\/a>\u00a0are some of the options for running serverless\u00a0applications. This blog will show how to\u00a0write your first AWS Lambda function.<\/p>\n AWS Lambda is a FaaS service from Amazon Web Services. It runs your code on a high-availability compute infrastructure and performs all of the administration of the compute resources, including server and operating system maintenance, capacity provisioning and automatic scaling, code monitoring and logging. AWS Lambda charges you for the duration your code runs in increments of 100ms. There is no cost associated with storing the Lambda function in AWS.<\/p>\n First million requests per month are free and the pricing after that is nominal. Read more details on Lambda pricing<\/a>.\u00a0It also provides visibility into performance by providing real time metrics and logs to AWS CloudWatch<\/a>. All you need to do is write the code! Here is a quick introduction:<\/p>\n Also check out What’s New in AWS Lambda from AWS ReInvent 2016<\/a>:<\/p>\n Also checkout Serverless Architectural Patterns and Best Practices from AWS ReInvent 2016:<\/p>\n The code you run on AWS Lambda is called a Lambda Function. You upload your code as a zip file or design it using the AWS Lambda Management Console<\/a>. There is a built-in support for AWS SDK and this simplifies the ability to call other AWS services. In short,\u00a0Lambda is scalable, serverless, compute in the cloud. AWS Lambda provides several\u00a0execution environments:<\/a><\/p>\n This blog will show how to:<\/p>\n The complete code in this blog is available at\u00a0github.com\/arun-gupta\/serverless\/tree\/master\/aws\/hellocouchbase<\/a>.<\/p>\n First, let’s look at a Java application that will be used for this Lambda function. Programming Model for Lambda Functions in Java<\/a> provide more details about how to\u00a0write your\u00a0Lambda function code in Java. Our Lambda function will implemented\u00a0the pre-defined interface This is once again using Couchbase Java API\u00a0CouchbaseCluster<\/a>\u00a0as a main entry point to the Couchbase cluster. The The bucket name is AWS FaaS needs a deployment package. This Lambda package is either a More details about Maven configuration are available in Creating a .jar Deployment Package Using Maven without any IDE<\/a>.\u00a0The maven-shade-plugin<\/a> allows you to create an uber-jar including all the dependencies. The The Create an AWS Lambda Function using AWS CLI<\/a>.\u00a0The CLI command in this case looks like:<\/p>\n In this CLI:<\/p>\n Lambda Console shows:<\/p>\n Test the AWS Lambda Function using AWS CLI.<\/p>\n It shows the output as:<\/p>\n The output from the command is stored in Invoking this function stores a\u00a0JSON\u00a0document in Couchbase. Documents stored in Couchbase can be seen using\u00a0the Couchbase Web Console<\/a>. The username is Note that the Clicking on each document shows more details about the JSON\u00a0document:<\/p>\n Lambda function can also be tested using the Console:<\/p>\n If the application logic changes then\u00a0a new deployment package needs to be uploaded for the Lambda function. In this case, Shows the result:<\/p>\n The function can then be invoked again. During the writing of this blog, this was often used to debug the function as well. This is because Lambda functions do not have any state or box associated with them. And so you cannot log in to a box to check out if the function did not deploy correctly. You can certainly use CloudWatch log statements once the function is working.<\/p>\n What is a Serverless Architecture? Serverless architecture runs\u00a0custom code in ephemeral containers\u00a0that are fully managed by a 3rd party. The custom code is typically a small part of a complete application. It is also called as\u00a0function. This gives another name […]<\/p>\n","protected":false},"author":58,"featured_media":13873,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"inline_featured_image":false,"footnotes":""},"categories":[1816],"tags":[],"ppma_author":[8933],"class_list":["post-2464","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-couchbase-server"],"acf":[],"yoast_head":"\n![\"\"](\"https:\/\/martinfowler.com\/articles\/serverless\/sps.svg\")
<\/a><\/p>\n
\n![\"\"](\"https:\/\/www.couchbase.com\/blog\/wp-content\/uploads\/2017\/01\/vm-containers-serverless.png\")
<\/p>\nHow is FaaS Different From PaaS?<\/h2>\n
\n
\n![\"faas\"](\"\/wp-content\/original-assets\/december-2016\/serverless-faas-with-aws-lambda-and-java\/faas.png\")
<\/a><\/p>\nWhat is AWS Lambda?<\/h2>\n
\n
\n
Java Application for AWS Lambda<\/h2>\n
com.amazonaws.services.lambda.runtime.RequestHandler<\/code>. The code looks like:<\/p>\npublic class HelloCouchbase implements RequestHandler<Request, String> {\r\n\r\n CouchbaseCluster cluster;\r\n Bucket bucket;\r\n LambdaLogger logger;\r\n\r\n @Override\r\n public String handleRequest(Request request, Context context) {\r\n SimpleDateFormat dateFormat = new SimpleDateFormat(\"yyyy-MM-dd HH:mm:ss.SSS\");\r\n String timestamp = dateFormat.format(Calendar.getInstance().getTime());\r\n\r\n logger = context.getLogger();\r\n logger.log(\"Request received: %s\" + timestamp);\r\n ButtonDocument buttonDocument = new ButtonDocument();\r\n buttonDocument.setId(context.getAwsRequestId());\r\n buttonDocument.setRequestId(context.getAwsRequestId());\r\n buttonDocument.setTimestamp(String.valueOf(timestamp));\r\n \r\n getBucket().upsert(buttonDocument.toJson());\r\n\r\n return buttonDocument.toString();\r\n }<\/pre>\nhandleRequest<\/code> method is where the function code is implemented. Context<\/a><\/code> provides useful information about the Lambda execution environment. Some of the information from the context is stored a JSON document.\u00a0Finally,\u00a0Couchbase Java SDK<\/a>\u00a0API upsert<\/code> is used to write a JSON document to the identified Couchbase instance.\u00a0Couchbase on Amazon EC2<\/a> provides complete instructions to install Couchbase on AWS EC2. Information about the Couchbase server is obtained as:<\/p>\npublic CouchbaseCluster getCluster() {\r\n if (null == cluster) {\r\n logger.log(\"env: \" + System.getenv(\"COUCHBASE_HOST\"));\r\n cluster = CouchbaseCluster.create(System.getenv(\"COUCHBASE_HOST\"));\r\n }\r\n return cluster;\r\n}<\/pre>\nCOUCHBASE_HOST<\/code> environment variable is passed when the Lambda function is created. In our case, this would point to\u00a0a\u00a0single node Couchbase cluster running on AWS EC2.\u00a0Environment variables were recently introduced<\/a> in AWS Lambda. Finally, you need to access this bucket in the server:<\/p>\npublic Bucket getBucket() {\r\n while (null == bucket) {\r\n logger.log(\"Trying to connect to the database\");\r\n bucket = getCluster().openBucket(\"serverless\", 2L, TimeUnit.MINUTES);\r\n\r\n try {\r\n Thread.sleep(3000);\r\n } catch (Exception e) {\r\n logger.log(\"Thread sleep Exception: \" + e.toString());\r\n throw new RuntimeException(e);\r\n }\r\n }\r\n\r\n return bucket;\r\n}<\/pre>\nserverless<\/code> and all JSON\u00a0documents are stored in this. A simple Hello World application<\/a> may be used for creating this function as well.<\/p>\nCreate AWS Lambda Deployment Package<\/h2>\n
.zip<\/code> or .jar<\/code> file that contains all the dependencies of the function. Our application is packaged using Maven, and so we’ll use a Maven plugin to create\u00a0a deployment package. The application has pom.xml<\/code> with the following plugin fragment:<\/p>\n org.apache.maven.plugins\r\n maven-shade-plugin\r\n 2.3\r\n \r\n false\r\n \r\n \r\n \r\n package\r\n \r\n shade\r\n \r\n \r\n \r\n<\/pre>\n
shade<\/code> goal is tied to the package<\/code> phase. So the mvn package<\/code> command will generate a single deployment jar. Package the application using the mvn package<\/code> command. This will\u00a0show the output:<\/p>\n[INFO] --- maven-jar-plugin:2.4:jar (default-jar) @ hellocouchbase ---\r\n[INFO] Building jar: \/Users\/arungupta\/workspaces\/serverless\/aws\/hellocouchbase\/hellocouchbase\/target\/hellocouchbase-1.0-SNAPSHOT.jar\r\n[INFO] \r\n[INFO] --- maven-shade-plugin:2.3:shade (default) @ hellocouchbase ---\r\n[INFO] Including com.amazonaws:aws-lambda-java-core:jar:1.1.0 in the shaded jar.\r\n[INFO] Including com.couchbase.client:java-client:jar:2.3.6 in the shaded jar.\r\n[INFO] Including com.couchbase.client:core-io:jar:1.3.6 in the shaded jar.\r\n[INFO] Including io.reactivex:rxjava:jar:1.1.8 in the shaded jar.\r\n[INFO] Replacing original artifact with shaded artifact.\r\n[INFO] Replacing \/Users\/arungupta\/workspaces\/serverless\/aws\/hellocouchbase\/hellocouchbase\/target\/hellocouchbase-1.0-SNAPSHOT.jar with \/Users\/arungupta\/workspaces\/serverless\/aws\/hellocouchbase\/hellocouchbase\/target\/hellocouchbase-1.0-SNAPSHOT-shaded.jar\r\n[INFO] ------------------------------------------------------------------------\r\n[INFO] BUILD SUCCESS\r\n[INFO] ------------------------------------------------------------------------<\/pre>\n
target\/hello-couchbase-1.0-SNAPSHOT.jar<\/code> is the shaded jar that will be deployed to AWS Lambda. More details about creating a\u00a0deployment\u00a0package are at Creating a Deployment Package<\/a>.<\/p>\nCreate AWS Lambda Function<\/h2>\n
aws lambda create-function \r\n--function-name HelloWorld \r\n--role arn:aws:iam:::role\/service-role\/myLambdaRole \r\n--zip-file fileb:\/\/\/Users\/arungupta\/workspaces\/serverless\/aws\/hellocouchbase\/hellocouchbase\/target\/hellocouchbase-1.0-SNAPSHOT.jar \r\n--handler org.sample.serverless.aws.couchbase.HelloCouchbaseLambda \r\n--description \"Hello Couchbase Lambda\" \r\n--runtime java8 \r\n--region us-west-2 \r\n--timeout 30 \r\n--memory-size 1024 \r\n--publish<\/pre>\n
\n
create-function<\/code> creates a Lambda function<\/li>\n--function-name<\/code> provides the function name. The function name is case sensitive.<\/li>\n--role<\/code> specifies Amazon Resource Name (ARN) of an IAM role<\/a> that Lambda assumes when it executes your function to access any other AWS resources. If you’ve executed a Lambda
\nfunction using AWS Console then this role is\u00a0created for you.<\/li>\n--zip-file<\/code> points to the deployment package that was created in the previous step. fileb<\/code>\u00a0is an AWS CLI specific protocol to indicate that the content uploaded is binary.<\/li>\n--handler<\/code>\u00a0is the Java class that is called to begin\u00a0execution of the function<\/li>\n--publish<\/code> request AWS Lambda to create the Lambda function and publish a version as an atomic operation. Otherwise multiple versions may be created and may be published at a later point.<\/li>\n<\/ul>\n![\"servleress-couchbase-lambda-function\"](\"\/wp-content\/original-assets\/december-2016\/serverless-faas-with-aws-lambda-and-java\/servleress-couchbase-lambda-function-1024x629.png\")
<\/a><\/p>\nTest AWS Lambda Function<\/h2>\n
aws lambda invoke \r\n--function-name HelloCouchbaseLambda \r\n--region us-west-2 \r\n--payload '' \r\nhellocouchbase.out<\/pre>\n
{\r\n \"StatusCode\": 200\r\n}<\/pre>\nhellocouchbase.out<\/code> and looks like:<\/p>\n\"{\"id\":\"e6bbe71a-ca4f-11e6-95a7-95f2ed410493\",\"installationId\":null,\"requestId\":\"e6bbe71a-ca4f-11e6-95a7-95f2ed410493\",\"identityId\":null,\"timestamp\":\"2016-12-25 03:12:01.157\"}\"<\/pre>\nAdministrator<\/code> and the password is the EC2 instance id. All data buckets in this Couchbase instance are shown below:<\/p>\n![\"serverless-couchbase-bucket-overview\"](\"\/wp-content\/original-assets\/december-2016\/serverless-faas-with-aws-lambda-and-java\/serverless-couchbase-bucket-overview-1024x321.png\")
<\/a><\/p>\nserverless<\/code> bucket is\u00a0manually created. Clicking on Documents shows details of\u00a0different documents stored in the bucket:<\/p>\n![\"serverless-couchbase-bucket-documents\"](\"\/wp-content\/original-assets\/december-2016\/serverless-faas-with-aws-lambda-and-java\/serverless-couchbase-bucket-documents-1024x500.png\")
<\/a><\/p>\n![\"serverless-couchbase-bucket-document\"](\"\/wp-content\/original-assets\/december-2016\/serverless-faas-with-aws-lambda-and-java\/serverless-couchbase-bucket-document-1024x608.png\")
<\/a><\/p>\n![\"serverless-couchbase-console-test\"](\"\/wp-content\/original-assets\/december-2016\/serverless-faas-with-aws-lambda-and-java\/serverless-couchbase-console-test-1024x427.png\")
<\/a><\/p>\nUpdate AWS Lambda Function<\/h2>\n
mvn package<\/code> will create a deployment package and aws lambda<\/code> CLI command is used to update the function code:<\/p>\naws lambda update-function-code \r\n--function-name HelloCouchbaseLambda \r\n--zip-file fileb:\/\/\/Users\/arungupta\/workspaces\/serverless\/aws\/hellocouchbase\/hellocouchbase\/target\/hellocouchbase-1.0-SNAPSHOT.jar \r\n--region us-west-2 \r\n--publish<\/pre>\n
{\r\n \"CodeSha256\": \"w510ejw\/OoVsQt2JiLG2bPZPAaFvQCRrYYYlQWctCQE=\", \r\n \"FunctionName\": \"HelloCouchbaseLambda\", \r\n \"CodeSize\": 6978108, \r\n \"MemorySize\": 1024, \r\n \"FunctionArn\": \"arn:aws:lambda:us-west-2::function:HelloCouchbaseLambda:8\", \r\n \"Environment\": {\r\n \"Variables\": {\r\n \"COUCHBASE_HOST\": \"ec2-35-165-249-235.us-west-2.compute.amazonaws.com\"\r\n }\r\n }, \r\n \"Version\": \"8\", \r\n \"Role\": \"arn:aws:iam:::role\/service-role\/myLambdaRole\", \r\n \"Timeout\": 30, \r\n \"LastModified\": \"2016-12-25T04:17:38.717+0000\", \r\n \"Handler\": \"org.sample.serverless.aws.couchbase.HelloCouchbaseLambda\", \r\n \"Runtime\": \"java8\", \r\n \"Description\": \"Java Hello Couchbase\"\r\n}<\/pre>\nAWS Lambda References<\/h2>\n
\n