An In-Depth Look at Junos Space SDK

JUNOS SPACE SDK
Ivan Vojvodić
Sr. Director, DBU

SETTING THE AGENDA FOR THE NEXT DECADE

2 Copyright © 2011 Juniper Networks, Inc. www.juniper.net
Transforming the experience and economics of networking

THE PLACE OF THE NETWORK


CHANGES IN THE WORLD OF NETWORKING

The Evolution of a Platform

SINGLE MULTI GENERAL
PURPOSE PURPOSE PURPOSE
Simple Functionality Feature Phone App Enabled Devices


THE NEW NETWORK EQUATION

Network Innovation Ecosystem Innovation The New Network

High Performance Networking Developer Solutions Accelerated Innovation

Fast New, better experiences
Agile
Secure
Innovative New flexibility & agility
Scalable
RAD New customer solutions
Reliable

Open
Simple $ New revenue sources

layers of software instead of layers of protocols

OUR MISSION AND COMMITMENT TO DEVELOPERS

CONNECT EVERYTHING
from Client, through the Network, to the Device

SILICON SYSTEMS SOFTWARE


JUNIPER PROGRAMMABLE NETWORK PLATFORMS

User
Opportunity for Network
Application
End-point Innovation
Layer

Network
Opportunity for Across-
Application
the-network Innovation
Layer

Network
Opportunity
Device
for On-device Innovation
Layer


OPEN, NETWORK-CENTRIC APP PLATFORM

CHALLENGES SOLUTION BENEFITS FOR
DEVELOPERS

“…there’s no Open, Extendable, Flexible and • Easy Monetization
standard way to Powerful Network Application and
tap into the Orchestration Platform • Open App Platform
network.” • Language Independent
“…long / complex dev cycles.” • Network Abstraction
“…I need an end-to-end view.”
• Flexible Integration
“…I’m not a networking expert.” Junos Space
Development Platform • RAD, Quicker GTM

“ “… high
complexity of
networks and
services”
Toolkit APIs
“…leverage investment in
existing OSS/BSS solutions.”
“…end to end service mgmnt.”


SOFTWARE = PLATFORM + APPS

OLD WAY NEW WAY
Application
Innovation

 Focus on innovation
 Expensive and
Reduce Application  Reduce production costs
inefficient
developer Innovation  Increase speed of
time to development
 Consistency, System, innovation
security and Platform,  An SDK decouple velocity of
performance lapses Interfaces, application innovation from
and platform innovation
Foundation
Development Software
Development Kit
+
Platform


JUNOS SPACE SDK

Innovate Accelerate Collaborate
Community of
Insight into the network Reduce time, complexity
partners and developers

Powerful toolset:
Extend to boost value Access existing customers
Eclipse, RESTful APIs

End to end service Accelerate through
Gain expert knowledge!
and data correlation collaboration

Innovate with Junos Space Accelerate development cycle Training, support + leverage
Platform utilizing a direct with open, extendable and partnerships to influence and
access to network data and powerful development monetize.
resources platform and toolkit


UNLOCK THE POWER OF THE NETWORK

Action Value
Configure Filter
Provision GENERATE Correlate
Dynamic Policy Combine
AFFECTS

INSIGHT
Assets Data

Inventory
History
CREATE Real-time
Networking Devices, Servers,
Databases, Applications etc.


THE JUNOS SPACE PLATFORM

HOW DO YOU TURN NETWORK DATA INTO KNOWLEDGE?

Junos Space All controlled from your browser

Management, Analytics, Monitoring, Orchestration


ANSWER:
Add network operations insight to businesses, and
business insight to network operations

Other Business
Space UI: Systems
RESTful Web Services
Abstract the Network

Native RESTEasy Servlet
(JAX-RS)
Stateless Session Beans
or MDBs (Business Logic)
Service Application(s)
RESTful Resource Class
@Stateless
@Path(“/foo”) Application(s)Inject
Service JPA
public class FooEjb {}
public class FooResource {
@EJB private FooEJB fooEjb; }
Web Container EJB Container
JBoss Java EE Application Server Database Server

DMI
Network
Junos Space Fabric/Cluster:

PROGRAMMABLE NETWORK APPLICATION PLATFORM

