Zetta is an API-First Internet of Things Platform
Zetta is an open source platform built on Node.js for creating Internet of Things servers that run across geo-distributed computers and the cloud. Zetta combines REST APIs, WebSockets and reactive programming – perfect for assembling many devices into data-intensive, real-time applications.
Zetta servers run in the cloud, on PCs and on single-board computers. With Zetta you can link Raspberry Pis, BeagleBones and PCs together with cloud platforms like Heroku to create geo-distributed networks.
var zetta = require(‘zetta’);
API Every Thing:
Zetta turns any device into an API. Zetta servers communicate with microcontrollers like Arduino and Spark Core giving every device a REST API both locally and in the cloud. Zetta’s reactive hypermedia design marries reactive programming with Siren hypermedia APIs so that you can assemble distributed systems of devices that communicate and react via APIs.
“name”: “Robot Arm”,
Code with Joy:
Building Internet of Things systems is complex. Zetta provides helpful abstractions for increased developer productivity while also giving direct access to underlying protocols and conventions allowing you to focus on the big picture without losing track of the details so that you joyfully transform sensors, actuators and controllers into big, creative applications.
Stream Big Data:
Zetta’s architecture is optimized for data-intensive, real-time applications. Zetta allows you to observe and react to device and system behavior in code and using visualization tools so that you gain actionable insights and take insightful actions. You can also stream data into machine analytics platforms like Splunk.
Dream Big Apps:
IoT developers work on projects with multiple devices across multiple locations running multiple apps made by multiple companies. Yet they must create harmonious experiences that benefit people.
Zetta allows you to assemble smartphone apps, device apps and cloud apps together into large, complex adaptive ‘systems of systems’ that operate at scale in the physical world of home automation, smart transportation, wearable computing and wherever your imagination leads.
What is Zetta?
Open source – Zetta is an open source Node.js based platform for the internet of things. It’s a complete toolkit for generating HTTP APIs for devices.
Real time – Zetta exposes websocket endpoints to stream real time events out of the Zetta system. This paradigm of merging Hypermedia with websocket streaming is also known as Reactive Hypermedia.
Protocol agnostic – Zetta can support almost all device protocols, and mediate them to HTTP.
Persistent connections – Zetta can create persistent connections between servers to expose APIs in new and unique ways. You can peer a Zetta server in your home with a server in the cloud, and allow for access to devices on the open internet.
App creation – Zetta allows you to write stateless applications that live in the server itself. You can query for devices, and wire up interactions between them in these applications. The apps run consistently whether or not your hub has internet connectivity.
Query and notification – Zetta has a robust query system that allows you to not only search for devices, but also subscribe to websockets to be notified when new devices come online that fulfill the query. The queries have a SQL-like syntax that makes it easy to wrangle devices in the API, and Zetta itself.
Consistent interfaces – Built from the ground up, Zetta solves specific problems around generating consistent interfaces for devices.
Installing Zetta platform:
You can install Zetta by cloning it from GitHub or using NPM:
Clone from GitHub
git clone firstname.lastname@example.org:zettajs/zetta.git && cd zetta
npm install zetta
Zetta Architecture Sub Systems:
The Zetta server is the highest level of abstraction in Zetta. The Zetta server contains Drivers, Scouts, Apps, and Server Extensions. A Zetta server will typically run on a hardware hub such as a BeagleBone Black, Intel Edison, or Raspberry Pi. The server itself coordinates interactions between all of the contained components to communicate with devices, and generate HTTP APIs that an API consumer can interact with.
Zetta scouts serve as a discovery mechanism for devices that may be on the network, or require system resources to speak a specific protocol. Scouts will search for devices on a particular protocol, and report back to Zetta when they’ve been found. Scouts can also use identifying information about devices (e.g. a device’s MAC address) to identify whether or not Zetta has interacted with the device before, and ensure any relevant data or security credentials are maintained when interacting with that device an additional time.
Zetta follows a pluggable model for extending functionality. Most of these will be server extensions. Server extensions will deal with API management, defining addtional APIs, or even adding security to your API.
The registry is a persistence layer for Zetta. It’s a small database that lives in the server context, and holds information about devices connected to the server itself.
How Zetta is deployed?
This section describes a typical Zetta deployment.
- One Zetta server runs on a hardware hub. This hub is typically something like a BeagleBone Black, Intel Edison, or Raspberry Pi.
- The Zetta hub connects to devices. Zetta mediates from HTTP to the particular protocols used in a deployment.
Another Zetta server runs in the Cloud. This server uses the exact same Node.js packages as Zetta running on the hub.
- The Zetta server on the hardware hub connets to the server in the Cloud.
- Zetta then exposes an API at the Cloud endpoint for developers to consume.
Where do my Zetta APIs live?
APIs exist on each instance of a Zetta server. Zetta uses hypermedia to expose a walkable set of links for navigating the API from a response, and affordances for streaming and interacting with devices. Zetta APIs conform to the Siren specification. Zetta APIs allow:
- Querying for devices on a particular server
- Setting up links between servers
- Interacting with devices
- Streaming sensor data with websockets
- Registering hubless devices
Zetta Hardware and Software Requirements:
As you plan for your Zetta hardware platform, please keep in mind the suggested minimums assume Zetta running with around six connected devices per hub. As the number of devices, types of data and load of each device increases so will the minimum hardware requirements.
Zetta runs well on a 500MHz CPU. 500mb of RAM is the ideal minimum. Storage of 1 to 2 GB is optimal depending on the size of the operating system. Zetta requires only 500 MB to run.
Minimum Hardware Requirements
CPU: 500 Mhz
Memory: 500 MB
Storage: 500 MB
Suggested Operating Systems
Confer with common Node.js operating systems:
Linux – 32-bit, 64-bit
Windows – 32-bit, 64-bit
Mac OS X
Universal – 32-bit, 64-bit
Zetta Tutorials: https://github.com/zettajs/zetta-tutorials
Zetta Projects: http://www.zettajs.com/projects/
Zetta Platform Source Code: http://github.com/zettajs
Do you want to learn about other open source IoT Platforms? – Link