Camel in Action, Second Edition

Camel in Action, Second Edition

by Claus Ibsen, Jonathan Anstey
Released February 2018
Publisher(s): Manning Publications
ISBN: 9781617292934

Read it now on the O’Reilly learning platform with a 10-day free trial.

O’Reilly members get unlimited access to books, live events, courses curated by job role, and more from O’Reilly and nearly 200 top publishers.

Start your free trial

Book description

Camel in Action, Second Edition is the most complete Camel book on the market. Written by core developers of Camel and the authors of the highly acclaimed first edition, this book distills their experience and practical insights so that you can tackle integration tasks like a pro.



About the Technology

Apache Camel is a Java framework that implements enterprise integration patterns (EIPs) and comes with over 200 adapters to third-party systems. A concise DSL lets you build integration logic into your app with just a few lines of Java or XML. By using Camel, you benefit from the testing and experience of a large and vibrant open source community.



About the Book

Camel in Action, Second Edition is the definitive guide to the Camel framework. It starts with core concepts like sending, receiving, routing, and transforming data. It then goes in depth on many topics such as how to develop, debug, test, deal with errors, secure, scale, cluster, deploy, and monitor your Camel applications. The book also discusses how to run Camel with microservices, reactive systems, containers, and in the cloud.



What's Inside

  • Coverage of all relevant EIPs
  • Camel microservices with Spring Boot
  • Camel on Docker and Kubernetes
  • Error handling, testing, security, clustering, monitoring, and deployment
  • Hundreds of examples in Java and XML


About the Reader

Readers should be familiar with Java. This book is accessible to beginners and invaluable to experts.



About the Authors

Claus Ibsen is a senior principal engineer working for Red Hat specializing in cloud and integration. He has worked on Apache Camel for the last nine years where he heads the project. Claus lives in Denmark.

Jonathan Anstey is an engineering manager at Red Hat and a core Camel contributor. He lives in Newfoundland, Canada.



Quotes
I highly recommend this book to anyone with even a passing interest in Apache Camel. Do take Camel for a ride...and don't get the hump!
- From the Foreword by James Strachan, Creator of Apache Camel

Claus and Jon are great writers, relying on figures and diagrams where needed and presenting lots of code snippets and worked examples.
- From the Foreword by Dr. Mark Little, Technical Director of JBoss

The second edition of this all-time classic is an indispensable companion for your Apache Camel rides.
- Gregor Zurowski, Apache Camel Committer

The absolute best way to learn and use Camel - top to bottom, front to back, and all the way through. Camel is a fantastic tool - every Java coder should have a copy of this book.
- Rick Wagner, Red Hat

An excellent book and the definite reference for experienced engineers.
- Yan Guo, EventBrite

