Unit 5

IoT Physical Servers,

Cloud Offerings & IoT
CaseStudies
Conte
nt
• Introduction to Cloud Storage Models
• Communication API
• WAMP: AutoBahn for IoT
• Xively Cloud for IoT
• Python Web Application Framework:
Djanjo
• Amazon Web Services for IoT
• SkyNet IoT Messaging Platform.
• Case Studies:
• Home Intrusion Detection,
• Weather Monitoring System,
• Air Pollution Monitoring,
• Smart Irrigation.
Introduction to Cloud
StorageModels
• Popular Models are
• Amazon Web Service
(AWS)
• Xively Cloud (PAAS)
Communication
API
• Cloud Models are relied on Communication API
• Communication API facilitate data transfer, control information
transfer from application to cloud, one service to another
• It also exist in the form of Communication Protocols
• It supports RPC, PUBSUB and WAMP
• Eg. Popular API is RESTful API (communication in cloud
model)
• Django web framework is used to implement Communication
API
 WAMP: AutoBahn for
IoT
• WAMP : Web Application Messaging Protocol
• Mainly used in cloud storage model for IoT & other messaging services
• WAMP is a routed protocol, with all components connecting to a WAMP Router,
where the WAMP Router performs message routing between the component
• It is protocol for Web Socket (PUBSUB based protocol) : uses RPC Messaging
Pattern
• Some Important Key Terminologies
• Transport
• Session
• Clients (Publisher & Subscriber)
• Router
• Broker
• Dealer
• Application Code
 WAMP for IoT

• Web Application Messaging Protocol (WAMP) is a sub-protocol of WebSocket

which provides publish–subscribe and remote procedure call (RPC) messaging
patterns.

Book website: http://www.internet-of-things-book.com Bahga & Madisetti, ©

 WAMP – Concepts
• Transport: Transport is a channel that connects two peers.
• Session: Session is a conversation between two peers that runs over a transport.
• Client: Clients are peers that can have one or more roles.
• In the publish–subscribe model, the Client can have the following roles:
– Publisher: Publisher publishes events (including payload) to the topic maintained by the Broker.
– Subscriber: Subscriber subscribes to the topics and receives the events including the payload.
• In the RPC model, the Client can have the following roles:
– Caller: Caller issues calls to the remote procedures along with call arguments.
– Callee: Callee executes the procedures to which the calls are issued by the Caller and returns the results to the Caller.
• Router: Routers are peers that perform generic call and event routing.
• In the publish–subscribe model, the Router has the role of a Broker.
– Broker: Broker acts as a Router and routes messages published to a topic to all the subscribers subscribed to the topic.
• In the RPC model, the Router has the role of a Dealer.
– Dealer: Dealer acts a router and routes RPC calls from the Caller to the Callee and routes results from the Callee to the
Caller.
• Application code: Application code runs on the Clients (Publisher, Subscriber, Callee or Caller).

Book website: http://www.internet-of-things-book.com Bahga & Madisetti, ©

 Xively Cloud
Services™
Commercial Platform as a Service for the Internet of Things

• Supports hundreds of platforms, millions of

gateways and billions of smart devices
• Comprehensive and secure infrastructure
services
• Online development tools and dev center
• Best of breed approach

Built on LogMeIn’s Gravity platform connecting

