Red Hat Agile integration workshop - Atlanta

Agile Integration
Jeremy Davis
jeremy.davis@redhat.com
@argntprgrmr
Ram Maddali
rmaddali@redhat.com
@RamMaddali

Agenda
8:30 AM – 9:00 AM
INTRODUCTION & SETTLE IN
9:00 AM – 10:00 AM
AGILE INTEGRATION JOURNEY
10:00 AM – 10:30 AM
INTEGRATION DEMO
10:30 AM – 10:45 AM
BREAK
10:45 AM – 12:00 AM
DISTRIBUTED INTEGRATION AND MICROSERVICE
12:00 AM – 1:00 PM
LUNCH

Agenda
1:00 PM – 2:00 PM
API FIRST
2:15 PM – 3:30 PM
CONTAINER
2:00 PM – 2:15 PM
BREAK
4:45 PM – 5:15 PM
SUMMARY / Q & A
3:30 PM – 4:45 PM
API Management

Waterfall
CI/CD
Server/VM
Container
Data Center
Cloud
Monolith
MicroservicesAPIs
Webservices
BE COMPETITIVE

AGILE INTEGRATION
SOA
Microservices
Event-Base
Container
API
DEVOPS

SOA AND ESB
ESB
Contract
Platform Data
Application
UDDI Process Flow

INSERT DESIGNATOR, IF NEEDED13
● Stringent scalability
● Slow team co-ordination
● Complex service registry
● Long software delivery cycle
SOA AND ESB

MICROSERVICES
Faster Software Delivery
Resource Scalability
Failure Isolation

MICROSERVICES
Development
Security
DBA
Operation
Release

● Simple,small
● Boundary and Replaceable
● Independence
microservice
API
MICROSERVICES

Client API Routing
Protocol
Endpoints
Transformation
SMART ENDPOINT

APIs
RESTFul
HTTP
Swagger
Documentations
JSON
XML
APIManagement
●
●
●
●

Pipelines
source
repository
CI/CD
engine
dev container target
environment

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

CONTAINERS

CI/CD Container CloudMicroservicesAPIs
BE COMPETITIVE

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

AGILE INTEGRATION
Cloud native solutions
Lean artifacts,
individually deployable
Container based scaling
FUSE FUSE
3SCALE
OPENSHIFT
KUBERNETES
DOCKER
FABRIC8
APACHE KARAF
SPRING BOOT

AGILE INTEGRATION
Container Container Container
Container
Client
APIManagement
RESTFul API RESTFul APIAMQP
RESTFul API
RESTFul
API
ClientClient
API
API
API
Mgmt

MUST READ !
Download your copy:
https://developers.redhat.com/promotions/microservi
ces-for-java-developers/
@christianposta

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
Distributed
Integration

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

Building microservice with Fuse
RED HAT JBOSS FUSE
microservice
160+
Endpoint Components
Database
Msg
Broker
….
XML
JSON
HL7
…...
HTTP
Netty
FTP
….
REST
API
Resource
Connector
Twitter
FB
Salesforce
SaaS
….

Composing Microservice with Fuse
RED HAT JBOSS FUSE
microservice microservice microservice microservice
microservice
Enterprise
Integration
Patterns

Red Hat JBoss Fuse
APACHE CAMEL
SPRING-BOOT APACHE KARAF
CONTAINER
OPENSHIFT
JBOSS
DEVELOPER
STUDIO
Camel define routing
and mediation rules
based on Enterprise
Integration Pattern and
with 160+ built-in
components

PATTERN BASED
Split
orders
Send
each order
to it’s
process service
Electronics
Others
Aggregator
Normalizer
Content Enricher
Resequencer

WHAT IS APACHE CAMEL?
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"));

