e380ff2d

Deploying a Spring Cloud Function on AWS Lambda Platform using Serverless Framework

Tue, 31 Jan 2023 03:06:21 GMT

If Java Is Your Choice Of Programming Language – Spring Cloud Function + Serverless Framework Makes A Great Technology Stack. It Boosts Developer Productivity By Decoupling From Vendor Specific FaaS API, And Deployment Activities.

Quick introduction to Spring Cloud Function

Spring Cloud Function provides an uniform programming model to develop functions which can be run on any Function-as-a-Service platforms like AWS Lambda. The same code can run as a web endpoint, a stream processor, or a task. Also, enables Spring Boot features. More information is availabe at Spring Cloud Function .

Quick introduction to Serverless Framework

I found the definition of Serverless Framework @ Serverless Inc. is precisely explained.

Serverless is your toolkit for deploying and operating serverless architectures. Focus on your application, not your infrastructure.

Example project ( Source Code @ GitHub )

Use-case

This is a scenario in which when we provide a Member ID, the service should reply with the type of coverage that member has. In this fictional scenario it always returns a coverage type as MEDICAL for a given Member ID.

Function

@Bean

public Function<HealthFirstMemberRequest, HealthFirstMemberResponse> members() {

return member -> {

HealthFirstMemberResponse response = new HealthFirstMemberResponse();

response.setMemberId(member.getMemberId());

response.setCoverage(HealthFirstMemberResponse.Coverage.MEDICAL);

return response;

};

}

AWS Lambda Handler

A Handler class which just implements SpringBootRequestHandler is needed. This is what we are going to configure in serverless.yml file.

Maven POM file

The following dependencies in POM.xml file does all the magic of generating AWS specific Lambda code.

<groupId>org.springframework.cloud</groupId>

<artifactId>spring-cloud-function-adapter-aws</artifactId>

</dependency>

<groupId>com.amazonaws</groupId>

<artifactId>aws-lambda-java-core</artifactId>

<version>${aws-lambda-core.version}</version><scope>provided</scope>

</dependency>

Generating deployable Artifact

Run following command to generate deployable / uploadable .jar file.

$mvn clean package

This gnerates a JAR file ‘ member-function-0.0.1-SNAPSHOT-aws.jar ‘ under target folder. Serverless Framework uploads this JAR file to AWS Lambda.

Installing Serverless Framework

Run following command to install Serverless Framework from NPM

$npm install serverless -g

After installing you can run serverless or short form sis command to use Serverless Framework.

To check the command type

$serverless version

$sls version

Configuring serverless.yml file

We need to define serverless.yml file with all the settings needed.

service: sls-aws-java-spring-cloud-function-demo

provider:

name: aws

runtime: java8

timeout: 10

package:

artifact: target/aws-java-spring-cloud-function-demo-0.0.1-SNAPSHOT-aws.jar

functions:

members:

handler: com.healthfirst.memberfunction.AwsLambdaHandler

environment:

FUNCTION_NAME: members

Deploying on AWS Lambda Platform

Run following command to deploy the project on AWS Lambda

$sls deploy -v --aws-profile <your aws profile>

You would see something similar to this

Serverless: Packaging service...

Serverless: Creating Stack...

Serverless: Checking Stack create progress...

CloudFormation - CREATE_IN_PROGRESS - AWS::CloudFormation::Stack - sls-aws-java-spring-cloud-function-demo-dev

CloudFormation - CREATE_IN_PROGRESS - AWS::S3::Bucket - ServerlessDeploymentBucket

CloudFormation - CREATE_COMPLETE - AWS::S3::Bucket - ServerlessDeploymentBucket

CloudFormation - CREATE_COMPLETE - AWS::CloudFormation::Stack - sls-aws-java-spring-cloud-function-demo-dev

Serverless: Stack create finished...

Serverless: Uploading CloudFormation file to S3...

Serverless: Uploading artifacts...

Serverless: Uploading service .zip file to S3 (12.91 MB)...

Serverless: Validating template...

Serverless: Updating Stack...

Serverless: Checking Stack update progress...

CloudFormation - UPDATE_IN_PROGRESS - AWS::CloudFormation::Stack - sls-aws-java-spring-cloud-function-demo-dev

CloudFormation - CREATE_IN_PROGRESS - AWS::Logs::LogGroup - MembersLogGroup

CloudFormation - CREATE_IN_PROGRESS - AWS::IAM::Role - IamRoleLambdaExecution

CloudFormation - CREATE_IN_PROGRESS - AWS::Logs::LogGroup - MembersLogGroup

CloudFormation - CREATE_IN_PROGRESS - AWS::IAM::Role - IamRoleLambdaExecution

CloudFormation - CREATE_COMPLETE - AWS::Logs::LogGroup - MembersLogGroup

CloudFormation - CREATE_COMPLETE - AWS::IAM::Role - IamRoleLambdaExecution

CloudFormation - CREATE_IN_PROGRESS - AWS::Lambda::Function - MembersLambdaFunction

CloudFormation - CREATE_COMPLETE - AWS::Lambda::Function - MembersLambdaFunction

CloudFormation - CREATE_IN_PROGRESS - AWS::Lambda::Version - MembersLambdaVersionN8TC7eR31v5vRUjauJUxtjhrj6n1C123yUgLKetxebM

CloudFormation - CREATE_COMPLETE - AWS::Lambda::Version - MembersLambdaVersionN8TC7eR31v5vRUjauJUxtjhrj6n1C123yUgLKetxebM

CloudFormation - UPDATE_COMPLETE_CLEANUP_IN_PROGRESS - AWS::CloudFormation::Stack - sls-aws-java-spring-cloud-function-demo-dev

