Developing applications with Cloud Services (jax jax2013)

DEVELOPING WITH CLOUD
SERVICES
Chris Richardson
Author of POJOs in Action
Founder of the original CloudFoundry.com
@crichardson
chris.richardson@springsource.com
http://plainoldobjects.com

@crichardson
Presentation goal
How to build robust,
scalable applications with
Cloud Services

@crichardson
About Chris
http://www.theregister.co.uk/2009/08/19/springsource_cloud_foundry/

@crichardson
vmc push About-Chris
Developer Advocate for
CloudFoundry.com

@crichardson
Agenda
• Why use cloud services?
• Developing location-based applications
• Building SMS and telephony enabled applications
• Developing robust, fault tolerant applications

@crichardson
Three phases of every galactic
civilization
Survival
Inquiry
Sophistication

@crichardson
Three phases of every galactic
civilization
How
Why
Where
can we eat?
do we eat?
Where shall we have lunch?

@crichardson
Where shall we
have lunch?

@crichardson
Solved byVoteMeetEat.com
•What restaurants are nearby?
•Which friends are close by?
•Where do your friends prefer to eat?
To sign up text
"register" to 510-
XXX-YYYY

@crichardson
VoteMeetEat.com
Friend and restaurant location databases
+
SMS
+
Voice calls
To sign up text
"register" to 510-
XXX-YYYY

@crichardson
Key story: registration
5
551212

@crichardson
Key story: registration
+5105551212

@crichardson
Key story: voting
555 1212

@crichardson
Key story: announce location

VOTEMEETEAT.COM
To sign up text
"register" to 510-
XXX-YYYY

@crichardson
High-level architecture
VoteMeet
Eat
Telephony
Integration
Friend Geo
Database
Restaurant
Database
Mobile
Phone
Do we really want to
build all this?
DIY = DIFFICULT

@crichardson
Use cloud-based services
• Highly scalable services
• Someone else’s headache to develop and maintain
• Provided by IaaS/PaaS
• Provided by 3rd party

@crichardson
Cloud Foundry services

@crichardson
Thousands of 3rd party services
http://www.programmableweb.com/apis/directory
http://www.slideshare.net/jmusser/j-musser-apishotnotgluecon2012

@crichardson
• Predominantly REST
• Predominantly JSON
• > billion API calls/day:Twitter, Google, Facebook, Netﬂix,
Accuweather, ...
• Increasing number of API-only companies
http://www.slideshare.net/jmusser/j-musser-apishotnotgluecon2012
Cloud service trends

@crichardson
Beneﬁts of cloud services
• Someone else’s headache to develop and operate
• Focus on your core business problem
• Get up and running quickly
• Elasticity
• Capex Opex

@crichardson
Drawbacks of cloud services
• Complexity and drawbacks of a distributed system
• You are dependent on service provider

@crichardson
Risks of cloud services
Urban Airship’s Strategic Partnership With
SimpleGeoTurns Into An Acquisition

@crichardson
Cloud Services-based
architecture
VoteMeetEat
Twilio
MongoDB
Factual.Com
Mobile
Phone

@crichardson
Location-based services are hot!

@crichardson
Client-side APIs for ﬁnding
location
W3C Geolocation API

@crichardson
BUT what about the server-side?

@crichardson
Lots of really difﬁcult problems
•Scalable, spatial database – CRUD records, ﬁnd nearby
•Data management – database of places, street information
•Forward geo-coding: address lat/lon
•Reverse geo-coding: lat/lon address
•Maps
•Directions
Easier to use Geo-aaS

@crichardson
Examples of Geo-aaS
Beware the terms of
service
• Maps
• Forward and reverse geocoding
• Directions
• Elevation
• Places
• Freely available geographic
database
• Various APIs including
reverse geocoding
• Business+review database
• Neighborhood database
• Places database
• Reverse geocoding

@crichardson
VoteMeetEat.com & Geo
trait FriendService {
def addOrUpdate(request : AddOrUpdateUserRequest)
def findNearbyFriends(request : NearbyFriendsRequest) :
FindNearbyFriendsResponse
}
trait RestaurantService {
def findNearbyRestaurants(location: Location) :
FindNearbyRestaurantResponse
}

@crichardson
def addOrUpdate(request : AddOrUpdateUserRequest)
FindNearbyFriendsResponse
}
Implementing the friends
database

@crichardson
MongoDB
• Document-oriented database
• Very fast, highly scalable and available
• Rich query language that supports location-
based queries
• Provided by CloudFoundry.com

@crichardson
MongoDB server
Database: VoteMeetEat
Collection: friendRecord
Storing friends in MongoDB
{
"_id": "+15105551212",
"name": "Chris R.",
"location": {
"x": -122.25206103187264,
"y": 37.847427441773796
}
}

