Agile integration workshop Seattle

Agile Integration
Achieving true agility through Microservices, Containerization and APIs
Seattle, WA
10-26-2017

Red Hat Team
Tony Aguirre Middleware & Container Sales Specialist
(Seattle, WA)
taguirre@redhat.com
Ganesh Radhakrishnan MW Solution Architect (Seattle, WA) ganesh@redhat.com
Josh Reagan MW Integration Architect, Tiger Team
SME (Denver, CO)
jreagan@redhat.com
Hugo Guerrero APIs & Integration Technology Evangelist
(Mexico City, MX)
hguerrero@redhat.com
Chad Holmes MW Integration Architect, Tiger Team
SME (Boston, MA)
cholmes@redhat.com

Agenda
8:30 AM – 9:00 AM
INTRODUCTION & SETTLE IN
9:00 AM – 10:30 AM
AGILE INTEGRATION JOURNEY
DISTRIBUTED INTEGRATION AND MICROSERVICES
10:45 AM – 12:00 PM
INTEGRATION AND MICROSERVICES LAB
10:30 AM – 10:45 AM
BREAK
12:00 PM – 1:00 PM
LUNCH
1:00 PM – 2:00 PM
CONTAINERS AND API MANAGEMENT
2:15 PM – 4:45 PM
CONTAINERS AND API MANAGEMENT LAB
4:45 PM – 5:00 PM
SUMMARY / Q & A

What people think when moving to cloud

What it really is when moving to cloud

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.

INTEGRATION ARCHITECTURE
Non-Containerized
Software
Agile IT Infrastructure
Containerized
Apps
Container-native
Apps
External
Apps
Distributed
Integration
APIs
Containers
ContainerManagement
APIManagement

DISTRIBUTED
INTEGRATION
CONTAINERS APIs
FLEXIBILITY SCALABILITY RE-USABILITY
Tools and processes
Lightweight
Pattern-based
Event-oriented
Community-sourced
Cloud-native solutions
Individually deployable,
lean artifacts
Container-based scaling
& high availability
Well-defined, reusable,
& well-managed
endpoints
Connected ecosystem
BRING INTEGRATION WHERE IT’S NEEDED
KEY CAPABILITIES FOR FLEXIBILITY, SCALABILITY, & REUSABILITY

CLOUD-NATIVE APP INTEGRATION
SOLUTIONS FROM RED HAT
Distributed integration
Lightweight, pattern-
based, event-oriented,
community sourced
Containers
Cloud-native solutions,
container based scaling,
& high availability
APIs
Well-defined, reusable,
well-managed endpoints
& ecosystem

Integration #microservice #distributed
The
Legacies
The not so
legacy
legacies
The SaaS Microservices
Compose Integrate
Integration is always going to happen...
The problem is WHAT is the BEST WAY to do integration

CONTAINERS
Distributed
Deployment
Immutable delivery
● Operating system
● JVM
● side-car applications
● configuration

INSERT DESIGNATOR, IF NEEDED13
CONTAINERS Rapid software
releases
Multi-tenancy
Guarantee high
availability
Scaling
management
Failure
detection

QA PROD
hours...days
DEV
CI/CD

APIs
RESTFul
HTTP
Swagger
Documentations
JSON
XML
3scaleAPIManagement
API
● Package
● Distribute
● Control
● Monetize

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

MORE ON AGILE INTEGRATION
Whitepaper
www.redhat.com/en/resources/innovation-through-agile-integration-whitepaper

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 Base
○ Enterprise Integration Pattern
● Reusable Connector
○ Camel components

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

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

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

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>

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

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

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

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

35
CAMEL EXCHANGE
Exchange
Header
IN Message
Header
Body
AttachmentAttachmentAttachment
Key:ValueKey:ValueKey:Value
Out Message
Header
Body
Key:ValueKey:Value
Key:Value
Arbitrary type
arbitrary MIME types

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

Container
Fuse and OSGi
Name:
artifactIDJarA
version: 1.2.1
Name:
artifactIDJarB
version: 2.0
Name:
artifactIDJarC
version: 1.0
Name:
artifactIDJarD
version: 4.1
Boundaries
Export
Dependent

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

CAMEL BLUEPRINT TESTING EXAMPLE
public class BlueprintCBRTest extends CamelBlueprintTestSupport {
@Produce(uri = "file:work/cbr/input")
protected ProducerTemplate inputEndpoint;
@EndpointInject(uri = "mock:outputUK")
protected MockEndpoint outputEndpointUK;
@Test
public void testCamelRoute() throws Exception {
// Create routes from the output endpoints to our mock endpoints so we
// can assert expectations
context.addRoutes(new RouteBuilder() {
@Override
public void configure() throws Exception {
from("file:work/cbr/output/uk").to(outputEndpointUK);
}
});
String value1 = getFileContents("src/test/resources/data/order1.xml");
outputEndpointUK.expectedMessageCount(2);
assertMockEndpointsSatisfied();
}
}

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

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