CloudFormation - UPDATE_COMPLETE - AWS::CloudFormation::Stack - sls-aws-java-spring-cloud-function-demo-dev

Serverless: Stack update finished...

Service Information

service: sls-aws-java-spring-cloud-function-demo

stage: dev

region: us-east-1

stack: sls-aws-java-spring-cloud-function-demo-dev

api keys:

None

endpoints:

None

functions:members: sls-aws-java-spring-cloud-function-demo-dev-members

Stack Outputs

MembersLambdaFunctionQualifiedArn: arn:aws:lambda:us-east-1:899022498951:function:sls-aws-java-spring-cloud-function-demo-dev-members:1

ServerlessDeploymentBucketName: sls-aws-java-spring-clou-serverlessdeploymentbuck-1qadcge7s5r27

Run following command to invoke the function

$ sls invoke -f members -l --aws-profile <your AWS profile name> --data '{"memberId":"1234567890"}'

This will invoke the function by passing the Member ID. You would see console output with response MEDICAL as below.

{

"memberId": "1234567890",

"coverage": "MEDICAL"

}

--------------------------------------------------------------------

START RequestId: ae39247a-7c6d-11e8-b022-eb1234c7df4f Version: $LATEST

13:58:36.347 [main] INFO org.springframework.cloud.function.adapter.aws.SpringFunctionInitializer - Initializing: class com.healthfirst.memberfunction.MemberFunctionApplication

. ____ _ __ _ _

/\\ / ___'_ __ _ _(_)_ __ __ _ \ \ \ \

( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \

\\/ ___) _) (_ ) ) ) )

' ____ .__|_ _|_ _\__, / / / /

=========|_|==============|___/=/_/_/_/

:: Spring Boot ::

2018-06-30 13:58:39.013 INFO 1 --- [ main] lambdainternal.LambdaRTEntry : Starting LambdaRTEntry on ip-10-22-39-231.ec2.internal with PID 1 (/var/runtime/lib/LambdaJavaRTEntry-1.0.jar started by sbx_user1060 in /)

2018-06-30 13:58:39.016 INFO 1 --- [ main] lambdainternal.LambdaRTEntry : No active profile set, falling back to default profiles: default

2018-06-30 13:58:39.297 INFO 1 --- [ main] s.c.a.AnnotationConfigApplicationContext : Refreshing org.springframework.context.annotation.AnnotationConfigApplicationContext@23fe1d71: startup date [Sat Jun 30 13:58:39 UTC 2018]; root of context hierarchy

2018-06-30 13:58:44.069 INFO 1 --- [ main] o.s.j.e.a.AnnotationMBeanExporter : Registering beans for JMX exposure on startup

2018-06-30 13:58:44.152 INFO 1 --- [ main] lambdainternal.LambdaRTEntry : Started LambdaRTEntry in 7.536 seconds (JVM running for 8.879)

END RequestId: ae39247a-7c6d-11e8-b022-eb1234c7df4f

REPORT RequestId: ae39247a-7c6d-11e8-b022-eb1234c7df4f Duration: 8002.57 ms Billed Duration: 8100 ms Memory Size: 1024 MB Max Memory Used: 142 MB

Run the following command to uninstall the project from AWS

$sls remove --aws-profile <your aws profile>

This one command will uninstall the stack on AWS cloud so that you may not be charged for any more usage.

Serverless: Getting all objects in S3 bucket...

Serverless: Removing objects in S3 bucket...

Serverless: Removing Stack...

Serverless: Checking Stack removal progress...

........

Serverless: Stack removal finished...

Summary

If Java is your choice of programming language – Spring Cloud Function + Serverless Framework makes a great technology stack. It boosts developer productivity by decoupling from Vendor specific FaaS API, and deployment activities.

TDD of Microservice-Nanoservice Combination with a Contract (In other words, SpringBoot-SpringFunction Combo with a Spring RestDocs-Contract)

Tue, 31 Jan 2023 02:56:41 GMT

This Article Attempts To Demonstrate How Powerful Is Test Driven Development & Consumer-Driven-Contract When There Is A Dependency On An Internal/External Service. If There Is A Mix Of Microservices And Nanoservices This Approach Really Boosts Developer Productivity To Produce Quality Testable Code.

What is this all about?

Most of the monolithic applications developed are modularized into layers (tiers) based on their purpose like Web (Client-side), Business logic (Server-side), database access (Database-side). Slicing the application vertically based on bounded contexts into independent micro-monoliths is like a microservices architectural style.

Spring Boot & Spring Cloud Frameworks made the Development of Microservice style applications easy.

PaaS (Platform-as-a-Service) offerings like Cloud Foundry made the Operations part of microservices easy with simple configurations and deployments.

Serverless programming (sometimes referred to as Nanoservices) is gaining popularity day by day. All major cloud vendors have Serverless computing platforms. Serverless computing sometimes also called FaaS (Function-as-a-Service).

If a project is a collection of Microserivces, chances are a few of those microservices fit right as Nanoservices or a remote Nanoservice (serverless) dependency may exist. And then that project can be a combination of Microservices-Nanoservices.

TDD (Test Driven Development) is essential to tackle the complexity and communication between services. Consumer-Driven-Contracts are handy and reduce the dependency on other services during development.

From a developers point of view what matters is the programming language, development Framework, and ease of testing and deployment.

In this blog post I am trying to address the Dev part of DevOps with a simple Microserivce-to-Nanoservice style project by taking advantage of Spring Cloud Framework.

What are all “good to know”?

Familiarity with following Spring Frameworks is good to know.

Spring Boot & MockMvc
Spring Cloud Function
Spring Cloud Contract
Spring RestDocs

