Cloudify your applications: microservices and beyond

Cloudify your applications:
microservices and beyond
Intro
Vittorio Colabella

TYPICAL CUSTOMER LANDSCAPE TODAY
Where the journey starts...
RUN
Brownfield
TRANSFORM
Greenfield
GROW
VIRTUALPHYSICAL
PRIVATE & PUBLIC
CLOUD
Complex &
heterogeneous
Lack of
common
standards
Inconsistent
automation
& governance

Without
adding more
complexity and
inconsistencies?
TYPICAL CUSTOMER LANDSCAPE TODAY
Where the journey starts...
MODERNIZE
EXISTING APPS
DEVELOP NEW APPLICATIONS
THE MODERN WAY

APPLICATION PORTFOLIO MODERNIZATION
One platform to support you today and tomorrow
TRANSFORM
Greenfield
GROWRUN
Modernized brownfield
COMMON HYBRID APPLICATION INFRASTRUCTURE
BETTER
SOFTWARE
ARCHITECTURE
AGILE
INTEGRATION
STREAMLINE
APPLICATION
LIFECYCLE
CONTINUOUS
INNOVATION
MODERN APPLICATION CONCEPTS

APPLICATION SERVICES
FOUNDATION INTEGRATION AUTOMATION
IT’S ALL THERE!
COMPLETE TECHNOLOGY STACK FOR HYBRID CLOUD
INFRASTRUCTURE SOFTWARE
CONTAINER PLATFORM
SECURITY &
MANAGEMENT
DEVELOPER
TOOLS
OTHER CLOUD
PROVIDERS
+
PHYSICAL VIRTUAL PRIVATE CLOUD

Ready to use capabilities to facilitate innovation
Data
Virtualization
Complex
Event
Processing
Intelligent
Process
Integration Messaging Data Grid
Java EE
Application
Web
Application
Single
Sign-On
Business
Rules
API
Management
Micro
services
Talk 1
A Microservices story
Talk 2-3-4
EAP and beyond: Red Hat
Open Application Runtimes

Data
Virtualization
Complex
Event
Processing
Intelligent
Process
Java EE
Application
Web
Application
Single
Sign-On
Business
Rules
API
Management
Micro
services
Talk 5
Fuse Integration
Services

Ready to use capabilities to facilitate innovationTalk 6 Openshift.io

Data
Virtualization
Complex
Event
Processing
Intelligent
Process
Java EE
Application
Web
Application
Single
Sign-On
Business
Rules
API
Management
Micro
services
Talk 7
MAAS, Messaging As
A Service

Data
Virtualization
Complex
Event
Processing
Intelligent
Process
Java EE
Application
Web
Application
Single
Sign-On
Business
Rules
API
Management
Micro
services
Talk 8
Model decisions,
manage cases and
make it optimal

MICROSERVICES 2.0 & RHOAR
Cloudify your applications: Microservices and beyond
Ugo Landini
Solution Architect
Samuele Dell’Angelo
Solution Architect

“Most teams we work with favor bundling an embedded
http server within your web application. There are
plenty of options available: Jetty, SimpleWeb, Webbit
and Owin Self-Host amongst others. Easier automation,
easier deployment and a reduction in the amount of
infrastructure you have to manage lead us to
recommend embedded servers over application
servers for future projects”
ThoughtWorks Technology Radar, May 2015
2015 AP Revenue (Gartner, Nov. 2016) :
● Oracle -4.5%
● IBM -9.5%
● Red Hat +33.3%
● Amazon +50.6%
● Pivotal +22.7%
“Resist the temptation to simply lift and shift Java EE
applications from closed-source to open-source
application servers for modest license savings. If you
are contemplating porting an application, consider
rearchitecting it to be cloud-native and moving it to
aPaaS - presuming that business drivers warrant the
investment.”
Gartner (November 2016)
State of the Market

“... is an approach to developing a single application as a suite of small
services, each running in its own process and communicating with
lightweight mechanisms, often an HTTP resource API. These services are
built around business capabilities and independently deployable by fully
automated deployment machinery. There is a bare minimum of centralized
management of these services, which may be written in different
programming languages and use different data storage technologies.”
Martin Fowler
http://martinfowler.com/articles/microservices.html
Microservices defined

● Small single-purpose services driven from DDD (Domain Driven Design) or practical decomposition
of an existing application or existing SOA-style mini-services
● Combined to form a system or application
● Independently deployable (replaceable)
● Independently scalable
● Antifragile - increased robustness and resilience under pressure
● Fully automated software delivery
● Polyglot (language and framework independence)
● API / Contract Focused
● Typically event-driven
● Decentralized data management
Microservices 101

