Integration and Batch Processing on Cloud Foundry

Enterprise Application Integration and
Batch Processing in the Cloud
Josh Long, Spring Developer Advocate
josh.long@springsource.com @starbuxman

© 2012 SpringOne 2GX. All rights reserved. Do not distribute without permission.

Josh Long
Spring Developer Advocate
josh.long@springsource.com @starbuxman

2

Worker processes on Cloud Foundry

Lots of Potential
 http://blog.springsource.org/2012/05/09/using-cloud-foundry-workers-with-spring/
 lots of use cases ---
applications:
• background jobs target/appassembler/:
• headless applications name: integration-service
• batch jobs framework:
• embedded web servers name: standalone
info:
mem: 64M
description: Standalone Application
exec:
runtime: java
command: bin/main
url:
mem: 512M
instances: 1
services:
stock_rabbitmq:
type: rabbitmq

4

Easy to Package Multi-component Java applications
<build>
<plugins>
<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>appassembler-maven-plugin</artifactId>
<executions>
<execution>
<phase>package</phase>
<goals>
<goal>assemble</goal>
</goals>
<configuration>
<assembledirectory>target</assembledirectory>
<programs>
<program>
<mainClass>org.cloudfoundry.workers.stocks.integration.service.Main</mainClass>
</program>
</programs>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
</build>

5

Cloud Scale Messaging with RabbitMQ

First, an Introduction to
AMQP & RabbitMQ

Messaging Use Cases

Decoupling

producer consumer

shopping cart sending request CC merchant

NOT CONFIDENTIAL -- TELL EVERYONE 8

Messaging Use Cases

Bidirectional Decoupling

producer consumer

eg: remote procedure call


Messaging Use Cases


producer producer

consumer

eg: place order and wait for confirmation


Messaging Use Cases


producer consumer producer

consumer

eg: place order and wait for confirmation


Messaging Use Cases

work distribution and decoupling

consumer

producer consumer

distribution can be duplicate or round-robin:
- duplication for information (logging, auditing, etc)
- round robin for scaling and load balancing


Messaging Use Cases

 Other Things a Message Broker Can Do
• Store-and-forward of messages
• Absorbing spikes of activity (again, decoupling)
• Routing to different consumers based on message properties


AMQP and JMS

How does AMQP compare to JMS?
When would I use one or the other?


AMQP and JMS

AMQP JMS
Protocol API
No language Java
Industry committee, mainly finance JEE

Interoperability from client libraries Interoperability from proprietary features

Resources can be managed by clients Resources often centrally managed

Not ubiquitous in enterprise Ubiquitous through JEE

Flexible usage patterns, emphasise routing Two basic producer patterns (Queue and Topic)

Designed for large numbers of queues and exchanges Hard to manage large numbers of Destinations


AMQP and JMS

 JMS
• standard in the Java space
• lots of open source options
• provided with Java EE application servers
• Spring JMS

Java producers Message broker Java consumers

C
P queue

C

P queue
C

16

JMS

 Sending JMS Messages
• Inject an instance of Spring's JmsTemplate.
• Provide the JMS ConnectionFactory in the JmsTemplate bean definition.

@Component
public class MessageSender {

@Autowired
private volatile JmsTemplate jmsTemplate;

public void send(String message) {
this.jmsTemplate.convertAndSend("example.queue", message);
}

} @Bean public ConnnectionFactory cf (){
return new CachingConnectionFactory(...);
}
@Bean public JmsTemplate template(){
return new JmsTemplate(this.cf()) ;
}

17

AMQP and JMS

 AMQP
• real standard
• a product of the the companies with the most mission critical requirements
• Spring AMQP

AMQP producers exchanges Message broker AMQP consumers

C
P X queue

C

P X queue
C

1

AMQP and JMS

 JMS Topic Explosion:
• Messages with fine-grained routing, e.g.
• Market data: region, country, exchange, ticker, …
• Online gambling: sport, match, event-type, …
• Message selectors are inefficient and fiddly to work with in the API
• Exponential explosion of possible combinations of interesting subscriptions
• Can implement as hierarchy of Topics
• 1000s or 10000s of Destinations
• Management nightmare
• Sweet spot for AMQP


AMQP

 Sending AMQP Messages
• Use AmqpTemplate instead of JmsTemplate (accepts exchange and routingKey).
• Nothing changes on the listener side (just a POJO).

@Component public class MessageSender {

@Autowired
private volatile AmqpTemplate amqpTemplate;

public void send(String message) {
this.amqpTemplate.convertAndSend(
"myExchange", "some.routing.key", message);
}

}

20

Spring AMQP
 Java and .NET
 AMQP core abstraction plus RabbitMQ implementation (built on rabbit client libraries)
 Higher level patterns for clients: admin, producers and consumers
 RabbitAdmin – declare exchanges, queues, bindings
 RabbitTemplate – convenience methods for send and receive
 MessageListenerContainer – POJO message handler, asynchronous
 Spring Integration support
http://www.springsource.org/spring-amqp


Spring AMQP: RabbitTemplate