I have provided links to various resources at the end of this blog post to get an understanding of these concepts.

Sample Application

Use case:

When you call a doctor’s office to schedule an appointment, they first verify your health insurance to make sure you have right coverage.

Design:

First we develop an appointment REST service at Doctor’s Office application. Then a members function at fictional Health Insurance company (HealthFirst) application to verify insurance coverage.

Typical workflow is

We call Doctor-Office’s appointment request REST service by supplying First name, Last name, and Health Insurance MemberID.
Appointment request REST service in-turn calls Health Insurance company’s Member-Function to get given member’s coverage level.

Doctor-Office (Hospital) [Consumer of the Contract]

Doctor-Office is an independent Spring boot service. We expose a REST service to request an appointment. This application consumes Health Insurance’s Member-Function Serverless application.

Member-Function (Health Insurance Company) [Producer of the Contract]

Member-Function is a Spring Cloud Function. It provides coverage level for a given member Id.

This is the producing service which produces the service contract to check its member’s coverage type.

- Full Source Code is here

Consumer-Driven-Contract initiated from Producer side

In a Consumer-Driven-Contract the contract starts from consumer side. Here Doctor-Office is the consuming application and Health Insurance companies Member-Function app is the producing application.

But, it makes more sense if Health Insurance company publishes its contract out to all associated hospitals.New Paragraph

In this sample application, lets generate a service contract at Health Insurance application. Then, publish that contract out so that any doctor’s office (Hospital) would know how to check health insurance coverage.

Nanoservice - Member-Function (Contract Producer)

After considering all the design aspects Health Insurance check application is better suited to be developed as a Nanoservice, aka a serverless application.

For following reasons this can be a serverless app

Its a simple check service.
Used by various associated hospitals via different communication channels (Web, Messaging, events)
Doesn’t need to be up and running all the time.
No need to gauge the load and traffic.

Setup

Lets implement Health Insurance company’s Member-Function app using Spring Cloud Function. We need following dependencies in our pom.xml to start with.

Serverless apps are invoked by events via various channels. Lets choose Web channel to keep it simple. We need spring-cloud-starter-function-web. This starter BOM provides Function implementation also exposes the function as a REST web serivce.

<dependency>

<groupId>org.springframework.cloud</groupId>

<artifactId>spring-cloud-starter-function-web</artifactId>

</dependency>

Then, we need RestDocs dependency for generating doc snippets.New Paragraph

<dependency>

<groupId>org.springframework.restdocs</groupId>

<artifactId>spring-restdocs-mockmvc</artifactId>

<scope>test</scope>

</dependency>

And, we need ASCII Doc dependency to generate html out of doc snippets.

<dependency>

<groupId>org.springframework.restdocs</groupId>

<artifactId>spring-restdocs-asciidoctor</artifactId>

</dependency>

To integrate Rest Docs with Cloud Contract we need following WireMock dependency.

<dependency>

<groupId>org.springframework.cloud</groupId>

<artifactId>spring-cloud-contract-wiremock</artifactId>

<scope>test</scope>

</dependency>

Spring-cloud-starter-contract-verifier BOM is needed if we are writing a DSL contract manually. We don’t need this here as we are not going to write DSL contract. Rest Docs auto generate the DSL contract for us.

Now, we need following plugin to assemble generated contract and stubs to publish out to consuming applications. To demonstrate, we install the stubs jar to local Maven repository.

<plugin>

<groupId>org.apache.maven.plugins</groupId>

<artifactId>maven-assembly-plugin</artifactId>

<configuration>

<attach>true</attach>

<descriptors>

<descriptor>${project.basedir}/src/assembly/stub.xml</descriptor>

</descriptors>

</configuration>

<executions>

<execution>

<id>stub</id>

<phase>prepare-package</phase>

<goals>

<goal>single</goal>

</goals>

<inherited>false</inherited>

</execution>

</executions>

</plugin>

and the stub.xml which defines the assembly rules. Please refer the codebase for the stub.xml file.

We don’t need spring-cloud-contract-maven-plugin as we are not going to generate test-case out of DSL contract. Because, we are going to auto generate DSL from a test-case.

TDD

Lets start with a failing test-case. We use MockMvc to call the function which I am going to describe in a bit.

So, we invoke the function by passing in a HealthFirstMember object. Member ID is mandatory field and other fields are optional.

After invoking the Mock service we check if the coverage is MEDICAL to pass the test-case.

@Test

public void provideCoverageForGivenMemberId() throws Exception {

HealthFirstMember member = new HealthFirstMember();

member.setMemberId("123456789");

member.setCoverage(HealthFirstMember.Coverage.NONE);

MvcResult result = mockMvc.perform(post("/members")

.contentType(MediaType.APPLICATION_JSON_UTF8)

.content(json.write(member).getJson())

).andReturn();

mockMvc.perform(asyncDispatch(result))

.andExpect(status().isOk())

.andExpect(jsonPath("coverage").value("MEDICAL"))

}

We will revisit the test-case when we are ready to generate contracts and docs.

Member Function

In order to pass the test-case we need to real implementation of a Function. Following code snippet shows how this is implemented using Spring Cloud Function.

public static void main(String[] args) {

SpringApplication.run(MemberFunctionApplication.class, args);

}

@Bean

public Function<HealthFirstMember, HealthFirstMember> members() {

return member -> {

member.setCoverage(HealthFirstMember.Coverage.MEDICAL);

return member;

};

}

Now, if you run the test-case it should pass.

Contract Generation

Now we have a passing test-case and implementation. We are ready to generate a contract and stubs out of it.

Lets re-visit the test-case to achieve this.

