This page shows everything you need to know to get started with IOTICS. If you haven't done it already, you might want to take a quick look at what IOTICS is and our overview of the IOTICS Digital Twins.
On this page, we will cover
- General Overview
- IOTICS API (REST)
- IOTICS API (gRPC)
- IOTICS Programming Language Overview
Currently, the IOTICS API is available through two types of protocols:
- REST - a standardised approach with explicit methods, endpoints, headers and payload.
We refer to it as IOTICS API (REST).
- gRPC - an open-source high-performance Remote Procedure Call framework.
We refer to it as IOTICS API (gRPC).
The table below compares their requirements and provides you with further information.
|IOTICS API (REST)||IOTICS API (gRPC)|
|Experience||Beginner||Beginner (if using the supported gRPC Client Libraries)|
Advanced (if using the raw gRPC framework).
|Identity Library||Needs to be installed separately (see here for more info).||Included in the Client Library.|
|Supported Languages||Any programming language capable of using HTTP methods for RESTful services.||The programming languages supported by gRPC are listed here.|
|When to use it||When you are interested in exploring and experimenting with the basics of IOTICS.||When you want to build advanced applications that require a high level of performance.|
|Other considerations||Needs to be used in combination with a STOMP Client when following a Twin's Feed and receiving Input Message.||We provide an IOTICS Client Library for a number of programming languages.|
Need more info? Great, we break it down for you in the next section!
Is that enough information? Nice! Go ahead and check our Programming Language overview.
The IOTICS API (REST) works with WebAPIs, which travel through the Internet via the HTTP protocol in a Client-Server model. The Server has several endpoints set up that perform different actions. Once the Server performs these actions, it returns the response back to the Client along with a Status Code to let the Client know how the request went. The client and Server need to have an agreed-upon way to send these requests so they can understand one another. One popular way is to use REST. It provides interoperability between the Client and Server and is defined by its architectural style.
We suggest using the REST when you are interested in exploring and experimenting with IOTICS. If your goal is to try and understand the IOTICS CRUD (Create, Read, Update, Delete) operations on Twins, Feeds and Inputs, then the IOTICS API (REST) is the best option.
Pro tip: use the IOTICS API (REST) in combination with a STOMP Client when:
- Implementing Twin Followers. A STOMP Client can subscribe to a Twin's Feed and provide a callable to be executed on its data whenever the latter is shared by a Twin Publisher.
- Implementing Twins with Inputs. A STOMP Client can subscribe to a Twin's Input and provide a callable to be executed on its data whenever the latter is received by a Twin Sender
Please go to our IOTICS API Reference for more details. You will also find helpful tutorials and code snippets for the most used IOTICS actions within docs.iotics:
- Create Twins
- Create Twin Models
- Upsert Twins
- Update Twins
- Search & Describe Twins
- Share Data and Follow Feed
- Send & Receive Input Messages
- Delete Twins
We also provide a STOMP Client Library example in Python, to illustrate how to follow a Twin's Feed.
In gRPC (Google Remote Procedure Call), a Client application can directly call a method on a Server application on a different machine as if it were a local object, making the creation of distributed applications and services easier. gRPC is based around the idea of defining a service, specifying the methods that can be called remotely with their parameters and return types. gRPC Clients and Servers can run and talk to each other in a variety of environments and can be written in any of gRPC’s supported languages.
We recommend using the gRPC Client Libraries because they provide an easy way of interacting with IOTICS by hiding all the complexities that gRPC brings with it. Furthermore, they enhance the performance of your application, making it lighter and faster in line with what is described in the section below.
However, if your preferred programming language is not among the gRPC Client Libraries that we provide and you are not very familiar with gRPC, you may find the REST quicker and more intuitive to use.
The main benefits of using gRPC include:
- You only need the Proto files to generate custom classes for your specific language;
- gRPC is fast and efficient: Protocol Buffers are serialised and sent using HTTP 2.0 as binaries across the wire; this results in the Proto messages being significantly smaller than usual JSON messages sent through REST;
- parsing Protocol Buffers (binary format) is less CPU intensive because it is closer to how a machine represents data;
- gRPC makes it very easy to plug in authentication, load balancing, logging and monitoring.
You can navigate through any of the IOTICS API (gRPC) Client GitHub repositories we provide support for. They contain information on how to use it along with comprehensive examples.
If the gRPC Client Library has not been implemented in your preferred programming language you will have to:
- compile the IOTICS Proto Files with a gRPC compiler;
- provide an implementation of the generated compiled files in your preferred language.
You can follow this link for further information on how to proceed with the steps above.
The following table summarises the IOTICS public libraries supported and the support we provide to each programming language. The links will take you to the libraries' corresponding GitHub repositories.
N/A: not available
Updated 6 months ago