Exercise 2: The Java implementation

Note: This exercise is structured in understanding and hands-on tasks.
Step 1: Understand
1 Usage of Maven for Java
We begin with the Maven part for our Java project.
Maven Apache Maven is a software project management and comprehension tool. Based on the concept of a project object model (POM), Maven can manage a project's build, reporting and documentation from a central piece of information.
In the pom file we define the configuration of our Java project with dependencies, build, and properties including the compiler information as you can see in the pom file below.
1
<project xmlns="http://maven.apache.org/POM/4.0.0"
2
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
3
 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
4
 <modelVersion>4.0.0</modelVersion>
5
 <groupId>com.ibm.cloud</groupId>
6
 <artifactId>authors</artifactId>
7
 <version>1.0-SNAPSHOT</version>
8
 <packaging>war</packaging>
9
​
10
 <dependencies>
11
  <dependency>
12
   <groupId>org.eclipse.microprofile</groupId>
13
   <artifactId>microprofile</artifactId>
14
   <version>3.0</version>
15
   <scope>provided</scope>
16
   <type>pom</type>
17
  </dependency>
18
 </dependencies>
19
​
20
 <build>
21
  <finalName>authors</finalName>
22
 </build>
23
​
24
 <properties>
25
  <maven.compiler.source>1.8</maven.compiler.source>
26
  <maven.compiler.target>1.8</maven.compiler.target>
27
  <failOnMissingWebXml>false</failOnMissingWebXml>
28
  <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
29
 </properties>
30
</project>
Copied!
REMEMBER: We use this pom file to build our Authors service with RUN mvn -f /usr/src/app/pom.xml clean package inside our Build environment container.
1
FROM maven:3.5-jdk-8 as BUILD
2
​
3
COPY src /usr/src/app/src
4
COPY pom.xml /usr/src/app
5
RUN mvn -f /usr/src/app/pom.xml clean package
Copied!
2 Configuration of the Open Liberty Server
Our Authors Microservice will run on an OpenLiberty Server in a container on Kubernetes.
We need to configure the OpenLiberty server with a server.xml file. For our Java implementation we decided to use MicroProfile and within the feature definition in the server.xml we provide this information to our server with the entry microProfile-3. The server must be reached in the network. Therefore we define the httpEndpoint including httpPort we use for our microservice. For configuration details take a look into the openliberty documentation.
IMPORTANT: We should remember that this port (httpPort="3000") must be exposed in the Dockerfile for our container and mapped inside the Kubernetes deployment configuration.
Also the name of the executable web application is definied in the server.xml.
1
<?xml version="1.0" encoding="UTF-8"?>
2
<server description="OpenLiberty Server">
3
​
4
    <featureManager>
5
        <feature>microProfile-3</feature>
6
    </featureManager>
7
​
8
    <httpEndpoint id="defaultHttpEndpoint" host="*" httpPort="3000" httpsPort="9443"/>
9
​
10
    <webApplication location="authors.war" contextRoot="api"/>
