Skip to content

Object Storage (Archive)

Service ownership

Owner: storage-platform (storage-pm@clouddigit.ai) — Status: GA — Last audited: 2026-05-11

Cold tier for data you rarely read but must retain — backups, regulatory archives, compliance evidence.

What it is

S3-compatible API, same endpoint structure as Object Storage (S3), but with Archive as the storage class. Lower per-GiB-month cost in exchange for higher per-request cost and longer first-byte latency.

Storage class

Set at upload time:

bash aws --endpoint-url https://s3.bd-dha-1.clouddigit.ai \ s3 cp ./big-archive.tar.zst s3://archive-bucket/ \ --storage-class ARCHIVE

Or transition automatically with a lifecycle rule on a Standard-tier bucket — typical pattern:

json { "Rules": [{ "ID": "transition-to-archive-after-90d", "Status": "Enabled", "Filter": { "Prefix": "" }, "Transitions": [{ "Days": 90, "StorageClass": "ARCHIVE" }] }] }

Performance characteristics

Property Value
First-byte latency Seconds to minutes (vs ms for Standard)
Throughput once streaming Comparable to Standard
Durability 99.99999999% (10 nines)
Restore Synchronous reads supported; expect higher latency

Unlike AWS Glacier Deep Archive, Cloud Digit Archive is online — no separate "restore" job. You read it, you wait a bit longer.

Pricing

  • Storage: ~80% lower per GiB-month than Standard
  • Requests: ~2× higher per 1,000 GET/HEAD
  • No retrieval fee beyond the request cost
  • Minimum object size: 128 KiB (smaller objects billed as if 128 KiB)
  • Minimum retention: 30 days (early-delete fees apply)

See Pricing.

When to pick this

Scenario Pick
Off-site backups for compliance, rarely restored Archive
7-year regulatory archives (BB FX records, NBR audit) Archive + Object Lock
Customer-facing media (videos, images) Standard
Application objects Standard
Snapshot lineage / deep history Archive

Object Lock for compliance retention

Pair Archive with Object Lock in COMPLIANCE mode for WORM retention that survives even root credentials. Standard pattern for BB / IDRA / BSEC archive obligations.

Operate this service

Cold tier for long-retention data. S3-compatible API, much lower per-GB cost, restore-required for reads.

When Archive fits

  • Compliance retention (3+ years)
  • Legal hold
  • Disaster recovery copies of database backups
  • Video / image masters that won't be re-edited

Not for anything that needs same-second access. Restores take 5 min – 12 h.

IAM

Same role names as S3 (archive.viewer, archive.reader, etc.), separate bindings. A user can have S3 access without Archive access — useful for separation between hot and cold tiers.

Restore policy

Three retrieval tiers:

Tier Restore time Cost
expedited 1–5 min ~10× standard
standard 3–5 hours baseline
bulk 5–12 hours ~0.5× standard

Pick bulk unless you actually need it sooner — Archive retrievals can add up fast.

Lifecycle transitions

The canonical use case: S3 → Archive after N days.

yaml rules: - id: tier-down prefix: backups/ transitions: - days: 30 storage_class: archive expiration: days: 2555 # 7 years

Object Lock for compliance

Archive supports Object Lock — WORM retention. Required for some regulators; nice for ransomware resistance.

Storage classes within Archive

Class Min retention Use case
archive-instant 90 days Predictable cold-but-readable
archive-flexible 90 days Standard cold, 3–5 h restore
archive-deep 180 days Long-term retention, 5–12 h restore

Deleting before minimum retention bills the full minimum-retention period — Archive is not for hot data.

Restore workflow

bash cd archive restore \ --bucket acme-archive \ --key backups/2024/db.tar.gz \ --tier standard \ --copy-to-bucket acme-tmp \ --expires-in 7d

The restored object lives in the destination bucket as standard S3 for the specified window, then disappears. The Archive copy is untouched.

Metrics

Metric Healthy Alert
archive.bytes_stored grows linearly sudden drop (audit)
archive.restores_24h.cost within budget climbing — review restore patterns
archive.early_delete_charges_mtd 0 > 0 — minimum-retention violation

Vault inventory

Quarterly:

bash cd archive inventory generate --bucket acme-archive --output s3://acme-tmp/inv/

Generates a CSV of every object — useful for compliance audit and reconciling against your retention catalogue.

Object Lock integration

Combine Archive + Object Lock for legal-hold:

bash cd s3 object-lock put \ --bucket acme-archive \ --key legal/case-2026-014/* \ --retain-until 2033-01-01 \ --mode COMPLIANCE

COMPLIANCE mode cannot be shortened, even by root. Use GOVERNANCE if you need an audit-trail-bypassable hold.

Restore taking longer than tier SLA

Tier SLAs are upper bounds, not guarantees on every restore. Investigate when:

Tier Concerning duration
expedited > 15 min
standard > 6 hours
bulk > 16 hours

cd archive restore status --request-id <id> shows current stage.

Early-delete charge surprise

ERROR: EarlyDeleteCharge: object stored 12 days, min-retention 90 days Charged for 78 days at archive-flexible rate.

Archive isn't for short-lived data. Mitigations:

  • Audit the writer pattern — usually a misconfigured lifecycle rule sent hot data to archive
  • For genuine hot+cold mix: use a separate archive-instant bucket (90-day min, but no restore delay)

Restore destination bucket full

ERROR: RestoreFailed: destination bucket 'acme-tmp' over quota

Each restore re-materializes the object as S3 — counts against project storage. Either:

  • Bump the bucket quota
  • Restore in smaller batches
  • Use a dedicated restores/ bucket with a 7-day lifecycle expiration

InvalidObjectState: object is in archive class

You tried to GET an archived object without restoring first:

ERROR: InvalidObjectState: object stored as archive-flexible; restore required

Submit a restore request, wait for the tier SLA, then GET the copied object in the destination bucket.

Inventory report missing recent objects

archive inventory generate snapshots state at request time but actually emits a 24h-old view (the inventory pipeline is batch). For an up-to-the-minute query, use cd s3 ls --bucket acme-archive --recursive directly — slower, but real-time.