API FIRST
FOR Speaker ONLY
Data Transformation
REST DSL
API Best Practice
Swagger docs

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

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

DIFFERENT DATA FORMAT
bindy protobuf
castor serialization
csv soap
crypto syslog
dozer tidy markup
flatpack xml beans
gzip xml security
hl7 xstream
jaxb zip
json

54
CAMEL EXCHANGE
Exchange
Header
IN Message
Header
Body
Out Message
Header
Body
Key:ValueKey:Value
Key:Value
Arbitrary type
arbitrary MIME types

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

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

APPLYING API BEST PRACTICES
Simple 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

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

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

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

URLS to access LABS
https://github.com/jbossdemocentral/fuse-introlab
Password is r3dh4t1!

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

● Sandboxed application processes on a
shared Linux OS kernel
● Simpler, lighter, and denser than virtual
machines
● Portable across different environments
● Package my application and all of its
dependencies
● Deploy to any environment in seconds
and enable CI/CD
● Easily access and share containerized
components
Sys-Admins / Ops Developers
It Depends on Who You Ask
What Are Containers?

● Enable efficiency and 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
Containers - An Evolution in Application Deployment

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

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
codeGit
Repository
Source-to-Image
(S2I)
Application
Container
deploy
CODE
BUILD
DEPLOY
Container
Image
Image
Registry
OPSDEV
BUILDING IMAGES

OPENSHIFT
DEPLOYMENTS
B
G
A
B
E
N
30%
70%
Blue Green
Deployment
A/B Testing Canary release

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
Container
Integration
Container
A
P
I
API management
Customer Data
ID
Balance
VIP Status
Customer Data
{“ID”,
“Balance”,
“VIP Status”}

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

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

Modular
No single point of failure
Hybrid cloud access
Highly scalable
Red Hat 3scale API Management
Flexible Distributed Control

Red Hat 3Scale AMP85
Security & Access Control
How do you manage who gets access to your API? Can you establish different
levels of access for different types of users? Can you control how different
applications interact with your API?
Access control features are essential to making sure you determine exactly
who uses your API, how it is used and how much they can use it. We make it
easy to centrally set up and manage policy and application plans for all your
APIs on one platform
It goes without saying that if you’re planning to open an API,
security needs to be carefully considered from the start. Whether
your API is public, private or internal, with 3scale you can choose
the authentication type most appropriate to your needs. We offer
a range of authentication patterns and credentials to choose from,
including unique API keys, and OAuth tokens.

Your API Security
Multiple authentication mechanisms
Can be combined with IP / Domain referrer whitelisting
Authenticate traffic
Restrict by policy
Drop unwelcome calls
Protect backend services
Generate overage alerts
Impose rate limits
– API Key – App ID / App Key – OAuth 2.0
Authenticate and restrict access to your APIs. Protect backend services.

Allow/restrict access
to your API endpoints
along with rate limits
- Endpoint A
- Endpoint t B
- X Calls / Minute
- Y Calls / Day
- Free
- $X per Month
- $Y per Call
Package #1
Package #2
Package #3 Developers
Internal
Teams
Strategic
Partners
API services
Rate limits
Monetization
API Contracts, Throttling & Rate Limits
Package your APIs. Crete access tiers. Set rate limits.

Reports & Analytics
Track and monitor usage. Get reports by API, app, method and metric.
Gain and share API program insights.
Monitor and set alerts on traffic flow. Provide partners and
developers with reports on their traffic with a user dashboard
designed for them. Analyze your API traffic through detailed traffic
analytics by account, application or service and share performance
insights across the organization with crisp clear reporting.
High-level data at your fingertips
The Dashboard part of the Admin Portal gives you quick,
centrally located visibility into any traffic and customer
engagement opportunities or issues with your APIs. It is
available now on all 3scale API Management Platform
plans from free through enterprise.

Interactive API
Documentation
Developer & Partner Portal
Your brand. Your developer experience. Your user interface

Many of our customers choose
to monetize access to their APIs,
and 3scale makes that very
simple.
We offer key payment solution
integrations with Stripe,
Braintree, or Adyen which all
allow easy end to end billing
between the API consumer and
API provider.
Monetization
Billing and payments management. Setup pricing rules. Invoice every month

Packaging, Billing & Payments
Multiple pricing rules
● One time payment
● Fixed recurring
monthly fee
● Variable recurring
monthly fee
● Cost per unit
● Tiered pricing
Billing cycles
Invoices issues on a monthly
basis
● Prepaid (fixed fees
charged beginning of
month, variable fees
charged end of month)
● Postpaid (all fees
charged at the end of
the month)
No credit card details stored
on 3scale infrastructure
Setup pricing rules. Invoice every month. 100% PCI compliant.

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

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

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

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

Agile integration workshop Seattle

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (20)

Similaire à Agile integration workshop Seattle

Similaire à Agile integration workshop Seattle (20)

Plus de Judy Breedlove

Plus de Judy Breedlove (20)

Dernier

Dernier (20)

Agile integration workshop Seattle