@crichardson
Spring Data for MongoDB
• Provides MongoTemplate
• Analogous to JdbcTemplate
• Hides boilerplate code
• Domain object Document mapping

@crichardson
Using Spring data: creating an
index on location attribute
@Component
class MongoFriendService extends FriendService {
@Autowired
var mongoTemplate: MongoTemplate = _
@PostConstruct
def createGeoIndex {
val dbo = new BasicDBObject
dbo.put("location", "2d")
mongoTemplate.getCollection("friendRecord").ensureIndex(dbo)
}
Create geospatial 2d index
Collection name
Attribute and
index type

@crichardson
Using Spring Data: adding record
@Component
override def addOrUpdate(request: AddOrUpdateUserRequest) = {
val name = request.name
val phoneNumber = request.phoneNumber
val fr = new FriendRecord(phoneNumber, name,
new Point(request.longitude, request.latitude))
mongoTemplate.save(fr)
}
case class FriendRecord(id : String,
name : String,
location : Point)

@crichardson
Using Spring Data: ﬁnding nearby
friends
@Component
override def findNearbyFriends(request: NearbyFriendsRequest) = {
val location = new Point(request.longitude, request.latitude)
val distance = new Distance(3, Metrics.MILES)
val query = NearQuery.near(location).maxDistance(distance)
val result = mongoTemplate.geoNear(query, classOf[FriendRecord])
val nearby = result.getContent.map(_.getContent)
FindNearbyFriendsResponse(nearby.map(f => FriendInfo(f.name, f.id)))
}

@crichardson
MongoDB and Cloud Foundry
$ vmc create-service mongodb vme-mongo

@crichardson
$ vmc push vme-user --path web/target/
Application Deployed URL [cer-spring.cloudfoundry.com]:
Detected a Java SpringSource Spring Application, is this correct? [Yn]:
Memory Reservation (64M, 128M, 256M, 512M, 1G) [512M]:
Creating Application: OK
Would you like to bind any services to 'vme-user'? [yN]: y
Would you like to use an existing provisioned service? [yN]: y
The following provisioned services are available
1: vme-mongo
2: mysql-135e0
Please select one you wish to use: 1
Binding Service [vme-mongo]: OK
Uploading Application:
Checking for available resources: OK
Processing resources: OK
Packing application: OK
Uploading (12K): OK
Push Status: OK
Binding a service to an application
Would you like to bind any services to 'vme-user'? [yN]: y
Would you like to use an existing provisioned service? [yN]: y
The following provisioned services are available
1: vme-mongo
2: mysql-135e0
Please select one you wish to use: 1
Binding Service [vme-mongo]: OK

@crichardson
Connecting to MongoDB
<bean id="mongoTemplate"
class="org.springframework.data.mongodb.core.MongoTemplate">
<constructor-arg ref="mongoFactory" />
</bean>
<beans profile="default">
<mongo:db-factory id="mongoFactory" dbname="surveygeo" />
</beans>
<beans profile="cloud">
<cloud:mongo-db-factory id="mongoFactory" />
</beans>
Outside of Cloud Foundry
Inside Cloud Foundry

@crichardson
Implementing the restaurant
database
FindNearbyRestaurantResponse
}

@crichardson
Using Factual
• Geographic database as a Service
• Including 1.2M restaurants in the US
• Pricing: 10K calls day free, pay per use

@crichardson
Factual API
• RESTful/JSON interface
• Uses 2-legged OAuth 1.0.
• Geo and text ﬁlters
• Pagination
• Libraries for various languages

