Gestione di Multi - Cloud Object Gateway

È possibile utilizzare NooBaa per gestire le risorse di archiviazione degli oggetti S3-compatible, come IBM Object Storage, Amazon S3 o Azure Blob. Con NooBaa, è inoltre possibile creare e gestire lo storage a oggetti in modo coerente tra cluster e zone.

Configurazione degli archivi di backup utilizzando la CLI NooBaa

Gli archivi di backup sono le risorse di NooBaa per la gestione dei servizi e dei bucket di S3-compatible. Quando si crea un backing store, si forniscono le credenziali del servizio S3, come l'ID della chiave di accesso, la chiave di accesso segreta e l'endpoint del servizio di archiviazione degli oggetti. Dopo aver aggiunto i backing store al cluster, è possibile creare classi di bucket, che consentono di configurare i criteri di federazione dei dati per i servizi di storage S3-compatible.

Dopo aver distribuito ODF, è possibile configurare più archivi di backup nel cluster di memoria. È possibile creare un backing store utilizzando un qualsiasi object store di S3-compatible, come Amazon S3 o IBM Cloud Object Storage.

È inoltre possibile creare e gestire gli archivi di backup nella console web Red Hat OpenShift.

Per aggiungere un archivio di backup al tuo cluster di archiviazione utilizzando la CLI NooBaa:

Accedi al tuo cluster Red Hat OpenShift.

Installa la NooBaa Operator CLI.

Eseguire il comando noobaa backingstore create per visualizzare un elenco di tipi di archivio di backup supportati.

noobaa backingstore create

Output di esempio

Create backing store

Available Commands:
aws-s3               Create aws-s3 backing store
azure-blob           Create azure-blob backing store
google-cloud-storage Create google-cloud-storage backing store
ibm-cos              Create ibm-cos backing store
pv-pool              Create pv-pool backing store
s3-compatible        Create s3-compatible backing store

Ottenere i dettagli del servizio che si desidera utilizzare. Se si desidera configurare IBM Cloud Object Storage, ottenere le credenziali HMAC. Per ulteriori informazioni, vedere Utilizzo delle credenziali HMAC. L'esempio di comando seguente mostra i parametri di configurazione necessari per creare un backing store utilizzando un'istanza del servizio IBM Cloud Object Storage.
```
noobaa backingstore create ibm-cos <backing-store-name> -n openshift-storage --access-key=<access-key> --endpoint=<endpoint> --secret-key=<secret-key> --target-bucket=<target-bucket>
```

Ottieni i dettagli del tuo archivio di backup.

noobaa backingstore status <backing-store-name> -n openshift-storage

Creazione di una classe bucket che utilizza due archivi di backup con una politica di posizionamento mirror

Dopo aver installato ODF e configurato almeno due archivi di backup, è possibile creare una classe bucket che utilizzi più archivi di backup. Le classi bucket ti consentono di configurare le politiche di federazione dei dati nei tuoi archivi di backup. Quindi, quando le tue applicazioni scrivono oggetti nel tuo bucket, puoi eseguire il mirroring o distribuire gli oggetti su due o più archivi di backup.

Installare la CLI di NooBaa.
Ottieni lo stato della tua istanza NooBaa. Per i cluster in IBM Cloud, specifica lo spazio nomi openshift-storage.
```
noobaa status -n openshift-storage
```
Verificare di disporre di almeno due archivi di backup.
```
noobaa backingstore list -n openshift-storage
```
Crea una classe bucket che utilizza due dei tuoi archivi di backup e ha una politica Mirror per eseguire il mirroring degli oggetti in due o più archivi di backup.
```
noobaa bucketclass create <bucketclass-name> --backingstores=[<backingstore_one>,<backingstore_two>] --placement='<placement>' -n <namespace>
```

Facoltativo Puoi creare anche una classe bucket utilizzando un file di configurazione YAML.

apiVersion: noobaa.io/v1alpha1
kind: BucketClass
metadata:
  labels:
    app: noobaa
  name: mirror-bucket-class
  namespace: openshift-storage
spec:
  placementPolicy:
    tiers:
    - backingStores:
      - backing-store-one
      - backing-store-two
      placement: Mirror

Creazione di una classe di memoria

Dopo aver creato gli archivi di backup e una classe bucket, crea una classe di archiviazione per rendere disponibili le tue risorse della classe bucket tra gli spazi dei nomi nel tuo cluster.

Crea un file YAML della classe di archiviazione contenente un nome per la tua classe di archiviazione nel formato <name>-noobaa.noobaa.io, il nome della classe bucket che vuoi utilizzare e il provisioner impostato su openshift-storage.noobaa.io/obc.

apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: <name>-noobaa.noobaa.io
provisioner: openshift-storage.noobaa.io/obc
parameters:
  bucketclass: <bucket-class-name>
reclaimPolicy: Delete
volumeBindingMode: Immediate

Crea la classe di archiviazione nel tuo cluster.
```
oc create -f sc.yaml
```
Verificare che la classe di archiviazione sia stata creata.
```
oc get sc
```

Creazione di una richiesta bucket di oggetti

Dopo aver creato i backing store e una classe di bucket, è possibile creare un object bucket claim da utilizzare per rivendicare le risorse di storage per le applicazioni s3.

Crea un file YAML di richiesta bucket di oggetti che fa riferimento alla classe bucket che hai creato in precedenza.

apiVersion: objectbucket.io/v1alpha1
kind: ObjectBucketClaim
metadata:
  name: cos-obc
spec:
  storageClassName: cos-noobaa.noobaa.io
  bucketName: cos-bucket

Crea la richiesta del bucket di oggetti nel tuo cluster.
```
oc apply -f obc.yaml
```
Verificare che OBC sia stato creato.
```
noobaa obc list
```
Elenca i segreti e le mappe di configurazione nel tuo cluster e verifica che siano stati creati il segreto e la mappa di configurazione corrispondenti per il tuo OBC.
```
oc get secrets | grep <obc-name> && oc get cm | grep <obc-name>
```

Distribuzione di un'applicazione s3 in Multicloud Object Gateway

Crea un file YAML dell'app che fa riferimento al segreto e alla mappa di configurazione dal tuo OBC. La seguente applicazione di esempio utilizza l'immagine banst/awscli e configura la CLI AWS.

apiVersion: v1
kind: Pod
metadata:
    name: app
labels:
  app: app
spec:
    containers:
    - name: app
    envFrom:
    - secretRef:
        name: <secret-name>
    - configMapRef:
        name: <config-map-name>
    image: banst/awscli
    command:
        - sh
        - "-c"
        - |
            echo "----> Configuring S3 endpoint ...";
            pip install awscli-plugin-endpoint;
            aws configure set plugins.endpoint awscli_plugin_endpoint;
            aws configure set s3.endpoint_url https://s3.openshift-storage.svc;
            echo "----> Configuring certificates ...";
            aws configure set ca_bundle /var/run/secrets/kubernetes.io/serviceaccount/service-ca.crt;
            echo "----> Copying files ...";
            aws s3 cp --recursive /etc s3://$BUCKET_NAME;
            echo "----> List files ...";
            aws s3 ls $BUCKET_NAME;
            echo "----> Done.";

Creare l'applicazione nel cluster.
```
oc create -f app.yaml
```
Verificare che l'applicazione sia in esecuzione.
```
oc get pods
```