Apache Camel v3, Camel K and Camel Quarkus

Apache Camel v3
Camel K
Camel Quarkus
Claus Ibsen
Senior Principal Software Engineer
Red Hat
November 2019

About me
Claus Ibsen
● Senior Principal Software Engineer at Red Hat
● ASF Member & Java Champion
● Apache Camel tech lead
● Author of Camel in Action books
● Based in Denmark
● Blog: https://medium.com/@davsclaus

Agenda
● Integration Evolution
● Apache Camel
● Camel 3
● Camel K
● Serverless
● Camel K & Knative
● Camel Quarkus
● Roadmap
● More Material

Today's ESB Architecture
Apache
Camel
OSGi Framework
Apache
CXF
Apache
ActiveMQ
App App App App
App App App App
App App App App
Deployer Shell Config
Manage Blueprint HTTP
Integration
Core
Application
Apache Karaf

Microservice Architecture (MSA 1.0)
Data
store
SaaS

Today's Microservice Architecture (MSA 1.0)
Apache
Camel
Apache Tomcat
Spring
Rest
App
Spring
Framework
Spring Boot
Integration
Core
Application
Spring Boot
Hystrix
Circuit
Breaker

Cloud Native Architecture
Camel
App
Integration
Core
Application
Service
Mesh
Pod
Sidecar
Camel
Spring Boot
Spring Boot
Tomcat

Camel
App
Integration
Core
Application
Service
Mesh
Pod
Sidecar
Camel Main

Camel
App
Integration
Application
Service
Mesh
Pod
Sidecar
Camel
Quarkus
Quarkus
Core

Serverless Architecture
Camel
App
Integration
Core
Application
Knative
Pod
Sidecar
Camel K
K

What is Apache Camel
● The swiss knife of integration
● 10+ years of development and one
of the most active Apache projects

● Packed with functionality
The giant Swiss knife 😅

● Java based integration framework
● Runtime support: Spring Boot, Apache Karaf / OSGi, JEE / WAR,
Microproﬁle, Quarkus, Standalone, and more ...
● Based on Enterprise Integration Patterns
● Comes with 300+ components (connectors)
● DSL (Java or XML) to describe integration ﬂow (routes)
● Can integrate everything ... almost everything
● 10+ years of development - still one of the most active Apache projects
● The cornerstone of Red Hat Fuse

System Integration
System A System B?

System Integration
System A System B?
● Different Transports
● Different Data Model
● Asynchronous vs Synchronous
● Failures
● Observability
● ...

Enterprise Integration Patterns

System Integration
System A System B
Transport A Transport B
?

Camel Routes
from("file:data/inbox")
.to("jms:queue:order");
<route>
<from uri="file:data/inbox"/>
<to uri="jms:queue:order"/>
</route>
Java DSL
XML DSL

Camel Routes with Splitter
from("file:inbox")

from("file:inbox")
.split(body().tokenize("n"))

from("file:inbox")
.marshal(customToXml)
Custom data
transformation

from("file:inbox")
.marshal(customToXml)
.to("activemq:line");

Camel runs everywhere
Application
Servers
Linux
Containers

Camel connects everything
Enterprise
Systems
● File
● FTP
● JMS
● AMQP
● JDBC
● SQL
● TCP/UDP
● Mail
● HDFS
● JPA
● MongoDB
● Kafka
● ...
Public Cloud
● AWS
○ S3
○ SQS
○ Kinesis
○ ...
● Google
○ BigQuery
○ PubSub
● Azure
○ Blob
○ Queue
● Box
● Dropbox
● Facebook
● Linkedin
● Salesforce
● SAP
● ServiceNowIoT
● CoAP
● MQTT
● PubNub
SaaS

