The document discusses deploying Java microservices applications to Kubernetes. It covers running a sample Spring Boot app in Docker containers, then deploying it and its MongoDB dependency to a local Kubernetes cluster using Minishift. It also discusses using the Fabric8 Maven plugin to simplify building Docker images and generating Kubernetes manifests from a Maven project. Helm is introduced as a way to package full applications and dependencies for Kubernetes.

1. BASEL BERN BRUGG DÜSSELDORF FRANKFURT A.M. FREIBURG I.BR. GENEVA
HAMBURG COPENHAGEN LAUSANNE MUNICH STUTTGART VIENNA ZURICH
Microservices in Java
Anwendungsentwicklung mit K8S/Openshift
Anatole Tresch, Principal Consultant
@atsticks

2. About me...
Open Source Enthusiast
JCP Expert Group Member
Apache PPMC Member
Consultant, Trainer, Software Architect
Oracle Star Spec Lead
Contact: anatole.tresch@trivadis.com
Blog: http://maketechsimple.wordpress.com
Slideshare: http://www.slideshare.net/anatoletresch
Twitter: @atsticks

3. Agenda
• Microservices
• Run in Docker
• Deploying into Kubernetes
• Fabric8
• DevOps and Advanced Topics

4. Microservices

5. Microservices
• Single Concerns Principle based on bounded contexts
• Independently deployable
• Isolated
• Clear, minimal API, typically REST
• Development Platforms in Java:
• Java EE
• Microprofile
• OSGI
• Vertx
• Akka
• Dropwizard
• …

6. Microservices - Build
Build Tools:
• Maven
• Gradle
Created Artifacts:
• jar, war, ear, rar etc.
• Java EE server RT configuration
Our Focus:
• Maven
• Single Jar Deployment

7. Example Application
https://github.com/atsticks/openshift-workshop/tree/master/spring-boot-CRUD-admin-step1
• Spring Boot Application
• Bootstrap/AngularJS UI
• REST API
• MongoDB Backend
• Standard Maven Build

8. Starting the Application
1. start a mongodb at @localhost, e.g.
docker run --name mongo -p 27017:27017 -d mongo mongod
2. run mvn clean package spring-boot:run
3. Point your browser at http://localhost:8090/index.html

9. Run our app as a Docker Container

10. Run the App as a Docker Container
 See: https://github.com/atsticks/openshift-workshop/tree/master/spring-boot-CRUD-admin-step2
 No changes in your Java Project or Maven
 Write a Dockerfile
 Use Docker to build a local Docker image
 Start DB and APP in Docker

11. Run the app as a Docker container
Add Dockerfile to application project dir:
Build and run the db and the app as containers:
docker run --name mongo -p 27017:27017 -d mongo mongod
mvn clean package
docker build -t step2 .
docker run -p 8090:8090 --link mongo:mongo -it --name myapp

12. Challenges
• We have to learn to write Docker files
• Testing the application requires manual action (starting Mongo-DB)
• DB and APP must be linked explicitly.
• Deployment is a separate and manual process
• Separate for the Java App and the Mongo DB
• Different for different stages.

13. But what we really want is…
• A deployment and packaging technique
• A stable and reliable runtime that
• Supports monitoring and restart components
• Provides easy service location
• Provides automatic fail-over
Container Orchestration
+
Unified Deployment

14. Possible Container Orchestration Targets today
• Amazon ECS
• Azure Container Service (ACS)
• Cloud Foundry’s Diego
• CoreOS Fleet
• Docker Swarm
• Google Container Engine
• Kubernetes / Openshift
• Mesosphere Marathon
• Cloud Native Computing Foundation (CNCF) recently selected Google’s
Kubernetes container orchestration tool as its first containerization technology.
• Docker also will support Kubernetes OOTB.

15. Deploy our app into Kubernetes

16. Deploying into Kubernetes
• Kubernetes requires container images for
• The mongo DB (available in Dockerhub)
• The app container (available in a private Docker registry)
• For each of them we require
• A deployment defining
• The container image to use
• The Number of replicas
• Volume mounts
• Environment and Config
• A service making a deployment accessible

