Agile Integration Workshop

Container Native Integration Services
Achieving true agility through microservices, containerization and APIs
Oct 17, 2017

Agenda
● 9:00 AM - CONTAINER NATIVE INTEGRATION INTRODUCTION
● 10:00AM - DISTRIBUTED INTEGRATION LAB
● 12:00AM - LUNCH
● 1:00PM - API FIRST LAB
● 2:00PM - CONTAINERS LAB
● 3:30PM - API MANAGEMENT LAB
● 5:00PM - WRAP UP / Q & A

Why modernize integration ?
SOA & ESB
Microservices
Event-Based
Containers
APIs
DevOps

Development Process
Waterfall
CI/CD
Deployment
Server/VM
Container
Infrastructure
Data Center
Cloud
Architecture
Monolith
MicroservicesAPIs
Webservices
Service Endpoints
BE COMPETITIVE
Enterprise IT is undergoing fundamental change. To remain competitive, businesses need
an integration platform capable of supporting current and next generation architectures.

Traditional Integration: Challenges
● Centralized integration (ESB)
● Re-use business functions
● Slow team co-ordination
● Single point of failure
● Not applicable for cloud
● Stringent scalability
Enterprise Service Bus (ESB)
Mainframe

7
Source: https://blog.akana.com/wp-content/uploads/2016/01/New-Integration-Redefined.png

8
3 Pillars of Modern Integration

Distributed Integration - Microservices
Faster Software Delivery
Resource Scalability
Failure Isolation

INSERT DESIGNATOR, IF NEEDED10
TRADITIONAL
INTEGRATION
INTEGRATION
MICROSERVICES
Distributed Integration - Microservices
Integration Hub (ESB)
Adapters
Exposed services Exposed services/APIs
1

microservice by Fuse
Client
API
(Interface,
Contracts)
Routing
Protocol
connector
Transformation
SMART ENDPOINTS AND SIMPLE PIPES

12
Distributed Integration: Red Hat JBoss Fuse
Distributed, pattern based Integration Services
Lightweight
integration
Container Toolkit
Rich transformation,
routing, messaging
Move away from the monolith
Build integration services as
self-contained deployable units
Create and Connect APIs,
Microservices
Includes messaging (JBoss AMQ)

TRADITIONAL
INTEGRATION
INTEGRATION
MICROSERVICES
API Management
Integration Hub (ESB)
Adapters
Exposed services
API Gateway / Management
Exposed services/APIs
2

Red Hat API Management
RBDMS
SAP
NoSQL
WS
REST
JMS
+ more
FUSE INTEGRATION
SERVICES
JBoss Fuse
Service API
JBoss Fuse
Service API
JBoss Fuse
Service API
Developers
Partners
Mobile App
Affiliates
Internal Projects
+ more
API MANAGEMENT
Access control and
security
API contracts and
rate limits
Analytics and
reporting
Developer portal and
docs
Billing and payments

Packaging Integration Services: Containers
Distributed
Deployment
Immutable delivery
● Operating system
● JVM
● side-car applications
● configuration

Managing Containers Rapid software
releases
Multi-tenancy
Guarantee high
availability
Scaling
management
Failure
detection

Fuse Integration services on OpenShift
● Cloud Native
○ Multi-tenancy
○ Security
○ Networking
○ Containers
○ Self healing
● Application centric
○ Cloud deployment support
○ Service lookup

Container Native Integration Services
API Gateway/Management
Container Container Container
Container
Container
REST API AMQP
APIs
REST API
3

21
Three Pillars for Modern Integration
DISTRIBUTED
INTEGRATION
LIGHTWEIGHT, PATTERN
BASED, EVENT
ORIENTED,
COMMUNITY SOURCED
CONTAINERS
CLOUD NATIVE
SOLUTIONS, CONTAINER
BASED SCALING AND
HIGH AVAILABILITY
..
.
API
MANAGEMENT
WELL DEFINED,
REUSABLE,
AND WELL MANAGED
END-POINTS,
ECOSYSTEM LEVERAGE
1 2 3

HOW TO GET STARTED
WE HAVE WRITTEN BOOKS FOR YOU
23
https://developers.redhat.com/resources/

Agile Integration
● Lightweight
● Pattern Based
● Reusable Connectors
● Microservices 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