300+ Components
ahc ahc-ws amqp apns as2 asn1 asterisk atmos atmosphere-websocket atom atomix avro aws aws-xray azure bam barcode base64
beanio beanstalk bean-validator bindy blueprint bonita boon box braintree cache caffeine cassandraql castor cdi chronicle chunk cmis
cm-sms coap cometd consul context corda core-osgi core-xml couchbase couchdb crypto crypto-cms csv cxf cxf-transport
digitalocean disruptor dns docker dozer drill dropbox eclipse ehcache ejb elasticsearch elasticsearch5 elasticsearch-rest elsql etcd
eventadmin exec facebook fastjson fhir flatpack flink fop freemarker ftp ganglia geocoder git github google-bigquery google-calendar
google-drive google-mail google-pubsub google-sheets gora grape groovy groovy-dsl grpc gson guava-eventbus guice hawtdb
hazelcast hbase hdfs hdfs2 headersmap hessian hipchat hl7 http http4 http-common hystrix ibatis ical iec60870 ignite infinispan
influxdb ipfs irc ironmq jackson jacksonxml jasypt javaspace jaxb jbpm jcache jclouds jcr jdbc jetty jetty9 jetty-common jgroups jibx
jing jira jms jmx johnzon jolt josql jpa jsch jsonpath json-validator jt400 juel jxpath kafka kestrel krati kubernetes kura ldap ldif leveldb
linkedin lra lucene lumberjack lzf mail master metrics micrometer milo mina mina2 mllp mongodb mongodb3 mongodb-gridfs mqtt
msv mustache mvel mybatis nagios nats netty netty4 netty4-http netty-http nsq ognl olingo2 olingo4 openshift openstack opentracing
optaplanner paho paxlogging pdf pgevent printer protobuf pubnub quartz quartz2 quickfix rabbitmq reactive-streams reactor restlet
rest-swagger ribbon rmi routebox rss ruby rx rxjava2 salesforce sap-netweaver saxon scala schematron scr script service servicenow
servlet servletlistener shiro sip sjms sjms2 slack smpp snakeyaml snmp soap solr spark spark-rest splunk spring spring-batch
spring-boot spring-cloud spring-cloud-consul spring-cloud-netflix spring-cloud-zookeeper spring-integration spring-javaconfig
spring-ldap spring-redis spring-security spring-ws sql ssh stax stomp stream stringtemplate swagger swagger-java syslog tagsoup
tarfile telegram test test-blueprint test-cdi testcontainers testcontainers-spring test-karaf testng test-spring thrift tika twilio twitter
undertow univocity-parsers urlrewrite velocity vertx weather web3j websocket wordpress xchange xmlbeans xmljson xmlrpc
xmlsecurity xmpp xstream yammer yql zendesk zipfile zipkin zookeeper zookeeper-master

Apache Camel 3 - Projects
Camel
Integration Framework
Swiss knife of integration

Camel KCamel
Lightweight Serverless
Integration Platform
Camel on Kubernetes &
Knative

Camel
Quarkus
Camel KCamel
Lightweight Serverless
Integration Platform
Camel on Kubernetes &
Knative
Camel extensions
for Quarkus
Optimized JVM & Native
compiled Java (GraalVM)

Camel 3 Goals
● Tidy up APIs & cleanup of technical debt
● Light-weight & modular camel-core
● Reactive Routing Engine
● Camel Main (standalone)
● Fluent Builder Endpoint conﬁguration (Java)
● Backwards compatible (for most end users)
● Java 11 support
● New website
● Camel K
● Camel Quarkus

Camel 3 - Website
● New website and documentation

Camel 3 - Platforms & Runtimes
● Java 8
○ will be dropped later on 3.x
● Java 11
○ ﬁrst version to support
● GraalVM
○ camel-quarkus sub-project
● Spring Boot 2.x
● Standalone (camel-main)
● Apache Karaf (OSGi)
● WAR / JEE
● Eclipse Microproﬁle

Camel 3 - Modularized
● Modularized camel-core
camel-core
( Camel 2.x)
camel-api camel-core-osgi camel-management-api
camel-base camel-core-xml camel-management-impl
camel-caffeine-lrucache camel-endpointdsl camel-support
camel-cloud camel-headersmap camel-util
camel-core camel-jaxp camel-util-json
camel-core-engine camel-main

● Modularized camel-core components
camel-core
( Camel 2.x)
camel-bean camel-log camel-stub
camel-browse camel-mock camel-timer
camel-controlbus camel-properties camel-validator
camel-dataformat camel-ref camel-vm
camel-direct camel-rest camel-xpath
camel-directvm camel-saga camel-xslt
camel-file camel-scheduler camel-zip-deflater
camel-language camel-seda

● camel-core vs camel-core-engine
camel-core
(Camel 3.x)
camel-core-engine
(Camel 3.x)
Includes 33 Camel JARs
(core & core components)
(similar to camel-core 2.x)
Includes 12 Camel JARs
(core only functionality)