Lets add following annotation so Rest Docs can generate snippets.

@AutoConfigureRestDocs(outputDir = "target/snippets") Then, we can call WireMockRestDocs.verify() method to register and check request/response. Then call the .stub() to store reqeust/response stubs.

mockMvc.perform(asyncDispatch(result))

.andExpect(status().isOk())

.andExpect(jsonPath("coverage").value("MEDICAL"))

.andDo(WireMockRestDocs.verify().jsonPath("$.memberId")

.contentType(MediaType.APPLICATION_JSON_UTF8).stub("healthfirst-member-check")) Finally, we call SpringCloudContractRestDocs.dslContract() by passing it to MockMvcRestDocumentation.document() to generate the DSL contract.

After, all the above steps the completed test-case looks like this.

public void provideCoverageForGivenMemberId() throws Exception {

HealthFirstMember member = new HealthFirstMember();

member.setMemberId("123456789");

member.setCoverage(HealthFirstMember.Coverage.NONE);

MvcResult result = mockMvc.perform(post("/members")

.contentType(MediaType.APPLICATION_JSON_UTF8)

.content(json.write(member).getJson())

).andReturn();

mockMvc.perform(asyncDispatch(result))

.andExpect(status().isOk())

.andExpect(jsonPath("coverage").value("MEDICAL"))

.andDo(WireMockRestDocs.verify().jsonPath("$.memberId")

.contentType(MediaType.APPLICATION_JSON_UTF8).stub("healthfirst-member-check"))

.andDo(MockMvcRestDocumentation.document("healthfirst-member-check",

SpringCloudContractRestDocs.dslContract()));

} Now, run

$mvn clean install

and check the target folder. Generated snippets, docs, json stub, and dsl groovy contract should be available under snippets folder.New Paragraph

The stubs.jar is installed to local Maven repository. Which serves as the contract and shared with consuming application.New Paragraph

Microserivce - Doctor-Office - (Contract Consumer)

Lets implement this consuming application a simple Spring boot service with a simple REST service. This application calls our Nanoservice Member-Function above to check a member’s coverage.

As we are doing TDD and offline development we need code against to the shared contract.

Setup

We need following dependencies in our pom.xml to start with.

We are going to write a REST controller we need spring-boot-starter-web.

<dependency>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-web</artifactId>

</dependency>

To call the Health Insurance company’s Member-Function we can use either RestTemplate or Feign. Lets use Feign. So, we need Feign dependency for defining a Feign Client Interface

<dependency>

<groupId>org.springframework.cloud</groupId>

<artifactId>spring-cloud-starter-openfeign</artifactId>

</dependency>

Now, we need contract stub runner to run the stub shared by Health Insurance company.

<dependency>

<groupId>org.springframework.cloud</groupId>

<artifactId>spring-cloud-starter-contract-stub-runner</artifactId>

</dependency>

Finally, we need the Member-Function stub dependency listed as dependency. Following dependency gets the -stubs.jar which we installed to local maven repository before.

<dependency>

<groupId>com.healthfirst</groupId>

<artifactId>member-function</artifactId>

<classifier>stubs</classifier>

<version>0.0.1-SNAPSHOT</version>

<scope>test</scope>

<exclusions>

<exclusion>

<groupId>*</groupId>

<artifactId>*</artifactId>

</exclusion>

</exclusions>

</dependency>

TDD

Lets write a failing test-case for the REST controller. We use MockMvc to call the controller which I am going to describe in a bit.

So, we invoke the controller by passing in a Appointment object. We need Firstname, Lastname, and memberId.

After invoking the Mock service we check if the appointment is CONFIRMED to pass the test-case.

@Test

public void scheduleAppointmentWhenPatientHasCoverage() throws Exception {

Appointment appointment = new Appointment();

appointment.setFirstName("Madhu");

appointment.setLastName("Sambangi");

appointment.setMemberId("123456789");

appointment.setDateOfBirth("01/01/2018");

mockMvc.perform(post("/api/v1/appointments")

.contentType(MediaType.APPLICATION_JSON_UTF8)

.content(objectMapper.writeValueAsString(appointment))

.accept(MediaType.APPLICATION_JSON_UTF8))

.andDo(print()).andExpect(status().isOk())

.andExpect(jsonPath("status").value("CONFIRMED"));

}

We will revisit the test-case when we are ready to generate contracts and docs.

Appointments REST Service

We need the controller implemented to pass the test-case. Also, inject the HealthFirstService Feign client so that it can call Member-Function.

@RestController

@RequestMapping("api/v1")