17. Deploying into Kubernetes
Deployment Descriptors
Service Descriptors
Configuration Descriptor

18. Still there is one thing missing…

19. We need a (local)
Kubernetes/Openshift
Cluster
Still there is one pice missing…

20. Local Kubernetes/Openshift
• Minishift (https://github.com/minishift/minishift )
minishift start --cpus 2 --memory 6000 --vm-driver=virtualbox
$ minishift start
Starting local OpenShift cluster using 'kvm' hypervisor...
...
OpenShift server started.
The server is accessible via web console at:
https://192.168.99.100:8443
You are logged in as:
User: developer
Password: developer
To login as administrator:
oc login -u system:admin

22. Manually deploying into Kubernetes
1. Setup Openshift/Kubernetes/Docker environment
2. Create mongodb service : oc create -f kube/mongoservice.yml
3. Start mongodb deployment: oc create -f kube/mongodeployment.yml
4. Deploy config map : oc create -f kube/configmap.yml
5. Create app service: oc create -f kube/service.yml
6. Build the project: mvn clean package
7. Build the docker image: docker build -t step3 .
8. Tag the built docker image: docker tag step3 $(minishift openshift
registry)/myproject/step3
9. Push the built image: docker push $(minishift openshift
registry)/myproject/step3
10. Create app deployment: oc create -f kube/deployment.yml
11. get $NODEPORT : oc export svc step3 | grep nodePort
12. Verify service: http://$(minishift ip):$NODEPORT/index.html

23. Cool, that was
easy…!

25. Fabric8
• Integrated Development Platform for Kubernetes
• Targeting the creation of cloud native applications and microservices
• Build, test and deploy
• Continuous Delivery pipelines
• Run and manage
• Continuous Improvement and ChatOps

26. The parts of Fabric8
• Developer Console: web app to create, edit, build, deploy and test Microservices
• Continuous Integration and Continous Delivery: Jenkins Workflows
• Application Management:
• Logging and Metrics, ChatOps and Chaos Monkey
• Integration of Hawtio and Jolokia
• Integration Platform As A Service:
• Visualisation of your Apache Camel integration services
• API Registry
• Messaging As A Service (ActiveMQ)
• Java Tools helps the Java community take full advantage of Kubernetes:
• Maven Plugin
• Junit Kubernetes Support based on Arquillian
• Java Libraries and support for working with Kubernetes

27. The Fabric8
Maven Plugin

28. The Fabric8 Maven Plugin
 Brings Java apps on to K8S and Openshift.
 Leverages existing maven config.
 Builds Docker images and K8S/Openshift manifests.
 Supports different levels of customization
 Integrates also the Fabric8 Docker Plugin
<plugin>
<groupId>io.fabric8</groupId>
<artifactId>fabric8-maven-plugin</artifactId>
<version>${latest.version}</version>
</plugin>

29. The Fabric8 Maven Plugin Goals
Build Goals
 fabric8:build
 fabric8:resource
 fabric8:apply
 fabric8:resource-apply
 fabric8:push
 fabric8:helm
 fabric8:distro
 fabric8:app-catalog
 Development goals
 fabric8:run
 fabric8:deploy
 fabric8:undeploy
 fabric8:start
 fabric8:stop
 fabric8:log
 fabric8:debug
 fabric8:watch

30. The Fabric8 Maven Plugin Configuration Options
• Zero-Config (using defaults)
• Maven XML configuration (image, deployment)
• External Kubernetes/Openshift resource fragments
• External Dockerfiles

31. F8MP: Zero-Config Example
1) Setting up dependencies and plugins.
2) Enables a simple embedded Tomcat.
3) Responsible for packaging the application.
4) Generation of a Docker image and
Kubernetes / OpenShift descriptors.
To build the Docker image:
mvn package fabric8:build
To deploy to a cluster:
mvn fabric8:resource fabric8:deploy