Network Activate ● Virtual NM ● Security ● OSS ● BSS ● Green/Energy
Control ● Service Now ● ● Adapters (MTOSI,…) ● … others
… others

FLEXIBLE

Juniper Apps 3rd Party Apps
POWERFUL APPLICATIONS

Junos Space RESTful Web Service

PROGRAMMABLE Device & Network Abstraction Services Infrastructure Services
Topology

JUNOS SPACE PLATFORM
Open Network
Application Network Interface (DMI)
Platform


HIGH LEVEL JUNOS SPACE ARCHITECTURE

Network Activate ● Virtual OSS ● BSS ● Green/Energy ● Adapters APIs & Libraries
Control ● Service Now ● (MTOSI,…) ● … others
… others

Interface Services
RESTful wrappers,
RBAC (UI, NBI), Application Deployment, UI,…
Juniper Apps 3rd Party Apps

APPLICATIONS
Device and
Junos Space RESTful Web Service Network Infrastructure
Abstraction Services
Device & Network Abstraction Services Infrastructure Services Services

Local Persistence

Platform Management
Network Interface (DMI)
Junos Space Functional Architecture


JUNOS SPACE SDK - WHAT’S INSIDE THE BOX
Powerful, integrated, familiar developer environment

APIs Developer Tools Community

DEVICE API
Eclipse Logging + Developer
& NETWORK IDE debugging Guide Reference
ABSTRACTION Guide
SERVICES APIs
Reference
Device Platform &
Simulator Inline help
Simulators Sample
Apps
INFRSTRUCTURE
SERVICES APIs
Support
UI Builder UI Library and Training
Forums

JUNOS SPACE SDK

THE POWER OF ABSTRACTION
Mastering complexity vs extracting simplicity


THE POWER OF ABSTRACTION
Example of NOT extracting simplicity


THE ROLE OF APIS

Good example of extracting simplicity: Abstractions
Interfaces (APIs) are instantiations of abstractions
Interfaces shield from low-level details
Allow freedom of implementation (on both sides)
They do not remove complexity, just hide it!

Extracting simplicity example:


JUNOS SPACE APIs
DEVICE NETWORK &
DEVICE
& NETWORK CONFIGURATION DEVICE DEVICE MGMT SCRIPT MGMT

Device & Network
SOFTWARE

S/W Image Mgmt
ABSTRACTION MGMT SERVICE INVENTORY SERVICE SERVICE
MGMT SERVICE

Device Mgmt
Config Mgmt
SERVICE

inventory
SERVICES APIs
Modify device Archive raw and
configuration using Discover devices in Archive JunoScripts Archive Device
expanded device
Change Requests the network on Space Software
configurations

Configuration Network & Device Fetch Device Upload and execute Manage software
Templates inventory Syslog scripts on devices versions on devices

Archive
Configurations Execute CLI Execute Op Scripts, Upload software to
Logical and
using Configuration commands via Event Scripts and one or more
Physical inventory
Files NetConf RPC Commit Scripts devices

INFRA
SERVICES APIs USER MGMT. & JOB APP LIFE CYCLE TAGGING &
API DISCOVERY
AUTHENTICATION MANAGEMENT MANAGEMENT FILTERING

Create, Read, Create, Read,
Manage Discover the
Update and Delete List of active and Update and Delete
Applications services exposed
operations on Users completed jobs application defined
installed on Space by the platform
Tags

Determine status of Specify and
Associate tags with Discover the
Manage User Roles job execution Configure run time
objects defined in services exposed
& Capabilities including Job parameters for
your applications by applications
Details applications

User Authorization
Ability to create new Read the meta data
and Authentication Control Application Search and Filter
Jobs and cancel a associated with the
(includes external Lifecycle using Tags
running job services
authentication)

JS SDK - DEVELOPMENT TOOLKIT
1 2 3 4 5

Plug-in for Logging & Platform Device
UI Builder
Eclipse Debugging Simulator Simulator

New Application

Drag & Drop UI Debug and test Junos compatible
Chainsaw Logger
Components applications device simulation

EJB to REST

Module definition
Static Analysis Space UI Qualify apps on
using PMD Components Scale testing
Space platform