WHAT IS APACHE CAMEL?
<route id="cbr-route">
<from id="_from1" uri="file:work/cbr/input"/>
<split id="_split1">
<xpath>//orders</xpath>
<choice id="_choice1">
<when id="_when1">
<xpath>/order:order/order:type = 'E'</xpath>
<to id="_to1" uri="activemq:queue:electronic"/>
</when>
<otherwise id="_otherwise1">
<recipientList id="_recipientList1">
<simple>http4://otherservice</simple>
</recipientList>
</otherwise>
</choice>
</split>
</route>

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

ENDPOINT CONFIGURATION
file://myfolder/directory? delete=true&readLock=changed
Programmatic Example:
FileEndpoint fileEp = new FileEndpoint();
fileEp.setFile(new File(“/some/dir”));
fileEp.setDelete(true);
fileEp.setReadLock(“changed”);
from(fileEp).to(...);
URI Example:
Component
Name Configuration
Parameters

CAMEL BEAN INJECTION
<beans ....>
<bean class="org.apache.camel.component.servlet.CamelHttpTransportServlet"
id="camelHttpTransportServlet"/>
<bean
class="org.springframework.boot.web.servlet.ServletRegistrationBean" id="servlet">
<property name="name" value="CamelServlet"/>
<property name="servlet" ref="camelHttpTransportServlet"/>
<property name="urlMappings" value="/demos/*"/>
</bean>
<bean class="com.redhat.fisdemoblockchain.MockBitcoinApp" id="mockBitcoinApp"/>
<camelContext id="camel" xmlns="http://camel.apache.org/schema/spring">
<route>

<route>
</camelContext>
</beans>
@BeanInject("mockBitcoinApp")
MockBitcoinApp mockBitcoinApp;

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

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 EXCHANGE in ROUTE
PROCESSOR PROCESSOR PROCESSOR
PRODUCER
Exchange
Exchange
In In In
In
Out Out Out
Out

RUNNING CAMEL
Spring Boot Karaf
Spring DSL/Java
Spring Boot Starter module
Fat JARs
Stand-alone App
Embedded dependency
Pre-configured, pre-sugared
Small and lightweight
Blueprint DSL/Java
Blueprint module
Bundles
Modularized
Explicit dependency
Versioned
Hot redeploy

Container
Fuse and Spring Boot
Application
Camel Spring Boot Starter
Camel route
Configurations
Auto-wires components
Tomcat, Undertow
JDBC
Messaging
(application.properties/yml)
Auto-detects
routes
Auto-configure
Camelcontext, register
Camel utilities

TESTING
Spring Boot Karaf
@RunWith(SpringRunner.class)
@SpringBootTest annotation
Autowire CamelContext
Extends CamelBlueprintTestSupport
camel-test-blueprint
Specify Camel blueprint descriptor
location
ASSERT
● # of messages are received on each endpoint,
● Payloads are received in the right order,
● Messages arrive match some kind of Predicate

TESTING
<route id="cbr-route">
<from id="_from1" uri="file:work/cbr/input"/>
<choice id="_choice1">
<when id="_when1">
<xpath>/order:order/order:type = 'E'</xpath>
<to id="_to1" uri="activemq:queue:electronic"/>
</when>
<otherwise id="_otherwise1">
<to id="_to1" uri="activemq:queue:others"/>
</otherwise>
</choice>
</route> public void configure() throws Exception {
// mock the for testing
interceptSendToEndpoint("activemq:queue:electronic")
.skipSendToOriginalEndpoint()
.to("mock:catchElectronic");
}

CAMEL SPRING BOOT TESTING EXAMPLE
@RunWith(SpringRunner.class)
@ActiveProfiles("dev")
@SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)
public class ApplicationTest {
@Autowired
private TestRestTemplate restTemplate;
@Autowired
private CamelContext camelContext;
@Test
public void testProfile() {
ResponseEntity<Accounts> profileResponse
= restTemplate.getForEntity("/demos/account/profile/123456", Accounts.class);
assertThat(profileResponse.getStatusCode()).isEqualTo(HttpStatus.OK);
Accounts account = profileResponse.getBody();
assertThat(account.getAcctname()).isEqualTo("Simon C");
assertThat(account.getBalance()).isEqualTo(5000);
assertThat(account.getAddr()).isEqualTo("43 SLIVER EAGLE ST, RIVER");
}
}

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

