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
- IOTICS Programming Language overview
There are currently two options to integrate with IOTICS:
- IOTICS WebAPI: a standardised REST approach with explicit methods, endpoints, headers and payload. We refer to it as simply IOTICS API.
- gRPC: an open source high performance Remote Procedure Call framework.
The table below compares their requirements and provides you with further information on them.
Beginner (if using the supported gRPC Client libraries)
Needs to be installed separately (see here for more info)
Included in the library
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 the basics of IOTICS
When you want to build advanced applications that require a high level of performance
Needs to be used in combination with a STOMP Client when following a Twin's Feed
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 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 Client and Server and is defined by its architectural style.
We suggest using the IOTICS API when you are interested in exploring and experimenting with IOTICS. If your goal is to try and understand the IOTICS CRUD operations on Twins and Feeds, then the IOTICS API is the best option.
Pro tip: use the IOTICS API 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.
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
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 IOTICS API 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 to be 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 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 repository.
N/A: not available
Updated about 1 month ago