Introduction to Amazon Timestream Database

Written by Bits Lovers on 17 Apr 2023

Introduction to Amazon Timestream Database

If you are working with time-stamped data – sensor readings, log streams, stock prices, that sort of thing – you have probably run into the problem of regular databases not being great at it. Queries that should be fast end up slow, and storage costs climb faster than you expect. Amazon Timestream was built specifically for this kind of work.

What is Timestream?

Timestream is a serverless time-series database on AWS. Serverless here means what it usually means on AWS: you do not provision instances or worry about capacity planning. It scales automatically and you pay for what you actually use.

The database stores data in two tiers. The Memory Store holds recent data for fast reads – sub-second query latency on your latest metrics. Once data ages past your retention window, it moves automatically to the Magnetic Store, which is cheaper and backed by S3. You can keep years of data without rebuilding your own tiering logic.

You ingest data via MQTT, Kafka, Kinesis Data Firehose, or the SDK. There is also direct InfluxDB line protocol support, which means existing Telegraf setups and InfluxDB clients can pipe data in without rewriting their ingestion pipelines.

How it stores data

Timestream uses a flexible schema. Each record has dimensions (device_id, location, sensor_type – whatever labels you need), a timestamp, and one or more measures. A measure is just a named value: temperature, pressure, cpu_load.

One thing worth knowing about: multi-measure records. Instead of writing three separate records for a device that reports temperature, humidity, and battery level at the same timestamp, you write one record with all three. This reduces write overhead and storage footprint. Whether that matters to you depends on your volume, but it is a handy option to have.

Querying

Timestream speaks SQL. Not a subset, not a variant – standard ANSI SQL with time-series extensions baked in. You get functions like TIME_SERIES, INTERPOLATE, and DOWNsample built in, but the syntax is regular SQL, which means your analysts can query it without learning something new.

You can connect visualization tools directly. Grafana has a Timestream plugin. Tableau and Power BI connect via JDBC/ODBC. For ad-hoc analysis, the AWS console has a query editor.

Pricing

This is where it gets concrete. You pay separately for:

Writes: per million records written
Memory Store: storage in GB per month
Magnetic Store: cheaper storage for aged data, also per GB per month
Queries: on-demand, metered per second of compute used (30-second minimum per query)

There is no flat monthly fee. For IoT workloads with bursty ingestion patterns, this can work out well. For steady high-volume workloads, you want to model the costs carefully before committing.

Security

Data is encrypted at rest with AES-256. Access control runs through IAM. Timestream is HIPAA-compliant, PCI DSS-compliant, and SOC 2-compliant, if that is relevant to your situation.

Getting started

You create a database and tables through the AWS console, CLI, or SDK. Tables have retention settings for both the Memory Store and Magnetic Store independently.

Data ingestion configuration happens separately. You might use a Kinesis Data Firehose delivery stream with a Lambda transform, or you might push directly from your application via the SDK. AWS IoT Core can also feed directly into Timestream if you are already running that stack.

Scaling is handled automatically. You do not tune connection pools or shard counts. The database absorbs ingestion bursts and query load without intervention.

Where it fits

Timestream makes sense for:

IoT sensor data with real-time querying needs
Application performance monitoring where you need fast aggregations over recent windows
Industrial equipment monitoring with variable schema (different sensors reporting different measures)
Financial tick data

It is less suited for general-purpose data where you need complex joins across unrelated entities, or for workloads that are not primarily time-ordered.

The key difference from relational databases is the two-tier storage model and the time-series query functions. From general NoSQL or document stores, it is the automatic data lifecycle management and SQL interface. Graph databases are in a completely different problem space.

What it looks like in practice

Here is a Python example of writing a multi-measure record with the SDK:

import boto3, time

timestream = boto3.client("timestream-write")

record = {
    "Dimensions": [{"Name": "device_id", "Value": "sensor-001"}],
    "Measures": [
        {"Name": "temperature", "Value": "23.5", "Type": "DOUBLE"},
        {"Name": "humidity", "Value": "55", "Type": "DOUBLE"}
    ],
    "Time": str(int(time.time() * 1000)),
    "TimeUnit": "MILLISECONDS"
}

resp = timestream.write_records(
    DatabaseName="IoTData",
    TableName="SensorReadings",
    Records=[record]
)

And a query:

SELECT
    device_id,
    BIN(time, 1h) AS t,
    AVG(temperature) AS avg_temp,
    AVG(humidity) AS avg_hum
FROM "IoTData"."SensorReadings"
WHERE time BETWEEN ago(7d) AND now()
GROUP BY device_id, BIN(time, 1h)
ORDER BY t DESC;

Integrations worth knowing about

AWS IoT Core can feed directly into Timestream, which is convenient if you are already using it for device management. CloudWatch logs can stream in as well. For ETL workloads, there is a Spark connector. EventBridge can trigger scheduled queries that write results back to another table.

On the output side, Grafana is probably the most common pairing. The built-in query builder helps if you are not comfortable writing SQL directly.

Things to watch

Timestream is serverless, but the pricing model has moving parts. Write costs, storage costs, and query costs add up differently depending on your access patterns. If you are coming from InfluxDB or Prometheus, the cost structure will feel unfamiliar.

The SQL support is broad, but some analytics patterns that work easily in specialized time-series databases require more careful query construction here. Window functions and interpolation work, but you need to know they are there.

Schema changes are handled flexibly, but if you are used to a rigid schema, the approach may feel loose at first.

Summary

Timestream is a capable time-series database that gets out of your way once you have data flowing in. The two-tier storage model is practical, the SQL interface lowers the learning curve, and the integrations with other AWS services cover most pipeline needs without requiring custom glue code. The pricing model is more predictable than provisioning your own database servers, but you still want to model your specific workload before going all in.