A Solid Backend for a Solid Mobile Application

© 2013 The Qt Company
A Solid Back End for a Solid
Qt Mobile Application

About Me

Lauri Nevala
nevalau nevalla nevalla
• Over ten years of experience
in creating web and mobile
based applications
• Working in Qt Cloud Services
team at The Qt Company

Awesome mobile applications…

…and they all need back-end systems!

How do you implement your
back end solution?

You have an idea
X
BUY AND SETUP
HARDWARE
INSTALL OS
INSTALL
SOFTWARE
DEFINE ACCESS
CONTROL
SETUP ANALYTICS
BUILD
JUST START BUILDING
APP APP

PaaS
Platform as a Service

What is PaaS?
On#Premises#
Applica'on*
Data*
Run'me*
Middleware*
OS*
Virtualiza'on*
Servers*
Storage*
Networking*
You*Manage*
IaaS$
Applica'on*
Data*
Run'me*
Middleware*
OS*
Virtualiza'on*
Servers*
Storage*
Networking*
Vendor*Provides* You*Manage*
PaaS$
Applica'on*
Data*
Run'me*
Middleware*
OS*
Virtualiza'on*
Servers*
Storage*
Networking*
Vendor*Provides* You*Manage*
SaaS#
Applica'on*
Data*
Run'me*
Middleware*
OS*
Virtualiza'on*
Servers*
Storage*
Networking*
Vendor*Provides*
With PaaS, developer can focus just on building great apps. No need to worry about
servers, operating system, loadbalancing, network or infrastructure.

