TimescaleDB Integration

Deploy TimescaleDB ingestion on ALPON

Connect your ALPON X5 AI or ALPON X4 to TimescaleDB and store real-time sensor data in a time-series database. This guide builds a small Python ingestion container, deploys it through ALPON Cloud with the database connection as environment variables, and verifies the readings with a SQL query.

ALPON X5 AI ALPON X4 TimescaleDB Time-series data

Overview

TimescaleDB is a time-series database built on PostgreSQL, designed for efficiently storing and querying sensor and event data. With an ALPON X5 AI or ALPON X4 it can be used from a fully containerized environment managed through ALPON Cloud, letting you continuously ingest and manage time-series data from your device fleet.

This guide walks through creating a simple TimescaleDB data ingestion container and deploying it on the ALPON using ALPON Cloud. The steps are identical on ALPON X4 and ALPON X5 AI. For more on TimescaleDB itself, see the Timescale documentation.

1. 1

   Prepare the Dockerfile

   On your development machine, create a file named Dockerfile that defines a Python-based ingestion environment:

   Dockerfile · TimescaleDB ingestor

   FROM python:3.11-slim
   
   RUN apt-get update && apt-get install -y \\
       gcc \\
       libpq-dev \\
       && rm -rf /var/lib/apt/lists/*
   
   WORKDIR /app
   
   RUN pip install --no-cache-dir psycopg2-binary==2.9.9
   
   COPY main.py .
   
   CMD ["python", "main.py"]

   This container runs a Python script that sends data into your TimescaleDB instance.

2. 2

   Write the data ingestion script

   Create a file named main.py in the same directory as your Dockerfile. The script:

   • connects to your TimescaleDB instance,
   • creates a sensor_data table if it doesn’t exist, and
   • inserts simulated temperature and humidity readings every 10 seconds.

   main.py · data ingestion script

   import psycopg2
   import os
   import random
   import time
   from datetime import datetime
   
   class PostgresClient:
       def __init__(self):
           self.conn = psycopg2.connect(
               f"postgres://{os.getenv('DB_USER')}:{os.getenv('DB_PASSWORD')}@"
               f"{os.getenv('DB_HOST')}:{os.getenv('DB_PORT')}/{os.getenv('DB_NAME')}?sslmode=require"
           )
           print("Database connected!")
   
       def setup_table(self):
           with self.conn.cursor() as cur:
               cur.execute("""
                   CREATE TABLE IF NOT EXISTS sensor_data (
                       id SERIAL PRIMARY KEY,
                       sensor_name VARCHAR(50),
                       temperature DECIMAL(5,2),
                       humidity DECIMAL(5,2),
                       timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP
                   )
               """)
           self.conn.commit()
           print("Table created!")
   
       def insert_data(self):
           sensors = ['TEMP_001', 'TEMP_002', 'HUMID_001']
   
           with self.conn.cursor() as cur:
               cur.execute("""
                   INSERT INTO sensor_data (sensor_name, temperature, humidity)
                   VALUES (%s, %s, %s)
               """, (
                   random.choice(sensors),
                   round(random.uniform(15.0, 35.0), 2),
                   round(random.uniform(30.0, 80.0), 2)
               ))
           self.conn.commit()
           print(f"{datetime.now().strftime('%H:%M:%S')} - Data inserted")
   
       def show_data(self):
           with self.conn.cursor() as cur:
               cur.execute("SELECT * FROM sensor_data ORDER BY timestamp DESC LIMIT 5")
               for row in cur.fetchall():
                   print(f"ID: {row[0]}, Sensor: {row[1]}, Temp: {row[2]}°C, Humidity: {row[3]}%")
   
       def run_continuous(self):
           print("Starting continuous data generation... (Ctrl+C to stop)")
           try:
               while True:
                   self.insert_data()
                   time.sleep(10)
           except KeyboardInterrupt:
               print("\
   Stopped by user")
           finally:
               self.conn.close()
   
   def main():
       db = PostgresClient()
       db.setup_table()
       db.show_data()
       db.run_continuous()
   
   if __name__ == "__main__":
       main()

3. 3

   Build and push the image

   From the directory containing your Dockerfile and main.py, build the image for the ALPON’s arm64 architecture:

   bash · build the image

   docker buildx build --platform linux/arm64 --load -t timescale-ingestor .

   Then log in to Sixfab Registry, click + Add Container, and follow the prompts to push the timescale-ingestor image.

   Pushing images to the Sixfab Container Registry

   For the full walkthrough of tagging and pushing an image, see Update Containers from the Sixfab Container Registry.

4. 4

   Deploy the container on ALPON

   Open your device in ALPON Cloud, go to the Applications section, and click + Deploy. In the Deploy Container window, use these settings:

   Container Name timescale

   Image The timescale-ingestor image and tag you pushed to the Sixfab Container Registry.

   Environment Click + Add More in the Environment section and add the five variables in the table below.

   Key	Value
   DB_USER	your_timescale_username
   DB_PASSWORD	your_timescale_password
   DB_HOST	your_timescale_host
   DB_PORT	5432
   DB_NAME	your_database_name

   Click + Deploy to launch the ingestion container on the device.

5. 5

   Verify the data in TimescaleDB

   Once the container is running, data is continuously sent to your TimescaleDB instance. To check, run this query against the database:

   sql · latest readings

   SELECT * FROM sensor_data ORDER BY timestamp DESC LIMIT 5;

   You should see the latest simulated readings from your ALPON. If the table is empty, confirm the container is running in the Applications section and that the connection variables in step 4 point at a reachable database.

Continue exploring

Related guides

Build on this workflow with deployment, fleet-management, and hardware guidance for the ALPON platform.

Workflow Deploy Applications on ALPON Push an ARM64 image, configure its runtime, and launch it from ALPON Cloud. Open guide Platform ALPON Cloud Manage devices, applications, connectivity, and remote operations from one workspace. Open guide Hardware Compare ALPON devices Compare ALPON X4 and ALPON X5 AI capabilities for your edge workload. Open guide