Microservices 101
MyService
Tracing
API
Discovery
Invocation
Resilience
Pipeline
Authentication
Logging Elasticity
Monitoring

Pod
Container
JVM
Service A
Pod
Container
JVM
Service B
Pod
Container
JVM
Service C
Microservices == Distributed Computing

Wait, but weren’t we already doing this
distributed stuff...
● … what about CORBA?
● … and RMI?
● … EJB?
● … SOA?
What’s the difference?

Maturing the Application LifeCycle
Month
0
Month
3
Week
1
Week
2
Week
3
Week
4
Week
5
Week
6
Week
7
Week
8
Week
9
Week
10
Week
11
Monolith Java EE Lifecycle

Month
0
Month
3
Week
1
Week
2
Week
3
Week
4
Week
5
Week
6
Week
7
Week
8
Week
9
Week
10
Week
11
Fast Moving Java EE Monolith

Month
0
Month
3
Week
1
Week
2
Week
3
Week
4
Week
5
Week
6
Week
7
Week
8
Week
9
Week
10
Week
11
Fast Moving Java EE Monolith
Java EE Microservices

What’s the difference?
● Same ideas, new technologies (which will evolve in the
future)
● But now, we should be able to bring a new feature in
production in a few minutes

The Good
● Domain-Driven Design
● Low coupling, high cohesion
● APIs and contracts
● Agile software development
● Full lifecycle automation
● Dev and Ops working together
● Common packaging / container format
● Rethinking Data
Microservices: the Good, the Bad...

The Bad
● Too much Dogma / CS purity
● Tradeoff between Agility & Operational
Complexity
● Magnificent Monoliths and Stupendous SOA
are not necessarily bad
● Microservices / Unicorn Envy
● Not all organizations can afford the skills and
talent required to be successful
● Maintaining data consistency is hard in
distributed systems

The Ugly
● Building large scale distributed systems is really
hard
● Monitoring / APM tools need to catch up
● Heterogeneity (languages, frameworks, data
stores)
● Event-based, asynchronous, reactive programming
is still in it’s infancy and skills are rare
● CAP: Consistency, Availability, Partition Tolerance
? – choose two

● Understand and state your goals
● Understand the tradeoffs
● Start with People, Process and Culture
○ Agile Dev / DevOps is a prerequisite
● Invest in automation (provisioning, CI/CD, etc.)
● Start small
○ Small non-mission-critical green-field
○ Decomposition of existing monolith
● Get help - eg. Red Hat Innovation Labs
Microservices Recommendations

Config Server
NETFLIX Ribbon
Java Microservices Platform (2014)

Why these components?
Eureka is the Service Registry where the clients
lookup for service locations a.k.a Service Discovery
Config Server
Zuul is the smart proxy purely based on Java
Ribbon is the client side Load Balancer
Hystrix is the Circuit Breaker
Config Server externalized the Configuration
Zipkin is the Distributed Tracer

Config Server
NETFLIX Ribbon
Better Microservices Platform
(2016/2017)

Config Server
NETFLIX Ribbon
Even Better Microservices Platform (2018)

Istio - Sail
(Kubernetes - Helmsman or ship’s pilot)
Istio

Pod
Container
JVM
Service A
Side-car Container
Pod
Container
JVM
Service B
Side-car Container
Pod
Container
JVM
Service C
Side-car Container
Pods with 2 containers!

Infrastructure cluttering your code?
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-config</artifactId>
</dependency>
<dependency>
<artifactId>spring-cloud-starter-eureka</artifactId>
</dependency>
<dependency>
<artifactId>spring-cloud-starter-zuul</artifactId>
</dependency>
<dependency>
<artifactId>spring-cloud-starter-hystrix</artifactId>
</dependency>
<dependency>
<artifactId>spring-cloud-starter-sleuth</artifactId>
</dependency>

Istio
Resilience Across
Languages and Platforms
Increase reliability by shielding
applications from flaky networks
and cascading failures in adverse
conditions.
Policy Enforcement
Apply organizational policy to
the interaction between
services, ensure access
policies are enforced and
resources are fairly
distributed among
consumers.
Intelligent Routing and
Load Balancing
Control traffic between
services with dynamic route
configuration.
Conduct A/B tests, release
canaries, and gradually
upgrade versions using
red/black deployments.
Telemetry and Reporting
Understand the dependencies
between services, the nature and
flow of traffic between them, and
quickly identify issues with
distributed tracing.

