---
updatedAt: 2026-06-30T13:22:04.000Z
agentTools:
  projectIndex: https://kb.telemaxx.de/llms.txt
---

# HowTo: Object Storage - Container/Bucket nutzen

OpenCloud Objektspeicher

TelemaxX bietet zwei Storage Services an, die ähnlich, aber nicht gleich und für unterschiedliche Anwendungsfälle gedacht sind:

<Cards>
  <Card title="TelemaxX S3 Object Storage" icon="fa-box">
    Eigenständige Cloud Service Plattform.

    <ul>
      <li><strong>Use Case: Backup- & Archive-Storage mit Standard-Performance</strong></li>
      <li>Datenhaltung: Lokale Redundanz</li>
      <li>Endpoint: <code>s3.telemaxx.cloud</code></li>
      <li>Dokumentation: <a href="https://kb.telemaxx.de/docs/s3-overview">TelemaxX S3 Object Storage</a></li>
    </ul>
  </Card>

  <Card title="TelemaxX OpenCloud Object Storage" icon="fa-rocket">
    Integrierter S3 Service der OpenCloud Plattform.

    <ul>
      <li><strong>Use Case: High-Performance Object Storage für Apps mit hohen Leistungsanforderungen</strong></li>
      <li>Datenhaltung: Redundant über 3 Rechenzentren gespiegelt</li>
      <li>Endpoint: <code>radosgw.opencloud.telemaxx.de</code></li>
      <li>Dokumentation: diese Seite hier 😃</li>
    </ul>
  </Card>
</Cards>

Jedes Projekt in der OpenCloud stellt auch einen Objektspeicher über Container bereit.<br />Diese ähneln AWS S3 Buckets und können ebenfalls über das S3 Protokoll angesprochen und verwaltet werden. Verwenden Sie Object-Storage Container, um beliebige Dateien zu speichern und sie bei Bedarf über eine öffentliche URL freizugeben.

Sie können Container und Daten über verschiedene Wege nutzen und verwalten:

* OpenCloud Dashboard: [**Horizon**](https://horizon.opencloud.telemaxx.de)
* Swift API: [**OpenStack CLI**](https://docs.openstack.org/python-openstackclient/latest/cli/command-objects/object-store/v1/index.html), <Anchor target="_blank" href="https://docs.openstack.org/python-swiftclient/latest/cli/index.html">Swift CLI</Anchor>, <Anchor target="_blank" href="https://docs.openstack.org/api-ref/object-store/index.html">Object Storage API</Anchor>
* S3 API: [**AWS S3 Client**](https://docs.aws.amazon.com/cli/latest/reference/s3/), <Anchor target="_blank" href="https://github.com/s3tools/s3cmd">s3cmd</Anchor>

***

## Object Storage über das Dashboard managen

Sie können Daten entweder über das OpenCloud Dashboard oder über die CLI hinzufügen. Im Folgenden werden beide Wege beschrieben. Zuerst geht es um das Dashboard.

### Container (Bucket) erstellen

Um einen Container zu erstellen, navigieren Sie zur *Containers* im linken Bereich *Object Store*. Dort sehen Sie eine einfache Oberfläche, die Ihre Container anzeigt und mit der Sie neue Container erstellen können.

![](https://files.readme.io/afd9d9d45b00d7d536262255e5e04b70b0ba993fb6ed10cd8042a8b6f463a278-image.png)

<br />

Verwenden Sie die Schaltfläche **+ Container** und geben Sie im Modalfenster den Namen Ihres Containers ein. Wählen Sie außerdem die Sichtbarkeit des Containers aus: **public** oder **not public**

![](https://files.readme.io/8f9a31042066373ab48b48bb2900b3303d9c126ecccab1c1be7da9d0445f2b6c-image.png)

### Folder erstellen

Über die Schaltfläche **+ Folder&#x20;**&#x6B;önnen Ordnerstrukturen angelegt werden.

![](https://files.readme.io/eef2b8fde45eade73e357ce348b4ac66298308fbc95761bcb0a7d095d3c30550-image.png)

### Daten hinzufügen

Klicken Sie in der Container-Übersicht auf den Container, den Sie verwalten möchten. Der Inhalt des Containers wird rechts angezeigt. Dort finden Sie auch die Upload-Schaltfläche.

![](https://files.readme.io/a6cab32de01bb09996b68f5c5bd07733774b7c50bb37955c9b82b9fab34d1b2c-image.png)

Wählen Sie im Modalfenster die gewünschte Datei aus, geben Sie optional einen Dateinamen an und bestätigen Sie das Hochladen mit **Upload File**.

![](https://files.readme.io/a3008e4a25d55a720361111a912442e18f28e4f36d98f7f2dca8f445de268bf2-image.png)

### Public Access – Container-Daten öffentlich zugänglich machen

Hier können Sie außerdem die Sichtbarkeit des Containers ändern und den Freigabe-Link kopieren, sofern es sich um einen öffentlichen Container handeln soll.

![](https://files.readme.io/d293824788de7ffcf6d5a1b24c0f1ba454d1a314de9c53527d44e0e4ec03cfc9-c64814a88731d6053fbd19fc197d418e58da76d9b6dba980564aa346217d5805-image.png)

<br />

***

## Object Storage über die CLI managen

### Voraussetzungen

Für die Nutzung werden folgende Werkzeuge benötigt:

* **OpenStack CLI**
* **AWS CLI**
* [jq](https://jqlang.org) – bessere Darstellung von JSON-Text (optional)
* Zugriff auf ein OpenStack-Projekt bspw. mithilfe von Application Credentials

### S3 Credentials erzeugen

S3-Zugangsdaten können über die OpenStack CLI wie folgt erstellt werden:

```shell
openstack ec2 credentials create
```

Die Ausgabe enthält unter anderem einen `access` und einen `secret` Wert.

```
+------------+----------------------------------------------------------------+
| Field      | Value                                                          |
+------------+----------------------------------------------------------------+
| access     | fd41da26fcbc4280ae3ae5ff6ac71346                               |
| links      | {'self': 'https://keystone.opencloud.telemaxx.de:5000/v3/...'} |
| project_id | 11111111111111111111111111111111                               |
| secret     | ********************************                               |
| trust_id   | None                                                           |
| user_id    | 22222222222222222222222222222222                               |
+------------+----------------------------------------------------------------+
```

Die AWS CLI kann nun über Umgebungsvariablen für den Zugriff auf S3 konfiguriert werden.

Beispiel:

```shell
export AWS_ACCESS_KEY_ID='fd41da26fcbc4280ae3ae5ff6ac71346'
export AWS_SECRET_ACCESS_KEY='********************************'
export AWS_ENDPOINT_URL='https://radosgw.opencloud.telemaxx.de'
export AWS_DEFAULT_REGION=default
export AWS_REQUEST_CHECKSUM_CALCULATION=when_required
export AWS_RESPONSE_CHECKSUM_VALIDATION=when_required
```

<Callout icon="ℹ️" theme="info">
  ###

  **Info:** Die Variablen `AWS_REQUEST_CHECKSUM_CALCULATION` und `AWS_RESPONSE_CHECKSUM_VALIDATION` können notwendig sein, um Kompatibilitätsprobleme zwischen neueren AWS-CLI-Versionen und S3-kompatiblen Backends wie RadosGW zu vermeiden.
</Callout>

### Bucket erstellen

Im folgenden Beispiel legen wir einen Bucket mit dem Namen `awesome-bucket` an.

**Methode 1:** über die OpenStack CLI

```shell
openstack container create awesome-bucket
```

<Callout icon="ℹ️" theme="info">
  ###

  **Info:&#x20;**&#x49;n OpenStack werden Buckets als _Container_ bezeichnet.
</Callout>

**Methode 2:** über die AWS CLI

```shell
aws s3 mb s3://awesome-bucket
```

<Callout icon="⚠️" theme="warn">
  ### Caveat: Eindeutige Bucket-Namen

  Bucket-Namen beziehungsweise Container-Bezeichner sind **global eindeutig**. Das bedeutet, dass ein Bucket-Name nur einmal innerhalb der Object-Storage-Plattform vergeben werden kann. Auch wenn in Ihrem eigenen Projekt noch kein Bucket mit diesem Namen existiert, kann es sein, dass der gewünschte Name bereits durch ein anderes Projekt belegt ist. Wählen Sie in diesem Fall einen anderen, eindeutigen Bucket-Namen.
</Callout>

### Objekte hochladen

Ein Objekt kann mit der AWS CLI in einen Bucket hochgeladen werden:

```shell
aws s3 cp image.png s3://awesome-bucket/
```

In diesem Beispiel wird die Datei `image.png` in den Bucket `awesome-bucket` hochgeladen.

Soll ein Objekt direkt öffentlich lesbar sein, kann es beim Upload mit der ACL **public-read** hochgeladen werden:

```shell
aws s3 cp image.png s3://awesome-bucket/ --acl public-read
```

Ein öffentliches Objekt kann anschließend über die folgende URL abgerufen werden:

```
https://radosgw.opencloud.telemaxx.de/awesome-bucket/image.png
```

Der Zugriff über diese URL funktioniert nur, wenn das Objekt oder der entsprechende Pfad öffentlich lesbar ist.

Alternativ kann ein temporärer, signierter Download-Link für private Objekte erstellt werden:

```shell
aws s3 presign s3://awesome-bucket/image.png --expires-in 3600
```

Der Parameter `--expires-in` gibt die Gültigkeit des Links in Sekunden an. In diesem Beispiel ist der Link eine Stunde gültig.

### ACL eines bestehenden Objekts ändern

Die ACL eines bereits vorhandenen Objekts kann nachträglich gesetzt werden:

```shell
aws s3api put-object-acl --bucket awesome-bucket --key image.png --acl public-read
```

Damit wird das Objekt `image.png` im Bucket `awesome-bucket` öffentlich lesbar gemacht.

### Übersicht gängiger ACLs

| ACL                      | Scope                                                                                                              |
| :----------------------- | :----------------------------------------------------------------------------------------------------------------- |
| **private**              | Nur der Owner hat Vollzugriff. Kein öffentlicher Zugriff. Dies ist üblicherweise der Standard.                     |
| **public-read**          | Der Owner hat Vollzugriff. Jeder kann Objekte lesen.                                                               |
| **authenticated-read**   | Jeder authentifizierte S3-Benutzer (auch außerhalb des eigenen Projekts) kann lesen.                               |
| ⚠️ **public-read-write** | Jeder (auch außerhalb des eigenen Projekts) kann lesen und schreiben. <br />***Achtung: In der Regel vermeiden!*** |

### Zugriff auf einen Ordner bzw. Prefix erlauben

S3 kennt technisch keine echten Ordner. Stattdessen werden Pfade als sog. Prefixes innerhalb eines Buckets behandelt. Wenn alle Objekte unterhalb eines Prefixes öffentlich lesbar sein sollen, kann eine Bucket Policy verwendet werden.

<Callout icon="ℹ️" theme="info">
  ### **ACL vs. Bucket Policy**

  ACLs eignen sich vor allem, wenn die Berechtigung für einzelne Buckets oder einzelne Objekte gesetzt werden soll, zum Beispiel um eine einzelne Datei mit **public-read** öffentlich lesbar zu machen.

  Wenn jedoch mehrere Objekte nach einem gemeinsamen Prefix freigegeben werden sollen, ist eine Bucket Policy in der Regel besser geeignet. Ein typisches Beispiel ist ein Prefix wie `images/*`, bei dem alle darunterliegenden Objekte öffentlich lesbar sein sollen. Mit einer Policy kann die Berechtigung zentral auf das gesamte Prefix angewendet werden, ohne jedes einzelne Objekt nachträglich per ACL anfassen zu müssen.
</Callout>

Beispiel: Öffentlicher Lesezugriff auf alle Objekte unterhalb von `images/`.

Datei: `allow-read.json`

```json
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "PublicReadImagesPrefix",
      "Effect": "Allow",
      "Principal": "*",
      "Action": [
        "s3:GetObject"
      ],
      "Resource": [
        "arn:aws:s3:::awesome-bucket/images/*"
      ]
    }
  ]
}
```

Die Policy wird anschließend wie folgt auf den Bucket angewendet:

```shell
aws s3api put-bucket-policy --bucket awesome-bucket --policy file://allow-read.json
```

Danach sind alle Objekte unterhalb des Prefixes `images/` öffentlich lesbar, zum Beispiel:

```
https://radosgw.opencloud.telemaxx.de/awesome-bucket/images/image.png
```

### Bucket Policy prüfen

Eine gesetzte Bucket Policy kann mit folgendem Befehl geprüft werden:

```shell
aws s3api get-bucket-policy --bucket awesome-bucket --output json | jq -r '.Policy'
```

Unter dem Key `Policy` finden wir den ursprünglichen Inhalt der JSON-Datei wieder:

```json
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "PublicReadImagesPrefix",
      "Effect": "Allow",
      "Principal": "*",
      "Action": ["s3:GetObject"],
      "Resource": ["arn:aws:s3:::awesome-bucket/images/*"]
    }
  ]
}
```

## S3 Policy Generator

Zum Erstellen von S3 Policies im geeigneten Format kann der **[AWS Policy Generator](https://awspolicygen.s3.amazonaws.com/policygen.html)** verwendet werden.

Dabei sollte darauf geachtet werden, dass der *Amazon Resource Name (ARN)* den passenden Bucket-Namen sowie das gewünschte Resource Pattern enthält, z.B.:

```
arn:aws:s3:::awesome-bucket/images/*
```

Typische *Actions* sind beispielsweise **GetObject**, **PutObject** und **DeleteObject**.

Nach einem Klick auf *Generate Policy* wird ein passendes JSON-Dokument erzeugt. Dieses kann anschließend, wie oben beschrieben, als Bucket Policy hinterlegt werden.

<br />