255+ m devices for 55+ m users
Xively …
Contd…
• Xively is an IoT Cloud Platform
• It is an enterprise platform for building, managing, and deriving
business value from connected products.
• It also provides the cloud base API with an SDK
• It supports platforms and technologies like Android, Arduino, C
etc.
• Xively is a PaaS (Platform as a Service) which exposes its service
via RESTful API
• It supports messaging service based on MQTT
Case Study: “Smart Plant
System“[3]
Detai
ls
• This IoT project uses Arduino Uno and a set of sensors:
• DHT11: Temperature and humidity sensor
• TEMT6000: Light intensity sensor
• YL-38 + YL-69: Soil moisture sensor
• We want to send all values read from these sensors to Xively and
create a dashboard so we can monitor these parameters.
• Code : Download
Results by
Xively
 Amazon EC2 (Elastic Compute
Cloud) Python Example
• Boto is a Python package that provides interfaces to Amazon Web Services
(AWS)
#Python program for launching an EC2 instance
• In this example, a connection to EC2 service import boto.ec2
is first established by calling the from time import sleep
boto.ec2.connect_to_region function. ACCESS_KEY="<enter access
key>" SECRET_KEY="<enter
secret key>"
• The EC2 region, AWS access key and AWS
secret key are passed to this function. After REGION="us-east-1"
AMI_ID = "ami-
connecting to EC2 , a new instance is launched d0f89fb9"
using the conn.run_instances function. EC2_KEY_HANDLE = "<enter key
handle>" INSTANCE_TYPE="t1.micro"
SECGROUP_HANDLE="default"
• The AMI-ID, instance type, EC2 key handle
and security group are passed to this function. conn =
boto.ec2.connect_to_region(REGION,
aws_access_key_id=ACCESS_KEY,
aws
_sec
ret_a
cces
s_ke
y=S Bahga & Madisetti, ©
Book website: http://www.internet-of-things-book.com
 what is boto?
Boto is a software development kit (SDK) designed to improve the use of the Python programming language in
Amazon Web Services. The Boto project started as a customer-contributed library to help developers build Python-
based applications in the cloud, converting application programming interface (API) responses from AWS into
Python classes.

Boto has become the official AWS SDK for Python. Boto versions include Boto, Boto3 and Botocore. Boto3 is the
latest version of the SDK, providing support for Python versions 2.6.5, 2.7 and 3.3. Boto3 includes several service-
specific features to ease development. Boto supports all current AWS cloud services, including Elastic Compute
Cloud, DynamoDB, AWS Config, CloudWatch and Simple Storage Service.

Boto3 replaced Boto version 2, which lacks compatibility with the latest versions of Python, but still appeals to
software developers using older versions of the programming language. Botocore provides more rudimentary
access to AWS tools, simply making low-level client requests and getting results from APIs.

Boto derives its name from the Portuguese name given to types of dolphins native to the Amazon River.
 Amazon AutoScaling – Python
Example #Python program for creating an AutoScaling group (code excerpt)
• AutoScaling Service import boto.ec2.autoscale
:
• A connection to the AutoScaling service is first established print "Connecting to Autoscaling Service"
by calling the boto.ec2.autoscale.connect_to_region conn = boto.ec2.autoscale.connect_to_region(REGION,
function. aws_access_key_id=ACCESS_KEY,
aws_secret_access_key=SECRET_KEY)
• Launch Configuration print "Creating launch configuration"
• After connecting to the AutoScaling service, a new launch
configuration is created by calling lc = LaunchConfiguration(name='My-Launch-Config-2',
conn.create_launch_con f iguration. Launch configuration image_id=A
contains instructions on how to launch new instances MI_ID,
including the AMI-ID, instance type, security groups, etc. key_name=EC2_KEY_HANDLE,

• AutoScaling Group instance_type=INSTANCE_TYPE,

security_gro
• After creating a launch configuration, it is then associated ups = [
with a new AutoScaling group. The AutoScaling group is SECGROUP_HANDLE, ])
created by calling conn.create_auto_scaling_group. There conn.create_launch_configuration(lc)
are settings for the AutoScaling group such as the
maximum and minimum number of instances in the print "Creating auto-scaling group"
group, the launch configuration, availability zones,
optional load balancer to use with the group, etc. ag = AutoScalingGroup(group_name='My-
Group', availability_zones=['us-east-
connection=conn)
1b'],
conn.create_auto_scaling_group(ag)
launch_config=lc, min_size=1, max_size=2,
Book website: http://www.internet-of-things-book.com B
 Amazon AutoScaling – Python
Example
• AutoScaling Policies #Creating AutoScaling policies

After creating an AutoScaling group, the policies for scale_up_policy = ScalingPolicy(name='scale_up',

scaling up and scaling down are defined. adjustment_type='ChangeInCapacity',
• In this example, a scale up policy with adjustment type as_name='My-Group',
ChangeInCapacity and scaling_ad justment = 1 is
defined. scaling_adjustment=1,

• Similarly, a scale down policy with adjustment type cooldown=180)

ChangeInCapacity and scaling_ad justment = −1
scale_down_policy =
is defined. ScalingPolicy(name='scale_down',

adjustment_type='Cha
ngeInCapacity',
scaling_adjustment=-1, a
s
cooldown=180) _
n
a
conn.create_scaling_policy(scale_up_policy) m
e
conn.create_scaling_policy(scale_down_policy)
=
'
Book website: http://www.internet-of-things-book.com BahgaM& Madisetti, ©
Amazon AutoScaling – Python Example
#Connecting to CloudWatch
cloudwatch = boto.ec2.cloudwatch.connect_to_region(REGION,
CloudWatch Alarms aws_access_key_id=ACCESS_KEY,
• With the scaling policies defined, the next step is to aws_secret_access_key=SECRET_KE
Y)
create Amazon CloudWatch alarms that trigger these alarm_dimensions = {"AutoScalingGroupName": 'My-Group'}
policies.
#Creating scale-up alarm
• The scale up alarm is defined using the CPUUtilization scale_up_alarm =
metric with the Average statistic and threshold greater MetricAlarm( name='scale_up_on_cpu',
70% for a period of 60 sec. The scale up policy created namespace='AWS/EC2', metric='CPUUtilization',
statistic='Average', comparison='>', threshold='70',
previously is associated with this alarm. This alarm is period='60', evaluation_periods=2,
triggered when the average CPU utilization of the alarm_actions=[scale_up_policy.policy_arn],
dimensions=alarm_dimensions)
instances in the group becomes greater than 70% for cloudwatch.create_alarm(scale_up_alarm)
more than 60 seconds.
#Creating scale-down alarm
• The scale down alarm is defined in a similar manner scale_down_alarm =
with a threshold less than 50%. MetricAlarm( name='scale_down_on_cpu',
namespace='AWS/EC2', metric='CPUUtilization',
statistic='Average', comparison='<', threshold='40',
period='60', evaluation_periods=2,
alarm_actions=[scale_down_policy.policy_arn],
dimensions=alarm_dimensions)
cloudwatch.create_alarm(scale_down_alarm)

Book website: http://www.internet-of-things-book.com Bahga & Madisetti, ©

 Amazon S3 (Simple Storage
Service) Python Example
• In this example, a connection to the S3 service is first established by calling the boto.connect_s3
function.
• The upload_to_s3_bucket_path function uploads the file to the S3 bucket specified at the specified
path.
# Python program for uploading a file to an S3 bucket
import boto.s3

conn = boto.connect_s3(aws_access_key_id='<enter>',
aws_secret_access_key='<enter>')

def percent_cb(complete, total):

print ('.')

def upload_to_s3_bucket_path(bucketname, path, filename):

mybucket = conn.get_bucket(bucketname)
fullkeyname=os.path.join(path,filename)
key = mybucket.new_key(fullkeyname)
key.set_contents_from_filename(filename, cb=percent_cb,
num_cb=10)

Book website: http://www.internet-of-things-book.com Bahga & Madisetti, ©

 Amazon RDS (Relational Database
Service) Python Example
#Python program for launching an RDS instance (excerpt)
import boto.rds
• In this example, a connection to the RDS service
is first established by calling the ACCESS_KEY="<enter>"
SECRET_KEY="<enter>"
boto.rds.connect_to_region function. REGION="us-east-1"
INSTANCE_TYPE="db.t1.mic
• The RDS region, AWS access key and AWS secret ro" ID = "MySQL-db-
key instance-3" USERNAME =
'root'
are passed to this function. PASSWORD =
'password' DB_PORT =
• After connecting to the RDS service, the 3306
DB_SIZE = 5
conn.create_dbinstance function is called to launch a DB_ENGINE =
new RDS instance. 'MySQL5.1'
DB_NAME = 'mytestdb'
SECGROUP_HANDLE="defa
• The input parameters to this function include the ult"
instance ID, database size, instance type, database
#Connecting to RDS
username, database password, database port, conn = boto.rds.connect_to_region(REGION,
database engine (e.g., MySQL5.1), database name, aws_access_key_id=ACCESS_KEY,
aws_secret_access_key=SECRET_KEY)
security groups, etc.
#Creating an RDS instance
db = conn.create_dbinstance(ID, DB_SIZE, INSTANCE_TYPE,
Book website: http://www.internet-of-things-book.com Bahga & Madisetti, ©
USERNAME, PASSWORD, port=DB_PORT,
 Amazon DynamoDB –Non Relational
Databases Python Example
# Python program for creating a DynamoDB table (excerpt)
• In this example, a connection to the import boto.dynamodb

DynamoDB service is first established by ACCESS_KEY="<ent

er>"
calling boto.dynamodb.connect_to_region. SECRET_KEY="<ente
r>" REGION="us-east-
• After connecting to the DynamoDB service, a schema 1"
for the new table is created by calling #Connecting to
conn.create_schema. DynamoDB
conn = boto.dynamodb.connect_to_region(REGION,
• The schema includes the hash key and range key aws_access_key_id=ACCESS_KEY,
aws_secret_access_key=SECRET_KEY)
names and types.
table_schema =
• A DynamoDB table is then created by calling the conn.create_schema( hash_key_n
ame='msgid',
conn.create_table function with the table schema, hash_key_proto_value=str,
read units and write units as input parameters. range_key_name='date',
range_key_proto_value=str
)

#Creating table with schema

table =
conn.create_table( nam
e='my-test-table',
schema=table_schema,
Book website: http://www.internet-of-things-book.com Bahga & Madisetti, ©
read_units=1,
 Python Packages of Interest

• JSON
• JavaScript Object Notation (JSON) is an easy to read and write data-interchange format. JSON is used as an alternative to XML
and is easy for machines to parse and generate. JSON is built on two structures: a collection of name–value pairs (e.g., a Python
dictionary) and ordered lists of values (e.g., a Python list).
• XML
• XML (Extensible Markup Language) is a data format for structured document interchange. The Python minidom library
provides a minimal implementation of the Document Object Model interface and has an API similar to that in other languages.
• HTTPLib & URLLib
• HTTPLib2 and URLLib2 are Python libraries used in network/internet programming.
• SMTPLib
• Simple Mail Transfer Protocol (SMTP) is a protocol which handles sending email and routing email between mail servers.
The Python SMTPLib module provides an SMTP client session object that can be used to send email.
• NumPy
• NumPy is a package for scientific computing in Python. NumPy provides support for large multi-dimensional arrays
and matrices.
• Scikit-learn
• Scikit-learn is an open source machine learning library for Python that provides implementations of various machine learning
algorithms for classification, clustering, regression and dimension reduction problems.

Book website: http://www.internet-of-things-book.com Bahga & Madisetti, ©

 Python Web Application Framework –
Django
• Django is an open source web application framework for developing web applications in Python.
• A web application framework in general is a collection of solutions, packages and best practices
that allows development of web applications and dynamic websites.
• Django is based on the Model–Template–View architecture and provides separation of the data
model from the business rules and the user interface.
• Django provides a unified API to a database backend.
• Thus, web applications built with Django can work with different databases without requiring
any
code changes.
• With this flexibility in web application design combined with the powerful capabilities of the Python
language and the Python ecosystem, Django is best suited for cloud applications.
• Django consists of an object-relational mapper, a web templating system and a regular-expression-
based URL dispatcher.

Book website: http://www.internet-of-things-book.com Bahga & Madisetti, ©

 Frame work
A frame work is a set of conceptual structure and guidelines, used to build
something useful.

A framework may include predifinrd classes and functions that can be

used to process input, manage hardware devices and interact with system
software.
 Django
Architecture
• Django uses a Model–Template–View (MTV) framework.

• Model
• The model acts as a definition of some stored data and handles the interactions with the database. In a web application, the
data can be stored in a relational database, non-relational database, an XML file, etc. A Django model is a Python class
that outlines the variables and methods for a particular type of data.
• Template
• In a typical Django web application, the template is simply an HTML page with a few extra placeholders. Django’s
template language can be used to create various forms of text files (XML, email, CSS, Javascript, CSV, etc.).
• View
• The view ties the model to the template. The view is where you write the code that actually generates the web pages.
View determines what data is to be displayed, retrieves the data from the database and passes the data to the template.

Book website: http://www.internet-of-things-book.com Bahga & Madisetti, ©

Django Project
Layout
django-admin.py startproject
<PROJECT_ROOT>
manage.py
<PROJECT_DIR>
init

.py
settings.py
urls.py
wsgi.py
settings.
py
• Defines settings used by a Django application
• Referenced by wsgi.py to bootstrap the project loading
• Techniques for managing dev vs prod settings:
• Create settings-dev.py and settings-prod.py and use symlink to link settings.py
to the correct settings
• Factor out common settings into base-settings.py and import. Use
conditionals to load correct settings based on DEBUG or other
setting.
• WSGI: Web Server Gateway Interface.
 Sample
Settings…
DEBUG = True
TEMPLATE_DEBUG =
True
ALLOWED_HOSTS =
[]
# Application
definition
INSTALLED_APPS =
(
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
Django
Apps
• Reusable modules
• django-admin.py startapp <app_name>
• Creates stub layout:
<APP_ROOT>
admin.py
models.py
templates
(directory
)
tests.py
views.y
urls.py
Django
Models
• Defined in models.py
•Typically inherit from django.db.models.Model
Example Model:
from django.db import models
class TestModel(models.Model):
name = models.CharField(max_length =
20) age = models.IntegerField()
Models
(cont’d)
• Default is to set NOT NULL on all fields. Override by adding
null = True to field definition:
name = models.CharField(max_length=20, null = True)
• Relationships defined through special field types:
models.OneToOneField(model)
models.ForeignKey(model)
models.ManyToManyField(model
)
Models
(cont’)
• Need Nulls in a Boolean Field? Use models.NullBooleanField()
• Set Default value with “default”:
count = models.IntegerField(default = 0)
• Use a inner Meta class to define additional options, especially useful
for abstract classes:
class TestModel(models.Model):
class Meta:
abstract = True
Model
Methods
• model.save(self, *args, **kwargs)
• model.delete(self, *args, **kwargs)
• model.get_absolute_url(self)
• model. str (self) [Python 3]
model. unicode (self) [Python 2]
• Override with super(MODEL,
self).save(*args, **kwargs)
Activating a
Model
• Add the app to INSTALLED_APPS in
settings.py
• Run manage.py validate
• Run manage.py syncdb
• Migrations
• Write custom script or manually handle migrations
• Use South
Selecting
Objects
• Models include a default manager called objects
• Manager methods allow selecting all or some instances
Question.objects.all()
Question.objects.get(pk = 1)// (primary key)
Use try block, throws DoesNotExist exception if no
match Question.objects.filter(created_date lt = ‘2014-01-01’)
• Returns QuerySet
Introspecting Legacy
Models
• manage.py inspectdb
• Cut and paste generated code into models.py – Easy!!
• django is the best suited for developing new applications, its quite possible
to integrate it into legacy databasses.
• onceyou’ve got Django set up, you’ll follow this general process to
integrate with exixteng database.
• passing parameters to jango by editing the Databases setting and assigning
values to the following keys
• NAME
• USER
 Full
Sample
from django.db import models
datetime
from datetime import

class TimestampedModel(models.Model): created_datetime =

models.DateTimeField() updated_datetime =
models.DateTimeField()
def save(self, *args, **kwargs): if self.id is None:
self.created_datetime = datetime.now() updated_datetime = datetime.now()
super(TimestampedModel,self).save(*args, **kwargs)
class Meta: abstract = True
Full Sample
(cont’d)
class Question(TimestampedModel):
question_text = models.CharField(max_length = 200)
def str (self):
return self.question_text
Function vs. Class
Views
• Django allows two styles of views – functions or class based views
• Functions – take a request object as the first parameter and must
return a response object
• Class based views – allow CRUD operations with minimal code. Can
inherit from multiple generic view classes (i.e. Mixins).
• Create
• Read
• Update
• Delete
 Sample – Viewing a List of
Questions
• Function based:
from .models import Question
from django.shortcuts import render_to_response

def question_list(request): questions =Question.objects.all()

return render_to_response(‘question_list.html’, {‘questions’:questions})
Quick CRUD Operations with
GenericViews
• ListView
• UpdateView
• CreateView
• If Model is specified, automagically creates a matching ModelForm
• Form will save the Model if data passes validation
• Override form_valid() method to provide custom logic (i.e sending
email or setting additional fields)
Sample – As Class
Based View
from .models import Question
from django.views.generic import
ListView

class
QuestionList(ListView):
model = Question
context_object_name =
‘questions’
Django
Templates
• Very simple syntax:
variables = {{variable_name}}
template tags = {%tag%}
• Flexible – can be used to render html, text, csv, email, you name it!
• Dot notation – template engine attempts to resolve by looking for
matching attributes, hashes and methods
Question List
Template
<!doctype html>
<html lang=en>
<head>
<meta charset=utf-8>
<title>List of Questions</title>
</head>
<body>
{%if questions%}
<ul>
{%for q in questions%}
<li>{{q.question_text}}</li>
{%endfor%}
</ul>
{%else%}
<p>No questions have been defined</p>
{%endif%}
</body>
</html>
urls.p
y
• Defines routes to send urls to various views
• Can use regular expressions
• Extract parameters from a url and pass to the view as a named
parameter:
r(‘^question/(?P<question_id>\d+)/$’,’views.question_detail’)
• Extensible – urls.py can include additional url files from apps:
r(‘^question/’,include(question.urls))
 Hooking up the
QuestionList
from django.conf.urls import patterns, url, include urlpatterns =
patterns(‘’,(r’^questions/$’,’views.QuestionList’))
OR:
from django.conf.urls import patterns from views import
QuestionListView
urlpatterns =
patterns(‘’,(r’^questions/$’,’views.QuestionList.as_view
()))
Forms in
Django
• django.forms provides a class to build HTML forms and validation.
• Example:
from django import forms
class EditQuestionForm(forms.Form):
question_text = forms.CharField(max_length = 200)

• Often redundant when creating forms that work on a single model

ModelFor
•ms
Automatically generate a form from a model.
• Handles saving a bound model
• Can specify fields to be included or excluded in the
form
• Sample:
from django.forms import ModelForm
from .models import Question
class
QuestionForm(ModelForm):
class Meta:
model = Question
fields = [‘question_text’]
Using a
ModelForm
• Create an instance of an empty form:
form = QuestionForm()
• Create a form to update an existing instance of a model:
question = Question.objects.get(pk = 1)
form = QuestionForm(instance = question)
• Pass the form into the template and use the form methods to render
the form:
form.as_p
form.as_ul
form.<field_name
>
form.<field_name>
.errors
 Request &
Response
• Request object encapsulate the request and provide access to a number of
attributes and methods for accessing cookies, sessions, the logged in user
object, meta data (i.e environment variables),
• Response objects are returned to the browser. Can set content type,
content length, response does not have to return HTML or a rendered
template
• Special response types allow for common functionality:
HttpResponeRedirect
Http404
HttpStreamingResponse
Authentication
• Django’s out of the box Auth system uses database authentication.
• Changed extensively in Django 1.6 to allow custom User objects.
• AUTHENTICATION_BACKENDS setting in settings.py allows
overriding how User objects are authenticated
• If using the Authentication middleware and context_processors the
current user is available to code as request.user and {{user}} is
defined in all templates
• (giving permission to user to acces the resources).
Django
Extras
• CRSF Middleware – enabled by default. Include template tag in
all forms:
{%csrf_token%}
• Authentication
• Caching
• Sessions
• Messages
• Email
• Logging
Decorating CBVs(classbae views)
• Decorator is applied to the dispatch method
• Must be converted to a method_decorator – use
django.utils.decorators.method_decorator function:
class MyView(ListView):

@method_decorator(login_required)
def dispatch(self, *args, **kwargs):
super(MyView,self).dispatch(*args,
**kwargs)
 Auth
•Decorators
Live in django.contrib.auth.decorators
• login_required
@login_required
def function_view(request):
….
• user_passes_test (can be used with lambda functions for real power)
–
@user_passes_test(lambda u: u.is_staff)
def function_view(request):
…
• has_perms – test for user permissions
• (can take any no.of arguments, but can only
have one expression)
Custom Auth Backend for
theBubble
Sending
Email
• django.core.mail includes functions and classes for handling email
• Set EMAIL_HOST in settings.py to outgoing mailserver
• Import send_mail for simple mail:
send_mail(subject, message, from, to_emails)
• Use django.template.render_to_string to format a message using a
template
• Use EmailMultiAlternatives to create a text message and attach a
html version as well.
Resourc
es
• Python – http://www.python.org
• Django – http://www.djangoproject.com
• Python Packages – https://pypi.python.org
• Django Packages – https://www.djangopackages.com