Set up Datacake HTTP connections on ALPON
Publish device data from your ALPON X5 AI or ALPON X4 to Datacake over its HTTP API for real-time monitoring and visualization. This guide packages a Python HTTP client as a container, deploys it through ALPON Cloud, configures the Datacake payload decoder, and verifies the endpoint with cURL.
Build a small Python container that POSTs a JSON payload with device,
temperature, and humidity fields to your Datacake HTTP API endpoint, push it to your
Sixfab Container Registry, then deploy it from the Applications → Deploy
panel on ALPON Cloud with the DATACAKE_API_ENDPOINT,
DATACAKE_INTEGRATION_TOKEN, and DEVICE_SERIAL environment variables. In Datacake,
add an HTTP payload decoder to map the JSON keys to device fields; the ALPON X5 AI or
ALPON X4 then sends a reading every 10 seconds.
The Datacake HTTP API offers a simple and efficient way to send device data to the cloud, enabling integration with the Datacake platform for real-time monitoring and visualization. This guide walks you through deploying a Datacake HTTP client on your ALPON X5 AI or ALPON X4 to publish messages, complete with setup instructions, code, and testing steps.
The steps are identical on ALPON X4 and ALPON X5 AI. For detailed API options, refer to the Datacake HTTP API documentation.
To enable Datacake HTTP communication you will create a containerized environment with a custom Python
script. On your local machine, create a file named Dockerfile with the following content to set
up a lightweight environment with the necessary tools:
FROM alpine:latest
RUN apk update && apk add \\
curl \\
python3 \\
py3-pip \\
bash
RUN pip3 install requests
WORKDIR /app
COPY datacake_http_client.py /app/
CMD ["python3", "/app/datacake_http_client.py"]
Create a Python file named datacake_http_client.py to handle data transmission to Datacake.
It reads the endpoint and device serial from the DATACAKE_API_ENDPOINT and
DEVICE_SERIAL environment variables and posts a sample temperature and humidity reading every
10 seconds:
import requests
import time
import json
import random
import os
# Datacake HTTP API configuration
api_endpoint = os.environ.get("DATACAKE_API_ENDPOINT", "your-datacake-http-endpoint")
device_serial = os.environ.get("DEVICE_SERIAL", "your-device-serial")
# Datacake data format
def create_datacake_payload(device_serial, temperature, humidity):
data = {
"device": device_serial,
"temperature": temperature,
"humidity": humidity
}
return data
# Function to send HTTP POST request to Datacake
def send_to_datacake(payload):
try:
response = requests.post(api_endpoint, json=payload)
print(f"Status Code: {response.status_code}")
print(f"Response: {response.text}")
return response.status_code == 200
except Exception as e:
print(f"Error sending data to Datacake: {e}")
return False
# Publish messages every 10 seconds
try:
print(f"Starting Datacake HTTP client for device: {device_serial}")
while True:
# Create sample data
temperature = round(random.uniform(20, 30), 2)
humidity = round(random.uniform(40, 60), 2)
# Create Datacake formatted payload
payload = create_datacake_payload(device_serial, temperature, humidity)
print(f"Sending data: Temperature: {temperature}°C, Humidity: {humidity}%")
# Send data to Datacake
success = send_to_datacake(payload)
if success:
print("Data sent successfully to Datacake!")
else:
print("Failed to send data to Datacake.")
# Wait before next reading
time.sleep(10)
except KeyboardInterrupt:
print("Exiting...")
In your terminal, navigate to the directory containing the Dockerfile and
datacake_http_client.py, then build the image on your local machine for
linux/arm64:
docker build --platform=linux/arm64 -t datacake-http-alpon-x4:latest .
Log in to ALPON Cloud and open the
Sixfab Container Registry
page. Click + Add Container and follow the prompts to push the
datacake-http-alpon-x4 image to the Sixfab Container Registry.
Visit the Deploy Applications page for all the necessary details on pushing your container image to the Sixfab Container Registry.
Go to the Applications section of your asset on ALPON Cloud and click + Deploy. In the Deploy Container window, use these settings:
Container Name
datacake-http-client
Image
The datacake-http-alpon-x4 image and tag you pushed to the Sixfab Container Registry.
Environment
Click + Add More in the environment section and add the three variables in the table below.
| Key | Value |
|---|---|
DATACAKE_API_ENDPOINT | your-datacake-endpoint |
DATACAKE_INTEGRATION_TOKEN | your-integration-token |
DEVICE_SERIAL | your-device-serial |
The endpoint URL and integration token come from the HTTP API integration in your Datacake account (the endpoint is also shown next to the payload decoder in step 6). Click + Deploy to deploy the Datacake client.
To process incoming data in Datacake, configure a decoder function in your account. Log in to your Datacake account and navigate to your device, open the Configuration tab, and locate the HTTP Payload Decoder section. Add the following JavaScript decoder function to parse and process the incoming data:
function Decoder(request) {
var payload = JSON.parse(request.body)
var serialNumber = payload.device
try {
var datacakeUUID = deviceSerialToId[serialNumber]
var temperatureInDatabase = measurements[datacakeUUID]["TEMPERATURE"].value
var temperatureInPayload = payload["temperature"]
if (temperatureInPayload > temperatureInDatabase) {
payload["temperature_higher"] = true
}
} catch (e) {
console.log(JSON.stringify(e))
console.log("Error reading measurement from the device. Does the field exist?")
}
try {
var datacakeUUID = deviceSerialToId[serialNumber]
var temperatureLimit = configurationValues[datacakeUUID]["TEMPERATURE_LIMIT"]
if (payload["temperature"] > temperatureLimit) {
payload["temperature_limit_reached"] = true
}
} catch (e) {
console.log(JSON.stringify(e))
console.log("Error parsing Configuration Field")
}
var timestamp = Math.floor(Date.now() / 1000);
var result = Object.keys(payload).map(function(key) {
if (key !== "device") {
return {
device: payload.device,
field: key.toUpperCase(),
value: payload[key],
timestamp: timestamp
};
}
});
return result
}
Save the decoder and note the HTTP Endpoint URL provided by Datacake — this is the value
of the DATACAKE_API_ENDPOINT environment variable.
To verify your Datacake HTTP API setup, send one request manually from your terminal. The request the container makes has this shape:
Method
POST to your-datacake-endpoint
Content-Type
application/json
Authorization
Bearer your-integration-token
Body
JSON with device, temperature, and humidity keys.
curl -X POST -H "Content-Type: application/json" \\ -H "Authorization: Bearer your-integration-token" \\ -d '{"device":"your-device-serial","temperature":25.4,"humidity":48.3}' \\ your-datacake-endpoint
A successful response looks like this:
{
"method": "POST",
"GET": {},
"POST": {},
"body": "{\\"device\\":\\"your-device-serial\\",\\"temperature\\":25.4,\\"humidity\\":48.3}",
"headers": {
"Content-Length": "68",
"Content-Type": "application/json"
},
"path": "/integrations/api/your-integration-token"
}
datacake-http-client container shows as running in the Applications section.body.TEMPERATURE and HUMIDITY values every 10 seconds.Once deployed, your ALPON sends temperature and humidity data to Datacake every 10 seconds. Log in to your Datacake account to view the data in your dashboards or configure alerts. With the Datacake HTTP client running on the ALPON, you are ready to monitor and analyze your device data.