Istio Service Mesh
Currently upstream only
Envoy
istio-ingress
Envoy
App A
Envoy
App B
Envoy
App C
istio-pilot istio-mixer istio-auth
HTTP Req/Resp
Kubernetes Pods
Istio Components Config to Envoy Access Control and Telemetry

Istio Components
● Control Plane
○ Istio-Pilot - istioctl, API, config
○ Istio-Mixer - Quota, Telemetry, Rate Limiting, ACL
○ Istio-Auth - TLS and Certificates
● Data Plane
○ Envoy proxy deployed as “side-cars” with applications

Circuit Breakers
Before Istio After Istio
Boiler plate code No code related to circuit breaking mixed with
business logic
Multiple libraries and dependencies e.g. Hystrix No libraries
Separate dashboard to collect circuit breaker
e.g. Hystrix Turbine
All metrics can be collected and displayed in Grafana
without extra bit of code
Define circuit breakers using Kubernetes Tags

Tracing
Before Istio After Istio
Boiler plate code No code related to tracing mixed with business logic
Multiple libraries and dependencies e.g. Zipkin No libraries

How to use it
Routes and commands injected via CLI or API:
apiVersion: config.istio.io/v1alpha2
kind: RouteRule
metadata:
name: reviews-test-v2
spec:
destination:
name: reviews
precedence: 2
match:
request:
headers:
cookie:
regex: "^(.*?;)?(user=jason)(;.*)?$"
route:
- labels:
version: v2

Infrastructure
Circuit Breaker
Configuration
Service
Service
Registry
Client-side Load
Balancing
Infrastructure Infrastructure
Supporting Services
Cache /
DataGrid
SSO Service
2014 2016 2018
Microservice Business Logic
Configuration
(ConfigMap)
Service
Registry
API Mgmt Messaging
Server-Side
Load
Balancing
Circuit Breaker
Istio+Cache / DataGrid SSO Service
API Mgmt Messaging
Service
Registry
Configuration
(ConfigMap)
Server-Side
Load Balancing
Circuit
Breaker
Cache / DataGrid SSO Service
API Mgmt Messaging
Smart Routing
Distributed
Tracing
Distributed
Tracing
Distributed
Tracing
Distrib.Tracing
Distributed
Tracing
Microservice Business Logic Microservice Business Logic
Smart Routing
Smart Routing
Supporting Services
Supporting ServicesService
Registration
Container Platform
Services
Container Platform
Services
Commodification
Simplification
Evolution of Microservices

Ok, but that’s all about MSA infrastructure...
OpenShift is the best Container Platform, it will solve for
you many of the problems at an infrastructure level
without cluttering your code but...
… we still need to code our microservices!

Funktion
50% OF THE
ENTERPRISE APP
MARKET
Where developers are going

“Almost all the successful
microservice stories have started with
a monolith that got too big and was
broken up”
“Almost all the cases where I've heard
of a system that was built as a
microservice system from scratch, it
has ended up in serious trouble.”
Martin Fowler: monolith first!

Modern, cloud-native application runtimes and an opinionated
developer experience for organizations that are moving
beyond 3-tier architectures and embracing cloud-native
application development.

● Multiple runtime options
○ JBoss EAP - existing Java EE / Spring apps.
○ WildFly Swarm / MicroProfile - Java EE centric MSA
○ Spring Boot / Cloud - Spring centric MSA
○ Vert.x - greenfield reactive Java
○ Node.js - greenfield reactive JavaScript
● OpenShift - Public, Dedicated Public & Enterprise
● Tightly integrated with OpenShift & Kubernetes
● Tightly Integrated with Red Hat Developer SaaS
● 3rd-party Integrations - eg. Netflix Ribbon, Hystrix, etc.
● Opinionated DevX starting with launch.openshift.io
RHOAR: OpenShift Application Runtimes

JBoss EAP
Existing, Java EE,
Spring MVC
Fast Monoliths
(Java EE, Spring)
Tomcat
Spring Boot /
MVC
Greenfield
Reactive Java
Java EE - mono to
micro. / greenfield
Vert.x
Reactive Java
/ Polyglot
MSA 2.0
Node.js
Reactive
client /
server-side
JavaScript
Greenfield
polymorphic
JavaScript
FaaS /
Server-le
ss
Existing Applications New Applications
Greenfield
Java / Spring
MSA
JBoss WS
Tomcat,
Spring MVC,
Spring Boot Spring
Cloud
Java
MSA 1.0WildFly
Swarm
Monolith
Decomposition,
Enterprise Java
MSA 2.0

Ok, so it’s (also) about being lighter?
Don’t believe it? Try it out yourself http://bit.ly/modern-java-runtimes
Runtime
(framework)
Boot time
server only
Boot time including app
deployment
Memory usage
without load
Memory usage
under load
Measured
throughput
JBoss EAP (Java EE) 2 - 3 sec 3 sec 40 MB 200 - 400 MB 23K req/sec
JBoss EAP (Spring) 2 - 3 sec 7 sec 40 MB 500 - 700 MB 9K req/sec
JBoss WS/Tomcat (Spring) 0 - 1 sec 8 sec 40 MB 0.5 - 1.5 GB 8K req/sec
Fat JAR (Spring Boot) N/A 3 sec 30 MB 0.5 - 2.0 GB 11K req/sec
Fat JAR (WF Swarm) 1-2 sec 5 sec 30 MB 250 - 350 MB 27K req/sec
Theoretically, yes. But, beware:
● A simple ReST service deployed in EAP used ⅕ of the memory used
by Spring Boot under load and was 2x faster!

Polyglot
● Language agnostic platform
● Initial focus on Java & JavaScript
Best in class OSS
● Container, Kubernetes, Java, JavaScript, Spring
Poly-architecture
● Fast monoliths (existing Java EE, Spring MVC)
● Mini and microservices
● Serverless (in the future)
Key Differentiators

● Resource efficiency
● Automation for microservices, but also
support traditional applications
● Enable faster and more consistent
deployments from Development to
Production
● Enable application portability across 4
infrastructure footprints: Physical,
Virtual, Private & Public Cloud
Key Differentiators

Multiple Runtimes supported in single SKU
Support 12-factor / cloud-native design-patterns :
● Healthcheck / load-balancing / proxying
● Registry / config.
● Rolling upgrades / retries / failover
● Separation of concerns
Cloud-scale design
● Networking, storage, auto-scaling, logs, alerting
Key Differentiators

The books you’ll need to read

RUNTIMES
(Container images and Maven Artifacts)
JAVA EE
(JBoss EAP)
MICROPROFILE
(WildFly Swarm)
OPENSHIFT SERVICES
REACTIVE
(vert.x)
NODE.JS
APACHE
TOMCAT
TESTED FRAMEWORKS
(Maven Artifacts)
SPRING BOOT /
CLOUD
NETFLIX OSS
Ribbon
OpenShift.io
(Developer
SaaS)
Generators
IDE
etc.
Management
APM
Metrics
Service
Discovery
Config.
Logging
Health
Check
Load
Balancing
CI/CDSSOMessaging IMDG API Mgmt
NETFLIX OSS
Hystrix
...
RHOAR: OpenShift Application Runtimes

WILDFLY SWARM:
RED HAT’S MICROPROFILE
EAP and beyond: Red Hat Open Application Runtimes
Giuseppe Bonocore
Solution Architect

● An innovative approach to package and
run Java EE applications
● Just enough App server : package your
app with required runtime dependencies
(but nothing more)

● Focus on modern cloud applications
○ No UI, no session replication
● Adds non-Java EE capabilities
○ Netflix OSS, Swagger, etc.
● Implementation of the MicroProfile
specification
Monoliths
Microservices

● Eclipse Foundation project
● Open source Java microservices
specifications
● WildFly Swarm is Red Hat’s
implementation

1:1 Relationship
Loose Relationship

● A maven artifact providing a
specific piece of functionality
● Can be auto-detected or
explicitly declared
● 184 fractions currently available
○ 158 stable
○ 26 experimental
○ JAX-RS, CDI, Swagger…
○ org.wildfly.swarm:microprofile:${version.wildfly-swarm}
Fractions
Supported Specifications
Java EE 7 Web Profile* MicroProfile 1.0
Certifications
Hystrix Ribbon MySQL Oracle DB
Metrics
Additional Supported Fractions
Health
Configuration
Topology
Monitor
Keycloak
Upstream (Community)
Flyway
Logstash
Fluentd
Swagger
JMS
Vert.x Integration
Consul
Spring
Jolokia
Infinispan
jGroups

● Uber Jar (packages your app +
what’s needed to run it)
● Hollow Jar (excludes app)
(Community)
Packaging

Uber Jar anatomy
Maven repo containing fraction dependencies
Manifest-Version: 1.0
Main-Class: org.wildfly.swarm.bootstrap.Main
The app’s original WAR file (could be JAR)
Bootstrapping glue using JBoss modules system
Default main()
WildFly Swarm classes/resources

Hollow Jar anatomy
● Contains the bits needed to run the
application, but not the application itself.
● Container based deployments: hollow jar
as part of the base image
○ Only the top image layer needs to be
updated.

Configuration
Define by:
● System properties
● Project stages (yml)
● XML
● Command-line arguments
Access by:
● Java API
● Annotation

Monitoring
● Provided through the monitor fraction
● Exposes REST endpoints providing runtime status
{
"name": "swarm-server",
"server-state": "running",
"suspend-state": "RUNNING",
"running-mode": "NORMAL",
"uuid": "ea781a82-904d-4b4f-a7ad-68e99e0ce4fd",
"swarm-version": "2017.8.1"
}
/node

Monitoring
{
"heap-memory-usage": {
"init": 325058560,
"used": 315881232,
"committed": 574095360,
"max": 4610064384
}
}
/heap

Monitoring
{
"thread-count": 51,
"peak-thread-count": 76,
"total-started-thread-count": 89,
"current-thread-cpu-time": 18220976,
"current-thread-user-time": 10000000
}
/threads

Monitoring
{
"checks": [
{
"id": "server-state",
"result": "UP",
"data": {
"date": "Mon Sep 04 22:17:43 CEST 2017"
}
}
],
"outcome": "UP"
}
/health
@GET
@Health
@Path("/status")
public HealthStatus check() {
return HealthStatus.named("server-state").up().withAttribute("date", new Date().toString());
}

mvn package
Build
mvn wildly-swarm:run
OR
java -jar <my-app>-swarm.jar
OR
IDE > Run …
org.wildfly.swarm.Swarm()
Run

Tooling
● JBoss Forge add-on
○ Generate code/scaffolding
● SwarmTool
○ Standalone jar that is used to wrap an existing JAR or
WAR file in a -swarm.jar without requiring any other
tooling
forge$ project-new --named demo --stack JAVA_EE_7
forge$ wildfly-swarm-setup
forge$ wildfly-swarm-new-test --target-package org.example.rest --named HelloWorldEndpointTest

Ok, so it’s (also) about being lighter?
Don’t believe it? Try it out yourself http://bit.ly/modern-java-runtimes
Runtime
(framework)
Boot time
server only
Boot time including app
deployment
Memory usage
without load
Memory usage
under load
Measured
throughput
JBoss EAP (Java EE) 2 - 3 sec 3 sec 40 MB 200 - 400 MB 23K req/sec
JBoss EAP (Spring) 2 - 3 sec 7 sec 40 MB 500 - 700 MB 9K req/sec
JBoss WS/Tomcat (Spring) 0 - 1 sec 8 sec 40 MB 0.5 - 1.5 GB 8K req/sec
Fat JAR (Spring Boot) N/A 3 sec 30 MB 0.5 - 2.0 GB 11K req/sec
Fat JAR (WF Swarm) 1-2 sec 5 sec 30 MB 250 - 350 MB 27K req/sec

How to select the runtimes
Selection
Consideration
Project Type Framework Pref Learning Effort Deployment Pkg
Runtimes
Cloud
Native
(new)
Cloud Enable (existing) Java EE
Non-Java
EE
No Little Invest Thin Fat Hollow
Lift &
Shift
Connect
&
Enhance
Refactor
&
Rewrite
EAP + + + + + + +
Swarm + + + + + + + + + +
Vert.x + + + + + + +
Node.js + + + + + +
Tomcat + Spring
Boot + + + + + Spring
Boot

VERTX.IO: REACTIVE MICROSERVICES
EAP and beyond: Red Hat Open Application Runtimes
Ugo Landini
Solution Architect

Free from : https://developers.redhat.com/

● Reactive Microservices Toolkit for
the JVM
● Polyglot - Java, JavaScript, jRuby,
Python, Groovy, Scala, Kotlin
● Distributed Event Bus for
lightweight messaging
● Event Driven Non-Blocking I/O
● Ideal for high concurrency, low
latency applications / services
● 2014 JAX Innovation Awards Winner

Why Reactive?
Apps In The Past Apps Today
Single/Few
Machines
Clusters of
Machines
Single/Few Core
Machines
Multicore
Machines
Expensive RAM Cheap RAM
Expensive Disk Cheap Disk
Slow N/W Fast N/W
Few Concurrent
Users
Many Concurrent
Users
Small Data Sets Large Data Sets
Latency in secs Latency in ms

The 2 faces of Reactive
Reactive
A software showing
responses to stimuli
Reactive
Systems
Reactive
Programming
Akka, Vert.x Reactor, RX, Vert.x
Actor, Agent
Autonomic
Systems
Data flow,
Functional
programming

