In this article, we’ll learn how to use Spring Cloud Function. Serverless function using spring cloud function.
A serverless function is a modern industry buzzword and the reason behind that is boost in cloud computing.
As part of this article, We’ll build and run a simple Spring Cloud Function locally and then deploy it to the AWS cloud platform.
Spring Cloud Function is a project with the following high-level goals as per spring cloud official website:
- Promote the implementation of business logic via functions.
- Decouple the development lifecycle of business logic from any specific runtime target so that the same code can run as a web endpoint, a stream processor, or a task.
- Support a uniform programming model across serverless providers, as well as the ability to run standalone (locally or in a PaaS).
- Enable Spring Boot features (auto-configuration, dependency injection, metrics) on serverless providers.
If you could able to understand the above things you will be able to relate things this with any serverless technology by any cloud provider. The reason behind serverless is concentrating on business logic, not on infra and any other things.
Features:
There are below number features spring cloud function provides.
- Choice of programming styles — reactive, imperative or hybrid.
- Function composition and adaptation (e.g., composing imperative functions with reactive).
- Support for reactive function with multiple inputs and outputs allowing merging, joining and other complex streaming operations to be handled by functions.
- Transparent type conversion of inputs and outputs.
- Packaging functions for deployments, specific to the target platform (e.g., Project Riff, AWS Lambda and more)
- Adapters to expose a function to the outside world as HTTP endpoints etc.
- Deploying a JAR file containing such an application context with an isolated classloader, so that you can pack them together in a single JVM.
- Compiling strings which are Java function bodies into bytecode, and then turning them into
@Beansthat can be wrapped as above. - Adapters for AWS Lambda, Microsoft Azure, Apache OpenWhisk and possibly other “serverless” service providers.
Let us deep dive and do some coding.
We will take one simple example
- Convert a String to lower case, using a String method
- And a HelloWorld greeting message using a dedicated class.
For this example, I am using Maven you can use Gradle as a build tool as well.
#add spring cloud function dependency
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-function-web</artifactId>
<version>1.0.1.RELEASE</version>
</dependency>First Spring Cloud Function:
We will expose @Bean of type function using spring cloud function. As part of this code, we are exposing toLowerCase functionality as a spring cloud function.
@SpringBootApplication
public class CloudFunctionApp {
public static void main(String[] args) {
SpringApplication.run(CloudFunctionApp.class, args);
}
@Bean
public Function<String, String> lowerCaseString() {
return value -> new StringBuilder(value).toString().toLowerCase().toString();
}
}Test this functionality in our local using curl command
curl localhost:8087/lowerCaseString -H "Content-Type: text/plain" -d "Spring cloud FUNCTION"
The endpoint is the name of the bean. here it is lowerCaseString.
Spring Cloud Function in Packages:
In the above we have exposed @Bean as method Apart from this, we could also write our software as classes that implement the functional interface Function<T, R>. We can specify the packages to scan for relevant beans in the application.properties file.
package com.techwasti.spring.cloudfunction.functions;
public class Hello implements Function<String, String> {
@Override
public String apply(String s) {
return "Hello " + s + ", and welcome to Server less world!!!";
}
}Also as mentioned above add below line in application.properties file
spring.cloud.function.scan.packages=com.techwasti.spring.cloudfunction.functions
We can also test this one in our local
curl localhost:8080/hello -H "Content-Type: text/plain" -d "Maheshwar"
The endpoint is the name of the class that implements the functional interface.
Spring Cloud Function on AWS:
The best thing about the spring ecosystem is seamless adoption and customization. The same applies to Spring Cloud Function, spring cloud function so powerful is that we can build Spring enabled functions that are cloud-agnostic. Spring cloud function provides abstraction API and adapter so that we can build function tests on local and deploy on any cloud provider such as AWS, Azure or Google Cloud platform without changing any of the business logic.
AWS is a popular one so for this exercise we choose AWS.
Remember we have used above spring cloud function maven dependency we need the same one for this as
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-function-web</artifactId>
<version>1.0.1.RELEASE</version>
</dependency>
##to handle AWS lambda we need below dependency
<dependency>
<groupId>com.amazonaws</groupId>
<artifactId>aws-lambda-java-events</artifactId>
<version>2.0.2</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>com.amazonaws</groupId>
<artifactId>aws-lambda-java-core</artifactId>
<version>1.1.0</version>
<scope>provided</scope>
</dependency>We are going to upload the artifact generated by the maven build to AWS Lambda, we need to build an artifact that is shaded, which means, it has all the dependencies burst out as individual class files instead of jars.
We are adding spring-boot-thin-layout dependency that helps us to reduce the size of the artifact by excluding some dependencies that are not needed.
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-deploy-plugin</artifactId>
<configuration>
<skip>true</skip>
</configuration>
</plugin>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<dependencies>
<dependency>
<groupId>org.springframework.boot.experimental</groupId>
<artifactId>spring-boot-thin-layout</artifactId>
<version>1.0.10.RELEASE</version>
</dependency>
</dependencies>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-shade-plugin</artifactId>
<configuration>
<createDependencyReducedPom>false</createDependencyReducedPom>
<shadedArtifactAttached>true</shadedArtifactAttached>
<shadedClassifierName>aws</shadedClassifierName>
</configuration>
</plugin>
</plugins>
</build>If we are shipping our spring cloud function such as lower case String converter to handle this over AWS we need Handler
public class MyHelloWorldHandlers extends SpringBootRequestHandler<String, String> {
}Spring Cloud Function AWS also ships with SpringBootStreamHandler and FunctionInvokingS3EventHandler as well.
This is just an empty class but it plays a very important role in both acting as an entry point and also defines the input and output types.
How Does AWS lambda Know Which Spring Cloud Function to Invoke?
In our example, if we have more than one spring cloud function How AWS know which one we have to invoke,
Even if we have more than one Spring Cloud Function in our application, AWS can invoke only one of them.
We have to specify the cloud function name in an environment variable called FUNCTION_NAME on the AWS console.
Upload function over AWS and Test:
Now we are ready to upload spring cloud function over AWS.
On the AWS Lambda console page, in the Function code section, we can select a Java 8runtime and simply click Upload. As I mentioned we need to specify handler as well i.e MyHelloWorldHandlers.
And then specify FUNCTION_NAME in environment variable as lowerCaseString.
it’s time for us to test the Lambda spring cloud function by creating a test event and supplying a sample string such as “Spring CLOUD function”, then save it and, then click the Test button. Similar way we can test the “hello” spring cloud function by changing the value of FUNCTION_NAME parameter.
Spring Cloud Function is a powerful tool for decoupling the business logic from any specific runtime environment.
References:
