# S3 Object Storage

Phoeniqs Cloud provides S3-compatible object storage for buckets used by your applications, backups, media, and data lakes. Object storage is backed by Ceph RGW (Red Hat OpenShift Data Foundation / NooBaa) and is served from Phoeniqs' Swiss sovereign infrastructure.

Object storage is different from the block storage in your Capacity Pool. Block storage is purchased and consumed through a Capacity Pool and PersistentVolumeClaims inside a Namespace. S3 object storage is allocated in the portal, but provisioned on OpenShift through an ObjectBucketClaim. Using it therefore takes two steps:

  1. In the portal, add the S3 storage subscription to the resource group you want it billed to.
  2. On OpenShift, create an ObjectBucketClaim YAML in your project to provision the bucket and obtain access credentials.

Setting up S3 is not complete by adding it to a resource group alone — the bucket is only created on OpenShift.


# Step 1: Purchase & allocate in the portal

  1. Sign in to the Phoeniqs Portal.
  2. Go to Products → Infrastructure Services.
  3. Click Add on the S3 Object Storage tile.
  4. At checkout, select the Resource Group you want the storage allocated and billed to, agree to the terms, and click Buy subscription.

This mirrors the checkout flow for the other IaaS products. See the IaaS Quickstart Guide for the general purchase flow and Resource Pricing for rates.


# Step 2: Provision the bucket on OpenShift

The bucket must be provisioned on OpenShift with an ObjectBucketClaim. Do not use the OpenShift console's GUI wizard to create the bucket — it does not expose the required maxSize field, so you must apply the manifest directly.

  1. Log in to the OpenShift console. See Access Your OpenShift for the login and project navigation steps.

  2. Open the project (namespace) you want to hold the bucket.

  3. Create a persistent claim using the manifest below, adjusting metadata.name and metadata.namespace to match your project:

    apiVersion: objectbucket.io/v1alpha1
    kind: ObjectBucketClaim
    metadata:
      name: obc-smoke-test
      namespace: d01000-e26-4229-test-15657
    spec:
      generateBucketName: obc-smoke-test
      storageClassName: ocs-storagecluster-ceph-rgw
      additionalConfig:
        maxSize: 10Gi

# Field notes

Field Description
metadata.name A name for the bucket claim (for example obc-smoke-test, backups, uploads).
metadata.namespace The OpenShift project the bucket is provisioned into.
spec.generateBucketName The name generated for the underlying bucket, for example obc-smoke-test.
spec.storageClassName Must be set to ocs-storagecluster-ceph-rgw.
spec.additionalConfig.maxSize Required. The maximum size (capacity cap) for the bucket, for example 10Gi. This field is mandatory and is why the GUI wizard cannot be used.

Apply the manifest with oc apply -f <file>.yaml or paste it into the OpenShift console's + Add → Import YAML.


# Step 3: Connect & use

Once the ObjectBucketClaim is provisioned, OpenShift creates an S3 access Secret in the same namespace containing your access key and secret key. These credentials are required to use the bucket.

  1. Retrieve the Secret in your project (OpenShift console Workloads → Secrets, or oc get secret).

  2. Point any S3-compatible client (AWS CLI, mc, or an application library) at the public Ceph RGW S3 endpoint and authenticate with those keys:

    https://ocs-storagecluster-cephobjectstore-secure-openshift-storage.apps.basel.kvant.cloud/
  3. Create and use your buckets through the client.


# Existing customers on AI-2 / AI-3

The AI-2 and AI-3 clusters do not run the RGW provider, so you cannot provision an ObjectBucketClaim directly on them. If your workloads already run on AI-2 or AI-3 and you need S3, you can still use object storage by provisioning the bucket on Basel and consuming it cross-cluster over the public RGW route. This pattern is verified to work from AI-3 against Basel.

The single most important point: the bucket's credentials and settings are created on Basel, but you must point your S3 client at the public RGW endpoint — not at the internal BUCKET_HOST that OpenShift provisions alongside the bucket.

# Step 1: Provision the bucket on Basel

Create the ObjectBucketClaim on the Basel cluster, exactly as described in Step 2: Provision the bucket on OpenShift, with spec.storageClassName set to ocs-storagecluster-ceph-rgw and a maxSize.

Once the claim becomes Bound, OpenShift creates a Secret and a ConfigMap named after the claim in the same namespace on Basel:

# On Basel
oc -n <basel-namespace> get secret <obc-name> -o jsonpath='{.data}' | jq 'keys'
# AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY

oc -n <basel-namespace> get cm <obc-name> -o jsonpath='{.data}'
# BUCKET_NAME, BUCKET_HOST, BUCKET_PORT, BUCKET_REGION, BUCKET_SUBREGION

# Step 2: Copy the credentials to your AI-2 / AI-3 namespace