Reactive Manifesto
http://www.reactivemanifesto.org/
Reactive Systems are an architecture style focusing on responsiveness

Asynchronous message passing => Elasticity
Components interacts using messages
Messages allows elasticity
Resilience is not only about failures, it’s also about self-healing
Send to an address
Dispatch to components subscribed
to the address

Pragmatic Reactive systems
And that’s what Vert.x offers to you
Development model => Embrace asynchronous
Simplified concurrency => Event-loop, not thread-based
I/O
● Non-blocking I/O, if you can’t isolate
● HTTP, TCP, RPC => Virtual address
● Messaging

Asynchronous development models
Async programming
● Exists since the early days of computing
● Better usage of hardware resource, avoid blocking threads
Approaches
● Callbacks
● Future / Promise (single value, many read, single write)
● Data streams - Reactive Programming
● Data flow variables (cell)
● Continuation
● Co-Routines

Reactive Architecture / Software
Application to software
A software showing responses to stimuli
● Events, Messages, Requests, Failures, Measures, Availability…
● The end of the flow of control ?
Is it new?
● Actors, Object-oriented programming…
● IOT, Streaming platform, complex event processing, event sourcing…

Building Reactive Systems
Message Driven
Microservices https://www.reactivemanifesto.org/
Tooling (OCP, Kubernetes)
Reactive Systems

Vert.x
Event Loop
Multi-Reactor
Verticle
Verticle
Verticle
Verticle
Verticle
JVM
Vert.x Instance
Verticle
Verticle
Verticle
Verticle
Verticle
JVM
Vert.x Instance
vertx.eventBus

All you need is (reactive) love
Reactive
Systems
Reactive
Programming

L’Integrazione nell’era dei Microservizi
Cloudify your applications: Microservices and beyond
Filippo Calà
Solution Architect

Integration
ESB
Contract
Platform
Data
Application
UDDI Process Flow

YOU WILL STILL NEED INTEGRATION,
EVEN WITH MICROSERVICES!

“L'integrazione agile è un approccio
architetturale che combina metodi e
pratiche agili con le tecnologie, allo
scopo di integrare rapidamente
applicazioni e dati tramite piattaforme
specificamente idonee a soluzioni
integrate flessibili e adattative.”

AGILE INTEGRATION
Cloud native solutions
Lean artifacts,
individually deployable
Container based scaling
and high availability
● Lightweight
● Pattern Based
● Reusable
Connectors
● Microservice Based
● Cloud native
solutions
● Lean artifacts,
individually
deployable
● Container based
scaling and high
availability
● Well defined,
re-usable, and well
managed end-points
● Ecosystem leverage
Flexibility Scalability Re-Usability
Distributed
Integration
Container API

AGILE INTEGRATION
Lean artifacts,
Distributed
Integration
Container API
APACHE CAMEL APACHE CAMEL
3SCALE
OPENSHIFT
KUBERNETES
DOCKER
FABRIC8
APACHE KARAF
SPRING BOOT

AGILE INTEGRATION
Lean artifacts,
Distributed
Integration
Container API
FUSE FUSE
3SCALE
OPENSHIFT
KUBERNETES
DOCKER
FABRIC8
APACHE KARAF
SPRING BOOT

Fuse iPaaS
Fuse Integration Services
Fuse Standalone
FUSE
Three Fuse Product Initiatives

Fuse Integration Service
APACHE CAMEL
SPRING-BOOT APACHE KARAF
CONTAINER
OPENSHIFT
JBOSS
DEVELOPER
STUDIO
Writing, configure,
test and debug
integration/MSA
route in JBDS
Camel define routing
and mediation rules
based on Enterprise
Integration Pattern and
with 160+ built-in
components Choose between
OSGi standard or
Spring-boot
standalone
framework
Deploy, run and
manage integration
application on
enterprise-class
cloud development
Platform
Build and
produces
ready-to-run
container image
using s2i toolkit

CAMEL DSL
JBOSS
DEVELOPER
STUDIO
Java DSL
Blueprint DSL (XML)
Spring DSL (XML)

microservice by Fuse
Client
API
(Interface,
Contracts)
Routing
Protocol
Endpoints
Transform
ation
Microservice

Openshift.io: Portiamo l'IDE nel cloud
Giuseppe Bonocore
Solution Architect

Openshift.io - Eclipse CHE tooling
125

What is needed to make a contribution?
IDE Project Files Runtimes

What is needed to make a contribution?
Configuration
IDE RuntimesProject Files
Workspace
Today

Che Workspaces
IDE RuntimesProject Files