Application
packaging and
licensing


JS SDK COMMUNITY
Docs & Support

Junos Space SDK Junos Space SDK Developer community
Sample applications
Documentation Training and forums

Online Developer
App Developer Guides Training JDN

API Reference Guide 1 day hands-on training JS SDK Download

SDK Installation Guide 3 day expert training JS SDK Forum

Juno Space Platform
Built-in Reference
Training


DEVELOPMENT ENVIRONMENT
All you need is one laptop.

Host OS
Browser VM Host
Junos Space
Application UI

Application
Eclipse

Junos Space IDE
Simulated Devices


APPLICATION EXAMPLE
SUSTAINABILITY & COMPLIANCE: KNOWLEDGE GLOBAL

CHALLENGE APPROACH SOLUTION
Lack of holistic energy usage Leverage Junos Space to  Comprehensive energy
metric to reduce cost and retrieve device level energy insight
carbon emissions and its usage and integrate to a  Combination of IT & facility
impact on operations in a system of energy energy data
global scale. measurement, analysis and  Sustainability compliant
reporting, EMMA. reports
1 2 3

Retrieve IT
resource power
consumption
devices

The Network
Generate
sustainability &
compliance
Facilities reports –
Greenhouse reports
Gas

EMMA - ARCHITECTURE OVERVIEW
Melbourne


KG API-S + CODE SAMPLE…
REST API Description

api/space/device- The API queries the space instance to get the devices connected. This command returns the
management/devices device id’s, status and associated information on each device. This is used to determine the
devices on line before querying the devices using the RPC calls.

REST API RPC command Description

api/space/device- get-interface-information The API allows an RPC command to be executed. This RPC command gets
management/devices/exec-rpc detailed information around the interfaces on the device. We used the
statistics information set to calculate total data throughput across the
interfaces. This command is periodically polled to the devices.

api/space/device- get-environment-pem-information The API allows an RPC command to be executed. This RPC command gets
management/devices/exec-rpc detailed information around the power modules in the device. This command
is periodically polled to the devices so we can determine aggregated power
consumed

ISSUE <get-environment-pem-information> RPC COMMAND
private static String DEVICES_URL = "/device-management/devices";
private static String API_RPC_URL_PRE = "/api/space/device-management/devices/";
private static String API_RPC_URL_POS = "/rpc";
…..
private static final String ENV_PEM_CMD = "<get-environment-pem-information/>";
…

