This workshop demonstrates the use of MicroProfile, Docker, Kubernetes and Istio technologies for implementing, deploy and update a set of cloud-native microservices. The workshop has be structured as four modules:
- Module 1 covers the foundational technologies for producing and consuming REST services
- Module 2 covers the technologies essential for developing and deploying microservices at scale where the microservices are the responsibility of autonomous teams.
- Module 3 covers the observability operational needs of microservice deployments at scale, such as tracing request and understanding microservice health.
- Module 4 covers the deployment, scaling and updating of microserivces at scale, through Kubernetes and Istio.
Each workshop module consists of a number of Open Liberty Guides each of which demonstrates a key cloud-native microservice technology. Each Guide is designed to be taken independently so if you just want to learn about a specific technology you can just take that guide. If, however, you're goal is to learn about all the technologies, then working through them in the order shown below is recommended.
- Cloud-native Java Workshop
- Introduction
- Module 1: REST Foundation
- Module 2: Scalable Microservice Development
- Module 3: Microservice Observability
- Module 4: Microservice Deployment and Update
To save time during the workshop, it's best to set up your machine beforehand. The instructions below show the pre-requisites to install and how to avoid lengthy downloads.
To use these guides you need the following pre-requisites:
- A Java 8 JDK (e.g. https://adoptopenjdk.net/?variant=openjdk8&jvmVariant=openj9)
- Apache Maven 3.5.4 or later (https://maven.apache.org/). Older versions may not work.
- A git client
- An editor with Java support (e.g. Eclipse, VS Code, IntelliJ)
- Docker & Kubernetes:
- Download latest stable Istio release (not a Pre-release): https://github.com/istio/istio/releases
If you will be taking the workshop at a location with limited network bandwidth, it is recommended you do the following beforehand in order to populate your local .m2 repo and Docker cache.
git clone https://github.com/gcharters/workshop-cloud-native-java.git
cd workshop-cloud-native-java
mvn install
docker build -t prime:mym2 .
Cloud-native is an approach to application development and deployment. It's the product of a number of industry movements over the past 10-15 years - agile development practices, DevOps, Microservices and Cloud. Cloud-native applications are developed using agile practices, use continuous integration/continuous delivery to streamline deployment, are architected around team-aligned microservices, and leverage the cloud for rapid deployment at scale.
When choosing which technologies to use for cloud-native microservices, the combination of open source and open standards can be very important. The combination enables a low cost (free) of entry and at the same time avoids being locked in to a single vendor implementation.
Eclipse MicroProfile is a set of industry specifications for developing and deploying cloud-native Java Microservices. The specifications address the important challenges of cloud-native microservices, such as toleration of service failures, security, service metrics and health, and more. Open Liberty is an open source, lightweight, composable Java server that implements the MicroProfile specifications.
Kubernetes is an Open Source platform for deployment, scaling and managing containers and services. It uses a declarative yaml-based approach to describe deployments, for example, the containers to be deployed, their scaling requirements, the services they provide, and so on.
Istio is an Open Source service mesh technology for the management of distributed microservices. It enables securing, connecting and monitoring of microservice deployments. Because Istio sits between the microservices in the mesh, it is able to route traffic (e.g. for blue-green deployments), handle faults (e.g. retry requests) and automatically secure service communications.
This workshop demonstrates how to address cloud-native microservice requirements using the combination of MicroProfile, Docker, Kubernetes and Istio technologies. The workshop guides can be taken independently, or in the order they are introduced, below.
If you have feedback on a specific guide, we'd appreciated a github issue or pull request against that guide, and similarly if you have feedback on this workshop document, please raise an issue or submit a pull request.
Learn how to create a REST service with JAX-RS, JSON-P, and Open Liberty that will expose the JVM’s system properties.
The Guide: https://openliberty.io/guides/rest-intro.html
If you have feedback or find problems, please raise an issue here: https://github.com/OpenLiberty/guide-rest-intro
Learn how to use Contexts and Dependency Injection to manage and inject dependencies into RESTful web services.
The Guide: https://openliberty.io/guides/cdi-intro.html
If you have feedback or find problems, please raise an issue here: https://github.com/OpenLiberty/guide-cdi-intro
Learn how to use MicroProfile Rest Client to invoke RESTful microservices over HTTP in a type-safe way.
The Guide: https://openliberty.io/guides/microprofile-rest-client.html
If you have feedback or find problems, please raise an issue here: https://github.com/openliberty/guide-microprofile-rest-client
Learn how to inject external static and dynamic configuration to microservices using MicroProfile Config.
The Guide: https://openliberty.io/guides/microprofile-config.html
If you have feedback or find problems, please raise an issue here: https://github.com/OpenLiberty/guide-microprofile-config
Learn how to use the MicroProfile Fault Tolerance specification to enable applications to function even when one of the microservices is unavailable.
The Guide: https://openliberty.io/guides/microprofile-fallback.html
If you have feedback or find problems, please raise an issue here: https://github.com/OpenLiberty/guide-microprofile-fallback
You’ll explore how to control user and role access to microservices with MicroProfile JSON Web Token (MicroProfile JWT).
The Guide: https://openliberty.io/guides/microprofile-jwt.html
If you have feedback or find problems, please raise an issue here: https://github.com/OpenLiberty/guide-microprofile-jwt
Explore how to document and filter RESTful APIs from code or static files by using MicroProfile OpenAPI.
The Guide: https://openliberty.io/guides/microprofile-openapi.html
If you have feedback or find problems, please raise an issue here: https://github.com/OpenLiberty/guide-microprofile-openapi
Learn how to provide system and application metrics from a microservice using MicroProfile Metrics.
The Guide: https://openliberty.io/guides/microprofile-metrics.html
If you have feedback or find problems, please raise an issue here: https://github.com/OpenLiberty/guide-microprofile-metrics
Learn how to provide and check the health of a microservice using MicroProfile Health.
The Guide: https://openliberty.io/guides/microprofile-health.html
If you have feedback or find problems, please raise an issue here: https://github.com/OpenLiberty/guide-microprofile-health
Explore how to enable and customize tracing of JAX-RS and non-JAX-RS methods by using MicroProfile OpenTracing.
The Guide: https://openliberty.io/guides/microprofile-opentracing.html
If you have feedback or find problems, please raise an issue here: https://github.com/OpenLiberty/guide-microprofile-opentracing
Deploy microservices in Open Liberty Docker containers to Kubernetes and manage them with the Kubernetes CLI, kubectl.
https://openliberty.io/guides/kubernetes-intro.html
If you have feedback or find problems, please raise an issue here: https://github.com/OpenLiberty/guide-kubernetes-intro
Explore how to externalize configuration using MicroProfile Config and configure your microservices using Kubernetes ConfigMaps and Secrets.
https://openliberty.io/guides/kubernetes-microprofile-config.html
If you have feedback or find problems, please raise an issue here: https://github.com/OpenLiberty/guide-kubernetes-microprofile-config
Learn how to check the health of microservices on Kubernetes by setting up readiness probes to inspect MicroProfile Health Check endpoints.
https://openliberty.io/guides/kubernetes-microprofile-health.html
If you have feedback or find problems, please raise an issue here: https://github.com/OpenLiberty/guide-kubernetes-microprofile-health
Explore how to manage microservice traffic using Istio.
https://openliberty.io/guides/istio-intro.html
If you have feedback or find problems, please raise an issue here: https://github.com/OpenLiberty/guide-istio-intro