LAB ONE
Container
Integration
Container
A
P
I
API management
Customer Data
ID
Balance
VIP Status
Customer Data
{“ID”,
“Balance”,
“VIP Status”}

LAB ONE
http://bit.ly/2i015H4
VM Password:
r3dh4t1!

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

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

API FIRST
microservice by
RED HAT JBOSS FUSE
REST DSL
Swagger
API Doc
API
Data
Format Transform
3ScaleAPImanagement

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
<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>

APPLYING API BEST PRACTICES
Make the most out of HTTP Errors
Setting the right granularity of data and using the common data format
Clear automatic generated documentation

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

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

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

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

DIFFERENT DATA FORMAT

MARSHAL/UNMARSHAL WITH TOOLS
<marshal>
<xmljson/>
</marshal>
<marshal>
<bindy classtype=”example.Product" type="Csv">
</marshal>
<marshal>
<jaxb partClass=“example.TradeOrder” contextPath=“example"/>
</marshal>

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"}
}

Transformation Tooling
XML
JSON
JAVA
Customize
Drag and drop
mapping
Set property
Set variable
Set expression
Add transformation
Add custom
transformation

REST DSL
<camelContext xmlns="http://camel.apache.org/schema/spring">
<rest path="/say">
<get uri="/hello">
<to uri="direct:hello"/>
</get>
<get uri="/bye" consumes="application/json">
<to uri="direct:bye"/>
</get>
<post uri="/bye">
<to uri="mock:update"/>
</post>
</rest>
<route>
<from uri="direct:hello"/> …
</route>
<route>
<from uri="direct:bye"> …
</route>
</camelContext>
Verb
defining
http
method
Basepath
The service
path
Uri template
The service
method and
parameters
Consumes
Accept data format
setting

REST DSL
<restConfiguration bindingMode="auto" component="servlet" port="8080"/>
Message Body Direction Binding Mode Message Body
XML Incoming auto, xml, json_xml POJO
POJO Outgoing auto, xml, json_xml XML
JSON Incoming auto, xml, json_xml POJO
POJO Outgoing auto, xml, json_xml JSON
● camel-netty4-http
● camel-jetty
● camel-servlet
● camel-undertow

SWAGGER
<restConfiguration apiContextPath="api-docs" bindingMode="json"
component="servlet" contextPath="/demos">
<apiProperty key="cors" value="true"/>
<apiProperty key="api.title" value="API for demo"/>
<apiProperty key="api.version" value="1.0.0"/>
</restConfiguration>
<get uri="/{id}" outType="com.redhat.User">
<description>Find user by id</description>
<param name="id" type="path" description="The id of the user to get" dataType="int"/>
<to uri="bean:userService?method=getUser(${header.id})"/>
</get

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

OPENSHIFT
CONTAINERS
Developer’s Local Env (laptop, desktop)
CDK
JBDS
VCS (Git)
Build
Run
Test
Jenkins
Nexus
(Library
Management)
Deployment Pipeline
Automatic Testing
Release management
Failure feedback

OPENSHIFT
CONTAINERS
● Containerized application run in Pods
● Pods exposed as a Service
● Edge router http://myapp.com
○ Integration API endpoints (JBoss pods)
○ database (MySQL pods with persistent storage)
○ Messaging (TBD...)

OPENSHIFT
CONTAINERIZED APPS RUN IN PODS

OPENSHIFT
PODS
● A small group of tightly coupled
Containers
● Ensures collocation
● Docker containers share resources
within the pod
○ Volumes
○ Network / IP
○ Port space
○ CPU / Mem allocations
● Pod health probes

OPENSHIFT
PODS EXPOSED AS SERVICE
● Defines a group of Pods and how to access them
○ Labels and Selectors
● Decouple providers and accessors of services
● Don’t depend on Pod IPs directly
● Use a single IP that doesn’t change
● Virtual IP load balancing and discovery
POD
SERVICE
POD
10.0.1.1 10.0.1.2
CLIENT Name: amq
IP: 170.30.10.10

