Introduction
Avaya OneCloud CPaaS was intuitively designed and offers a robust suite of features making it the go-to platform for developers looking to quickly and effectively build what they need, and integrate the project seamlessly into their existing communications system.
If you’re looking for a way to augment your communications capabilities as you derive vital data from Google’s Cloud IoT Core platform, then you’ve come to the right place. This integration guide will help you pair your Zang and GCP accounts, as well as take you through each step from the start of your project, to device registry, Pub/Sub creation and more.
Good luck, and happy building!
Introduction
Creating an account
Create a project
Service account
Create a device registry
Create a pub/sub topic
Create a pub/sub subscription
Register Zang
Code samples
Add a device
Publish an event
Subscribe a topic
Integration with Zang
Creating an account
Step 1
This integration requires you to have an account on the Google Cloud Platform.
google-iotCreate a project
Step 2
You will need to create a project which will be used to hold all related work. Once you've created the project, you will have a ProjectID.
Service account
Step 3
You now have a have a project named IoT-Zang. Expand the top left navigation button, navigate to IAM & Admin. Select Service accounts.
Follow the guide to create a service account with at least “Editor” permission to IoT Core/PubSub and have Furnish a new private key option checked.
After creation, you should have downloaded a .json key file. Rename it to gce-key.json
Create a device registry
Step 4
Navigate to the IoT Core section in the left panel.
You will create a device registry which is a store of the devices you want to integrate.
Ex: Create a device registry named “dealership-customers”
Create a pub/sub topic
Step 5
A topic is like a channel where the devices in this registry share information. You can either create a topic in IoT Core section or in Google cloud pub/sub. (Note: You have to have IAM permission on pub/sub)
Ex: Create a topic named "iot-zang-dealership"
Create a pub/sub subscription
Step 6
Click into the topic just created and find CREATE SUBSCRIPTION in the top panel.
Name your subscription.
For example: projects/iot-zang/subscriptions/iot-zang-sub
Register Zang
Step 7
Log in to your Avaya OneCloud CPaaS Dashboard to access your Account SID and Auth Token. You will need this pair of tokens to use the Avaya OneCloud CPaaS API.
Create a number that you can use to call and send messages.
Code samples
Add a device to a registry
The following is a Node.js example of a workflow with Zang + Google IoT.IoT core will provide an API to add a new device to registry.
You will need the following:
• apiKey: Check your api credentials in your cloud console.
• serviceAccountJson: Path of the private JSON key we created in Step 3 — gce-key.json
• rsaCertificateFile: Path of the rsa_cert.pem
A device needs a RS256/ES256 key pair to authenticate. For example, command to create a RS256 key pair.
openssl req -x509 -newkey rsa:2048 -keyout rsa_private.pem -nodes -out \ rsa_cert.pem -subj "/CN=unused"
Add a device
Code Sample
// Returns an authorized API client by discovering the Cloud IoT Core API with
// the provided API key.
function getClient (apiKey, serviceAccountJson, cb) {
const serviceAccount = JSON.parse(fs.readFileSync(serviceAccountJson));
const jwtAccess = new google.auth.JWT();
jwtAccess.fromJSON(serviceAccount);
// Note that if you require additional scopes, they should be specified as a
// string, separated by spaces.
jwtAccess.scopes = 'https://www.googleapis.com/auth/cloud-platform';
// Set the default authentication to the above JWT access.
google.options({ auth: jwtAccess });
const discoveryUrl = `DISCOVERY_API}?version=${API_VERSION}&key=${apiKey}`;
google.discoverAPI(discoveryUrl, {}, (err, client) => {
if (err) {
console.log('Error during API discovery', err);
return undefined;
}
cb(client);
});
}
function createRsaDevice (client, deviceId, registryId, projectId, cloudRegion,
rsaCertificateFile) {
// [START iot_create_rsa_device]
// Client retrieved in callback
// getClient(apiKey, serviceAccountJson, function(client) {...});
// const cloudRegion = 'us-central1';
// const deviceId = 'testDevice001';
// const projectId = 'iot-zang';
// const registryId = 'dealership';
const parentName = `projects/${projectId}/locations/${cloudRegion}`;
const registryName = `${parentName}/registries/${registryId}`;
const body = {
id: deviceId,
credentials: [
{
publicKey: {
format: 'RSA_X509_PEM',
key: fs.readFileSync(rsaCertificateFile).toString()
}
}
]
};
const request = {
parent: registryName,
resource: body
};
console.log(JSON.stringify(request));
client.projects.locations.registries.devices.create(request, (err, data) => {
if (err) {
console.log('Could not create device');
console.log(err);
} else {
console.log('Created device');
console.log(data);
}
});
// [END iot_create_rsa_device]
}
getClient(apiKey, serviceAccountJson, function (client) {
console.log('success created client');
createRsaDevice (client, deviceId, registryId, projectId, cloudRegion, rsaCertificateFile);
});
If successfully done, you should be able to see a new device appear on your registry list.
Publish an event
Publish an event to IoT Core
Google IoT use standard MQTT to pu
b/sub events.
Scenario: Your car is installed with a chip which reads all the sensor data. A client application in your car needs to connect to topic with MQTT:
Code Sample
function createJwt (projectId, privateKeyFile, algorithm) {
// Create a JWT to authenticate this device. The device will be disconnected
// after the token expires, and will have to reconnect with a new token
// The audience field should always be set to the GCP project id
const token = {
'iat': parseInt(Date.now() / 1000),
'exp': parseInt(Date.now() / 1000) + 20 * 60, // 20 minutes
'aud': projectId
};
const privateKey = fs.readFileSync('./rsa_private.pem').toString()
return jwt.sign(token, privateKey, { algorithm: algorithm });
}
// The mqttClientId is a unique string that identifies this device. For Google
// Cloud IoT Core, it must be in the format below.
const mqttClientId = `projects/${project_id}/locations/${cloud_region}/registries/${registry_id}/devices/${device_id}`;
// With Google Cloud IoT Core, the username field is ignored, however it must be
// non-empty. The password field is used transmit a JWT to authorize the
// device. The "mqtts" protocol causes the library to connect using SSL, which
// is required for Cloud IoT Core.
const connectionArgs = {
host:mqtt_bridge_hostname,
port: mqtt_bridge_port,
clientId: mqttClientId,
username: 'unused',
password: createJwt(project_id,private_key_file,algorithm),
protocol: 'mqtts'
};
// Create a client, and connect to the Google MQTT bridge.
const client = mqtt.connect(connectionArgs);
Send your car’s data to Topic:
{
“engineOilLevel”: 0.3,
“tirePressure”: 32,
“transmissionOilLevel”: 0.99,
“brakeDiskLeft”: 0.9,
...
...
}
We use the Client to publish a payload to event topic reporting the carStatus:
// The MQTT topic that this device will publish telemetry data to. The MQTT
// topic name is required to be in the format below. Note that this is not the
// same as the device registry's Cloud Pub/Sub topic.
const mqttTopic = `/devices/${device_id}/events`;
const carStatus = {
engineOilLevel: 0.3,
tirePressure: 32,
transmissionOilLevel: 0.99,
brakeDiskLeft: 0.9
}
// Publish numMessages messages asynchronously, starting from message
// messageCount.
function publishMessage (data) {
data = carStatus; //
const payload = JSON.stringify(data);
// Publish "payload" to the MQTT topic. qos=1 means at least once delivery.
// Cloud IoT Core also supports qos=0 for at most once delivery.
console.log('Publishing message:', payload);
client.publish(mqttTopic, payload, { qos: 1 });
}
Subscribe a topic
Subscribe a topic to Pull events
A simple subscription sample code that runs on your application server.
Scenario: Your car published a message with payload of couple status data. Your server is sitting to pull such messages to execute the logics.
Code Sample
Sample Subscription:
var gcloud = require('google-cloud')({
projectId: ProjectId,
keyFilename: serviceAccount
});
var pubsub = gcloud.pubsub();
var subscription = pubsub.subscription(PubSubSubscriptionName);
Read Messages:
On subscription, message sent from device which is forwarded to related topic will be read.
subscription.on('message', function(message) {
// Called every time a message is received.
// message.id = ID used to acknowledge its receival.
// message.data = Contents of the message.
// message.attributes = Attributes of the message.
console.log(message);
// sendReminderMessage()
message.ack();
});
Integration with Zang
Integration with Zang
In this scenario, the server can be based on the message content to do interesting things, such as:
Sending SMS to dealer saying
“Customer Alice’s engine oil is running low at 20%, custom ID: 1234567 ”
Sending SMS to Alice as a reminder
“Alice, my engine oil level is only 20%, please contact your dealer to schedule maintenance soon”
Sample Code to send SMS with Zang:
function sendReminderMessage(data) {
const zang = require('zang-node');
const enums = zang.enums;
const connector = new zang.SmsConnector({
accountSid: '{AccountSid}',
authToken: '{AuthToken}'
});
//send sms message
connector.sendSmsMessage({
to: '+123456789',
from: ZangNumber,
body: " Alice, my engine oil level is only 20%, please contact your dealer to schedule maintenance soon",
statusCallback: 'http://mycallback.url.com',
statusCallbackMethod: enums.HttpMethod.GET,
allowMultiple: true
}).then(function (data) {
console.log(data);
});
}
subscription.on('message', function(message) {
// Called every time a message is received.
// message.id = ID used to acknowledge its receival.
// message.data = Contents of the message.
// message.attributes = Attributes of the message.
let data = JSON.parse(message.data);
if (data.engineOilLevel < 0.6 ) {
sendReminderMessage();
}
message.ack();
});