Copy the access key and secret from Basel into the namespace on your consumer cluster (AI-2 or AI-3). Pipe the values directly between the two clusters with oc, so the credentials are never printed or pasted. You only need the two keys, the bucket name, and the public RGW endpoint:

# From the Basel cluster to the AI-2 / AI-3 consumer cluster
oc --context <basel-ctx> -n <basel-namespace> get secret <obc-name> -o json \
  | jq --arg ns <consumer-namespace> '{apiVersion: "v1", kind: "Secret", type: "Opaque",
       metadata: {name: "s3-creds", namespace: $ns},
       data: {AWS_ACCESS_KEY_ID: .data.AWS_ACCESS_KEY_ID,
              AWS_SECRET_ACCESS_KEY: .data.AWS_SECRET_ACCESS_KEY}}' \
  | oc --context <consumer-ctx> -n <consumer-namespace> apply -f -

oc --context <consumer-ctx> -n <consumer-namespace> create configmap s3-bucket \
  --from-literal=BUCKET_NAME="$(oc --context <basel-ctx> -n <basel-namespace> \
      get cm <obc-name> -o jsonpath='{.data.BUCKET_NAME}')" \
  --from-literal=AWS_ENDPOINT_URL="https://ocs-storagecluster-cephobjectstore-secure-openshift-storage.apps.basel.kvant.cloud"

# Step 3: Connect & use from your consumer cluster

Point any S3-compatible client at the public endpoint (AWS_ENDPOINT_URL above) using the copied credentials. The verifiable pattern uses an aws-cli container, for example:

apiVersion: v1
kind: Pod
metadata:
  name: s3-consumer
  annotations:
    # Required on our clusters; without it the pod lands on the RHOAI image-volume SCC
    openshift.io/required-scc: restricted-v2
spec:
  restartPolicy: Never
  securityContext:
    runAsNonRoot: true
    seccompProfile:
      type: RuntimeDefault
  containers:
    - name: aws
      # Pinned below 2.23: newer CLIs send default CRC checksums that Ceph RGW may reject
      image: docker.io/amazon/aws-cli:2.17.0
      command: ["/bin/bash", "-c"]
      args:
        - |
          aws s3 ls s3://$BUCKET_NAME
          aws s3 cp /tmp/object.bin s3://$BUCKET_NAME/object.bin
      env:
        - name: HOME
          value: /tmp
        - name: AWS_DEFAULT_REGION
          value: us-east-1
      envFrom:
        - secretRef:
            name: s3-creds
        - configMapRef:
            name: s3-bucket

# Caveats for cross-cluster consumption

  • SCC annotation — add openshift.io/required-scc: restricted-v2 to the pod or workload. Without it, pods are admitted under the RHOAI image-volume SCC on our clusters.
  • aws-cli version — pin to 2.17.0. Newer CLI versions send default CRC checksums that Ceph RGW may reject.
  • Presigned URLs and addressing style — presigned GET URLs may fail with a DNS or certificate error if the client resolves them as bucket.host... (virtual-host addressing), because the wildcard route/certificate does not cover that style. If so, switch to path-style addressing (aws configure set default.s3.addressing_style path, or in boto3 Config(s3={'addressing_style': 'path'})).
  • Egress — if the consumer namespace has restrictive NetworkPolicies, allow egress TCP 443 to the Basel ingress routers so the client can reach the public endpoint.
  • Throughput — traffic crosses the Basel ingress routers, so upload/download throughput reflects this path rather than raw RGW speed.

# Capacity Pool S3 allowance & deprovisioning

Each Capacity Pool has an S3 object-storage allowance. The total maxSize of the ObjectBucketClaims tied to a pool counts against that allowance, so the pool only reserves the capacity your buckets actually need.


# Troubleshooting

Issue Likely cause Fix
Bucket claim stays pending maxSize missing or invalid Ensure spec.additionalConfig.maxSize is set (for example 10Gi).
Bucket does not appear Wrong storage class Confirm spec.storageClassName is ocs-storagecluster-ceph-rgw.
Cannot connect / access denied Missing or wrong credentials Retrieve the correct access key and secret from the Secret created in your namespace.
Can't reach the endpoint from AI-2 / AI-3 Using the internal BUCKET_HOST instead of the public route Point your client at the public RGW endpoint https://ocs-storagecluster-cephobjectstore-secure-openshift-storage.apps.basel.kvant.cloud/, not the cluster-internal host. See Existing customers on AI-2 / AI-3.
Presigned URL fails with a DNS or certificate error Virtual-host addressing (bucket.host...) not covered by the wildcard route/cert Switch to path-style addressing (aws configure set default.s3.addressing_style path).
Bucket not in the resource group Signup / billing mismatch Confirm the S3 subscription was added to the intended resource group at checkout.
Cannot deprovision the Capacity Pool ObjectBucketClaims still tied to the pool, so the sum of their maxSize exceeds the pool's S3 allowance Remove the affected ObjectBucketClaims or reduce their maxSize, then retry.