32. See https://maven.fabric8.io/#generator-spring-boot
F8MP: Zero-Config Example
What happened:
 As base image fabric8/java-jboss-openjdk8-jdk is chosen
 enables Jolokia, jmx_exporter.
 sophisticated startup script.
 Creates resource objects:
 Kubernetes Deployment
 Kubernetes Service
 Exports port
 8080 as the application service port
 8778 for Jolokia
 9779 for jmx_exporter access

33. F8MP: XML Configuration Example
• Docker
• <images> define the Docker images to build
→ Similar for Fabric8 Docker Plugin, except <run> and <external> (ignored)
• <resource> define the resource descriptors for OpenShift or Kuberneres.
• <generator> configures generators.
• <enricher> configured enrichers.
<configuration>…</configuration>

34. F8MP: XML Configuration Example
1) Standard docker-maven-plugin
configuration for building one
single Docker image

35. F8MP: XML Configuration Example
2) Kubernetes / OpenShift
resources to create
3) Labels applied globally to all
resource objects
1) Deployment Definition
2) Container to include in the
deployment
3) Container alias to correlate
image with the image definition
in the <images> section. Can
be omitted if only a single
image is used
4) Volume definitions used in the
ReplicaSet
5) One or more Service
definitions.

36. F8MP: Configuration with external resources
 External resource descriptors (YAML/JSON)
 in the src/main/fabric8 and
src/main/docker
 Each resource gets ist own file, which
contains some skeleton of a resource
description.
 The plugin will pick up the resource, enriches
it and then combines all to a single
kubernetes.yml and openshift.yml.
 Allows free use of any Kubernetes feature.
 Supports resource filtering.
src/main/fabric8/deployment.xml:

37. Run the App with the Fabric8 Plugin
 See: https://github.com/atsticks/openshift-workshop/tree/master/spring-boot-CRUD-admin-step5
 Mongo DB deployment has been added to the kube folder
 Start DB and APP in Kubernetes/Openshift:
1. oc login -u developer -p developer
2. mvn clean install fabric8:deploy
3. Evaluate the $ROUTE-URL: minishift openshift service list -n myproject
4. Open $ROUTE-URL/index.html in your browser

38. Packaging
38

39. More Details:
https://docs.openshift.com/enterprise/3.0/architecture/core_concepts/builds_and_image_streams.html
https://github.com/openshift/source-to-image
Openshift: Source to Image (S2I)
Source
Build
S2I build image Image Stream
Deployment
Pod
Container
Replication Controller
All customizable with Jenkins pipelines!

40. Helm
• https://helm.sh = Package Manager for Kubernetes
• The latest version of Helm is maintained by the CNCF - in collaboration
with Microsoft, Google, Bitnami and the Helm contributor community.
• With Helm you can
• Package your complete apps into Helm Charts
• Manage Charts in a repository
• Install Charts on CLI or with the helm UI (monocular)
• Update and Rollback installations
• Audit your installations
40

41. Kubernetes Templates
 https://docs.openshift.org/latest/dev_guide/templates.html
 Templates can contain any number of Kubernetes Descriptors
 Descriptors can be parametrized
 Templates can be used with the CLI as well
as the Web Console

42. Recap

43. Recap
 Moving from Java to Kubernetes/Openshift is easy!
 Fabric 8 allows to gradually move along your available skills.
 Minishift/Minikube provide an easy to use/setup local environment.
 S2I/Templates gives you powerful DevOps Support.
 Helm provides a package format applications including dependencies.

44. Topics not covered
 How to modernize your monoliths.
 How to establish a DevOps culture.
 How to test microservice based applications.
 Operating microservice based applications:
 Tracing, Monitoring, Log Collection, Alerting
 Application and Service Security.
 Data Persistence options in a microservice based architecture.
 Legacy Integration, Hybrid Clouds, Scaling, Data Security etc.

45. Microservices in Java
@atsticks maketechsimple.wordpress.com
anatole.tresch@trivadis.com
Anatole Tresch
Principal Consultant