DISTRIBUTED INTEGRATION - Microservice
microservice by
Red Hat JBoss Fuse
● Lightweight
○ Spring Boot deployment
○ DSL
○ S2i
● Pattern Based
○ Enterprise Integration Patterns
● Reusable Connector
○ Camel components

APACHE CAMEL
● Versatile and powerful, community led, open-source integration framework
● Led by the Apache Software Foundation
● Focused on making integration easy by
○ Offering concrete implementations for over 65 well known Enterprise
Integration Patterns
○ Connectivity to 160 different technology endpoints
○ Offering simple integration, routing and mediation using
■ Java based Domain Specific Language (or Fluent API); or,
■ Spring or Blueprint configuration files
● Large and vibrant world-wide community
○ Growing project with widespread adoption
○ Large Contributor and User base
○ 40 current, active and participating Committers
○ 27 Project Management Committee members
Aggregator
Normalizer
Content Enricher
Resequencer

WHAT IS JBOSS FUSE?
Apache Camel
Powerful pattern-based
integration engine
● 160+ connectors
● Built-in Data formats
● EIP support
Runtimes
● OSGi ✔
● JavaEE✔
● Microservice-ready
Spring Boot✔
Hybrid Deployment Env.
● Cloud ✔
● Onprem ✔
● Both ✔
API /
Webservice
● RPC ✔
● SOAP ✔
● REST ✔

APACHE CAMEL (in code)
Split
orders
Send
each order
to it’s
process service
Electronics
Others
Customer
Purchase
from("file:work/cbr/input")
.split(xpath("//orders"))
.choice()
.when(xpath("/order:order/order:type = 'E'"))
.to("activemq:queue:electronic/us")
.otherwise()
.recipientList(simple("http4://otherservice"));

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

160+ ENDPOINT COMPONENTS
activemq cxf kubernetes jasypt
activemq-journal cxfrs freemarker javaspace
amqp dataset ftp/ftps/sftp jbi
atom db4o gae jcr
bean direct hdfs jdbc
bean validation ejb hibernate jetty
browse esper hl7 jms
cache event http jmx
cometd exec ibatis jpa
crypto file irc jt/400

160+ ENDPOINT COMPONENTS
Kafka properties seda stream
ldap quartz servlet string-template
mail/imap/pop3 quickfix sip test
mina ref smooks timer
mock restlet smpp validation
msv rmi snmp velocity
nagios rnc spring-integration vm
netty rng spring-security xmpp
nmr rss spring-ws xquery
printer scalate sql xslt

CAMEL ROUTE
Producer
● Produce requests
● End of route
● Dispatching outgoing
requests
Consumer
● Consume requests
● Start of a route
● Dispatching
outgoing replies
Processor
● Intermediate node in
the pipeline
● standard processors
or customized ones

CAMEL CONTEXT
Camel ContextCamel
runtime
environment
Route Route Route
Registry
Endpoint
Endpoint
EndpointEndpoint
Endpoint
Endpoint
Endpoint
Message
source or sink
Place to register
and plug
Javabeans,
components or
endpoints, for
later lookup.
Definition of
message
flowing rules
Components
Components are built-in sets
of highly configurable
libraries, that represents as
the plug-in factories for the
endpoints

MORE INFORMATION
● Camel in Action
● Apache Camel Developer’s
Cookbook
● Community website
○ http://camel.apache.org/

API
Multiple Device
Support
Device are not
limited to
screen
Voice enable
Drome, VR
Customer/
Vendor/
Partner
More complex
ecosystem
SaaS
Frequency
Data volume
Monetize
Service
Increased
revenue
market share
Open up new
opportunities
Modularize and
agility
Enhanced
developer
experience
Reuse code
Hide
implementation
details
Scalability in
Distributed
System
Able to flexibly
allocate
resource
Cloud enabled

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

Red Hat Confidential39
RED HAT INTEGRATION PORTFOLIO
Connect APIs, applications and data across your entire enterprise
Lightweight multi-protocol
messaging platform
Lightweight integration platform
(Includes AMQ)
Full lifecycle API
Management
API Development API Management
Lightweight data
integration platform

API FIRST
microservice by
RED HAT JBOSS FUSE
REST DSL
Swagger
API Doc
API
Data
Format Transform
microservice by
RED HAT JBOSS FUSE
API
microservice by
RED HAT JBOSS FUSE
Consume
Exposes
3ScaleAPImanagement
External clients
Community,
Partners,
Customers

