Monoliths to Microservices with Jave EE and Spring Boot
- 1. MONOLITHS TO MICROSERVICES: APP TRANSFORMATION Hands-on Technical Workshop Ram Maddali Senior Architect @RamMaddali rmaddali@redhat.com Anand Akella Senior Architect aakella@redhat.com
- 2. PART 3: MONOLITHS TO MICROSERVICES WITH JAVA EE AND SPRING BOOT
- 3. MONOLITHS TO MICROSERVICES: APP TRANSFORMATION HANDS-ON LAB3 WHY MONOLITH TO MICROSERVICES Break things down (organizations, teams, IT systems, etc) down into smaller pieces for greater parallelization and autonomy and focus on reducing time to value.
- 4. MONOLITHS TO MICROSERVICES: APP TRANSFORMATION HANDS-ON LAB http://martinfowler.com/bliki/MonolithFirst.html Monolith First? http://martinfowler.com/bliki/MonolithFirst.html
- 5. MONOLITHS TO MICROSERVICES: APP TRANSFORMATION HANDS-ON LAB66 THE BIGGER PICTURE: THE PATH TO CLOUD- NATIVE APPS A DIGITAL DARWINISM SELF-SERVICE ON-DEMAND INFRA RE-ORG TO DEVOPS AUTOMATION CONTINUOUS DELIVERY ADVANCED DEPLOYMENT TECHNIQUES MICROSERVICES FAST MONOLITH
- 6. MONOLITHS TO MICROSERVICES: APP TRANSFORMATION HANDS-ON LAB7 ● In this lab, you will begin to ‘strangle’ the coolstore monolith by implementing its services as external microservices, split along business boundaries ● Once implemented, traffic destined to the original monolith’s services will be redirected (via OpenShift software-defined routing) to the new services STRANGLING THE MONOLITH Node.js Web WildFly Swarm Inventory Vert.x Cart Runtime Service Runtime Service Vert.x Orders Spring Boot Catalog JBoss EAP HTML Javascript Web CartCatalogInventory Promo Ratings Orders Data Access
- 7. MONOLITHS TO MICROSERVICES: APP TRANSFORMATION HANDS-ON LAB8 STRANGLING THE MONOLITH ● Strangling - incrementally replacing functionality in app with something better (cheaper, faster, easier to maintain). ● As functionality is replaced, “dead” parts of monolith can be removed/retired. ● You can also wait for all functionality to be replaced before retiring anything! ● You can optionally include new functionality during strangulation to make it more attractive to business stakeholders. Time
- 8. MONOLITHS TO MICROSERVICES: APP TRANSFORMATION HANDS-ON LAB
- 9. MONOLITHS TO MICROSERVICES: APP TRANSFORMATION HANDS-ON LAB RHOAR PRODUCT ARCHITECTURE RHOAR RUNTIMES (Container images, Maven Artifacts, Serverless) MICROPROFIL E / JAVA EE OPENSHIFT SERVICES REACTIVE (vert.x) JAVASCRIPT SERVLET APPS OpenShift.io (Developer SaaS) Generators IDE etc. Management APM Metrics Service Discovery Config. Logging Health Check Load Balancing CI/CDSSOMessaging IMDG API Mgmt OPENWHISK SERVICE MESH Istio Pilot Istio Mixer Istio Auth Envoy Proxy Envoy Proxy Envoy Proxy Envoy Proxy Service Catalog == Future
- 10. MONOLITHS TO MICROSERVICES: APP TRANSFORMATION HANDS-ON LAB TOMCAT SIMPLICITY JAVASCRIPT FLEXIBILITY SERVLET APPS REACTIVE SYSTEMS JAVA MICROSERVICES ENTERPRISE JAVA
- 11. SPRING
- 12. MONOLITHS TO MICROSERVICES: APP TRANSFORMATION HANDS-ON LAB • Microservices for Developers using Spring Framework • An opinionated approach to building Spring applications • Historical alternative to Java EE • Getting started experience • Spring MVC / DI / Boot most popular
- 13. MONOLITHS TO MICROSERVICES: APP TRANSFORMATION HANDS-ON LAB Spring in RHOAR • It’s the same Spring you know and love • Tested and Verified by Red Hat QE – Spring Boot, Spring Cloud Kubernetes, Ribbon, Hystrix • Red Hat components fully supported – Tomcat, Hibernate, CXF, SSO (Keycloak), Messaging (AMQ), … • Native Kubernetes/OpenShift integration (Spring Cloud) • Service Discovery via k8s (DNS), Ribbon • Spring Config via ConfigMap • Developer Tooling (launch.openshift.io, starters) • Additional planned support for – Transactions (Naryana), Messaging (Rabbit MQ -> AMQ), more
- 14. ● Health Checks (actuator) ● Externalized Config (spring-cloud-kubernetes) ● Client-side discovery / load balancing (Eureka/Kubernetes) ● Circuit Breaking / Bulkheading (Hystrix) ● Logging / Monitoring / Tracing / Metrics ● Secure deployments with Keycloak ● API Documentation (Swagger) Cloud Native Support in Spring
- 15. WILDFLY SWARM
- 16. My Svc Java EE microservices ● Leverage Java EE expertise ● Open standard ● Microservices focus ● Optimized for OpenShift ● Super lightweight ● Tooling for Developers ● MicroProfile Implementation My Svc JAX- RS $ java -jar my_microservice.jar
- 17. ● A tangible unit providing a specific piece of functionality ● Embodied in a maven artifact ● To support the compositional aspect in WF Swarm ● Provides the “runtime” capabilities ● Means to add API dependencies (e.g. JAX-RS) ● Means to configure the system ○ With reasonable defaults ● Means to discover other components (topology) ● Means to alter deployments (e.g. keycloak) ● Can be auto-detected or explicitly declared WildFly Swarm “pieces” - Fractions
- 18. ● Health Checks ● Externalized Config ● Client-side discovery / load balancing ● Circuit Breaking / Bulkheading ● Logging / Monitoring / Tracing / Metrics ● Secure deployments with Keycloak ● MicroProfile ● API Documentation Cloud Native Support in WildFly Swarm
- 19. Build microsevices ● Embeddable (Fat Jar) ● Lightweight ● Modular & extensible ● Built from WildFly (Trusted and Reliable) Supported Specifications Java EE 7 Web Profile MicroProfile 1.0 Tested and Verified Hystrix Ribbon MySQL Oracle DB Metrics Additional Supported Fractions Health Configuration Topology Monitor Keycloak Upstream (Unsupported) Flyway Logstash Fluentd Swagger JMS Vert.x Integration Consul Spring Jolokia Infinispan jGroups WildFly Swarm and RHOAR
- 20. ●Defines open source Java microservices specifications ● Industry Collaboration - Red Hat, IBM, Payara, Tomitribe, London Java Community, SouJava, Oracle, Hazelcast, Fujitsu, SmartBear... ●WildFly Swarm is Red Hat’s implementation ● Minimum footprint for Enterprise Java cloud-native services (v1.3) : JSON-P 1.0 Health Check 1.0 CDI 1.2 JAX-RS 2.0 JWT Propagation 1.0 Fault Tolerance 1.0 Metrics 1.0 Config 1.1 OpenTracing 1.0 OpenAPI 1.0 RestClient 1.0 New in 1.3:
- 21. LAB: MONOLITHS TO MICROSERVICES WITH JAVA EE AND SPRING BOOT
- 22. GOAL FOR LAB In this lab you will learn: ● How Red Hat OpenShift and Red Hat OpenShift Application Runtimes (RHOAR) help jumpstart app modernization ● Benefits and challenges of microservices ● How to transform existing monolithic applications to microservices using strangler pattern and 12-factor app patterns. ● Use modern app dev frameworks like WildFly Swarm and Spring Boot to implement microservice applications on OpenShift
- 23. CURRENT STATE - THE MONOLITH OpenShift coolstore-dev Coolstore monolith Coolstore database (dev) Coolstore Binary coolstore-prod Coolstore monolith Coolstore database (prod) Pipeline Promotion Debugger mvn package
- 24. LAB: MONOLITHS TO MICROSERVICES WITH JAVA EE AND SPRING BOOT SCENARIO 4 TRANSFORMING AN EXISTING MONOLITH (PART 1) SCENARIO 5 TRANSFORMING AN EXISTING MONOLITH (PART 2) +
- 26. RESULT OF LAB In this lab you learned how to: ● Implement a Java EE microservice using WildFly Swarm ● Implement a Java EE microservice using Spring Boot ● Develop container-based testing ● Add microservice concerns like Health checks, externalized configuration and circuit breaking ● Use the strangler pattern to slowly migrate functionality from monolith to microservices
Editor's Notes
- #18: Next up is WildFly Swarm which is targeted at Java-based microservices applications, but as you may have guessed from the name it also brings in a number of Java EE components from the WildFly ecosystem. This means that if you’re a Java EE developer you can continue to re-use your knowledge as you start to migrate existing applications to benefit from microservices. We say that WildFly Swarm brings just enough of the app server you used in the past to build lightweight and efficiently-packaged java applications, which contain only the bits you need to run as an executable JAR file, or uber-jar, on a container platform like OpenShift. For example, the diagram above shows a small microservice needing only support for RESTful communication using the JAX-RS standard from the Java EE world, so with WildFly Swarm you can build a WildFly Swarm uber-jar containing your service’s business logic along with only that JAX-RS component, and run it using java -jar. So you get a minimal execution footprint and minimal attack surface for those security-minded developers out there. Microservice apps generally need only a small subset of functionality as compared to a traditional monolithic enterprise app, and so last year several vendors including Red Hat collaborated to produce a new specification that that defines such a subset...
- #19: Fractions support explicit and implicit configuration In many cases you won’t need to configure anything Or configuration can be externalized Fractions can be detected or explicitly declared The most simple case is a <war> project, with just the maven plugin All of Java EE is supported in upstream WildFly Swarm JPA, JAX-RS, EJB, JMS, CDI, … Successfully ran Java EE 7 samples [blog] Successfully ran JBoss EAP 7 Quickstarts [blog]
- #22: Companies love standardization, as it gives them choice of implementation AND essentially free QA resources as the spec is developed and used across the industry through different implementations. The Microprofile spec is geared toward Java microservices applications, and there are a number of implementations available today. WildFly Swarm is Red Hat’s implementation of this spec, and as you can see includes some functions from the Java EE world like JAX-RS and CDI, but also includes typical functions you’d find in a microservice like health checks, fault tolerance for building resilient apps, externalized configuration support and support for securing microservices through JWT token propogation. If you want to learn more or get involved in the evolution of tis spec, visit microprofile.io.