Illustra(on
by
Rouge
Group
PaaS

“We believe PaaS will enable organizations
“Organizations who are late, don't adopt PaaS
become more agile and responsive”
will fall behind”
– Yefim Natis, Gartner

Modern Application
Development
1. Mobile First Approach - Factoring applications into many apps.
2. Cloud-Backed - Adopting more abstract and machine-independent application models for back
ends in the form of PaaS.
3. Agile Teams - Rapid iterations, frequent releases, integration of users
4. Continuously Integrated and Delivered - No downtimes
5. DevOps-Enabled - Developers own deployments
6. User Experience-Centric - Focusing on the design and appearance of the application
7. Service Oriented Architecture - Use of micro services to compose application
8. Lightweight - Less complex software that is less time-consuming to install, learn and use
9. Socially Oriented - UX patterns from social networks (timelines, event streams etc), Data is
updated using event-based push-oriented patterns. Integrated search functionality.
10.API Factored and Surfaced - Componentize and granularize back-end software in order to achieve
composable and easy-to-evolve back-end platforms.

Managed Application Runtime
(MAR)
Scalable,
Multi-language,
Multi-database,
Application Platform as a Service

Supported Frameworks
Supported frameworks by 3rd party build packs
Scala, Clojure, Play, Gradle, Grails, PHP, Go, Meteorite, Perl, Dart, Nginx, Apache, Jekyll

Built-In Services

Add Ons
Enginio Data Storage (EDS)
Managed WebSocket (MWS)

Enginio Data Storage (EDS)
Flexible and powerful cloud
data storage
with built-in user and data
access control

Managed WebSocket (MWS)
Fully managed service
implementing a bi-directional,
real-time
communication gateway
for WebSockets.

Developer Friendly Deployment
Deploy using Git – the most common VCS
among developers
>
git
push
qtc
master

Scalable Architecture
Redis MongoDB
Your Application
Built-‐In
Services
Applica2on
Instances End Users
Configure
Deploy
Scale With Your Business
Git Push API
MySQL
Environment Variables
Load Balancer
myawesome.com
Scaling

Web Console

Command Line Tool

I Have an Idea
$$$

Mobile application that
shows tweets in real
time

Back End
• DB where to store tweets
• Worker that retrieves/receives tweets from Twitter
• API that offers tweets to client app
• WebSocket server that push new tweets to client
app

• Enginio Data Storage
+ Schemaless
+ REST API
Database

WebSocket Server
• Managed WebSocket
+ Easy to start
+ REST API

Worker + API
• Managed Application Runtime
+ PaaS
+ Just build the app

1. get initial tweets
2. new tweet
3. save tweet
4. send WebSocket message

Worker - Ruby
require
'tweetstream'
require
'qtc-‐sdk'
!
TweetStream.configure
do
|config|
config.consumer_key
=
ENV['CONSUMER_KEY']
config.consumer_secret
=
ENV['CONSUMER_SECRET']
config.oauth_token
=
ENV['OAUTH_TOKEN']
config.oauth_token_secret
=
ENV['OAUTH_SECRET']
config.auth_method
=
:oauth
end
eds
=
Qtc::Eds::Client.new(ENV['EDS_BACKEND_ID'])
mws
=
Qtc::Mws::Client.new(ENV['MWS_GATEWAY_ID'],
{access_token:
ENV['MWS_SECURITY_TOKEN']})
tweets
=
eds.collection('tweets')
daemon
=
TweetStream::Daemon.new('tracker',
:multiple
=>
true,
:no_pidfiles
=>
true)
daemon.track('#QtDD14')
do
|status|
if
!status.text.start_with?('RT
@')
tweet
=
{
created:
status.created_at,
tweet_id:
status.id,
text:
status.text,
name:
status.user.name,
screen_name:
status.user.screen_name,
profile_img_url:
status.user.profile_image_uri,
hashtags:
status.hashtags.map{|h|
h.text.downcase
}
}
tweets.insert(tweet)
mws.send_message(tweet.to_json,
{sockets:
nil,
tags:
['QtDD14']})
end
end

API - Ruby / Sinatra
require
'sinatra'
require
'qtc-‐sdk'
!
set
:port,
ENV['PORT']
get
'/tweets/:hashtag'
do
eds
=
Qtc::Eds::Client.new(ENV['EDS_BACKEND_ID'])
tweets
=
eds.collection('tweets')
query
=
{
:q
=>
{
'hashtags'
=>
{'$in'
=>
[params[:hashtag]]
}
},
:limit
=>
50,
:sort
=>
[{"sortBy"
=>
"createdAt","direction"
=>
"desc"}]
}
content_type
:json,
'charset'
=>
'utf-‐8'
result
=
tweets.find(query)
result.to_json
end
get
'/websocket_uri'
do
mws
=
Qtc::Mws::Client.new(ENV['MWS_GATEWAY_ID'],
{access_token:
ENV['MWS_SECURITY_TOKEN']})
socket
=
mws.create_socket(["QtDD14"])
content_type
:json,'charset'
=>
'utf-‐8'
socket.to_json
end

Procfile
• When using most common
frameworks, MAR can
automatically detect the
executable.
• You can explicitly declare
what can be executed in a
Procfile.
• Each line declares a process
type - a command that can be
executed from your built
application
worker:
ruby
./worker.rb
run
web:
rackup
-‐p
$PORT
-‐E
production

> git push qtc master

lanevala@it-‐l-‐m0015
~/projects/qtdd-‐twitter-‐stream[master*]$
git
push
qtc
master
Counting
objects:
9,
done.
Delta
compression
using
up
to
8
threads.
Compressing
objects:
100%
(8/8),
done.
Writing
objects:
100%
(9/9),
1.46
KiB
|
0
bytes/s,
done.
Total
9
(delta
6),
reused
0
(delta
0)
-‐-‐-‐-‐-‐>
Ruby
app
detected
-‐-‐-‐-‐-‐>
Compiling
Ruby/Rack
-‐-‐-‐-‐-‐>
Using
Ruby
version:
ruby-‐2.1.2
-‐-‐-‐-‐-‐>
Installing
dependencies
using
1.6.3
Running:
bundle
install
-‐-‐without
development:test
-‐-‐path
vendor/bundle
-‐-‐binstubs
vendor/bundle/bin
-‐j4
-‐-‐deployment
Fetching
gem
metadata
from
https://rubygems.org/........
Using
eventmachine
1.0.3
Using
json
1.8.1
Using
thread_safe
0.3.4
Using
multi_json
1.10.1
Using
naught
1.0.0
Using
rack
1.5.2
Using
bundler
1.6.3
Using
em-‐socksify
0.3.0
Using
http
0.6.1
Using
faraday
0.9.0
Using
em-‐twitter
0.3.3
Installing
httpclient
2.5.2
Installing
inifile
3.0.0
Using
memoizable
0.4.2
Using
puma
2.9.1
Using
rails_12factor
0.0.3
Using
em-‐http-‐request
1.1.2
Using
twitter
5.11.0
Using
sinatra
1.4.5
Using
tweetstream
2.6.1
Installing
faye-‐websocket
0.7.5
Using
qtc-‐sdk
0.0.5
from
https://github.com/nevalla/qtc-‐sdk-‐ruby.git
(at
master)
Your
bundle
is
complete!
Gems
in
the
groups
development
and
test
were
not
installed.
It
was
installed
into
./vendor/bundle
Bundle
completed
(9.04s)
Cleaning
up
the
bundler
cache.
Removing
httpclient
(2.4.0)
Removing
qtc-‐sdk-‐ruby
(8e7a9e3858e8)
-‐-‐-‐-‐-‐>
Discovering
process
types
Procfile
declares
types
-‐>
worker,
web
Default
process
types
for
Ruby
-‐>
rake,
console,
web
-‐-‐-‐-‐-‐>
Compiled
slug
size
is
17M
-‐-‐-‐-‐-‐>
Deploying
app
Uploading
app
container
..
done.
mar-‐eu-‐1-‐13viqrf8
deployed
to
http://mar-‐eu-‐1-‐13viqrf8.qtcloudapp.com
To
git@git-‐mar-‐eu-‐1.qtc.io:mar-‐eu-‐1-‐13viqrf8
36e9190..b237ec8
master
-‐>
master
lanevala@it-‐l-‐m0015
~/projects/qtdd-‐twitter-‐stream[master*]$

Buildpacks
• When you deploy your Application, MAR slug
compiler uses buildpack to prepares your code for
execution.
• Each programming language and framework
support is implemented as buildpack.
• Buildpack script will build the runtime environment
on top of the Stack Image, a mini Linux distribution,
and install everything that is needed.

• Stack Image is a mini Linux distribution which
defines the core operating system and runtime
environment. MAR Stack Images are based on
following Linux distributions:
• Lucid based on Ubuntu 10.04 LTS Lucid Lynx
• Trusty based on Ubuntu 14.04 LTS Trusty Tahr
will be available soon!

How to scale the application?
• MAR application processes can be scaled up or
down dynamically.
• A typical web application has at least web process
type declared in Procfile.
• You can set wanted concurrency level for process
by issuing scale command using qtc-cli:

$ qtc-cli mar scale web=2
$ qtc-cli mar scale worker=4
$ qtc-cli mar scale worker=0

Configuration Variables
• When developing server-side applications, it is very
often required to have a configuration for
application that is varying between environments.
For example staging, production, testing, etc.
• Configuration to some external systems like
database addresses, credentials or other
environment variables might be required.

• This configuration data is not included in your
application code and can be changed
independently.
• The configuration is exposed to a running
application via environment variables.
• You can manage environment variables using the
qtc-cli command line tool:
• qtc-cli mar envs:set SECRET_CODE=donotsharethis

Ports
Application
instances Load Balancer Client
Application
GET /index.html:47435 GET your-mar-address/index.html:80
GET /index.html:47487

Logging
• Logs are a stream of time-ordered events
aggregated from the output streams of all your
application instance processes.
• MAR logger routes log streams from all these
sources into single stream.
• Anything written to standard out (stdout) or
standard error (stderr) is captured into application
instance logs.

• Qt/C++: qDebug() << "Log me to stdout”;
• QML & Node.js: console.log("Log me to stdout”);
• Ruby: puts "Log me to stdout”
!
• $ qtc-cli mar logs

Qt Backend
• Qt support is activated when application has one or
more qmake project files in the root folder.
• If you set QMAKE_ARGS environment variable it
will be passed to qmake command
• You must specify web process manually in Procfile:
• web: ./hello-world/server --port $PORT

Supported Qt Versions
• New applications will default to the latest stable version of Qt (currently
5.3.2).
• You can specify any supported Qt runtime version to be used to run your
application. This functionality is enabled when your project has .qt_runtime
file.
• Available Qt runtimes:
• qt-5.3.0
• qt-5.3.1
• qt-5.3.2
• qt-5.4.0-beta

Further Actions
• Visit qtcloudservices.com
• Sign-up
• Use it
• Give us feedback
• Qt forum
• info@qtcloudservices.com

Thank you!
http://www.qtcloudservices.com

A Solid Backend for a Solid Mobile Application

Recommended

Recommended

More Related Content

Recently uploaded

Recently uploaded (20)

Featured

Featured (20)

A Solid Backend for a Solid Mobile Application