Detaspace Policy‑Driven Data Tiering: Architecture, Design, and Operational Checklist

Problem & Takeaway

Modern workloads generate data that changes value over time: frequently accessed logs, rarely used archives, and everything in between. Manually moving files between storage classes is error‑prone and costly. Detaspace’s policy‑driven tiering automates this lifecycle, but only if the underlying architecture, trust boundaries, and operational checks are correctly configured. The key takeaway is that a small, declarative policy set plus a lightweight metadata service is sufficient to deliver safe, efficient, and isolated data movement.

Requirements

• Detaspace 3.1 or later (policy engine and metadata schema present).
• Three storage adapters configured: hot, warm, cold. Each exposes a storageClass identifier.
• Detaspace CLI or REST client with tenant‑level permissions.
• Cluster nodes time‑synchronized (NTP or chrony).
• ACLs protecting policy files (plain‑text storage).

Minimal Design

The smallest architecture that satisfies the tiering feature consists of:

1. Metadata Service – A lightweight key‑value store (e.g., etcd or a dedicated DB) that records lastAccess and lastModified per object, plus the current storageClass.
2. Policy Engine – A stateless daemon that parses declarative policies, watches the metadata store, and schedules migrations.
3. Scheduler Daemon – Runs background jobs during off‑peak windows. It reads the policy engine’s queue, performs copy‑verify, and atomically swaps metadata pointers.
4. Storage Adapters – Thin wrappers around the underlying file system, S3‑compatible object store, or block storage. Each adapter implements copyTo and remove operations used by the scheduler.

All components run inside the same Detaspace cluster; no external workflow orchestrator is required.

Trust & Data Boundaries

Detaspace isolates tenants via namespaces. Policies are namespaced, and the metadata service stores keys prefixed by tenant:{id}/object:{oid}. This guarantees that a policy for Tenant A cannot affect objects owned by Tenant B. The scheduler validates the namespace before executing any move and logs the tenant ID in audit records.

ACLs on the policy store are critical because the policies are plain text. Use the cluster’s RBAC to grant policy:write only to the tenant’s admin role.

Operational Checks

To confirm tiering is functioning, perform the following checks:

1. Policy Creation – Create a policy via CLI:

   detaspace policy create --namespace tenantA \
     --name "archive-30d" \
     --policy '{"match":{"tag":"log"},"rules":[{"age":30,"target":"cold"}]}'
   

   Verify the API returns status 201 and the policy appears in detaspace policy list.
2. Metadata Population – Insert a file tagged log and confirm a metadata entry appears:

   detaspace meta get --namespace tenantA --object /path/to/file.log
   

   The output should include storageClass: hot and a timestamp.
3. Scheduler Activity – Query the scheduler log: journalctl -u detaspace-scheduler | grep "archive-30d". Look for entries like "Scheduled migration of /path/to/file.log to cold".
4. Post‑Migration Verification – After the off‑peak window, check the object’s location by inspecting the storage adapter’s directory or bucket. The metadata should now show storageClass: cold.
5. Read Consistency – Perform a read via the API: detaspace get --namespace tenantA --object /path/to/file.log. The response time should remain within the SLA, and the file content must match the source.

Failure Modes

Detaspace’s design mitigates common failure scenarios:

• Copy Failure – The scheduler performs a copy‑verify step. If the checksum does not match, the copy is aborted, the source remains untouched, and an error is logged.
• Network Partition – If the cold tier is remote, a transient network failure pauses the job. The scheduler retries up to N times before marking the migration as failed and rolling back.
• Clock Drift – The scheduler relies on accurate timestamps. If a node’s clock drifts >5 s, the migration may be mis‑ordered. Periodic NTP sync and a health check endpoint (/health/timestamp) help detect drift early.
• Metadata Corruption – A corrupted metadata entry can cause the scheduler to misclassify an object. The scheduler validates the metadata schema before acting; corrupted entries trigger a manual audit.

Redesign Triggers

Certain operational conditions warrant revisiting the minimal design:

1. High Write‑Amplification – If write‑heavy workloads experience throughput degradation due to frequent migrations, consider disabling tiering for those namespaces or adding a warm tier to absorb intermediate states.
2. Cold Tier Latency – When the cold tier is a cloud object store and latency spikes above acceptable thresholds, introduce a cache tier or adjust the migration window to align with network bandwidth peaks.
3. Policy Complexity – If policies become too complex (e.g., multi‑dimensional rules), move to a policy microservice that can process rules asynchronously and provide richer analytics.
4. Security Breach – Any unauthorized modification of policy files should trigger a cluster‑wide audit and a potential rollback of all pending migrations.

Concrete Example: Tiering a Log Archive

Below is a step‑by‑step scenario that demonstrates the design in action.

1. Define the Policy – Move logs older than 30 days to the cold tier:

   detaspace policy create \
     --namespace tenantA \
     --name "log‑archive‑30d" \
     --policy '{"match":{"tag":"log"},"rules":[{"age":30,"target":"cold"}]}'
   

2. Tag a File – Upload a file and tag it:

   detaspace put \
     --namespace tenantA \
     --object /var/logs/app.log \
     --file app.log \
     --tag log
   

3. Wait for Migration Window – The scheduler runs between 02:00‑03:00 UTC. No manual intervention required.
4. Verify Migration – After the window, check metadata:

   detaspace meta get --namespace tenantA --object /var/logs/app.log
   

   The storageClass field should now read cold.
5. Read After Migration – Confirm data availability:

   detaspace get --namespace tenantA --object /var/logs/app.log > /tmp/app.log
   

   The file should download from the cold tier with latency within SLA.

Conclusion

Detaspace’s policy‑driven tiering can be enabled with a concise set of components: metadata store, policy engine, scheduler, and storage adapters. By respecting tenant namespaces, securing policy files, and performing rigorous operational checks, you can achieve automated, reliable data lifecycle management. Monitor for write‑amplification, cold‑tier latency, and clock drift, and be ready to adjust the design if those thresholds are exceeded.