public class PatientController {

private HealthFirstService healthFirstService;

public PatientController(HealthFirstService healthFirstService) {

this.healthFirstService = healthFirstService;

}

@PostMapping("/appointments")

public AppointmentResponse appointments(@RequestBody Appointment appointment) {

AppointmentResponse response = new AppointmentResponse();

HealthFirstMember member = new HealthFirstMember();

member.setMemberId(appointment.getMemberId());

member = healthFirstService.verifyCoverage(member);

if (member.getCoverage() == HealthFirstMember.Coverage.MEDICAL) {

response.setStatus(AppointmentResponse.AppointmentStatus.CONFIRMED);

}

return response;

}

`}`

Feign Client to call Member Function

And the Feigin client to call the Health Insurance’s Memebr-Function service.

@FeignClient(name = "HealthFirstService",

url = "http://localhost:8080", fallback = HealthFirstService.HealthFirstServiceFallback.class)

public interface HealthFirstService {

@RequestMapping(method = RequestMethod.POST, path = "/members")

@Headers("Accept:application/json;charset=UTF-8")

HealthFirstMember verifyCoverage(@RequestBody HealthFirstMember member);

@Component

class HealthFirstServiceFallback implements HealthFirstService {

@Override

public HealthFirstMember verifyCoverage(@RequestBody HealthFirstMember member) {

member.setCoverage(HealthFirstMember.Coverage.NONE);

return member;

}

} Now, if you run the test-case it still fails complaining ‘Connection Refused’ error. Because Feign client tries to call the Member-Function at http://localhost:8080. We haven’t configured the stub runner in the test case to mock the Member-Function using the contract yet.

Stubs from Member-Function Contract

Lets re-visit the test-case to configure the stub so that Feign client will work.

Lets add following annotation in Test class so the stub will run at localhost port 8080.

`@AutoConfigureStubRunner(ids = "com.healthfirst:member-function:+:stubs:8080", stubsMode = StubRunnerProperties.StubsMode.LOCAL)`

Appointments Test

Now the test case passes covering end-to-end testing.

Calling the appointment REST controller First

MockHttpServletRequest:

HTTP Method = POST

Request URI = /api/v1/appointments

Parameters = {}

Headers = {Content-Type=[application/json;charset=UTF-8], Accept=[application/json;charset=UTF-8]}

Body = {"firstName":"Madhu","lastName":"Sambangi","memberId":"123456789","dateOfBirth":"01/01/2018"}

Session Attrs = {}

Handler:

Type = com.hospital.doctoroffice.PatientController

Method = public com.hospital.doctoroffice.AppointmentResponse com.hospital.doctoroffice.PatientController.appointments(com.hospital.doctoroffice.Appointment)

Which calls the Feign client for member’s coverage.

127.0.0.1 - POST /members

User-Agent: [Java/1.8.0_131]

Connection: [keep-alive]

Host: [localhost:8080]

Accept: [*/*]

Content-Length: [40]

Content-Type: [application/json;charset=UTF-8]

{"memberId":"123456789","coverage":null}

Feign client calls the stubbed Health Insurance’s Member-Function and gets the member’s coverage as per the contract.

Matched response definition:

{

"status" : 200,

"body" : "{\"memberId\":\"123456789\",\"coverage\":\"MEDICAL\"}",

"headers" : {

"Content-Type" : "application/json;charset=UTF-8"

}

PatientController checks the coverage and returns CONFIRMED if the coverage is MEDICAL.

MockHttpServletResponse:

Status = 200

Error message = null

Headers = {Content-Type=[application/json;charset=UTF-8]}

Content type = application/json;charset=UTF-8

Body = {"status":"CONFIRMED"}

Forwarded URL = null

Redirected URL = null

Cookies = []

Finally, the test case passes if the appointment status is CONFIRMED. New Paragraph

Summary

This article attempts to demonstrate how powerful is Test Driven Development & Consumer-Driven-Contract when there is a dependency on an internal/external service. If there is a mix of microservices and nanoservices this approach really boosts developer productivity to produce quality testable code.

Please go over the Resources & References section below to learn more of the various pieces of the Spring Framework I used in the sample application, also to understand more about the keywords like microservices, nanoservices, and serverless.

Resources & References

- Microserivces & Nanoservices with Java

- Spring Cloud Contract with RestDocs

- Spring Cloud Function

- Serverless Architecture

Application Logging & Log Draining in Cloud Foundry

Tue, 31 Jan 2023 02:49:06 GMT

Introduction

The main goal of this blog post is to provide necessary information to get started on using Cloud Foundry Logging Component. A little introduction to concepts like Cloud-Native Apps, 12 Factor Apps is needed to understand System and Application logging on Cloud. Here is the breakdown of this blog post.

The purpose of aggregating logs from all running instances of an application on cloud.
How the aggregation of logs is handled on Open-Source PaaS - Cloud Foundry.
How easy it is to route the log streams to a specialized log management system - Papertrail.

Prerequisite

This article assumes you are familiar with

Cloud foundry
A brief understanding of Cloud Native Applications.
A high-level understanding of 12 Factor Apps concepts.

I have provided links to various resources at the end of this article to get an understanding of these concepts before you go on and read this blog post.

Why do we need to aggregate logs?

Cloud Native Apps

Applications designed and developed to take advantage of cloud features are supposed to be called cloud native apps. Following constraints makes cloud native applications difficult to troubleshoot.

Distributed applications like microservices hard to maintain, and debug.
Applications on cloud run on Virtual machines and(or) Containers which are ephemeral.
Container Instances are immutable.

Because of these constraints storing, analyzing application and system log information is difficult.

12 factor Apps

12 factor apps is like a benchmarking to make sure your application is built for cloud (like microservices) and following certain recommendations.

Among the 12 factors following four factors are pertinent to topic of this post.

Processes - 12 factor apps are supposed to be state-less so that scaling is easy.
Concurrency - For high availability multiple instances of an App are run and load is distributed across.
Disposability - To scale-out and scale-in, Apps should be quick to boot-up and easy to be disposable.
Logs - 12 factor apps recommends treating logs from all app instances as event streams, never store them inside containers or virtual machines.

Logs should be streamed out and stored somewhere else and should be aggregated not to loose them.

What component of Cloud Foundry handles logging?

Cloud Foundry Loggregator Component

A brief introduction to Cloud foundry

Cloud Foundry is an open-source Platform-As-A-Service (Paas) to run applications on any cloud. Instead of focusing on Cloud infrastructure CF abstracts all the operational activities and provides a platform to speedup application development and deployment. Various components of CF address certain factors of 12 factor operations. Loggregator component of CF takes care of aggregation of logs from all running instances of an application.

Following diagram explains various sub components within PCF Loggragator Component.

Loggregator

Cloud Foundry Loggregator component aggregates logs from all app instances for you. All the developer needed to do is direct the logs to standard OUT and standard ERROR.

Loggreator comprises of two sub-components

Doppler: Receives app syslogs from Metron agents. These can be further redirected to log drain systems like Papertrail or Loggly.
Traffic Controller: Collects both syslogs and metrics data. Syslogs can be pulled out from CFCLI command $cf logs. Or CF administrators can setup Nozzles to direct metrics data to third party APM (Application Performance Monitoring) tools like NewRelic.

How can we take advantage of CF Loggregator?

A quick lab using Pivotal Cloud Foundry and Papertrail Managed Log Management System.

> Push sample application onto PCF

To demonstrate log drain lets quickly build a sample Spring boot application. Please go to http://start.spring.io . Configure a sample Spring boot application with Web Starter dependency.

Here is the Sample Spring Boot Application for this lab. I just added a REST Controller which logs a log message appending the name it receives from the API call.

@SpringBootApplication

public class PcflogApplication {

public static void main(String[] args) {

SpringApplication.run(PcflogApplication.class, args);

}

@RestController

@RequestMapping("api/v1")

public class PcfLogDemo {

Logger logger = LoggerFactory.getLogger(PcfLogDemo.class);

@GetMapping("hello/{name}")

public ResponseEntity<String > sayHello(@PathVariable String name) {

logger.info(name + ": Your log statement");

return ResponseEntity.ok().body(name + ": Your Log statement.");

}

Please go ahead and build the application using Maven. After successful build the app should be available under target/{your app}.jar. Maven build log of the sample application.

[INFO] --- maven-jar-plugin:3.0.2:jar (default-jar) @ pcflog ---

[INFO] Building jar: /Users/msambangi/Downloads/pcflog/target/pcflog-0.0.1-SNAPSHOT.jar

[INFO]

[INFO] --- spring-boot-maven-plugin:2.0.0.RELEASE:repackage (default) @ pcflog ---

[INFO] ------------------------------------------------------------------------

[INFO] BUILD SUCCESS]

>Signup for free account on Pivotal Web services

Now our sample app is ready to be deployed on Pivotal Cloud Foundry. Please go ahead and create a free account @ Pivotal Web services.

After an account was setup on PWS. Please download and setup CFCLI on your machine. CFCLI provides access to PWS from command line tool. Here is how you need to login to PWS from your command line tool of choice.

~/Downloads/pcflog $ cf login

API endpoint: https://api.run.pivotal.io

Email> <email associated with PWS account>

Password>

Authenticating...

OK

Targeted org cloudmonkey

Targeted space development

API endpoint: https://api.run.pivotal.io (API version: 2.103.0)

User: <email associated with PWS>

Org: cloudmonkey

Space: development

~/Downloads/pcflog $

After successful login you would see similar information above with your org name, and space. My target SPACE is development under ORG cloudmonkey. You may setup your choice of ORG and SPACE when you signup.

Pushing app to PCF is very simple with one command cf push . Following screen print shows that my app push is successful.

~/Downloads/pcflog $ cf push pcf-log-demo -p ./target/pcflog-0.0.1-SNAPSHOT.jar

state since cpu memory disk details

#0 running 2018-03-08 04:17:00 PM 0.0% 43.8K of 1G 8K of 1G

Of course, you can always verify the app status on your PWS Console.

PWS Console

Its time to verify the app on PCF. PCF by default provides a route point to your application as {your-app-name}.cfapps.io. Please see the screen print below where my api call to my app by passing in my name.

I can see the output on screen “Madhu: Your log statement.”. Ok. The app is running and working as expected.

~/Downloads/pcflog $ http http://pcf-log-demo.cfapps.io/api/v1/hello/Madhu

HTTP/1.1 200 OK

Connection: keep-alive

Content-Length: 26

Content-Type: text/plain;charset=UTF-8

Date: Thu, 08 Mar 2018 21:22:06 GMT

X-Vcap-Request-Id: a08352e2-80ac-4239-5c8e-74179366a2ae

Madhu: Your Log statement.

~/Downloads/pcflog $

Now lets try to pull logs from the app using CFCLI. The command to do that is simple. $cf logs {your-app-name} . Here I can see the log statement from my app.

~/Downloads/pcflog $ cf logs pcf-log-demo

Retrieving logs for app pcf-log-demo in org cloudmonkey / space development as...

2018-03-09T12:10:15.26-0500 [RTR/5] OUT pcf-log-demo.cfapps.io - [2018-03-09T17:10:15.206+0000] "GET /api/v1/hello/Madhu HTTP/1.1" 200 0 26 "-" "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_3) AppleWebKit/604.5.6 (KHTML, like Gecko) Version/11.0.3 Safari/604.5.6" "10.10.2.227:2584" "10.10.148.72:61074" x_forwarded_for:"100.36.74.10, 10.10.2.227" x_forwarded_proto:"http" vcap_request_id:"4ef29682-cc19-429c-55c4-d7fa9431c618" response_time:0.053996806 app_id:"2295fb9c-176c-47ab-96e9-e736cfb91c51" app_index:"0" x_b3_traceid:"6d02249b20d1757c" x_b3_spanid:"6d02249b20d1757c" x_b3_parentspanid:"-"

2018-03-09T12:10:15.26-0500 [RTR/5] OUT

2018-03-09T12:10:15.37-0500 [RTR/3] OUT pcf-log-demo.cfapps.io - [2018-03-09T17:10:15.307+0000] "GET /favicon.ico HTTP/1.1" 200 0 946 " http://pcf-log-demo.cfapps.io/api/v1/hello/Madhu " "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_3) AppleWebKit/604.5.6 (KHTML, like Gecko) Version/11.0.3 Safari/604.5.6" "10.10.2.227:3791" "10.10.148.72:61074" x_forwarded_for:"100.36.74.10, 10.10.2.227" x_forwarded_proto:"http" vcap_request_id:"cdef7da2-57bd-404c-55b2-0d381bbf922c" response_time:0.063308529 app_id:"2295fb9c-176c-47ab-96e9-e736cfb91c51" app_index:"0" x_b3_traceid:"3ecb42e4d552b946" x_b3_spanid:"3ecb42e4d552b946" x_b3_parentspanid:"-"

2018-03-09T12:10:15.37-0500 [RTR/3] OUT

2018-03-09T12:10:15.24-0500 [APP/PROC/WEB/0] OUT 2018-03-09 17:10:15.247 INFO 13 --- [nio-8080-exec-1] c.e.pcflog.PcflogApplication$PcfLogDemo : Madhu: Your log statement

> Create a free account on Papertrail

Directing logs to a Cloud-hosted Log Management helps us further evaluate the logs. We get more tools to anaylyze, search, also setup notifications based on certain conditions. Here I am going to leverage Papertrail cloud-hosted Log Management system to direct logs from my app instance to my papertrail account.

Please go ahead and signup for a free account on Papertrail.

After you login to your Papertrail account, please go ahead and add a system to receive log messages.

> Setup Log Event listener system on papertrail

Copy the log URL provided by Papertrail. We need this URL to configure a Service Broker at PWS.

> Create a Service Broker

At PWS as a first step you need to create a service broker for your Papertrail account. Create a User-Provided-Service using $cf cups {service-name} -l {url from papertrail} command.

~/Downloads/pcflog $ cf cups papertrail-dump-demo -l syslog://logs.papertrailapp.com:<port provided by papertrail>

Creating user provided service papertrail-dump-demo in org cloudmonkey / space development as ...

OK

~/Downloads/pcflog $

> Connect Service Broker to sample application

After the service was created, we need to bind it to the app. CFCLI command $cf bs {app-name} {service-name} does the binding. After successful binding you would see a TIP to restage the app. Sometimes restaging is needed if the service which we are binding may need to configure agents inside the app container. In this example its not necessary.

~/Downloads/pcflog $ cf bs pcf-log-demo papertrail-dump-demo

Binding service papertrail-dump-demo to app pcf-log-demo in org cloudmonkey / space development as ...

OK

TIP: Use 'cf restage pcf-log-demo' to ensure your env variable changes take effect

~/Downloads/pcflog $

> View Logs on Papertrail Web Console

Now you need to invoke the sample application above one more time to generate a log message. After waiting a few seconds the app syslogs would start showing up on Papertrail web console.New Paragraph

That’s it. Its a very simple demonstration of distributed logging and log management. But, this is very powerful and elegant and makes a developer / operational person’s life easy to debug, troubleshoot a cloud hosted application.

Summary

As distributed systems are hard to debug and maintain, apps run inside immutable containers and virtual machines with ephemeral disks, we need a mechanism to aggregate logs from all running instances. CF Loggregator Component comes to the rescue. It collects logs from all the running instances and provides them as event streams. We can process the stream of logs in various ways like tail the logs using $cf logs {app-name} or divert them to sophisticated log management systems like Papertrail or Splunk. This addresses the logs factor of 12 Factor Apps .

Resources & References

- Cloud Native Apps

- 12 Factor Apps

- Cloud Foundry

- Loggregator documentation @Pivotal

- Pivotal Cloud Foundry Developer Course @Pluralsight

- Papertrail

Flutter- Bottom Navigation Bar- Navigation using Dart Streams & BLoC Pattern

Tue, 31 Jan 2023 02:43:01 GMT

Dart’s StreamController and Flutter’s StreamBuilder are powerful tools to achieve a better design and intra-app communication.

Prerequisites

Basic understanding of Flutter SDK and Scaffold Material Widget.
Dart Programming Language. (Basic idea of Streams).
BLoC Pattern — (Writing logic separate from UI in a Dart class and sharing it among Widgets).
Main focus is Scaffold Widget’s body and bottomNavigationBar sections.

“The Scaffold widget takes a number of different widgets as named arguments, each of which are placed in the Scaffold layout in the appropriate place.”

The most significant among those named arguments are

appBar: (The top section)
body: (Main body section)
bottomNavigationBar: (Bottom section)

Navigating between screens using Scaffold’s bottomNavigationBar can be achieved in many different ways. Most common way is

Hold the current BottomNavigationBarItem index value inside the State of a StatefulWidget every time a BottomNavigationBarItem was tapped,
and
Call that State’s setState() to repaint the whole widget tree to reflect those changes.

A slightly better approach can be using a combination of

BLoC — to separate business logic from UI
Dart’s StreamController — to communicate the UI intents.
Flutter’s StreamBuilder — to trigger UI updates.

Advantages

Using BLoC we can achieve clear separation of business logic from UI.
No need to store current BottomNavigationBarItem index inside the State.
No need to call setState() every time which re-creates the entire widget tree.
Use StreamBuilder to re-create only a sub-tree or widget(s) instead of entire widget tree.

So, how can it be achieved?

Two key things

Communication between the Scaffold’s bottomNavigationBar and body sections is done using Dart’s StreamController.
Use Flutter’s StreamBuilder to re-paint just the body section and the BottomNavigationBar.

First thing we need a BLoC

Let’s create a BLoC. This BLoC holds

an enum to represent various BottomNavigationBarItems.
a dart StreamController object.
a default Navigation Bar Item enum for initial state.
a function which can be attached to onTap() gesture of BottomNavigationBar on UI side.
a method to close the stream.

Lets go over each piece of BLoC in detail…

an enum to represent various BottomNavigationBarItems.

by listing out the Bottom NavBar Items as enum fields it’s easy to read the code and we can take advantage of enum indexes.

A Dart StreamController.

Note: By default, Dart StreamController’s Stream is not a broadcast type stream. We can create one by calling broadcast() as shown in the screen print.

We need a broadcast type stream because, both body and bottomNavigationBar sections of the Scaffold listen-on the same stream to switch view based on current NavBarItem tapped.

A default Navigation Bar Item enum for initial state

Now, we need to set a default NavBarItem to show the default screen and NavBarItem selected. Let’s just set HOME as default.

A function which can be attached to onTap() gesture on UI

This function holds the index tracking logic inside the BLoC separate from UI. This gets called out by onTap() when any BottomNavigationBarItem is tapped and receives the index of the tapped BottomNavigationBarItem.

Finally a handy method to close the stream (It’s a good practice to close the streams when not needed) New Paragraph

Because navBarController is a private field inside the BLoC we need a handy method to close the stream from outside of the BLoC.

Now, UI part of the app

A StatefulWidget A StatefulWidget/State combo is not necessarily needed because we are not going to depend on setState() method anyway. New Paragraph

But, closing the Dart Stream when not needed is a best practice. This can be achieved by calling BLoC’s close() method inside State’s dispose() lifecycle method. So, we need a StatefulWidget here.

A State New Paragraph

State’s lifecycle methods initState() creates the BLoC and dispose() closes the stream when not needed.

A StreamBuilder to switch the body section by listening to the NavBar item stream of the BLoC. New Paragraph

StreamBuilder in body section listens to BLoC’s stream and based on the NavBarItem enum in the current snapshot, it switches to corresponding view. Initial snapshot has the default NavBarItem (NavBarItem.HOME) and body will show homeArea().

Another StreamBuilder to update the BottomNavigationBar to highlight the BarItem selected and feed the stream with onTap() New Paragraph

This StreamBuilder listens to same stream but builds the BottomNavigationBar and highlights the BottomNavigationBarItem based on the NavBarItem enum in current snapshot of the stream. So, initial snapshot has default NavBarItem (HOME) and Home BarItem gets highlighted.

onTap: Calls the BLoC’s pickItem() function and supplies selected BarItem’s index value on tap. BLoC’s pickItem() feeds-in the stream with a NavBarItem enum based on the index it receives. This triggers the whole action.

In Action…

Full source code is here…

End Note

I am sure there are many different ways of doing it. But, the above approach is certainly one clean way to separate the logic from UI. Dart’s StreamController and Flutter’s StreamBuilder are powerful tools to achieve a better design and intra-app communication. I hope this article is useful.

e380ff2d

Deploying a Spring Cloud Function on AWS Lambda Platform using Serverless Framework

Quick introduction to Spring Cloud Function

Quick introduction to Serverless Framework

Example project ( Source Code @ GitHub )

Use-case

Function

AWS Lambda Handler

Maven POM file

Generating deployable Artifact

Installing Serverless Framework

Configuring serverless.yml file

Deploying on AWS Lambda Platform

Run following command to deploy the project on AWS Lambda

Run following command to invoke the function

Run the following command to uninstall the project from AWS

Summary

TDD of Microservice-Nanoservice Combination with a Contract (In other words, SpringBoot-SpringFunction Combo with a Spring RestDocs-Contract)

What is this all about?

What are all “good to know”?

Sample Application

Use case:

Design:

﻿ Doctor-Office (Hospital) [Consumer of the Contract]

Member-Function (Health Insurance Company) [Producer of the Contract]

- Full Source Code is here

﻿ Consumer-Driven-Contract initiated from Producer side

Nanoservice - Member-Function (Contract Producer)

Setup

TDD

﻿ Member Function

﻿ Contract Generation

Microserivce - Doctor-Office - (Contract Consumer)

Setup

TDD

Appointments REST Service

}

Feign Client to call Member Function

﻿ Stubs from Member-Function Contract

@AutoConfigureStubRunner(ids = "com.healthfirst:member-function:+:stubs:8080", stubsMode = StubRunnerProperties.StubsMode.LOCAL)

Appointments Test

Summary

﻿ Resources & References

- Microserivces & Nanoservices with Java

- Spring Cloud Contract with RestDocs

- Spring Cloud Function

Application Logging & Log Draining in Cloud Foundry

Introduction

Loggregator

How can we take advantage of CF Loggregator?

A quick lab using Pivotal Cloud Foundry and Papertrail Managed Log Management System.

> Push sample application onto PCF

>Signup for free account on Pivotal Web services

> Create a free account on Papertrail

> Setup Log Event listener system on papertrail

> Create a Service Broker

> Connect Service Broker to sample application

> View Logs on Papertrail Web Console

Summary

Resources & References

- Cloud Native Apps

- 12 Factor Apps

- Cloud Foundry

- Loggregator documentation @Pivotal

- Pivotal Cloud Foundry Developer Course @Pluralsight

- Papertrail

Flutter- Bottom Navigation Bar- Navigation using Dart Streams & BLoC Pattern

Prerequisites

Advantages

Two key things

First thing we need a BLoC

Now, UI part of the app

End Note

Doctor-Office (Hospital) [Consumer of the Contract]

Consumer-Driven-Contract initiated from Producer side

Member Function

Contract Generation

`}`

Stubs from Member-Function Contract

`@AutoConfigureStubRunner(ids = "com.healthfirst:member-function:+:stubs:8080", stubsMode = StubRunnerProperties.StubsMode.LOCAL)`

Resources & References