public String getDeviceReading(String deviceId, String rpcCommand){
String sret = "";
String apiURL = baseURL + API_RPC_URL_PRE + deviceId + API_RPC_URL_POS;
…
request.accept(acceptType);
String data="<netconf><rpcCommands><rpcCommand><![CDATA[" + rpcCommand + "]]></rpcCommand></rpcCommands></netconf>";
request.body(contentType, data);
ClientResponse<String> cresp = request.post(String.class);
int respStatus = cresp.getStatus();


KNOWLEDGE-GLOBAL DEMO VIDEO


OPEN FOR APPLICATIONS & INTEGRATION
Application and services platform to address real-world challenges

Independent
System Service
Software Enterprise
Integrators Provider
Vendors

APP CHOICES

RICH APPS EXTENSION MASHUPS RICH APPS MASHUPS

NATIVE NON-NATIVE

APIs

Device & Network
Infrastructure
Abstraction
Services
Services


JS SDK APPLICATION TYPES
APP CHOICES

RICH APPS EXTENSION MASHUPS RICH APPS MASHUPS

NATIVE NON-NATIVE

RICH APPS MASHUPS
MASHUPS
RICH APPS
EXTENSION UI Component UI Component
UI Component
UI Component
Web Service
Web Service Component
Component Web Service
Server-side
Component
Server-side Component
Component Server-side
Component
Externally Hosted Apps
JUNOS Space Platform Hosted Apps

Junos Space Platform API Services Stack

NON-NATIVE RICH APP :: INTEGRATION EXAMPLE:

 Both native and non-native apps can NON-NATIVE
access platform services and bus. logic. RICH APP
 Non-native Apps enable the delivery of
modular functionality with the ability to
plug-in new capabilities/ customizations
based on need

 Platform and hosted Apps expose RICH APPS EXTENSION MASHUPS

RESTful Web Services that can act as a UI Component UI Component
Northbound Interface out of the platform
Web Service Web Service
for external Apps/Services to consume Component Component
Server-side Server-side
 Adaptors can be created for technology Component Component
specific NBI.
 Examples - MTOSI, TMF 814, etc …
RESTful Web Services

Junos Space
Network Application Platform


LANGUAGE INDEPENDENT NETWORK
ABSTRACTION API
Get identifier for device

https://127.0.0.1/api/space/device-management/devices?filter=(name eq ‘Torino’)

XML Option for
JSON


JUNOS SPACE API AND JAVA EXAMPLE
Java pg1

package test;

import org.apache.commons.httpclient.HttpClient;
import org.apache.commons.httpclient.UsernamePasswordCredentials;
import org.apache.commons.httpclient.auth.AuthScope;
import org.apache.commons.httpclient.HttpStatus;
import org.codehaus.jettison.json.JSONObject;
import org.jboss.resteasy.client.ClientRequest;
import org.jboss.resteasy.client.ClientResponse;
Import org.jboss.resteasy.client.core.executors.ApacheHttpClientExecutor;

Java pg2
public class RESTdevice {
private static String SpaceURL;
Specify RESTful service
private static ApacheHttpClientExecutor clientExecutor;
ClientRequest request =
new ClientRequest(url, clientExecutor);
Issue RESTful service request to
request arguments
public static void main(String[] args) { get network device info
System.out.println("==> GET " + url);
SpaceURL = "http://127.0.0.1:8080";
string url = SpaceURL +
ClientResponse<String> response =
"/api/space/device-management/devices/229389";
request.get(String.class); // GET method
UsernamePasswordCredentials credentials =
if (HttpStatus.SC_OK != response.getStatus()) {
new UsernamePasswordCredentials(args[1], args[2]);
throw new Exception("Could not get device: " +
response.getStatus());
Process the response
HttpClient httpClient = new HttpClient();
}
httpClient.getState().setCredentials(AuthScope.ANY, credentials);
httpClient.getParams().setAuthenticationPreemptive(true);
JSONObject jsonObject =
new JSONObject(response.getEntity());
clientExecutor = new ApacheHttpClientExecutor(httpClient);
}
}


JUNOS SPACE API AND .NET C# EXAMPLE
Hammock open source lib To enable easy REST

Create User Auth Cred object

Create RestClient object w/ FQ URL to the API.
Assign ACCEPT header to request for XML

Create + Associate RestRequest object w/ the
Cred object

Submit GET request and receive RestResponse
and print response.Content

JUNOS SPACE API AND PERL EXAMPLE
Perl

#!/usr/bin/perl

use REST::Client; # Used for invoking RESTful APIs on Space

use MIME::Base64; # Used for encoding userid and password

use XML::LibXML; # Used for parsing XML responses from Space

my $client = REST::Client->new();

my $headers = {

Authorization => 'Basic ' . encode_base64($userid . ':' . $password),

"Content-Type" => "application/x-www-form-urlencoded" };
Issue RESTful service request to get network device info

$client->GET('http://127.0.0.1:8080/api/space/device-management/devices/229389', $headers);

if ( $client->responseCode() == 200 ) {

my $xmlResponse = $client->responseContent();

$xs = XML::LibXML->new();

$doc = $xs->parse_string($xmlResponse);

} else {

print $client->responseCode()."n";
Process the response

}


JUNOS SPACE API AND PYTHON EXAMPLE
import simplejson
import httplib, urllib
method = "GET"
host = "http://127.0.0.1:8080"
uri = "/api/space/device-management/devices/229389"
body = ""

headers = {
"Content-Type": service request to get
Issue RESTful "application/x-www-form-urlencoded",
} network device info

def request(method, host, uri, body, headers = {}):
conn = httplib.HTTPConnection(host)
conn.request(method.upper(), uri, body, headers)

response = conn.getresponse()
print response.status, response.reason

if response.status == 200:
"""
Load a JSON data
obj = simplejson.loads(response.read())
"""
obj = response.read()
return obj
else:
Process the
print response.status, response.reason, response.read()
conn.close() response

"""
Execute the HTTP call
"""
request(method, host, uri, body, headers = {}):

JUNOS SPACE API AND PHP EXAMPLE
PHP pg1
PHP pg2
<?php
require_once 'HTTP/Client.php';
/*-------
$url = "http://127.0.0.1:8080/api/space/device- * CURL synchronous call
management/devices/229389"; */
$headers = array( function request($method, $url, $headers = array(),
"Content-Type" => "application/x-www-form- $body) {
urlencoded", $conn = curl_init();
); curl_setopt($conn, CURLOPT_URL, $url);
$body = ""; curl_setopt($conn, CURLOPT_HTTPHEADER,
$headers);
/*------- RESTful service request to get curl_setopt($conn, CURLOPT_USERAGENT,
Issue "HTTP4e/3.0");
* HTTP_Client call
network device info
(http://pear.php.net/package/HTTP_Client) curl_setopt($conn, CURLOPT_CUSTOMREQUEST,
*/ strtoupper($method));
$client = new HTTP_Client(); curl_setopt($conn, CURLOPT_POSTFIELDS,
$responseCode = $client->get( $url, $headers) $xml_data);
curl_setopt($conn, CURLOPT_RETURNTRANSFER, 1);
echo $responseCode $data = curl_exec($conn);
$code = curl_getinfo($conn, CURLINFO_HTTP_CODE);
$resp = $client->currentResponse(); echo $code
$data = $resp['body']; curl_close($conn);
return $data;
echo $data }
// load XML data ?>
//$dom = new DomDocument();
//$dom->loadXML( $data );