CONVERTING BETWEEN DATA FORMAT
● Marshal
○ Java Bean → Textual format
● Unmarshal
○ Textual, Binary format → Java Bean
● Dozer
○ Fine-grained integration
■ mapping literal values
■ Use expressions

DATA FORMAT EXAMPLE
Input XML File:
<root>
<child1>text1</child1>
<child2>text2</child2>
</root>
Camel Route:
...
from(“file:///xmlsourcedir”)
.unmarshal().jaxb()
.process(...)
.marshal().json()
.to(“file:///jsondestdir”);
...
Output JSON File:
{"root":
{"child1": "text1",
"child2": "text2"}
}

SERVICE RESILIENCE
JBoss Fuse
microservice
API
JBoss Fuse
microservice
API
microservice
microservice
API
microservice
microservice
API
Chain reaction
JBoss Fuse
microservice
API
SLOW!!
Client

CIRCUIT BREAKER
<camelContext xmlns="http://camel.apache.org/schema/spring">
<route>
<from uri="direct:start"/>
<hystrix>
<to uri="http://fooservice.com/slow"/>
<onFallback>
<transform>
<constant>Fallback message</constant>
</transform>
</onFallback>
</hystrix>
<to uri="mock:result"/>
</route>
</camelContext>
JBoss Fuse
microservice
API
API
Service SaaS
Slow! No
response!
Timeout
Fallback

APPLYING API BEST PRACTICES
Simply but concrete naming for the URI.
Use HTTP Method for CRUD if possible:
● READ -> GET
● CREATE -> PUT
● UPDATE -> POST
● DELETE -> DELETE
● Globally recognized standard, easy consumable
Make the most out of HTTP Errors
Setting the right granularity of data and using the common data format
Clear automatic generated documentation
<get uri="customer/{customerid}">
<to uri="direct:getCustomerinfo"/>
</get>
<get uri="product/{id}">
<to uri="direct:productInventory"/>
</get>
<get uri="account/profile/{acctid}">
<to uri="direct:getprofile"/>
</get>

CONTINUOUS IMPROVEMENT
Building APIs
● Native support
● Intuitive tooling
● Light weight
● Flexible service
and code re-use
from backend
Deploy APIs
● Flexibility to scale
● Load balancing
● zero downtime
● Security
Distributing APIs
● Authorization
● Clear documentation
● Enforce policies
● Community
Performance Analyst
● Number of Hits
● Average response time
● Revenue earned
Business alignment
● Change in market
● Government regulation
● New service launch
Versioning
● Retire
● Update
● New Service
● Internal service
re-creation
API

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

OPENSHIFT TECHNICAL OVERVIEW50
VIRTUAL MACHINES AND CONTAINERS
VIRTUAL MACHINES CONTAINERS
virtual machines are isolated
apps are not
containers are isolated
so are the apps
VM
OS Dependencies
Kernel
Hypervisor
Hardware
App App App App
Hardware
Container Host (Kernel)
Container
App
OS deps
Container
App
OS deps
Container
App
OS deps
Container
App
OS deps

APPLICATION PORTABILITY WITH CONTAINERS
LAPTOP
Container
Application
OS dependencies
Guest VM
RHEL
BARE METAL
Container
Application
OS dependencies
RHEL
VIRTUALIZATION
Container
Application
OS dependencies
Virtual Machine
RHEL
PRIVATE CLOUD
Container
Application
OS dependencies
Virtual Machine
RHEL
PUBLIC CLOUD
Container
Application
OS dependencies
Virtual Machine
RHEL
Linux Containers + RHEL = Guaranteed Portability
Across Any Infrastructure

GENERAL DISTRIBUTION
?
● Which containers should be deployed together?
● Which containers can access each other?
● Which host has more capacity?
● How to monitor container health? What do you do if they have crashed?
● How to scale them up?
MANAGING CONTAINERS IN ENTERPRISE

Master(Control Plane) & Nodes(Container host)

Apps and components run in containers
Container
Image
Container
Pod

OPENSHIFT
Services connect application components
● Virtual IP load balancing and discovery
● Defines a group of Pods and how to access them
● Decouple providers and accessors of services
● Don’t depend on Pod IPs directly
● Use a single IP that doesn’t change
● Service Proxy
POD
SERVICE
POD
10.0.1.1 10.0.1.2
CLIENT Name: amq
IP: 170.30.10.10

Routing layer for external accessibility
POD
SERVICE
PODPOD
SERVICE
POD
ROUTE
CLIENT CLIENTCLIENT

OPENSHIFT
FAILURE RECOVERY
POD
SERVICE
PODPOD
SERVICE
POD
ROUTE
POD
Rebalance traffics
Redirect request to
available Pods
Replace failing pod
Starts another pod and
bind to serviceHealth Checks
periodically performs
diagnostics on a running
container.

DEPLOY SOURCE CODE WITH
SOURCE-TO-IMAGE (S2I)
Git
Repository
BUILD APP
Developer
code
Source-to-Image(S2I)
Builder
Image
Image
Registry
BUILD IMAGE
DEPLOY deployApplication
Container
Dockerfile
Binary

OPENSHIFT TECHNICAL OVERVIEW
INTEGRATED
IMAGE
REGISTRY
OPENSHIFT
CLUSTER
62
CONTINUOUS DELIVERY PIPELINE
DEVELOPER GIT SERVER ARTIFACT REPOSITORY
OPENSHIFT
CI/CD PIPELINE
(JENKINS)
IMAGE BUILD
& DEPLOY
INTEGRATED
IMAGE
REGISTRY
OPENSHIFT
CLUSTER
GO
LIVE?
PROMOTE
TO TEST
PROMOTE
TO UAT
PROMOTE
TO PROD
RELEASE MANAGER
NON-PROD PRODDEV TEST UAT
☒
☑

OPENSHIFT
● Reducing downtime and risk associated with
release
● Two identical environments in containing two
different releases (Blue and Green)
● After validating new release, can switch all
traffic to new version
● Quickly roll application back if you find issues
BLUE-GREEN DEPLOYMENT
router

Split Traffic: Canary Deployments
SERVICE A
App A App A
SERVICE B
App B App B
ROUTE
10% traffic90% traffic
Split Traffic Between
Multiple Services For A/B
Testing, Blue/Green and
Canary Deployments

OPENSHIFT TECHNICAL OVERVIEW
CENTRAL LOG MANAGEMENT WITH EFK
APPLICATION LOGS
OPERATION LOGS
ELASTIC
ELASTIC
65
RHEL
NODE
POD POD
PODPOD
FLUENTD
RHEL
NODE
POD POD
PODPOD
FLUENTD
ELASTICSEARCH
RHEL
NODE
POD POD
PODPOD
FLUENTD
USER
ELASTIC
ELASTIC
KIBANA
ELASTIC
ELASTIC
ELASTICSEARCH
ELASTIC
ELASTIC
KIBANA
ADMIN

Take Control of Your APIs
Creating & Exposing APIs is just the start
Security &
Authentication
Version Control
Documentation
Policies
Access Control
Monitoring
Lifecycle
Management
Provisioning
Alerts
Metering & Billing
Testing
Portal
Scalability
Reliability

API Life-cycle
The API Lifecycle Management Approach
DEFINE: Identify the API services that deliver value to
the business layer
DEVELOP: Design, code, test, document standardize
templates
PUBLISH: Run security with defined policies and
controls
SUPPORT: Offer community, forums, documentation to
interact and collaborate
RETIRE: EOL, un-publish, communicate and remove
from market place following version control best
practice

3scale API Management
RBDMS
SAP
NoSQL
WS
REST
JMS
+ more
FUSE INTEGRATION
SERVICE
JBoss Fuse
Service API
JBoss Fuse
Service API
JBoss Fuse
Service API
Developers
Partners
Mobile App
Affiliates
Internal Projects
+ more
API MANAGEMENT
Access control and
security
API contracts and
rate limits
Analytics and
reporting
Developer portal and
docs
Billing and payments

Red Hat 3Scale Distributed Architecture
Developer Apps
Branded
Developer Portal
Real time
Admin Console
Mobile Apps
API
Gateway …
Load Balancer
Swagger Doc
Node # 1 Node # 2 Node # N
API
Manager
API
Gateway
API
Backend
Your API Back-end

3Scale API Management
Stack
Access control Security
API contracts Rate limits
Analytics Reporting
Dev portal Docs
Billing Payments
Admin Console
Dev Portal
API
Management
Traffic Manager
APIs
Applications
Consumers
HTTP / HTTPS
Security, usage &
rate limits

The 3scale API Management solution
provides out-of-the-box three authentication
mechanisms :
• API Key
• API Key Pair (ID + Secret)
• OAuth 2.0 / OpenID Connect
In addition, custom mechanisms can be implemented
in the 3scale gateway
Authentication Mechanism
API SECURITY
75

76
Application plans allow you to set rate limits
for API usage and control traffic flow for
groups of developers.
Set per-period limits for incoming API calls to
protect your infrastructure and keep traffic
flowing smoothly.
Automatically trigger overage alerts for
applications that reach or exceed rate limits,
and define behavior for over-limit
applications.
API contracts & limits
API MANAGEMENT FEATURES

77
3scale API Analytics module lets you analyze
your API traffic by account, application or
service and much more :
• Define and present tailored metrics
• Drill down up to the API Method level
• Implement business metrics
• Export data in CSV format
Analytics

Ensure the success of your APIs by
providing an amazing developer experience.
The 3scale API Developer Portal provides :
• Developer Onboarding
• Application & API Keys creation
• Usage tracking
• Interactive API Documentation
• EULA Management
• Fully customizable CMS
Highly Customizable
API DEVELOPER PORTAL

79
The 3scale API Management solution lets you
implement monetization by providing :
• One-stop-shop for Monetization
• Customizable billing metrics :
• Setup fees (one-time)
• Recurring fees (per-month)
• Per usage fees (per-call)
• PCI-DSS compliant platform
Monetization & Payments

API Management Deployment Model

SaaS
Hosted API manager on
3scale scalable AWS platform
with built-in redundancy,
High-availability and SLA
Openshift
Openshift API manager - API
Management Platform (AMP)
2.x, provides an OpenShift
template to deploy AMP onto
OpenShift Container Platform
(OCP)
API Manager
Deployment Options

Native
apicast-gateway code from
upstream repo running on:
Openresty (NGINX + LUA)
for Red Hat Enterprise Linux
Docker
apicast-gateway
Docker Image
from Red Hat Registry
Openshift
Openshift API Gateway
Template (which will pull in
apicast-gateway Docker
Image)
Inside or Outside the same
API manager Cluster
Self-managed API Gateway
Deployment Options

microservice
microservice
microservice
OpenShift
3scale
Proxy
CLIENT
JBoss Fuse
microservice
API
Platform

3Scale API Management
Components - Flexible Distributed Control
Developers
Sync / Authorize
Mobile
Apps
Developer
Apps
Real Time
Admin Portal
Branded
Developer Portal
Swagger
Doc API Provider
Administrators
API ProvidersAPI GatewayAPI Consumers
API Manager

Deployment Options
Hybrid: Hosted Manager - Self-managed Gateway
Real Time Admin Portal
Sync / Authorize
API Provider
API Gateway API Manager
API Provider
Administrators
Mobile Apps Developer Apps
Branded Dev PortalSwagger Doc
Developers
API Consumers

Deployment Options
Full On-Premise
Sync / Authorize
API Provider
API Gateway
(Openshift)
API Manager
API Provider
Administrators
API Consumers
Developers

Deployment Options
On-premise: Self-managed APIs
Sync / Authorize
API Provider
API Gateway
(Openshift)
API Manager
API Provider
Administrators
API Consumers
Developers

Deployment Options
On-premise: Self-managed APIs & External Self-managed Gateway
Sync / Authorize
API Provider
API Gateway
(Native/Docker)
API Manager
API Provider
Administrators
API Consumers
Developers

91
Gartner
Magic Quadrant
Full API Lifecycle Management
(2016)

AGILE INTEGRATION
API Management
PaaS
Gateway
Automation
Layered microservice

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

THANK YOU
plus.google.com/+RedHat
linkedin.com/company/red-hat
youtube.com/user/RedHatVideos
facebook.com/redhatinc
twitter.com/RedHatNews

Agile Integration Workshop

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to Agile Integration Workshop

Similar to Agile Integration Workshop (20)

More from Judy Breedlove

More from Judy Breedlove (20)

Recently uploaded

Recently uploaded (20)

Agile Integration Workshop