SERVICE DISCOVERY
POD
SERVICE
POD
10.0.1.
1
10.0.1.2
CLIENT Name: amq
IP: 170.30.10.10
POD
10.0.1.3
Service label
common label you apply to
each of the pods
Service proxy
single IP address that other
services can call

ROUTES
POD
SERVICE
PODPOD
SERVICE
POD
ROUTE
CLIENT CLIENTCLIENTRouters support the
following protocols:
● HTTP
● HTTPS (with SNI)
● WebSockets
● TLS with SNI

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.

REPLICATION CONTROLLER
● Ensures that a specified number of Pod
replicas is running
● Holds Pod Templates for creating new
Pods
● Autoscaling
● Rolling Updates

OPENSHIFT
BUILDING IMAGES
● Build strategies
○ Source Source-to-Image (S2I)
○ Binary Source-to-Image (S2I)

OPENSHIFT
S2I
Docker
Custom
Git
Dockerfile
Binary
Image Build Docker Image
Build
Source
Build
Strategy
NEED UPDATE FOR BINARY S2i

OPENSHIFT
codeGit
Repository
Source-to-Image
(S2I)
Application
Container
deploy
CODE
BUILD
DEPLOY
Container
Image
Image
Registry
OPSDEV
BUILDING IMAGES

OPENSHIFT
PIPELINE
OpenShift
Jekins
Image
Repository
Git
Pods
Build
Deploy
Webhook
Git push
Pipeline
starts
Build
application
image
Running application
container in different
environment

OPENSHIFT
PIPELINE
node('maven') {
stage('build') {
openshiftBuild(buildConfig: 'buildconfigname', showBuildLogs: 'true')
}
stage('staging') {
openshiftDeploy(deploymentConfig: 'deploymentconfigame')
}
….
}

OPENSHIFT
● Deployment strategy determines the deployment process for containers
● Rolling strategy
○ Performs rolling updates
○ Supports life-cycle hooks for injecting code into deployment process
○ Waits for pods to pass readiness check before scaling down old components
○ Used by default if no strategy specified on deployment configuration
● Recreate strategy
○ Has basic rollout behavior
○ Scales down previous deployment before deploying the new one
○ Supports life-cycle hooks for injecting code into deployment process
● Custom strategy for custom deployment behaviour
DEPLOYMENTS

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

OPENSHIFT
● A/B testing is a way of testing features in
application for various reasons like usability,
popularity, noticeability, etc
● Usually associated with application UI however
the back-end services need to be available
● Can implement with either application-level or
static switches
A/B DEPLOYMENT

OPENSHIFT
CONTAINER
Developer’s Local Env (laptop, desktop)
CDK
JBDS
VCS (Git)
Build
Run
Test
Jenkins
Nexus
(Library
Management)
Deployment Pipeline
Automatic Testing
Release management
Failure feedback

LAB THREE
http://bit.ly/2yL7GPP

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
Developer 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

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

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

Deployment Options
Full SaaS: Hosted API Manager & API Gateways
Real Time Admin Portal
Sync / Authorize
API Provider
API Gateway API Manager
API Provider
Administrators
Mobile Apps Developer Apps
Branded Dev PortalSwagger Doc
API Consumers
Developers

Deployment Options
Hybrid: Hosted Manager - Self-managed Gateway
Sync / Authorize
API Provider
API Gateway API Manager
API Provider
Administrators
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

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

Lab Four
http://bit.ly/2z29V1Q

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

Red Hat Agile integration workshop - Atlanta

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to Red Hat Agile integration workshop - Atlanta

Similar to Red Hat Agile integration workshop - Atlanta (20)

More from Judy Breedlove

More from Judy Breedlove (20)

Recently uploaded

Recently uploaded (20)

Red Hat Agile integration workshop - Atlanta