public class MyComponent {
private RabbitTemplate rabbitTemplate;

public MyComponent(ConnectionFactory connectionFactory) {
this.rabbitTemplate = new RabbitTemplate(connectionFactory);
}

public void read() throws Exception {
...
String value = rabbitTemplate.receiveAndConvert("myQueueName");
...
}

}
Convenience methods


Spring AMQP: SimpleMessageListenerContainer
 Asynchronous message receiver
 POJO handlers
 Handles re-connection and listener failure (rollback, redelivery)
 Message conversion and error handling strategies

<listener-container connection-factory="connectionFactory">
<listener ref="handler" method="handle" queue-names="my.queue">
</listener-container>


Messaging Use Cases

 Patterns:
 spatial decoupling (aka communication)
 temporal decoupling (aka buffering)
 logical decoupling (aka routing)
 Promote: flexibility, resilience, performance, and scale
 Conclusion: There is an enormous range of applications and problems to which messaging is
an effective solution.


Not confidential. Tell everyone. 25

Batch Processing in the Cloud


First, an Introduction to Spring Batch


Why we’re here...


...So, What’s the Problem?


Job and Step

Job
* Step
*
JobInstance

Step Scope
*
JobExecution
* StepExecution


Getting Started

Application
Developer
implements ItemProcessor (optional)

input output (optional)
configures
ItemReader ItemWriter

Job

* StepExecutor concerns
Step

RepeatOperations ExceptionHandler


Spring Batch

 Supports Batch API...
• Jobs have Steps
• Steps have Readers, and optional Processors and Writers
• Readers read data
• Processors process data coming into them, optionally transforming it. Optional.
• Writers write data out


ItemReader

public interface ItemReader<T> {

T read() throws Exception,
UnexpectedInputException,
ParseException,
NonTransientResourceException;

}
Returns null at end of dataset

delegate Exception handling to framework


ItemProcessor (Optional)

public interface ItemProcessor<I, O> {
O process(I item) throws Exception;
}

Delegate Exception handling to framework


ItemWriter

public interface ItemWriter<T> {

void write(List<? extends T> items) throws Exception;

}

expects a “chunk”

delegate Exception handling to framework


All Together...

<job id="skipJob" incrementer="incrementer"
xmlns="http://www.springframework.org/schema/batch">

<step id="step1">
<tasklet>

<chunk reader="ﬁleItemReader"
processor="tradeProcessor"
writer="tradeWriter"
commit-interval="3" skip-limit="10">
</chunk>
</tasklet>
<next on="*" to="step2" />

<next on="COMPLETED WITH SKIPS" to="errorPrint1" />

<fail on="FAILED" exit-code="FAILED" />

</step>

...
</job>


Partitioning Overview

Job

Step

Step

Step


Partitioning Overview

Job

Slave
Step
Slave

Slave
Master
Slave

Slave
Step
Slave


Requests

We Have a Cloud, Let’s Scale!

 Spring Batch supports Remote Chunking over AMQP
• http://labs.bsb.com/2011/11/remote-partitioning-with-spring-batch/
• http://bit.ly/wrb8Ch
master

step execution results

RabbitMQ

Step Execution
Requests

slave 1 slave 2 slave 3


Simple Strategy SPI for Distribution and Aggregation


Application Integration (in the Cloud)


Integration's More Common Than You Think

channel
System A

System A
System A System B

6

Nobody Builds Systems in a Vacuum

do NOT reinvent
the Wheel!


Don't over extend your architecture!

Rooted in Classic Patterns

• By Gregor Hohpe & Bobby Woolf
• Published 2003
• Collection of well-known patterns
• http://www.eaipatterns.com/eaipatterns.html
• Icon library provided


What is Spring Integration?

• Light-weight messaging framework
• Provides an adapter-based platform

• Pipes and Filters at the core of Spring Integration’s architecture
– Endpoint (Filter)
– Channel (Pipe)
– Message


DEMO
• Spring Integration Primer

@starbuxman slideshare.net/joshlong

Spring Integration @Gateway

 Gateways...
• hide one system from the messaging semantics of another
• Support all the message exchange patterns
• Request
• Request asynchronous (fire-n-forget)
• Request/Reply
• Request/Reply asynchronous (fire-n-forget)

public class CustomerService {
void addCustomer( Customer customer )
throws CrmException;

}



MessageChannel crmChannel = ...;

MessagingOperations operations = .... ;

operations.sendAndReceive( crmChannel ,
MessageBuilder.withPayload(new Customer(..)).build() );



public interface CustomerService {
@Gateway
void addCustomer( Customer customer )
throws CrmException;

}


DEMO
• using Spring Integration gateways


Summary

 RabbitMQ is readily available Messaging in the Cloud
 Spring Integration makes integration over AMQP easy
 Spring Batch Makes Batch Jobs Easy
• Remote Chunking Makes Using AMQP as the Coordination Fabric Easy


springsource.org | cloudfoundry.org

Questions?
Say hi!
@starbuxman josh.long@springsource.com

Integration and Batch Processing on Cloud Foundry

More Related Content

What's hot (20)

Similar to Integration and Batch Processing on Cloud Foundry (20)

More from Joshua Long (20)

Recently uploaded (20)

Integration and Batch Processing on Cloud Foundry

Editor's Notes