Projects are mounted into the runtimes
Projects rely on
workspace runtimes

Workspaces define commands
mvn clean install
start mysql
deploy project
Commands are
executed as
processes in
workspace
runtimes

Workspaces provide their own browser IDE

Desktop IDEs can connect over SSH

Workspaces are hosted in Che’s server

Project Badging
Developer Workspace
Developer Workspace

Openshift.io: Cloud Based IDE, SDLC and
more...

OpenShift.io
Unified view across teams and projects
Plan and track
Analyze Plan
Assign Prioritize
Create and Build
Cloud
IDE
Desktop
IDE
Developer
Workspace
Artifact
Management
Testing
Code
Analysis
Git Repos
Openshift Pipelines
Runtime

Multiple, guided ways to Get Started

Wizards, powered by Forge project

EnMasse : open sourcing the messaging & IoT
The messaging as a service platform
Paolo Patierno
Senior Software Engineer
Luca Bigotta
Solution Architect
9/11/2017

EnMasse
Messaging-as-a-Service
● Open source cloud messaging running on Kubernetes and OpenShift
● enmasse.io
● github.com/enmasseproject/enmasse

EnMasse
Features
● Multiple communication patterns: request/response, publish/subscribe and
competing consumers
● Support for “store and forward” and direct messaging mechanisms
● Scale and elasticity of message brokers
● AMQP 1.0 and MQTT support
● Simple setup, management and monitoring
● Multitenancy: manage multiple independent instances
● Deploy “on premise” or in the cloud

Basic idea
Routers and brokers
R
R
R
P C
B
B

Routing vs Brokering
Broker
Producer Broker Consumer
Send message
Accepted
Send message
Accepted

Routing vs Brokering
Router
Producer Router Consumer
Send message
Accepted
Send message
Accepted

Address model
Address space
● Type
● Plan
Address
● Type
● Plan
● Properties
1 N 1 M
● Address space : group of addresses accessible through a single connection (per
protocol)
● Address : a destination used for sending and receiving messages
Spaces and Addresses

EnMasse
Architecture - “Standard” address space
Qpid Dispatch Router
network
ActiveMQ Artemis
brokers
Admin
MQTT gateway
MQTT clients
AMQP & JMS clients

EnMasse
“Brokered” address space
ActiveMQ Artemis
brokers
Admin
AMQP & JMS clients

EnMasse
Security
Qpid Dispatch Router
network
ActiveMQ Artemis
brokers
Admin
MQTT gateway
MQTT clients
AMQP & JMS clients
With AMQP SASL plugin

Scaling
Brokers
a a b b
Router network
a

MQTT over AMQP
● MQTT gateway
○ Handles connections with remote MQTT clients
○ Bridges MQTT - AMQP protocols
● MQTT lwt
○ Provides the “will testament” feature
○ In charge to recover & send the “will” if client dies
● It brings MQTT features over AMQP so …
○ … it’s not just about translating and bridging protocols …
○ … “will testament” works for AMQP clients as well

EnMasse
Future work
● HTTP(S) support
● Bridging address spaces
● Kafka integration
○ as part of the “standard” address space (i.e. one AMQP connection for multiple
destinations, even a Kafka topic)
○ as “kafka” address space (accessible through native Kafka clients)
● Improve Kubernetes support
○ RBAC
○ CI (only for OpenShift at present)
○ ingress (with better support for TLS SNI)
● Integrate better with Eclipse Hono
○ provides interface and API (telemetry, event, …) for connecting IoT devices

BUSINESS AUTOMATION
Process Driven Application, Decisions & Resource Planning
Donato Marrazzo
Specialist Solution Architect

Who cares? Let’s ask to Google Trends!
⬤ Business Process Management
⬤ Business Rules
⬤ Microservices
⬤ Artificial Intelligence
⬤ Cloud Computing
⬤ Microservices

Treating
business processes as
assets that can be
adapted,
automated and
re-designed
is key to
innovation and digital
transformation.
Only about 37% of most typical business processes have been digitized.
Source: McKinsey

Process Driven Application
GOAL
Reimagine processes for digital participation
HOW
Shift from BPM to low code process apps
MANIFESTATION
Process applications

Tools for
business experts
Tools for
developers
RED HAT JBOSS BPM SUITE
PROCESS
PARTICIPANTS
LEGACY
SYSTEMS
CLOUD SERVICES
APPS
APPS
APPS
Process
Services
Decision
Services
Enables construction of apps that automate a business process - using a model to drive
work through the process to completion…
Business Central Process Server