11
​
12
</server>
Copied!
Note: Later we will change the contextRoot.
3 Implementation of the REST GET endpoint with MicroProfile
3.1 MicroProfile basics
Some definitions:
Microservice architecture is a popular approach for building cloud-native applications in which each capability is developed as an independent service. It enables small, autonomous teams to develop, deploy, and scale their respective services independently.
Eclipse MicroProfile is a modular set of technologies designed so that you can write cloud-native Java™ Microservices. MicroProfile utilizes some of existing tools (JAX-RS, CDI, JSON-P for example), and combine them with new ones to create a baseline platform optimized for a Microservice architecture.
In the following image you see a list of MicroProfile specifications, we will use the red marked ones.
microprofiles
3.2 Java classes needed to expose the Authors service
For the Authors service to expose the REST API we need to implement three classes:
​AuthorsApplication class repesents our web application.
​Author class repesents the data structure we use for the Author.
​GetAuthor class repesents the REST API.
classdiagram
3.2.1 Class AuthorsApplication
Our web application does not implement any business or other logic, it simply needs to run on a server with no UI. The AuthorsApplication class extends the javax.ws.rs.core.Application class to do this.
The AuthorsApplication class provides access to the classes from the com.ibm.authors package at runtime. The implementation of the interface class Application enables the usage of easy REST implementation provided by MircoProfile.
With @ApplicationPath from MicroProfile we define the base path of the application.
1
package com.ibm.authors;
2
​
3
// JAX-RS from Microprofile specification
4
import javax.ws.rs.core.Application;
5
import javax.ws.rs.ApplicationPath;
6
​
7
// JAX-RS from Microprofile specification
8
@ApplicationPath("v1")
9
public class AuthorsApplication extends Application {
10
}
Copied!
Note: Later we will change the ApplicationPath in this class.
3.2.2 Class Author
This class simply repesents the data structure we use for the Author. No MircoProfile feature is used here.
1
package com.ibm.authors;
2
​
3
public class Author {
4
public String name;
5
public String twitter;
6
public String blog;
7
}
Copied!
3.2.3 Class GetAuthor
This class implements the REST API response for our Authors Microservice. We implement the REST endpoint using the MicroProfile REST Client. We use @Path and @Get statements from JAX-RS for the REST endpoint and for the OpenAPI documentation we use @OpenAPIDefinition statements. When you add MicroProfile with OpenAPI, OpenAPI always creates automatically an OpenAPI explorer for you.
REMEMBER: In the server.xml configuration we added MicroProfile to the Open Liberty server as a feature, as you see in the code below.
1
<featureManager>
2
        <feature>microProfile-3</feature>
3
        ....
4
</featureManager>
Copied!
With the combination of the server.xml and our usage of MicroProfile features in the GetAuthor class we will be able to access an OpenAPI explorer with this URL http://host:http_port/openapi later.
This is the source code of the GetAuthors class with the mentioned MicroProfile features:
1
// JAX-RS from Microprofile specification
2
@ApplicationScoped
3
@Path("/getauthor")
4
// OpenAPI from Microprofile specification
5
@OpenAPIDefinition(info = @Info(title = "Authors Service", version = "1.0", description = "Authors Service APIs", contact = @Contact(url = "https://github.com/nheidloff/cloud-native-starter", name = "Niklas Heidloff"), license = @License(name = "License", url = "https://github.com/nheidloff/cloud-native-starter/blob/master/LICENSE")))
6
public class GetAuthor {
7
 // JAX-RS from Microprofile specification
8
 @GET
9
 // OpenAPI from Microprofile specification
10
 @APIResponses(value = {
11
  @APIResponse(
12
       responseCode = "404",
13
       description = "Author Not Found"
14
     ),
15
     @APIResponse(
16
       responseCode = "200",
17
       description = "Author with requested name",
18
       content = @Content(
19
         mediaType = "application/json",
20
         schema = @Schema(implementation = Author.class)
21
       )
22
     ),
23
     @APIResponse(
24
       responseCode = "500",
25
       description = "Internal service error"
26
     )
27
 })
28
 @Operation(
29
      summary = "Get specific author",
30
      description = "Get specific author"
31
 )
32
 public Response getAuthor(@Parameter(
33
            description = "The unique name of the author",
34
            required = true,
35
            example = "Niklas Heidloff",
36
            schema = @Schema(type = SchemaType.STRING))
37
   @QueryParam("name") String name) {
38
​
39
   Author author = new Author();
40
   author.name = "Niklas Heidloff";
41
   author.twitter = "https://twitter.com/nheidloff";
42
   author.blog = "http://heidloff.net";
43
​
44
   return Response.ok(this.createJson(author)).build();
45
 }
46
​
47
 private JsonObject createJson(Author author) {
48
  JsonObject output = Json.createObjectBuilder().add("name", author.name).add("twitter", author.twitter)
49
    .add("blog", author.blog).build();
50
  return output;
51
 }
52
}
Copied!
Note: Later we will change the return values for the response in the local source code.
3.3 Supporting live and readiness probes in Kubernetes with HealthCheck
We have added the class HealthEndpoint to the Authors package as you see in the following diagram.
classdiagram
We want to support this Kubernetes function:
Kubernetes provides liveness and readiness probes that are used to check the health of your containers. These probes can check certain files in your containers, check a TCP socket, or make HTTP requests. MicroProfile Health exposes readiness and liveness endpoints on your Microservices. Kubernetes polls these endpoints as specified by the probes to react appropriately to any change in the Microservice’s status.
For more information check the Kubernetes Microprofile Health documentation and the documentation on GitHub.
This is the implementation of the Health Check for Kubernetes in the HealthEndpoint class of the Authors service:
1
@Readiness
2
public class HealthEndpoint implements HealthCheck {
3
​
4
    @Override
5
    public HealthCheckResponse call() {
6
        return HealthCheckResponse.named("authors").withData("authors", "ok").up().build();
7
    }
8
}
Copied!
Note: Later we will change return information of the HealthCheckResponse.
This HealthEndpoint is configured in the Kubernetes deployment yaml. In the following yaml extract we see the livenessProbe definition.
1
    livenessProbe:
2
      exec:
3
        command: ["sh", "-c", "curl -s http://localhost:3000/"]
4
      initialDelaySeconds: 20
5
    readinessProbe:
6
      exec:
7
        command: ["sh", "-c", "curl -s http://localhost:3000/health | grep -q authors"]
8
      initialDelaySeconds: 40
Copied!
Step 2: Hands-on tasks
Change the code of the authors Microservice and run the service in a container locally
Note: That lab does only need Docker and a terminal session on your local machine.
Step 1: Open a terminal session on you local machine
1
cd $ROOT_FOLDER/authors-java-jee
2
docker build -t authors .
3
docker run -i --rm -p 3000:3000 authors
Copied!
Step 2: Update server.xml
Change the contextRoot in server.xml to something similar like "myapi"
Open the file cloud-native-starter/authors-java-jee/liberty/server.xml in a editor and change the value.
1
<?xml version="1.0" encoding="UTF-8"?>
2
<server description="OpenLiberty Server">
3
​
4
    <featureManager>
5
        <feature>microProfile-3</feature>
6
    </featureManager>
7
​
8
    <httpEndpoint id="defaultHttpEndpoint" host="*" httpPort="3000" httpsPort="9443"/>
9
​
10
    <webApplication location="authors.war" contextRoot="myapi"/>
11
​
12
</server>
Copied!
Step 3: Update AuthorsApplication.java
Change the @ApplicationPath in the class AuthorsApplication.java something similar like "myv1"
Open the file cloud-native-starter/authors-java-jee/src/main/java/com/ibm/authors/AuthorsApplication.java in a editor and change the value.
1
package com.ibm.authors;
2
​
3
import javax.ws.rs.core.Application;
4
import javax.ws.rs.ApplicationPath;
5
​
6
@ApplicationPath("myv1")
7
public class AuthorsApplication extends Application {
8
}
Copied!
Step 4: Update GetAuthor.java
In the class GetAuthor.java change the returned author name to something similar like "MY NAME"
Open the file cloud-native-starter/authors-java-jee/src/main/java/com/ibm/authors/GetAuthor.java in a editor and change the value.
1
public Response getAuthor(@Parameter(
2
            description = "The unique name of the author",
3
            required = true,
4
            example = "MY NAME",
5
            schema = @Schema(type = SchemaType.STRING))
6
   @QueryParam("name") String name) {
7
​
8
   Author author = new Author();
9
   author.name = "MY NAME";
10
   author.twitter = "https://twitter.com/MY NAME";
11
   author.blog = "http://MY NAME.net";
12
​
13
   return Response.ok(this.createJson(author)).build();
14
 }
Copied!
Step 5: Update HealthEndpoint.java
In the class HealthEndpoint.java change the returned information to something similar like "ok for the workshop"
1
@Health
2
@ApplicationScoped
3
public class HealthEndpoint implements HealthCheck {
4
​
5
    @Override
6
    public HealthCheckResponse call() {
7
        return HealthCheckResponse.named("authors").withData("authors", "ok for the workshop").up().build();
8
    }
9
}
Copied!
Step 6: To test and see how the code works you can run the code locally as a Docker container
1
cd $ROOT_FOLDER/authors-java-jee
2
docker build -t authors .
3
docker run -i --rm -p 3000:3000 authors
Copied!
Step 7: Open the swagger UI of the mircoservice in a browser and verfiy the changes
1
http://localhost:3000/openapi/ui/
Copied!
changed-authors-open-api
Step 8: Open the health check of the mircoservice in a browser and verfiy the changes
1
http://localhost:3000/health
Copied!
changed-authors-healthcheck
​
Congratulations you have finished exercise 2.