Camel 3 - Optimized
● Faster startup and lower footprint
○ Smaller core & less classes loaded etc
● Optimized camel-core
○ Many smaller optimizations
examples/camel-example-console
Camel 2.x: 5179 classes loaded (5.3 mb camel JARs)
Camel 3.x: 4286 classes loaded (3.9 mb camel JARs)

Camel 3 - Optimized
● Source code generated invocation (no Java reflection)
○ Type Converters
○ Route configuration
○ Endpoint configuration
○ Component configuration
● Build & Init lifecycle phase
○ Prepare before start (eg Quarkus build time preparation)
● JMX management optional

Camel 3 - Endpoint DSL
● Endpoint DSL
○ Type Safe
○ Java Fluent Builder style

Camel 3 - Reactive
● Reactive Core
○ All EIPs now fully reactive
○ Blocking vs Non-Blocking code-paths merged into one (Non-Blocking)
● Postponed for Camel 3.x
○ Backpressure
○ Client API
○ Java 9+ Flowable API (requires to drop Java 8)

Camel 3 - Camel Main
● Standalone Camel
○ Bootstrap for Camel K & Camel Quarkus
○ Unified configuration (also for Camel Spring Boot)
● Configurable
○ application.properties (ala Spring Boot)
● Tooling Support
○ Eclipse
○ Eclipse Che
○ VSCode
○ IDEA

Camel 3 - Microprofile
● Eclipse Microprofile Integration
○ Configuration
○ Metrics
○ Health Checks
○ Fault Tolerance (in progress)
○ Reactive Messaging (3rd party)
■ https://smallrye.io/smallrye-reactive-messaging/#_integrating_with_apache_camel

Camel 3 - Other
● JUnit 5 support
○ camel-test-junit5
● Step EIP
○ Group together N+ EIPs (logical name)
○ Grouped performance statistics
● Lazy start producer
○ Avoid Camel to fail on startup if producer fails to start
(typically connecting to remote system)
● Writeable Registry
○ Easier to add your own beans
● Route Model more extensible
○ YAML route builder (Camel K)

19/12/2018
Master switched
to camel 3
02/2019
M1
❏ New Camel API
❏ Move components
out of camel core
❏ Extract basic
classes in a support
JAR
❏ Reactive Routing
Engine
❏ Faster releases
❏ Quarkus Support
for a subset of
components
❏ Writeable registry
❏ Step EIP
❏ Faster build
❏ Reactive Routing
Engine improved
❏ Java 11 support
improved
❏ EIP at scale
❏ More Quarkus
support
Final
Release
04/2019
M2
06/2019
M3
07/2019
M4
❏ Auto-generate
Endpoint DSL
❏ Camel-core-engine
❏ Camel-main
improved
❏ Website and docs
almost done
09/2019
RC1
❏ Renaming
components
❏ New website live
❏ Stabilizing
❏ Reduce footprint
Camel 3 - Timeline
10/2019
RC2 RC3
12/2019
GA
5700+ commits (Camel 3.x)

A lightweight integration platform, based on Apache Camel,
born on Kubernetes, with serverless superpowers.
What is Apache Camel K ?

Runs on “vanilla” Kubernetes (1) ...
K
1.

Runs on “vanilla” Kubernetes (1), Openshift (2) ...
K
1.
K
2.

Runs on “vanilla” Kubernetes (1), Openshift (2) and gives its best on a Knative-powered cluster (3)!
K
1.
K
2.
K
3.

How?
from(“telegram:bots/bot-id”)
.transform()...
.to(“kafka:topic”);
from(“kafka:topic”)
.to(“http:my-host/api/path”);
1. Create a integration ﬁle (Java, Groovy, Kotlin, JS, XML…)
Camel DSL, based on
EIPs...

How?
.transform()...
Camel DSL, based on
EIPs...
$ kamel run integration.groovy
2. Run it

How?
.transform()...
Camel DSL, based on
EIPs...
3. Runs on Openshift or
Kubernetes
$ kamel run integration.groovy
2. Run it

Architecture of Camel K
Dev Environment Remote Cloud
kamel CLI
Camel K
Operator
“Integration”
Custom
Resource
Running Pod
Live updates!
Fast redeploy!
Less than 1 second!
Tailored for cloud-native development experience

Fast Deployment of Camel K
Time to run a integration using different strategies (in seconds)
Lower is better
😃
F-m-p is the “fabric8-maven-plugin”
(http://maven.fabric8.io/) deploying a
average spring-boot based
integration on Minishift vs. a remote
OpenShift cluster (accounting time to
upload the fat Jar). Source S2I build
has been measured in Red Hat Fuse
Online.

Quick Camel K Demo
https://www.youtube.com/watch?v=I-g2xt-Qcb8

Camel K Chuck Demo
Routes.
java
Telegram Camel K

What is serverless?
“Serverless computing refers to the concept of building and running applications
that don’t require server management. It describes a ﬁner-grained deployment
model where applications, bundled as one or more functions, are uploaded to a
platform and executed, scaled, billed in response to the exact demand needed”
https://github.com/cncf/wg-serverless
Serverless personas:
● Developer: writes code for, and beneﬁts from the serverless platform.
● Provider: manages the serverless platform.

What is serverless?
“Serverless computing refers to the concept of building and running applications that
don’t require server management. It describes a ﬁner-grained deployment model
where applications, bundled as one or more functions, are uploaded to a platform and
executed, scaled, billed in response to the exact demand needed”
https://github.com/cncf/wg-serverless
Serverless personas:
● Developer: writes code for, and beneﬁts from the serverless platform.
● Provider: manages the serverless platform.

Serverless (Compute)
Here’s my personal deﬁnition of “serverless”.
Before it becomes a billing model, we need to deﬁne it “technically”.
Serverless is a programming model based on:

...
1) Auto-scaling services/functions
(including scaling to zero)

2) Event-driven execution
...
1) Auto-scaling services/functions
(including scaling to zero)

Serverless requirements
For the platform
● Scaling to zero
● Rapid scaling up and down
● Eventing mechanism
● Routing and networking
For the application runtime
● Fast startup
● Fast ﬁrst response
● Low on memory and CPU
● Small size on disk

Serverless requirements
For the platform
● Scaling to zero
● Rapid scaling up and down
● Eventing mechanism
● Routing and networking
For the application runtime
● Fast startup
● Fast ﬁrst response
● Low on memory and CPU
● Small size on disk
K

Build
A pluggable model for
building artifacts, like jar
ﬁles, zips or containers
from source code.
Knative Overview - Components
Serving
An event-driven model
that serves the container
with your application and
can "scale to zero".
Eventing
Common infrastructure for
consuming and producing
events that will stimulate
applications.
Kubernetes-based platform to build, deploy, and manage modern serverless workloads

What about Camel K & Knative ?
K

Camel K and Knative
<<custom-resource>>
Build
Knative components relevance to Camel
<<custom-resource>>
...<<custom-resource>>
...
Knative Build
<<custom-resource>>
Service
<<custom-resource>>
...
Knative Serving
<<custom-resource>>
...
Knative Eventing
Standardize building
container images
Auto-scaling and scale-to-zero Messaging for event-based
applications
<<custom-resource>>
Channel

Camel K and Knative
<<custom-resource>>
Build
<<custom-resource>>
...
Knative Build
<<custom-resource>>
Service
<<custom-resource>>
...
Knative Serving
<<custom-resource>>
...
Knative Eventing
container images
applications
<<custom-resource>>
Channel
XNo longer included in
Knative
Use external projects
such as Tekton

Camel K and Knative
<<custom-resource>>
Build
<<custom-resource>>
...
Knative Build
<<custom-resource>>
Service
<<custom-resource>>
...
Knative Serving
<<custom-resource>>
...
Knative Eventing
container images
applications
<<custom-resource>>
Channel
X

Camel K and Knative Serving
Kubernetes Namespace
rest().post(“/path”)
.to(“xx:system1”)
300+ components!
System 1
System 2
Knative
Service

300+ components!
System 1
System 2
Knative
Service
Request

A container is created only when needed!
300+ components!
System 1
System 2
Knative
Service
Request Pod

300+ components!
System 1
System 2
Knative
Service
Request Pod

Scale to zero when no load
300+ components!
System 1
System 2
Knative
Service

300+ components!
System 1
System 2
Knative
Service
Multiple containers under high load!
Request Pod
Request
Request
Pod
Pod

300+ components!
System 1
System 2
Knative
Service
Scale to zero when no load

Camel K and Knative Eventing
300+ components!
System 1
System 2
Channel a
Persisted by
Kafka, in-memory
(pluggable)