BPMS v7
● More convenient and pleasurable for citizen developer
● Extended Case Management support
● Improving collaborative Team work
● First class support for OpenShift
Major themes

BPM Usage spectrum
Straight Through
The BPM engine “choreographs” a
sequence of automated activities, it
involves humans by exception
● Trading processes (Capital
Market, Banking, Energy ...)
● Automatic claims processing
● Automatic reordering
● Inventory reduction / rebalancing
● Order to cash automation
Human Intensive
The BPM says to humans which is the
next action in a quiet pre-ordered
manner.
● Order fulfillment
● Claims processing
● Loan approvals
● Mortgage origination
● Travel requests
● Purchase requests
● Mobile workforce support
Case Management
BPM suggests possible next steps,
Humans decides the next best action
eventually overriding with and ad hoc
activity. Users look at the BPM as a task
and document organizer
● Investigation solution
● Incident management solution
● Next-Gen customer onboarding
● Customer retention program
● Personalized customer service
● Omni-channel engagement
marketing

Engine Support
Runtime Strategy
PER_CASE provides a single KIE-Session for all process instances within a
case.
Case Files
Live in session’s “WorkingMemory” (as opposed to process variables).
Case-scoped, so accessible to all process instances in a given case
Case Roles
Per-case mapping of users and groups to case-users and case-groups
People can have different roles in different case instances.
Mapping provided when case is created (and can be changed afterwards)
Case Management

Focus on Stages
At glance:
● Data
● Task
● Milestones
● Roles
● Activities
● Documents
Case view

CONTROLLER
Websocket communication
KIE Server initiate the communication at
startup and the controller reuse it.
Previously, for managed KIE Server
configuration, both controller and kie server
need to know how to communicate with each
other
● This was particularly complex to manage
in OpenShift environments, where pod
can be created and destroyed frequently

Main goals:
● Hide the complexity of many KIE Server
instances hosting different projects (kjars)
● Aggregate information from different KIE
Servers regardless if they share the same
DB or host the same projects (kjars)
KIE Server send notifications to Smarter Router
when configuration is changed: container start /
stop, instance start/ stop
SMARTER ROUTER
Hide configuration complexity

● Users interact with KIE Servers always via Smart Router
● KIE Servers can come and go at anytime and register/unregister in
the Smart Router
● Smart Router will dynamically update Controller with new
containers coming in
● Admin Console knows existing KIE servers
CLOUD ARCHITECTURE
Immutable Unmanaged KIE Servers with Smart Router
and Admin Console

The Execution Errors view shows a list of errors
User can acknowledge errors
Quick search
Filter by fields
● Process Instance Id
● Job Id
● Type
ERROR HANDLING

Tools for
business experts
Tools for
developers
RULES
RED HAT JBOSS BRMS
APPS
APPS
APPS
Decision
Services
Business Central Decision Server
Client
App
Enables construction of apps that automate business decisions, guided by business rules...

“DMN, which stands for Decision Model and Notation,
is a relatively new standard managed by OMG, the organization behind BPMN. It is trying to
do for Business Decision Management what BPMN did for Business Process Management a
decade ago: empower the business to take charge of the logic that drives its operations,
through a vendor-independent diagramming language.” (Bruce Silver)
● Version 1.1 released in June 2016
● Defines among other things:
○ a graphical language for business decision modelling
○ a standard notation for decision tables
○ an expression language called FEEL (which stands for Friendly Enough
Expression Language)
○ a metamodel and an interchange format (XML)
○ 3 conformance levels for tool implementations

Basic concepts
a Decision is the act
of determining an
output value from a
number of input values
A Business Knowledge Model
encapsulates business
know-how in the form of
business rules, analytic
models, or other formalisms.
Input Data may be data
structures, rather than
just simple data items.
a decision requires one
or more input data
a Decision requires one
or more Business
Knowledge

Optimize Goals With limited Resources Under Constraints
BUSINESS RESOURCE PLANNING

Business Resource Planner is an
“optimization engine” (or “constraint
satisfaction solver”) platform that runs on
JBoss BRMS
It enables regular Java developers to create
solvers for complex planning problems using
a variety of out-of-the-box provided
algorithms
It adds unique value to a JBoss BRMS
and/or JBoss BPM Suite subscription
BUSINESS RESOURCE PLANNER

Cloudify your applications: microservices and beyond

Cloudify your applications: microservices and beyond

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to Cloudify your applications: microservices and beyond

Similar to Cloudify your applications: microservices and beyond (20)

More from Ugo Landini

More from Ugo Landini (11)

Recently uploaded

Recently uploaded (20)

Cloudify your applications: microservices and beyond