Table of contents

  1. Cover
  2. Camel in Action
  3. Praise for the First Edition
  4. Copyright
  5. Dedication
  6. Foreword
  7. Foreword
  8. Foreword to the First Edition
  9. Preface
  10. Acknowledgments
  11. About This Book
    1. Roadmap
    2. Who should read this book
    3. Code conventions
    4. Source code downloads
    5. Software requirements
    6. Author Online
  12. About the Authors
  13. About the Cover Illustration
  14. Part 1: First steps
    1. Chapter 1: Meeting Camel
      1. 1.1 Introducing Camel
        1. 1.1.1 What is Camel?
        2. 1.1.2 Why use Camel?
      2. 1.2 Getting started
        1. 1.2.1 Getting Camel
        2. 1.2.2 Your first Camel ride
      3. 1.3 Camel’s message model
        1. 1.3.1 Message
        2. 1.3.2 Exchange
      4. 1.4 Camel’s architecture
        1. 1.4.1 Architecture from 10,000 feet
        2. 1.4.2 Camel concepts
      5. 1.5 Your first Camel ride, revisited
      6. 1.6 Summary
    2. Chapter 2: Routing with Camel
      1. 2.1 Introducing Rider Auto Parts
      2. 2.2 Understanding endpoints
        1. 2.2.1 Consuming from an FTP endpoint
        2. 2.2.2 Sending to a JMS endpoint
      3. 2.3 Creating routes in Java
        1. 2.3.1 Using RouteBuilder
        2. 2.3.2 Using the Java DSL
      4. 2.4 Defining routes in XML
        1. 2.4.1 Bean injection and Spring
        2. 2.4.2 The XML DSL
        3. 2.4.3 Using Camel and Spring
      5. 2.5 Endpoints revisited
        1. 2.5.1 Sending to dynamic endpoints
        2. 2.5.2 Using property placeholders in endpoint URIs
        3. 2.5.3 Using raw values in endpoint URIs
        4. 2.5.4 Referencing registry beans in endpoint URIs
      6. 2.6 Routing and EIPs
        1. 2.6.1 Using a content-based router
        2. 2.6.2 Using message filters
        3. 2.6.3 Using multicasting
        4. 2.6.4 Using recipient lists
        5. 2.6.5 Using the wireTap method
      7. 2.7 Summary and best practices
  15. Part 2: Core Camel
    1. Chapter 3: Transforming data with Camel
      1. 3.1 Data transformation overview
      2. 3.2 Transforming data by using EIPs and Java
        1. 3.2.1 Using the Message Translator EIP
        2. 3.2.2 Using the Content Enricher EIP
      3. 3.3 Transforming XML
        1. 3.3.1 Transforming XML with XSLT
        2. 3.3.2 Transforming XML with object marshaling
      4. 3.4 Transforming with data formats
        1. 3.4.1 Data formats provided with Camel
        2. 3.4.2 Using Camel’s CSV data format
        3. 3.4.3 Using Camel’s Bindy data format
        4. 3.4.4 Using Camel’s JSON data format
        5. 3.4.5 Configuring Camel data formats
      5. 3.5 Transforming with templates
        1. 3.5.1 Using Apache Velocity
      6. 3.6 Understanding Camel type converters
        1. 3.6.1 How the Camel type-converter mechanism works
        2. 3.6.2 Using Camel type converters
        3. 3.6.3 Writing your own type converter
      7. 3.7 Summary and best practices
    2. Chapter 4: Using beans with Camel
      1. 4.1 Using beans the hard way and the easy way
        1. 4.1.1 Invoking a bean from pure Java
        2. 4.1.2 Invoking a bean defined in XML DSL
        3. 4.1.3 Using beans the easy way
      2. 4.2 Understanding the Service Activator pattern
      3. 4.3 Using Camel’s bean registries
        1. 4.3.1 JndiRegistry
        2. 4.3.2 SimpleRegistry
        3. 4.3.3 ApplicationContextRegistry
        4. 4.3.4 OsgiServiceRegistry and BlueprintContainerRegistry
        5. 4.3.5 CdiBeanRegistry
      4. 4.4 Selecting bean methods
        1. 4.4.1 How Camel selects bean methods
        2. 4.4.2 Camel’s method-selection algorithm
        3. 4.4.3 Some method-selection examples
        4. 4.4.4 Potential method-selection problems
        5. 4.4.5 Method selection using type matching
      5. 4.5 Performing bean parameter binding
        1. 4.5.1 Binding with multiple parameters
        2. 4.5.2 Binding using built-in types
        3. 4.5.3 Binding using Camel annotations
        4. 4.5.4 Binding using Camel language annotations
        5. 4.5.5 Parameter binding using method name with signature
      6. 4.6 Using beans as predicates and expressions
        1. 4.6.1 Using beans as predicates in routes
        2. 4.6.2 Using beans as expressions in routes
      7. 4.7 Summary and best practices
    3. Chapter 5: Enterprise integration patterns
      1. 5.1 Introducing enterprise integration patterns
        1. 5.1.1 The Aggregator and Splitter EIPs
        2. 5.1.2 The Routing Slip and Dynamic Router EIPs
        3. 5.1.3 The Load Balancer EIP
      2. 5.2 The Aggregator EIP
        1. 5.2.1 Using the Aggregator EIP
        2. 5.2.2 Completion conditions for the Aggregator
        3. 5.2.3 Using persistence with the Aggregator
        4. 5.2.4 Using recovery with the Aggregator
      3. 5.3 The Splitter EIP
        1. 5.3.1 Using the Splitter
        2. 5.3.2 Using beans for splitting
        3. 5.3.3 Splitting big messages
        4. 5.3.4 Aggregating split messages
        5. 5.3.5 When errors occur during splitting
      4. 5.4 The Routing Slip EIP
        1. 5.4.1 Using the Routing Slip EIP
        2. 5.4.2 Using a bean to compute the routing slip header
        3. 5.4.3 Using an Expression as the routing slip
        4. 5.4.4 Using @RoutingSlip annotation
      5. 5.5 The Dynamic Router EIP
        1. 5.5.1 Using the Dynamic Router
        2. 5.5.2 Using the @DynamicRouter annotation
      6. 5.6 The Load Balancer EIP
        1. 5.6.1 Introducing the Load Balancer EIP
        2. 5.6.2 Using load-balancing strategies
        3. 5.6.3 Using the failover load balancer
        4. 5.6.4 Using a custom load balancer
      7. 5.7 Summary and best practices
    4. Chapter 6: Using components
      1. 6.1 Overview of Camel components
        1. 6.1.1 Manually adding components
        2. 6.1.2 Autodiscovering components
      2. 6.2 Working with files: File and FTP components
        1. 6.2.1 Reading and writing files with the File component
        2. 6.2.2 Accessing remote files with the FTP component
      3. 6.3 Asynchronous messaging: JMS component
        1. 6.3.1 Sending and receiving messages
        2. 6.3.2 Request-reply messaging
        3. 6.3.3 Message mappings
      4. 6.4 Networking: Netty4 component
        1. 6.4.1 Using Netty for network programming
        2. 6.4.2 Using custom codecs
      5. 6.5 Working with databases: JDBC and JPA components
        1. 6.5.1 Accessing data with the JDBC component
        2. 6.5.2 Persisting objects with the JPA component
      6. 6.6 In-memory messaging: Direct, Direct-VM, SEDA, and VM components
        1. 6.6.1 Synchronous messaging with Direct and Direct-VM
        2. 6.6.2 Asynchronous messaging with SEDA and VM
      7. 6.7 Automating tasks: Scheduler and Quartz2 components
        1. 6.7.1 Using the Scheduler component
        2. 6.7.2 Enterprise scheduling with Quartz
      8. 6.8 Working with email
        1. 6.8.1 Sending mail with SMTP
        2. 6.8.2 Receiving mail with IMAP
      9. 6.9 Summary and best practices
  16. Part 3: Developing and testing
    1. Chapter 7: Microservices
      1. 7.1 Microservices overview
        1. 7.1.1 Small in size
        2. 7.1.2 Observable
        3. 7.1.3 Designed for failure
        4. 7.1.4 Highly configurable
        5. 7.1.5 Smart endpoints and dumb pipes
        6. 7.1.6 Testable
      2. 7.2 Running Camel microservices
        1. 7.2.1 Standalone Camel as microservice
        2. 7.2.2 CDI Camel as microservice
        3. 7.2.3 WildFly Swarm with Camel as microservice
        4. 7.2.4 Spring Boot with Camel as microservice
      3. 7.3 Calling other microservices
        1. 7.3.1 Recommendation prototype
        2. 7.3.2 Shopping cart prototype
        3. 7.3.3 Rules and inventory prototypes
        4. 7.3.4 Rating prototype
        5. 7.3.5 Putting all the microservices together
      4. 7.4 Designing for failures
        1. 7.4.1 Using the Retry pattern to handle failures
        2. 7.4.2 Using the Retry pattern without Camel
        3. 7.4.3 Using Circuit Breaker to handle failures
        4. 7.4.4 Netflix Hystrix
        5. 7.4.5 Using Hystrix with Camel
        6. 7.4.6 Configuring Hystrix
        7. 7.4.7 Bulkhead pattern
        8. 7.4.8 Calling other microservices with fault-tolerance
        9. 7.4.9 Using Camel Hystrix with Spring Boot
        10. 7.4.10 The Hystrix dashboard
      5. 7.5 Summary and best practices
    2. Chapter 8: Developing Camel projects
      1. 8.1 Managing projects with Maven
        1. 8.1.1 Using Camel Maven archetypes
        2. 8.1.2 Using Maven to add Camel dependencies
      2. 8.2 Using Camel in Eclipse
        1. 8.2.1 Creating a new Camel project
      3. 8.3 Debugging an issue with your new Camel project
      4. 8.4 Developing custom components
        1. 8.4.1 Setting up a new Camel component
        2. 8.4.2 Diving into the implementation
      5. 8.5 Generating components with the API component framework
        1. 8.5.1 Generating the skeleton API project
        2. 8.5.2 Configuring the camel-api-component-maven-plugin
        3. 8.5.3 Setting advanced configuration options
        4. 8.5.4 Implementing remaining functionality
      6. 8.6 Developing data formats
        1. 8.6.1 Generating the skeleton data format project
        2. 8.6.2 Writing the custom data format
      7. 8.7 Summary and best practices
    3. Chapter 9: Testing
      1. 9.1 Introducing the Camel Test Kit
        1. 9.1.1 Using the Camel JUnit extensions
        2. 9.1.2 Using camel-test to test Java Camel routes
        3. 9.1.3 Unit testing an existing RouteBuilder class
      2. 9.2 Testing Camel with Spring, OSGi, and CDI
        1. 9.2.1 Camel testing with Spring XML
        2. 9.2.2 Camel testing with Spring Java Config
        3. 9.2.3 Camel testing with Spring Boot
        4. 9.2.4 Camel testing with OSGi Blueprint XML
        5. 9.2.5 Camel testing with CDI
        6. 9.2.6 Camel testing with WildFly Swarm
        7. 9.2.7 Camel testing with WildFly
      3. 9.3 Using the mock component
        1. 9.3.1 Introducing the mock component
        2. 9.3.2 Unit-testing with the mock component
        3. 9.3.3 Verifying that the correct message arrives
        4. 9.3.4 Using expressions with mocks
        5. 9.3.5 Using mocks to simulate real components
      4. 9.4 Simulating errors
        1. 9.4.1 Simulating errors using a processor
        2. 9.4.2 Simulating errors using mocks
        3. 9.4.3 Simulating errors using interceptors
        4. 9.4.4 Using adviceWith to add interceptors to an existing route
        5. 9.4.5 Using adviceWith to manipulate routes for testing
        6. 9.4.6 Using weave with adviceWith to amend routes
      5. 9.5 Camel integration testing
        1. 9.5.1 Performing integration testing
        2. 9.5.2 Using NotifyBuilder
      6. 9.6 Using third-party testing libraries
        1. 9.6.1 Using Arquillian to test Camel applications
        2. 9.6.2 Using Pax Exam to test Camel applications
        3. 9.6.3 Using other testing libraries
      7. 9.7 Summary and best practices
    4. Chapter 10: RESTful web services
      1. 10.1 RESTful services
        1. 10.1.1 Understanding the principles of a RESTful API
        2. 10.1.2 Using JAX-RS with REST services
        3. 10.1.3 Using Camel in an existing JAX-RS application
        4. 10.1.4 Using camel-restlet with REST services
        5. 10.1.5 Using camel-cxf with REST services
      2. 10.2 The Camel Rest DSL
        1. 10.2.1 Exploring a quick example of the Rest DSL
        2. 10.2.2 Understanding how the Rest DSL works
        3. 10.2.3 Using supported components for the Rest DSL
        4. 10.2.4 Configuring Rest DSL
        5. 10.2.5 Using XML and JSON data formats with Rest DSL
        6. 10.2.6 Calling RESTful services using Rest DSL
      3. 10.3 API documentation using Swagger
        1. 10.3.1 Using Swagger with JAX-RS REST services
        2. 10.3.2 Using Swagger with Rest DSL
        3. 10.3.3 Documenting Rest DSL services
        4. 10.3.4 Documenting input, output, and error codes
        5. 10.3.5 Configuring API documentation
        6. 10.3.6 Using CORS and the Swagger web console
      4. 10.4 Summary and best practices
  17. Part 4: Going further with Camel
    1. Chapter 11: Error handling
      1. 11.1 Understanding error handling
        1. 11.1.1 Recoverable and irrecoverable errors
        2. 11.1.2 Where Camel’s error handling applies
      2. 11.2 Using error handlers in Camel
        1. 11.2.1 Using the default error handler
        2. 11.2.2 The dead letter channel error handler
        3. 11.2.3 The transaction error handler
        4. 11.2.4 The no error handler
        5. 11.2.5 The logging error handler
        6. 11.2.6 Features of the error handlers
      3. 11.3 Using error handlers with redelivery
        1. 11.3.1 An error-handling use case
        2. 11.3.2 Using redelivery
        3. 11.3.3 Using DefaultErrorHandler with redelivery
        4. 11.3.4 Error handlers and scopes
        5. 11.3.5 Reusing context-scoped error handlers
      4. 11.4 Using exception policies
        1. 11.4.1 Understanding how onException catches exceptions
        2. 11.4.2 Understanding how onException works with redelivery
        3. 11.4.3 Understanding how onException can handle exceptions
        4. 11.4.4 Custom exception handling
        5. 11.4.5 New exception while handling exception
        6. 11.4.6 Ignoring exceptions
        7. 11.4.7 Implementing an error-handler solution
        8. 11.4.8 Bridging the consumer with Camel’s error handler
      5. 11.5 Working with other error-handling features
        1. 11.5.1 Using onWhen
        2. 11.5.2 Using onExceptionOccurred
        3. 11.5.3 Using onRedeliver
        4. 11.5.4 Using retryWhile
      6. 11.6 Summary and best practices
    2. Chapter 12: Transactions and idempotency
      1. 12.1 Why use transactions?
        1. 12.1.1 The Rider Auto Parts partner integration application
        2. 12.1.2 Setting up the JMS broker and the database
        3. 12.1.3 The story of the lost message
      2. 12.2 Transaction basics
        1. 12.2.1 Understanding Spring’s transaction support
        2. 12.2.2 Adding transactions
        3. 12.2.3 Testing transactions
      3. 12.3 The Transactional Client EIP
        1. 12.3.1 Using local transactions
        2. 12.3.2 Using global transactions
        3. 12.3.3 Transaction starting from a database resource
        4. 12.3.4 Transaction redeliveries
        5. 12.3.5 Using different transaction propagations
        6. 12.3.6 Returning a custom response when a transaction fails
      4. 12.4 Compensating for unsupported transactions
        1. 12.4.1 Introducing UnitOfWork
        2. 12.4.2 Using synchronization callbacks
        3. 12.4.3 Using onCompletion
      5. 12.5 Idempotency
        1. 12.5.1 Idempotent Consumer EIP
        2. 12.5.2 Idempotent repositories
        3. 12.5.3 Clustered idempotent repository
      6. 12.6 Summary and best practices
    3. Chapter 13: Parallel processing
      1. 13.1 Introducing concurrency
        1. 13.1.1 Running the example without concurrency
        2. 13.1.2 Using concurrency
      2. 13.2 Using thread pools
        1. 13.2.1 Understanding thread pools in Java
        2. 13.2.2 Using Camel thread pool profiles
        3. 13.2.3 Creating custom thread pools
        4. 13.2.4 Using ExecutorServiceManager
      3. 13.3 Parallel processing with EIPs
        1. 13.3.1 Using concurrency with the Threads EIP
        2. 13.3.2 Using concurrency with the Multicast EIP
        3. 13.3.3 Using concurrency with the Wire Tap EIP
      4. 13.4 Using the asynchronous routing engine
        1. 13.4.1 Hitting the scalability limit
        2. 13.4.2 Scalability in Camel
        3. 13.4.3 Components supporting asynchronous processing
        4. 13.4.4 Asynchronous API
        5. 13.4.5 Writing a custom asynchronous component
        6. 13.4.6 Potential issues when using an asynchronous component
      5. 13.5 Summary and best practices
    4. Chapter 14: Securing Camel
      1. 14.1 Securing your configuration
        1. 14.1.1 Encrypting configuration
        2. 14.1.2 Decrypting configuration
      2. 14.2 Web service security
        1. 14.2.1 Authentication in web services
        2. 14.2.2 Authenticating web services using JAAS
      3. 14.3 Payload security
        1. 14.3.1 Digital signatures
        2. 14.3.2 Payload encryption
      4. 14.4 Transport security
        1. 14.4.1 Defining global SSL configuration
      5. 14.5 Route authentication and authorization
        1. 14.5.1 Configuring Spring Security
      6. 14.6 Summary and best practices
  18. Part 5 : Running and managing Camel
    1. Chapter 15: Running and deploying Camel
      1. 15.1 Starting Camel
        1. 15.1.1 How Camel starts
        2. 15.1.2 Camel startup options
        3. 15.1.3 Ordering routes
        4. 15.1.4 Disabling autostartup
      2. 15.2 Starting and stopping routes at runtime
        1. 15.2.1 Using CamelContext to start and stop routes at runtime
        2. 15.2.2 Using the Control Bus EIP to start and stop routes at runtime
        3. 15.2.3 Using RoutePolicy to start and stop routes at runtime
      3. 15.3 Shutting down Camel
        1. 15.3.1 Graceful shutdown
      4. 15.4 Deploying Camel
        1. 15.4.1 Embedded in a Java application
        2. 15.4.2 Embedded in a web application
        3. 15.4.3 Embedded in WildFly
      5. 15.5 Camel and OSGi
        1. 15.5.1 Setting up Maven to generate an OSGi bundle
        2. 15.5.2 Installing and running Apache Karaf
        3. 15.5.3 Using an OSGi Blueprint-based Camel route
        4. 15.5.4 Deploying the example
        5. 15.5.5 Using a managed service factory to spin up route instances
      6. 15.6 Camel and CDI
      7. 15.7 Summary and best practices
    2. Chapter 16: Management and monitoring
      1. 16.1 Monitoring Camel
        1. 16.1.1 Checking health at the network level
        2. 16.1.2 Checking health level at the JVM level
        3. 16.1.3 Checking health at the application level
      2. 16.2 Using JMX with Camel
        1. 16.2.1 Using JConsole to manage Camel
        2. 16.2.2 Using JConsole to remotely manage Camel
        3. 16.2.3 Using Jolokia to manage Camel
      3. 16.3 Tracking application activity
        1. 16.3.1 Using log files
        2. 16.3.2 Using core logs
        3. 16.3.3 Using custom logging
        4. 16.3.4 Using Tracer
        5. 16.3.5 Using notifications
      4. 16.4 Managing Camel applications
        1. 16.4.1 Managing Camel application lifecycles
        2. 16.4.2 Using Jolokia and hawtio to manage Camel lifecycles
        3. 16.4.3 Using Control Bus to manage Camel
      5. 16.5 The Camel management API
        1. 16.5.1 Accessing the Camel management API using Java
        2. 16.5.2 Using Camel management API from within Camel
        3. 16.5.3 Performance statistics
        4. 16.5.4 Management-enable custom Camel components
        5. 16.5.5 Management-enable custom Java beans
      6. 16.6 Summary and best practices
  19. Part 6: Out in the wild
    1. Chapter 17: Clustering
      1. 17.1 Clustered HTTP
      2. 17.2 Clustered Camel routes
        1. 17.2.1 Active/passive mode
        2. 17.2.2 Active/active mode
        3. 17.2.3 Clustered active/passive mode using Hazelcast
        4. 17.2.4 Clustered active/passive mode using Consul
        5. 17.2.5 Clustered active/passive mode using ZooKeeper
      3. 17.3 Clustered JMS
        1. 17.3.1 Client-side clustering with JMS and ActiveMQ
      4. 17.4 Clustered Kafka
        1. 17.4.1 Kafka consumer offset
        2. 17.4.2 Crashing a JVM with a running Kafka consumer
      5. 17.5 Clustering caches
        1. 17.5.1 Clustered cache using Hazelcast
        2. 17.5.2 Clustered cache using JCache and Infinispan
      6. 17.6 Using clustered scheduling
        1. 17.6.1 Clustered scheduling using Quartz
      7. 17.7 Calling clustered services using the Service Call EIP
        1. 17.7.1 How the Service Call EIP works
        2. 17.7.2 Service Call using static service registry
        3. 17.7.3 Service Call with failover
        4. 17.7.4 Configuring Service Call EIP
        5. 17.7.5 Service Call URI templating
        6. 17.7.6 Service Call using Spring Boot Cloud and Consul
      8. 17.8 Summary and best practices
    2. Chapter 18: Microservices with Docker and Kubernetes
      1. 18.1 Getting started with Camel on Docker
        1. 18.1.1 Building and running Camel microservices locally
        2. 18.1.2 Building and running Camel microservices using Docker
        3. 18.1.3 Building a Docker image using the Docker Maven plugin
        4. 18.1.4 Running Java microservices on Docker
      2. 18.2 Getting started with Kubernetes
        1. 18.2.1 Installing Minikube
        2. 18.2.2 Starting Minikube
      3. 18.3 Running Camel and other applications in Kubernetes
        1. 18.3.1 Running applications using kubectl
        2. 18.3.2 Calling a service running inside a Kubernetes cluster
        3. 18.3.3 Running Java applications in Kubernetes using Maven tooling
        4. 18.3.4 Java microservices calling each other in the cluster
        5. 18.3.5 Debugging Java applications in Kubernetes
      4. 18.4 Understanding Kubernetes
        1. 18.4.1 Introducing Kubernetes
        2. 18.4.2 Kubernetes architecture
        3. 18.4.3 Essential Kubernetes concepts
      5. 18.5 Building resilient Camel microservices on Kubernetes
        1. 18.5.1 Scaling up microservices
        2. 18.5.2 Using readiness and liveness probes
        3. 18.5.3 Dealing with failures by calling services in Kubernetes
      6. 18.6 Testing Camel microservices on Kubernetes
        1. 18.6.1 Setting up Arquillian Cube
        2. 18.6.2 Writing a basic unit test using Arquillian Cube
        3. 18.6.3 Running Arquillian Cube tests on Kubernetes
        4. 18.6.4 Writing a unit test that calls a Kubernetes service
      7. 18.7 Introducing fabric8, Helm, and OpenShift
        1. 18.7.1 fabric8
        2. 18.7.2 Kubernetes Helm
        3. 18.7.3 OpenShift
      8. 18.8 Summary and best practices
    3. Chapter 19: Camel tooling
      1. 19.1 Camel editors
        1. 19.1.1 JBoss Fuse Tooling
        2. 19.1.2 Apache Camel IDEA plugin
        3. 19.1.3 Camel validation using Maven
      2. 19.2 Camel Catalog: the information goldmine
      3. 19.3 hawtio: a web console for Camel and Java applications
        1. 19.3.1 Understanding hawtio functionality
        2. 19.3.2 Debugging Camel routes using hawtio
      4. 19.4 Summary and best practices
    4. Chapter 20: Reactive Camel
      1. 20.1 Using Reactive Streams with Camel
        1. 20.1.1 Reactive Streams API
        2. 20.1.2 Reactive flow control with back pressure
        3. 20.1.3 First steps with Reactive Streams
        4. 20.1.4 Using Camel with Reactive Streams
        5. 20.1.5 Controlling back pressure from the producer side
        6. 20.1.6 Controlling back pressure from the consumer side
      2. 20.2 Using Vert.x with Camel
        1. 20.2.1 Building a football simulator using Vert.x
        2. 20.2.2 Using Camel together with Vert.x
        3. 20.2.3 Summary of using Camel with Vert.x for microservices
      3. 20.3 Summary and best practices
    5. Chapter 21: Camel and the IoT
      1. 21.1 The Internet of Things shopping list
        1. 21.1.1 Raspberry Pi
        2. 21.1.2 SD card for Raspberry Pi
        3. 21.1.3 Power bank for Raspberry Pi
        4. 21.1.4 Camera for Raspberry Pi
        5. 21.1.5 TI SensorTag
      2. 21.2 The Internet of Things architecture
      3. 21.3 Why Camel is the right choice for the IoT
        1. 21.3.1 Components
        2. 21.3.2 Data formats
        3. 21.3.3 Redelivery
        4. 21.3.4 Throttling
        5. 21.3.5 Content-based routing
        6. 21.3.6 Client-side load balancing
        7. 21.3.7 Control bus
      4. 21.4 Gateway-to-data-center connectivity
        1. 21.4.1 Understanding the architecture
        2. 21.4.2 Choosing a protocol
      5. 21.5 Camel and Eclipse Kura
        1. 21.5.1 Starting Kura in emulator mode
        2. 21.5.2 Defining Camel routes using the Kura web UI
        3. 21.5.3 Next steps with Camel and Kura
      6. 21.6 Next steps with Camel and the IoT
        1. LWM2M and the Eclipse Leshan project
        2. Eclipse Hono
      7. 21.7 Summary
  20. Appendix A: Simple, the expression language
    1. A.1 Introducing Simple
    2. A.2 Syntax
    3. A.3 Built-in variables
    4. A.4 Built-in functions
    5. A.5 Built-in file variables
    6. A.6 Built-in operators
      1. A.6.1 Combining expressions
    7. A.7 The OGNL feature
    8. A.8 Using Simple from custom Java code
    9. Summary
  21. Appendix B: The Camel community
    1. Apache Camel website
    2. JIRA, mailing lists, Gitter, and IRC
    3. Camel at GitHub
    4. Camel at Stack Overflow
    5. Commercial Camel offerings
    6. Camel tooling
    7. Camel-extra project
    8. Becoming a Camel committer
    9. Videos
    10. Other resources
  22. Index

Product information

  • Title: Camel in Action, Second Edition
  • Author(s): Claus Ibsen, Jonathan Anstey
  • Release date: February 2018
  • Publisher(s): Manning Publications
  • ISBN: 9781617292934