from(“knative:channel/a”)
300+ components!
System 1
System 2
Knative
Service
Knative
Subscription
Channel a

300+ components!
System 1
System 2
Knative
Service
Knative
Subscription
Cloud Event
https://cloudevents.io/
Channel a

300+ components!
System 1
System 2
Knative
Service
Knative
Subscription
PodCloud Event
https://cloudevents.io/
Channel a

Camel K: same model for different purposes
Channel
Channel
Channel
Ext
System

Channel
Channel
Channel
Ext
System
Event
Source
(Sink)
300+ components!

Channel
Channel
Channel
Ext
System
Event
Source
(Sink)
Enterprise
Integration
Patterns
(Routing)
300+ components!
65+ patterns

Channel
Channel
Channel
Ext
System
Event
Source
(Sink)
Enterprise
Integration
Patterns
(Routing)
Function
(Integration)
300+ components!
300+ components!
65+ patterns

Knative Eventing includes Camel
Standard Knative
Sources
That can be used
without any knowledge
of Camel K!
... but Camel K is under the
hood :)

Apache Camel K on CNCF
https://camel.apache.org/blog/CamelK-CNCF-Landscape/

Camel K and Knative Demo
Legacy to Telegram
Legacy Telegram

legacy.
groovy

legacy.
groovy
channel/in

legacy.
groovy
channel/in
process.
groovy

legacy.
groovy
channel/in
channel/out
channel/null
process.
groovy

legacy.
groovy
channel/in
channel/out
channel/null
process.
groovy
quarkus.
yaml

legacy.
groovy
channel/in
channel/out
channel/null
process.
groovy
quarkus.
yaml
telegram.
groovy

Quarkus is now supported out of the box with
Camel K since this demo was created
(no longer needed to build your own kit)
https://camel.apache.org/camel-k/latest/traits/quarkus.html

Camel K and Knative Demo (Video)

Characteristic Monolithic/SOA Microservies/CNA Functions/Serverless
Packaging Ear/War/Jar Fat-jar Native executable
Startup procedure XML scanning Annotation scanning Instant (ahead-of-time compilation)
Memory/binary size 1000s MBs 100s MBs 10s of MBs
Startup/ﬁrst response Minutes Seconds Milliseconds
Process lifecycle Long running Managed by platform Ephemeral (executed per request)
State (app/user) Stateful Stateless (no user state) Ephemeral (no application state)
Data ownership Shared data model Owns data No data ownership
Operations Multiple unrelated operations Multiple domain operations Single event driven operation
Scope Multiple business domains Single business domain Single task
Motivation Non-scalable, high complexity
domains
Portable, autonomous,
scalable workloads
Rapid productivity, at the expense
of control and portability
Application trends (Java)

Java Density Problem
CONTAINER ORCHESTRATION
Node Node Node
Traditional Cloud-Native
Java Stack
Java Stack
Java Stack
Java Stack
NodeJS
NodeJS
NodeJS
NodeJS
NodeJS
NodeJS
NodeJS
Go Go Go
Go Go Go
Go Go Go
Go Go Go
Go Go Go
Go Go Go
Go Go Go
https://developers.redhat.com/blog/2017/03/14/java-inside-docker/

SCALE-UP SCALE-DOWN SCALE-TO-
ZERO
Java Fast Scaling Problem

What is Quarkus ?
Supersonic Subatomic Java

What is Quarkus ?
Supersonic Subatomic Java
A Kubernetes Native Java stack tailored for GraalVM &
OpenJDK HotSpot, crafted from the best of breed Java libraries
and standards

Apache Camel and Quarkus runs blazingly fast with native compiled binaries.
Startup is 10 msec, 32mb binary file, and 13mb RSS memory used.

Observabilty Example
● Microproﬁle Health
● Microproﬁle Monitoring
● Random delay 1s to 5s
Jaeger UI

Camel K - Roadmap
● Support for Camel 3 (Now RC3, GA in Nov/Dec 2019)
○ Lightweight modules to reduce footprint
○ Webhook meta-component (more components that
can scale down to 0)
○ Camel K 1.0.0-M3 supports Camel 3.0.0-RC1
● Quarkus as integration runtime
○ Reduced footprint and cold start-up time
○ Native image build in parallel swapped with JVM
image during auto-scaling once ready
● Knative 1.0 → Camel K 1.0.0
● Support the Broker / Trigger model
● Support Tekton builds
● Push-based endpoints
● Fully integrated with Syndesis / Fuse Online
● Better IDE support
● Better integration with CI tools
● BDD testing
● Operator Capability Level 3+

Camel Quarkus - Roadmap
● Camel Extensions on http://code.quarkus.io
● Port more Camel components as Extensions
(22 done out of 300)
● More build time optimisations
● Reduce startup overhead
● Quarkus 1.0 → Camel Quarkus 1.0.0
● Better IDE support

Camel Kafka Connector
● A kafka connector source and sink implementation that embeds camel.
● It is conﬁgurable to use most of the camel-components.
● Making it able to talk with 300+ different kind of external systems.
300+ components!

Camel Debezium
● Stream changes from databases to Camel
● camel-debezium component in Camel 3
○ MySQL connector
○ Other databases on the way ...
Debezium
https://www.youtube.com/watch?time_continue=12&v=xLXx8bUyTtk

Knative
Camel Sources
&
Syndesis

300+ components!
CamelTwitterSource
CamelFacebookSource
CamelTelegramSource
CamelServiceNowSource
Camel components...
“Cloud Edition”
Knative Camel Sources
...

Camel Sources are an addon to Knative, currently in
Knative eventing-contrib
It translates Camel-based Knative eventing sources
into Camel K integrations
https://github.com/knative/eventing-contrib/tree/master/camel/source
apiVersion: sources.eventing.knative.dev/v1alpha1
kind: CamelSource
metadata:
name: camel-timer-flow-source
spec:
source:
flow: |
from:
uri: timer:tick?period=3s
steps:
- set-body:
constant: Hello world!
sink:
apiVersion: eventing.knative.dev/v1alpha1
kind: Channel
name: camel-test
kind: Integration
apiVersion: camel.apache.org/v1alpha1
metadata:
name: my-integration
spec:
source:
- content: |
- from:
steps:
- set-body:
- to:
uri: knative://endpoint/sink
language: yaml
name: flow.yaml
traits:
knative:
configuration:
configuration:
'{"services":[{"type":"endpoint","protocol":"h
ttp","name":"sink","host":"camel-test-channel-
4dlgs.camel-k.svc.cluster.local","port":80,"me
tadata":{"service.path":"/"}}]}'
Camel Sources
Operator

YourOwnSource
from("timer:tick?period={{period}}")
.to("xx:my-system")
.unmarshal().json()
.transform("custom")
.to("knative:endpoint/sink")
A Dev writes Camel K code Users can instantiate the
source to do their job

Serverless Integration Repository
Camel
Source
Camel
Source
Camel
Source
Camel
Source
Camel
Source
Camel
Source
Integration
function
Integration
Integration
function
Integration
apiVersion: sources.eventing.knative.dev/v1alpha1
kind: CamelSource
metadata:
name: camel-timer-flow-source
spec:
source:
flow: |
from:
steps:
- set-body:
sink:
apiVersion: eventing.knative.dev/v1alpha1
kind: Channel
name: camel-test

Serverless Integration
Microservices Microservices Microservices External SaaS
External SaaS
External SaaS
External SaaS
Integration
function
Integration
function
Integration
function
Integration
function
Integration
function
KNative
Service
Service
Service
Service
Microservices Microservices
function

More Material
● Apache Camel K
https://github.com/apache/camel-k
● Apache Camel Quarkus
https://github.com/apache/camel-quarkus
● Quick Camel K demo
https://www.youtube.com/watch?v=I-g2xt-Qcb8
● Camel K Introduction Blog
https://www.nicolaferraro.me/2018/10/15/introducing-camel-k
● Kubernetes enterprise integration patterns with Camel K webinar
https://www.youtube.com/watch?v=51x9BewGCYA
● Camel K and Knative video
https://www.youtube.com/watch?v=lOqubmVSGdw

Any Questions ?
Follow us on Twitter
@davsclaus
@ApacheCamel
https://github.com/apache/camel
A star on github is appreciated

Apache Camel v3, Camel K and Camel Quarkus

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to Apache Camel v3, Camel K and Camel Quarkus

Similar to Apache Camel v3, Camel K and Camel Quarkus (20)

More from Claus Ibsen

More from Claus Ibsen (18)

Recently uploaded

Recently uploaded (20)

Apache Camel v3, Camel K and Camel Quarkus