Process the
response


THE POWER OF RESTful APIs
APP APP
1 2

Native + Extension HTTP
Apps can extend the
platform, by way of
exposing their own
APIs for other Apps Junos Space APP 1 APP 2 No hard dependency
to consume. Platform Stack Provided service Provided service
between high level apps

Mash-up service to allow
3rd party APP 1 soft dependency
3rd party APP 2
RESTful API - exposed


BUILDING AND DEPLOYING
APPS
Developer Workflow System Administrator Workflow

Download and Install Junos APIs, Simulators, Test +
Space SDK Build Environment

Developer Code Loads the app on
Junos Space

Application Binary

Developer
Support Certificate Signed Application
Package


ARCHITECTURE
DEVICE HEALTH MONITOR APP

REST Google
Browser Clients Mashup

Device Health Monitor App
XML/JSON Google
HTTP DataTable

UI Layer

REST Web-Service Google DataSource
Layer API

EJB Layer
Uses Space API to monitor device health & traffic

Junos Space Platform


SPACE GUI

List of Devices

Basic Health Traffic Chassis View
Parameters Statistics


GOOGLE MASHUP GUI

External GUI using
JavaScript/HTML
Invokes the Google
DataSource APIs
implemented by our
Health Monitor App
Uses the following
Visualization API from
Google:
 Table
 Gauge
 AreaChart


MASHUP GUI
SPACE PLATFORM API + APPS API + GOOGLE API

External GUI using
JavaScript/HTML
Mashup between
 Space Platform APIs
 To obtain devices based on
tags
 TagIt API
 To automatically tag devices
 HealthMon API
 To collect traffic data for
devices
 Google Visualization API
 Geo Map to depict
concentration of devices
across locations
 Motion Chart to depict
change in traffic patterns
across locations


EXAMPLE: NETWORK VIRTUALIZATION

CHALLENGE APPROACH SOLUTION

Goal: Take a distributed multiple Old: Manually configure devices which Application:
domain, site, layer, tenant network and are harder to adapt quickly Virtual Switch
use OpenFlow switches to virtualize a
simpler network New: Benefits:
• Use Big Switch’s OpenFlow controller • Reduces operational complexity and
Target: to create “virtual L2 switches.” expense
• Data Center Networks • Make the selected nodes look as if • Rapid to setup/tear-down
(allocate servers on demand to the they are locally connected.
appropriate datacenter L2 network • Cheap/free to change
• Use Junos Space as the platform to
independent of network /VLAN design) integrate and deliver this solution. • Isolated from other users
• User chooses the :
Technology: • Connections, VLANs, ACLs…
• Juniper OpenFlow-enabled device run
the OpenFlow app built with the Junos
SDK. Availability:
• The Virtual Switch app is implemented OpenFlow: Any Juniper Networks
with the Junos Space SDK. systems supporting Junos control-plane
applications
Virtual Switch: Junos Space
Partner: Big Switch Networks
Application: Virtual Switch

