Storage
Encrypted object storage over plain HTTPS.
Storage keeps objects of up to 32 MiB in buckets. We encrypt each object and spread the pieces before anything is stored, so what ends up stored shows neither the contents nor the names.
Putting an object in a bucket
A Bucket is a resource in your project, like any other, so you create it with kubectl, OpenTofu or the console. Objects are not API resources. One HTTPS endpoint serves them, and every request carries an API token.
kind: Bucket
metadata: {name: docs}
---
curl -X PUT -H "Authorization: Bearer $ETORM_TOKEN" --data-binary @report.pdf \
https://storage.etorm.com/v1/<project>/docs/reports/q3.pdf
You get PUT, GET, HEAD and DELETE on whole objects, and a list by prefix that hands you a cursor to continue with. Keys can contain any / you like, but there are no directories behind them. A PUT with If-None-Match: * is atomic: when two writers race to create the same new key, one wins and the other gets 412. The developer docs have a guide to storing objects.
Who can read what
Every request is checked against the bucket with your project's roles. There are no public buckets and no anonymous access.
| Request | Right needed on the bucket's objects |
|---|---|
| GET or HEAD an object | get |
| List a bucket | list |
| PUT an object | create. Replacing an existing object needs update as well. |
| DELETE an object | delete |
A role can be restricted to one bucket. Two roles come with the platform, storage-admin and storage-reader.
Each bucket has its own keys
Each bucket gets its own keys, and an object is sealed in 64 KiB chunks before anything is stored. Etorm holds the keys for the life of the bucket. That way a reader needs a role and never a key, and you never handle key material. The other side of it is that the keys are held by us, not by you, and they are not rotated.
Deleting a bucket destroys its keys, so every object in it becomes unreadable at once. It also means a new bucket created under the same name starts empty and has no way to read the old objects.
Why tokens and whole objects
We check every request against an Etorm API token and your project's roles. Tokens are stored hashed, which is why we cannot offer S3 request signing. So there is no S3 compatibility, and there are no presigned URLs.
An object is held in memory while it is sealed, and a read returns the whole object or an error, never a part of it. That is where the 32 MiB limit comes from, and why there is no streaming, no range requests and no multipart upload.
Limits
| Property | Value |
|---|---|
| Object size | Up to 32 MiB. One platform limit for every bucket, not a bucket setting. A larger body is answered with 413. |
| Key | 1 to 1 024 bytes of UTF-8. Any / is allowed; there are no directories. |
| List page | 100 objects by default, 200 at most. Continue with the cursor until it is null. |
| List order | Not lexicographic. The order is stable for a given listing. To find a key you know, GET it. |
| Bucket | The name is a DNS label. The description is up to 1 000 characters. |
| Create-only write | PUT with If-None-Match: * writes only if no object of that key exists, else 412. |
| Access | An API token on every request. No anonymous access. |
| Keys | Every bucket has its own, held by Etorm for the life of the bucket. They are not rotated. |
| Requests | Whole objects: no ranges, streaming or multipart upload. Etorm API tokens, not S3 request signing: no presigned URLs. |
When a write or a read goes wrong
If the backend refuses a write, the request fails with 507 and the previous object stays readable. That is because we write the data before the record that points at it.
If a stored piece of an object is missing or damaged, the read fails with 500 DataCorrupt. You get an error, not partial data.
There is more on Storage on the architecture page.