@crichardson
Restaurant Service
@Service
class FactualRestaurantService extends RestaurantService {
@Value("${factual_consumer_key}") var consumerKey: String = _
@Value("${factual_consumer_secret}") var consumerSecret: String = _
var factual: Factual = _
@PostConstruct
def initialize {
factual = new Factual(consumerKey, consumerSecret, true)
}
override def findNearbyRestaurants(location: Location) = {
...
val restaurants = factual.get.fetch("restaurants-us",
new Query().within(new Circle(location.lat, location.lon, 1000)).limit(5))
val rs = restaurants.getData.map { map =>
RestaurantInfo(map.get("name").asInstanceOf[String])
}
FindNearbyRestaurantResponse(rs.toList)
}
...
5 restaurants within 1km

@crichardson
The telephony and SMS are
important
http://blog.nielsen.com/nielsenwire/online_mobile/new-mobile-obsession-
u-s-teens-triple-data-usage/
7/ waking hr !
Nielsen

@crichardson
Reporting trafﬁc light problems in London

@crichardson
Google 2-Factor authentication

@crichardson
VoteMeetEat.com &Telephony
• Handling registration SMS
• Sending SMS notifying users to vote
• Handling incoming voice call from voters:
• Text-to-speech of restaurants options
• Collecting digits entered via keypad
• Sending SMS/Voice notiﬁcations of voting results

@crichardson
DIY telephony = Difﬁcult
• Difﬁcult to setup and operate
• Expensive
• Complex SMS protocols
• …
Better to use SMS/Telephony-aaS:

@crichardson
Telephony/SMS - aaS
• SMS
• Inbound and outgoing calls
• Recording and transcription
• SMS
• Inbound and outgoing calls
• Recording and transcription
• Twitter
• IM

@crichardson
Twilio -Telephony and SMS as a
service
• REST API
• Allocate phone numbers
• Make and receive phone calls
• Send and receive SMS messages
• Pay per use:
• Phone calls - per-minute
• SMS – per SMS sent or received
• Phone number – per month
• Examples
• OpenVBX is a web-based, open source phone system
• StubHub – notiﬁes sellers of a pending sale via phone
• SurveyMonkey – interactive polling
• Salesforce – SMS-based voting for 19,000 conference attendees

@crichardson
UsingTwilio
Twilio Your
Application
TwiML doc
HTTP GET/
POST
REST API
Manage resources
Send SMS
Initiate voice calls
Handle incoming SMS and voice calls
Respond to user input
Voice
SMS
Phone number
SMS URL +VOICE URL

@crichardson
Handling SMS registration
5
551212
User
texts
‘register’
System
replies

@crichardson
Twilio
SMS
REGISTRATION
HTTP POST
http://≪smsUrl≫?From=≪PhoneNumber≫&
Body=≪Message≫&...
<Response>
<Sms>To complete registration please
go to http://...
</Sms>
</Response>
SMS

@crichardson
TwiML document
describing the
response

@crichardson
Inviting users to vote
5551212555121255512125551212
System sends
text

@crichardson
Inviting users to vote
POST /2010-04-01/Accounts/≪AccountSID≫/SMS/Messages
From=+15105551212
&To=+14155551212
&Body=≪MESSAGE≫
Authorization: Basic ....
Basic auth usingTwilio
AccountSid+AuthToken

@crichardson
Sending SMS using the Spring
RestTemplate
@Component
class TwilioService {
def sendSms(recipient : String, message : String) = {
val response = postToTwilio("SMS/Messages",
Map("From" -> twilioPhoneNumber, "To" -> recipient, "Body" -> message))
(response "SMSMessage" "Sid").text
}

@crichardson
Sending SMS using the Spring
RestTemplate
@Component
class TwilioService {
def postToTwilio(resourcePath : String, requestParams : Map[String, String]) = {

val entity = makeEntity(requestParams)
try {
val response = restTemplate.postForObject(twilioUrl +
"/Accounts/{accountSid}/{resource}",
entity, classOf[String],
accountSid, resourcePath)
XML.loadString(response)
} catch {
case e : HttpClientErrorException if e.getStatusCode == HttpStatus.BAD_REQUEST =>
val body = e.getResponseBodyAsString()
val xmlBody = XML.loadString(body)
val code = Integer.parseInt((xmlBody "Code").text)
val message = (xmlBody "Message").text
throw new TwilioRestException(message, code)
}
}

@crichardson
Voting: user calls number
555 1212

@crichardson
Voting
Twilio
Survey Management
<Response>
<Say> Chris would like to meet and eat. </Say>
<Gather action="handleresponse.html"
method="POST" numDigits="1">
<Say>Press 1 for ....</Say>
<Say>Press 2 for ....</Say>
</Gather>
</Response>
HTTP POST
http://≪voiceUrl≫?From=≪PhoneNumber≫
Call

@crichardson
Voting
Twilio
Survey Management
<Response>
<Say>Thank you for choosing.
The most popular place so far is ...
</Say>
<Pause/>
<Say>You will hear from us soon. Good bye</Say>
<Hangup/>
</Response>
HTTP POST
http://....handleresponse.html?
From=≪PhoneNumber≫&Digits=≪...≫
Digits

@crichardson
Voting code 1
@Controller
class TwilioController {
@Autowired
var surveyManagementService: SurveyManagementService = _
@RequestMapping(value = Array("/begincall.html"))
@ResponseBody
def beginCall(@RequestParam("From") callerId: String) = {
surveyManagementService.findSurveyByCallerId(callerId) match {
case None =>
<Response>
<Say>Sorry don't recognize your number</Say>
<Hangup/>
</Response>
case Some(survey) =>
<Response>
<Say>{ survey.prompt }</Say>
<Gather action="handleresponse.html" method="POST" numDigits="1">
{
for ((choice, index) <- survey.choices zipWithIndex)
yield <Say>Press { index } for { choice }</Say>
}
</Gather>
<Say>We are sorry you could not decide</Say>
<Hangup/>
</Response>
}
}

@crichardson
Voting code 2
class TwilioController {
...
@RequestMapping(value = Array("/handleresponse.html"))
@ResponseBody
def handleUserResponse(@RequestParam("From") callerId: String,
@RequestParam("Digits") digits: Int) = {
val survey = surveyManagementService.recordVote(callerId, digits)
<Response>
<Say>Thank you for choosing. The most popular place so far is
{ survey.map(_.mostPopularChoice) getOrElse "oops" }
</Say>
<Pause/>
<Say>You will hear from us soon. Good bye</Say>
<Hangup/>
</Response>
}
}

@crichardson
The need for parallelism
Service A
Service B
Service C
Service D
b = serviceB()
c = serviceC()
d = serviceD(b, c)
Call in parallel

@crichardson
Futures are a great concurrency
abstraction
• Object that will contain the result of a concurrent computation -
http://en.wikipedia.org/wiki/Futures_and_promises
• Various implementations
• Java 7 Futures = ok
• Guava ListenableFutures = better
• Scala’s composable Futures = really good
• Java 8 CompletableFuture = great
Future<Integer> result =
executorService.submit(new Callable<Integer>() {... });

@crichardson
Using futures to parallelize requests
Future[FindNearbyFriendsResponse]
}
Future[FindNearbyRestaurantResponse]
}
val f1 = friendsService.findNearbyFriends(NearbyFriendsRequest.fromLocation(vmeRecord.location))
val f2 = restaurantService.findNearbyRestaurants(vmeRecord.location)
val nearbyFriends = f1.get(2, TimeUnit.SECONDS)
val nearbyRestaurants = f2.get(2, TimeUnit.SECONDS)
Two calls execute concurrently
Client
Side
Proxies

@crichardson
Using external web services =
Distributed system
VoteMeetEat
Twilio
MongoDB
Factual.Com
Mobile
Phone

@crichardson
Internally = Distributed System
Survey
management
VME
management
Registration
SMS
Registration
web app
VME
web app
User
management
Rabbit
MQ

@crichardson
Handling failure
Service A Service B
Errors happen
in distributed systems

@crichardson
About Netﬂix
http://techblog.netﬂix.com/2012/02/fault-tolerance-in-high-volume.html
> 1B API calls/day
1 API call average 6 service calls
Fault tolerance is essential

@crichardson
How to run out of threads
Tomcat
Execute thread
pool
HTTP Request
Thread 1
Thread 2
Thread 3
Thread n
Service A Service B
If service B is down
then thread will be
blocked
XX
X
X
X
Eventually all threads
will be blocked

@crichardson
Their approach
• Network timeouts and retries
• Invoke remote services via a bounded thread pool
• Use the Circuit Breaker pattern
• On failure:
• return default/cached data
• return error to caller
• https://github.com/Netﬂix/Hystrix
http://techblog.netﬂix.com/2012/02/fault-tolerance-in-high-volume.html

@crichardson
@Service
class FactualRestaurantService extends RestaurantService {
@Autowired
@Qualifier("factualHystrixConfig")
var factualHystrixConfig: HystrixCommand.Setter = _
override def findNearbyRestaurants(location: Location) = {
class FindRestaurantsCommand
extends HystrixCommand[FindNearbyRestaurantResponse]
(factualHystrixConfig
.andCommandKey(HystrixCommandKey.Factory.asKey("FindRestaurantsCommand"))) {
override def run() = {
val restaurants = factual.fetch("restaurants",
new Query().within(new Circle(location.lat, location.lon, 1000)).limit(5))
val rs = for (map <- restaurants.getData) yield {
RestaurantInfo(map.get("name").asInstanceOf[String])
}
FindNearbyRestaurantResponse(rs.toList)
}
}
new FindRestaurantsCommand().queue()
}
}
Using Hystrix

@crichardson
Summary
Cloud services are highly scalable services developed and
operated by a 3rd party
Let’s you focus on your core business problem
Risk: provider is acquired and stops offering service
Developing an application that reliably consumes cloud
services requires careful design

@crichardson
Questions?
@crichardson chris.richardson@springsource.com
http://plainoldobjects.com - code and slides
Sign up for CloudFoundry.com

Developing applications with Cloud Services (jax jax2013)

Recommandé

Recommandé

Contenu connexe

Similaire à Developing applications with Cloud Services (jax jax2013)

Similaire à Developing applications with Cloud Services (jax jax2013) (20)

Plus de Chris Richardson

Plus de Chris Richardson (20)

Developing applications with Cloud Services (jax jax2013)