THE CONCEPT – SIMPLIFY THE NETWORK

Group together devices and
separate the groups with a virtual switch

THE SOLUTION – NETWORK VIRTUALIZATION

A simple switch connects only the
hosts for a specific
application/usecase/tenant:

• Rapid to setup/tear-down
• Cheap/free to change
• Isolated from other users
• Self-managed:
• User choose the connections
• User chooses the VLANs
• User chooses the ACLs …

Allow the Customer to define the logical networks they need

JUNOS SPACE INTEGRATION
Junos Space Server
Big Switch Controller Junos Space VM
(manages OF switches) (manages rest of devices)

RESTful Web Service APIs


TECHNICAL CHALLENGES SOLVED BY JUNOS SPACE

Building good user interface is hard
“Junos Space has done the “heavy lifting” of designing,
implementing and integrating all the components required for a
unified and complete management application.”

Good network knowledge/access is rare
“Junos Space SDK has made the network „plumbing‟ information
available in comprehensive and easy-to-use REST APIs (as
opposed to the nightmare of brittle screen scraping with expect),
enabling enterprise-class solutions.”


BUSINESS CHALLENGES SOLVED BY JUNOS SPACE

Reduced cost of development
“By building on a complete platform, we greatly reduced the cost of
developing the feature. We could focus on the novel and differentiated
solution for our customers without spending significant engineering
time on plumbing/infrastructure that Junos Space already has.”

Quicker go-to-market
“Very simply, getting to market quickly is crucial for everyone, but
especially for a startup. Junos Space means we‟re quicker to market
with a complete solution.”

Larger reach
“By integrating with Junos Space, we made our solution far more
accessible to a large section of our target market.”


REFLECTIONS AND LOOKING FORWARD

This is a new way to do network app development and delivery:

• It’s all about layers of software (not layers of protocols) – think web
application servers, mobile frameworks

• Enabling rapid application development

• Junos Space provides the overall application/management platform and
coordination functionality


KEY PLATFORM BENEFITS
Developer Experience
• Enables Focus on Innovation
• Enables RAD and Quicker GTM

Easy Monetization
• Junos deployed base as a first target market

Architecture
• Hot pluggable apps
• Language independent
• Open application platform with RestFull APIs
• Flexible integration options
• Built in HA /Carrier Grade capabilities

Service Design
• Ability to extend the services
• Network/service abstraction


LEARN MORE
Using the SDK gives you the tools and the power to achieve
requirements outside of the std. NPI process. You can leverage
apps in the pipeline, guide customers, SIs and/or develop
solutions yourself.
On the Juniper Matrix:
Email Aliases:
• Junos Space SDK download • JS-DE@juniper.net
http://www.juniper.net/us/en/products-services/junos-
developer/space-sdk-registration/
• TT-SPACE-
SDK@juniper.net
• Junos Space SDK Info Follow us on Twitter:
https://matrix.juniper.net/community/products/nm/junosspacesdk @ivojvodic
@junosdeveloper
• Junos Space SDK Forum
http://forums.juniper.net/t5/Junos-Space-Developer/bd-p/JSD


EXTERNAL TO JUNIPER:

VISIT juniper.net/developer

FOLLOW @junosdeveloper

CONTACT HelpMeBuildMyApp@juniper.net

THANK YOU!

innovation

juniper.net/developer

An In-Depth Look at Junos Space SDK

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (20)

En vedette

En vedette (20)

Similaire à An In-Depth Look at Junos Space SDK

Similaire à An In-Depth Look at Junos Space SDK (20)

Plus de Juniper Developer Resources Cooney

Plus de Juniper Developer Resources Cooney (10)

Dernier

Dernier (20)

An In-Depth Look at Junos Space SDK

Notes de l'éditeur