Gestisci l'archiviazione di oggetti

Linee guida per la denominazione dei bucket di archiviazione

I nomi dei bucket devono rispettare le seguenti convenzioni di denominazione:

• Essere univoco all'interno del progetto. Un progetto aggiunge un prefisso univoco al nome del bucket, garantendo che non si verifichino conflitti all'interno dell'organizzazione. Nell'improbabile eventualità di un conflitto tra prefisso e nome del bucket tra le organizzazioni, la creazione del bucket non riesce e viene visualizzato l'errore bucket name in use.
• Deve contenere almeno un carattere e non più di 57.
• Evita di includere informazioni che consentono l'identificazione personale (PII).
• Essere conforme al DNS.
• Inizia con una lettera e contiene solo lettere, numeri e trattini.

Installa l'interfaccia a riga di comando dello strumento s3cmd

Lo strumento s3cmd è uno strumento a riga di comando per la gestione dell'object storage.

1. Per scaricare lo strumento, vai alla directory da cui è stato estratto il bundle GDC.

2. Esegui questi comandi per estrarre l'immagine s3cmd, s3cmd.tar.tar.gz, in una directory temporanea vuota:

   tmpdir=$(mktemp -d)
   
   gdcloud artifacts extract oci/ $tmpdir \
     --image-name=$(gdcloud artifacts tree oci | grep s3cmd.tar | sed 's/^.* //')
   

3. scp il file tar in una macchina client in cui utilizzi s3cmd per le operazioni sugli oggetti; decomprimi e installa l'immagine.

Scegli uno dei seguenti metodi di installazione per installare lo strumento s3cmd:

Installare tramite file tar

1. Per decomprimere l'archivio e installare il pacchetto s3cmd, esegui questi comandi. Per installare il pacchetto, devi disporre del modulo Python distutils. Il modulo fa spesso parte del pacchetto Python di base oppure puoi installarlo utilizzando il gestore di pacchetti.

   tar xvf /tmp/gpc-system-tar-files/s3cmd.tar.tar.gz
   cd /tmp/gpc-system-tar-files/s3cmd
   sudo python3 setup.py install
   

2. (Facoltativo) Pulisci i file scaricati:

   rm /tmp/gpc-system-tar-files/s3cmd.tar.tar.gz
   rm -r /tmp/gpc-system-tar-files/s3cmd
   

Installare con l'immagine Docker

Nota: anteponi il prefisso /g/ a tutti i comandi che fanno riferimento a file locali. Ad esempio: s3cmd put /g/local_file s3://fully_qualified_bucket_name.

1. Per installare l'immagine s3cmd, esegui questi comandi:

   docker load --input s3cmd-docker.tar
   export S3CFG=/EMPTY_FOLDER_PATH/
   alias s3cmd="docker run -it --net=host --mount=type=bind,source=/$S3CFG/,target=/g/
   s3cmd-docker:latest -c /g/s3cfg"
   

   Nota: solo i file all'interno della cartella S3CFG sono accessibili al container Docker. Se necessario, aggiungi il flag --ca-certs=/g/certificate_file al comando Docker precedente oppure utilizza il flag --no-check-certificate per la modalità non sicura.

2. (Facoltativo) Pulisci i file scaricati:

   rm s3cmd-docker.tar
   

3. Aggiungi l'esportazione e l'alias al file .bashrc per mantenerli dopo il riavvio del client.

Nota: questo comando installa solo lo strumento s3cmd sulla macchina client e richiede una configurazione futura.

Configura lo strumento s3cmd

Utilizza lo strumento s3cmd per le operazioni basate sugli oggetti.

Esegui il comando s3cmd --configure e specifica quanto segue:

1. Chiave di accesso: inserisci la chiave di accesso ottenuta dal secret in Ottenere le credenziali di accesso.
2. Chiave segreta: inserisci la chiave segreta ottenuta dal secret in Ottenere le credenziali di accesso.
3. Regione predefinita: premi ENTER.
4. Endpoint S3: inserisci l'endpoint fornito dall'operatore dell'infrastruttura (IO).
5. Per l'assegnazione dei nomi dei bucket in stile DNS, inserisci s3://%(bucket).
6. (Facoltativo) Inserisci una password di crittografia per proteggere i file in transito.
7. In Percorso di GPG, inserisci /usr/bin/gpg.
8. Inserisci Yes per utilizzare il protocollo HTTPS.
9. Premi Enter per saltare l'inserimento del nome del server proxy.

Crea bucket di archiviazione

Prima di iniziare

Uno spazio dei nomi del progetto gestisce le risorse bucket nel cluster di amministrazione principale. Per creare un bucket devi avere un progetto. Per creare un nuovo progetto, consulta Creare un progetto. Per eseguire le seguenti operazioni, devi disporre delle autorizzazioni appropriate per il bucket. Consulta Concedere l'accesso al bucket.

Crea un bucket

Per creare un bucket, applica una specifica del bucket allo spazio dei nomi del progetto:

    kubectl apply -f bucket.yaml

Di seguito è riportato un esempio di specifica del bucket:

    apiVersion: object.gdc.goog/v1alpha1
    kind: Bucket
    metadata:
      name: BUCKET_NAME
      namespace: NAMESPACE_NAME
    spec:
      description: DESCRIPTION
      storageClass: standard-rwo
      bucketPolicy :
        lockingPolicy :
          defaultObjectRetentionDays: RETENTION_DAY_COUNT

Per ulteriori dettagli, consulta il riferimento API Bucket.

Elenca i bucket di archiviazione

Per elencare tutti i bucket a cui hai accesso in un determinato tenant di archiviazione oggetti, completa i seguenti passaggi:

1. Esegui i seguenti comandi per elencare tutti i bucket:

   kubectl get buckets --all-namespaces
   kubectl get buckets --namespace NAMESPACE_NAME
   

Elimina bucket di archiviazione

Puoi eliminare i bucket di archiviazione utilizzando l'interfaccia a riga di comando. I bucket devono essere vuoti prima di poter essere eliminati.

1. Utilizza il comando GET o DESCRIBE nella sezione Visualizza configurazione bucket per ottenere il nome completo del bucket.

2. Se il bucket non è vuoto, svuotalo:

   s3cmd rm --recursive -—force s3://FULLY_QUALIFIED_BUCKET_NAME
   

3. Elimina il bucket vuoto:

   kubectl delete buckets/BUCKET_NAME --namespace NAMESPACE_NAME
   

Visualizza la configurazione del bucket

Utilizza uno dei due comandi per visualizzare i dettagli di configurazione di un bucket:

    kubectl describe buckets/BUCKET_NAME --namespace NAMESPACE_NAME

    kubectl get buckets/BUCKET_NAME --namespace NAMESPACE_NAME -o yaml

Impostare un periodo di conservazione degli oggetti

Per impostazione predefinita, puoi eliminare gli oggetti in qualsiasi momento. Attiva il blocco degli oggetti con un periodo di conservazione per impedire l'eliminazione di tutti gli oggetti nel bucket per il numero di giorni specificato. Non puoi eliminare un bucket finché non elimini tutti gli oggetti dopo il periodo di conservazione.

Devi abilitare il blocco degli oggetti durante la creazione del bucket. Non puoi abilitare o disabilitare il blocco degli oggetti dopo aver creato un bucket. Tuttavia, puoi modificare il periodo di conservazione predefinito degli oggetti.

Puoi creare un bucket con o senza abilitare il blocco degli oggetti. Se hai attivato il blocco degli oggetti, specificare un periodo di conservazione predefinito è facoltativo.

Per modificare il periodo di conservazione, aggiorna il campo Bucket.spec.bucketPolicy.lockingPolicy.defaultObjectRetentionDays nella risorsa Bucket.

Di seguito è riportato un esempio di aggiornamento del campo nella risorsa Bucket:

apiVersion: object.gdc.goog/v1alpha1
kind: Bucket
metadata:
  name: BUCKET_NAME
  namespace: NAMESPACE_NAME
spec:
  description: "This bucket has a default retention period specified."
  storageClass: standard-rwo
  bucketPolicy :
    lockingPolicy :
      defaultObjectRetentionDays: RETENTION_DAY_COUNT
---
apiVersion: object.gdc.goog/v1alpha1
kind: Bucket
metadata:
  name: BUCKET_NAME
  namespace: NAMESPACE_NAME
spec:
  description: "This would enable object locking but not specify a default retention period."
  storageClass: standard-rwo
  bucketPolicy :
    lockingPolicy :
---
apiVersion: object.gdc.goog/v1alpha1
kind: Bucket
metadata:
  name: BUCKET_NAME
  namespace: NAMESPACE_NAME
spec:
  description: "This bucket does not have locking or retention enabled."
  storageClass: standard-rwo

Eventuali aggiornamenti al periodo di conservazione si applicano agli oggetti creati nel bucket dopo l'aggiornamento. Per gli oggetti preesistenti, il periodo di conservazione non cambia.

Quando hai attivato il blocco degli oggetti, se tenti di sovrascrivere un oggetto, aggiungi una nuova versione dell'oggetto. Puoi recuperare entrambe le versioni dell'oggetto. Per informazioni dettagliate su come elencare le versioni degli oggetti, consulta ListObjectVersions nella documentazione di Amazon Web Services: https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListObjectVersions.html

Per creare un bucket write-once, read-many (WORM), consulta la sezione Bucket WORM.

Concedi l'accesso al bucket

Puoi fornire l'accesso al bucket ad altri utenti o service account creando e applicando RoleBindings con ruoli predefiniti.

Ruoli predefiniti

• project-bucket-object-viewer: questo ruolo consente a un utente di elencare tutti i bucket nel progetto, elencare gli oggetti in questi bucket e leggere gli oggetti e i metadati degli oggetti. Questo ruolo non consente operazioni di scrittura sugli oggetti, come caricamento, sovrascrittura o eliminazione.

• project-bucket-object-admin: questo ruolo consente a un utente di elencare tutti i bucket nel progetto ed eseguire operazioni di lettura e scrittura sugli oggetti, ad esempio caricamento, sovrascrittura o eliminazione.

• project-bucket-admin::questo ruolo consente agli utenti di gestire tutti i bucket nello spazio dei nomi specificato, nonché tutti gli oggetti in questi bucket.

Per visualizzare un elenco completo delle autorizzazioni concesse per questi ruoli, consulta la sezione Autorizzazioni dei ruoli preimpostati.

Per ottenere le autorizzazioni necessarie per creare associazioni di ruoli del progetto, chiedi all'amministratore IAM del progetto di concederti il ruolo Amministratore IAM del progetto (project-iam-admin).

Di seguito è riportato un esempio di creazione di un RoleBinding per concedere l'accesso a un utente e a un account di servizio:

1. Crea un file YAML sul tuo sistema, ad esempio rolebinding-object-admin-all-buckets.yaml.

    apiVersion: rbac.authorization.k8s.io/v1
    kind: RoleBinding
    metadata:
      namespace: NAMESPACE_NAME
      name: readwrite-all-buckets
    roleRef:
      kind: Role
      name: project-bucket-object-admin
      apiGroup: rbac.authorization.k8s.io
    subjects:
    - kind: ServiceAccount
      namespace: NAMESPACE_NAME
      name: SA_NAME
    - kind: User
      namespace: NAMESPACE_NAME
      name: [e-mail]  # Could be bob or [e-mail] based on your organization settings.
      apiGroup: rbac.authorization.k8s.io
    ```
   

2. Applica il file YAML:

   kubectl apply \
   -f rolebinding-object-admin-all-buckets.yaml
   

Ottenere le credenziali di accesso al bucket

Quando concedi l'accesso a un bucket, le credenziali di accesso vengono create in un secret.

Il formato del nome del secret è object-storage-key-SUBJECT_TYPE-SUBJECT_HASH.

• I valori per SUBJECT_TYPE sono i seguenti:
  • user: l'utente.
  • sa: il ServiceAccount.
• SUBJECT_HASH è l'hash SHA256 con codifica base32 del nome del soggetto.

Ad esempio, l'utente [e-mail] ha il secret denominato:

object-storage-key-user-oy6jdqd6bxfoqcecn2ozv6utepr5bgh355vfku7th5pmejqubdja

Accedere al secret utente

Per un soggetto utente, il secret si trova nello spazio dei nomi object-storage-access-keys nel cluster di amministrazione radice.

1. Trova il nome del secret:

   kubectl auth can-i --list --namespace object-storage-access-keys | grep object-storage-key-
   

   Riceverai un output simile al seguente:

   secrets        []        [object-storage-key-nl-user-oy6jdqd6bxfoqcecn2ozv6utepr5bgh355vfku7th5pmejqubdja,object-storage-key-std-user-oy6jdqd6bxfoqcecn2ozv6utepr5bgh355vfku7th5pmejqubdja]        [get]
   

2. Recupera i contenuti del secret corrispondente per accedere ai bucket:

   kubectl get -o yaml --namespace object-storage-access-keys secret
   object-storage-key-rm-user-oy6jdqd6bxfoqcecn2ozv6utepr5bgh355vfku7th5pmejqubdja
   

   Riceverai un output simile al seguente:

   data:
     access-key-id: MEhYM08wWUMySjcyMkVKTFBKRU8=
     create-time: MjAyMi0wNy0yMiAwMTowODo1OS40MTQyMTE3MDMgKzAwMDAgVVRDIG09KzE5OTAuMzQ3OTE2MTc3
     secret-access-key: Ump0MVRleVN4SmhCSVJhbmlnVDAwbTJZc0IvRlJVendqR0JuYVhiVA==
   

3. Decodifica l'ID chiave di accesso e il secret:

   echo "MEhYM08wWUMySjcyMkVKTFBKRU8=" | base64 -d \
       && echo \
       && echo "Ump0MVRleVN4SmhCSVJhbmlnVDAwbTJZc0IvRlJVendqR0JuYVhiVA==" | base64 -d
   

   Riceverai un output simile al seguente:

   0HX3O0YC2J722EJLPJEO
   Rjt1TeySxJhBIRanigT00m2YsB/FRUzwjGBnaXbT
   

4. Segui la sezione Configura s3cmd con le informazioni risultanti.

Accedi al secret del account di servizio

Per un soggetto di un account di servizio (SA), il secret si trova nello stesso spazio dei nomi del bucket. Per trovare il nome, esegui:

  kubectl get --namespace NAMESPACE_NAME secrets -o=jsonpath=
  '{.items[?(@.metadata.annotations.object\.gdc\.goog/subject=="SA_NAME")].metadata.name}'

Riceverai un output simile al seguente:

  object-storage-key-rm-sa-mng3olp3vsynhswzasowzu3jgzct2ert72pjp6wsbzqhdwckwzbq

Puoi fare riferimento al secret nel pod come variabili di ambiente (https://kubernetes.io/docs/concepts/configuration/secret/#using-secrets-as-environment-variables) o file (https://kubernetes.io/docs/concepts/configuration/secret/#using-secrets-as-files-from-a-pod).

Autorizzazioni dei ruoli preimpostate

Autorizzazioni project-bucket-object-viewer

Questo ruolo concede le autorizzazioni per ottenere ed elencare gli oggetti e i relativi metadati nel bucket.

Il ruolo project-bucket-object-viewer dispone delle seguenti autorizzazioni:

• Autorizzazioni API bucket:

  1. Ottieni
  2. Elenco
  3. Guarda

• Autorizzazioni di archiviazione degli oggetti S3:

  1. GetObject
  2. GetObjectAcl
  3. GetObjectVersion
  4. ListBucket
  5. ListBucketVersions
  6. ListBucketMultipartUploads
  7. ListMultipartUploadParts

project-bucket-object-admin permissions

Questo ruolo concede le autorizzazioni per inserire ed eliminare oggetti, versioni degli oggetti e tag nel bucket. Inoltre, concede anche tutte le autorizzazioni in project-bucket-object-viewer.

Il ruolo project-bucket-object-admin dispone delle seguenti autorizzazioni di archiviazione di oggetti:

• Autorizzazioni di archiviazione degli oggetti S3:

  1. AbortMultipartUpload
  2. DeleteObject
  3. DeleteObjectVersion
  4. PutObject
  5. RestoreObject

autorizzazioni di amministratore del bucket del progetto

Questo ruolo concede le autorizzazioni per creare, aggiornare o eliminare risorse Bucket nello spazio dei nomi del progetto. Inoltre, concede anche tutte le autorizzazioni in project-bucket-object-admin.

Il ruolo project-bucket-object-admin dispone delle seguenti autorizzazioni:

• Autorizzazioni API bucket:

  1. Crea
  2. Aggiornamento
  3. Elimina

Crea un bucket WORM

Un bucket WORM garantisce che nessun altro sovrascriva gli oggetti e li conserva per un periodo di tempo minimo. La registrazione degli audit è un esempio di caso d'uso per un bucket WORM.

Nota: se tenti di sovrascrivere un oggetto in un bucket WORM, verrà aggiunta una nuova versione dell'oggetto. Solo dopo la fine del periodo di conservazione di un oggetto WORM, come stabilito dalla policy di blocco del bucket, puoi procedere con l'eliminazione di oggetti, bucket e progetti.

Per creare un bucket WORM:

1. Imposta un periodo di conservazione durante la creazione del bucket. Ad esempio, il seguente bucket di esempio ha un periodo di conservazione di 365 giorni.

   apiVersion: object.gdc.goog/v1alpha1
   kind: Bucket
   metadata:
     name: foo logging-bucket
     namespace: foo-service
   spec:
     description: "Audit logs for foo"
     storageClass: standard-rwo
     bucketPolicy :
       lockingPolicy :
         defaultObjectRetentionDays: 365
   

2. Concedi il ruolo project-bucket-object-viewer a tutti gli utenti che hanno bisogno dell'accesso di sola lettura:

   apiVersion: rbac.authorization.k8s.io/v1
   kind: RoleBinding
   metadata:
     namespace: foo-service
     name: object-readonly-access
   roleRef:
     kind: Role
     name: project-bucket-object-viewer
     apiGroup: rbac.authorization.k8s.io
   subjects:
   - kind: ServiceAccount
     namespace: foo-service
     name: foo-log-processor
   - kind: User
     name: [e-mail]
     apiGroup: rbac.authorization.k8s.io
   

3. Concedi il ruolo project-bucket-object-admin agli utenti che devono scrivere contenuti nel bucket:

   apiVersion: rbac.authorization.k8s.io/v1
   kind: RoleBinding
   metadata:
     namespace: foo-service
     name: object-write-access
   roleRef:
     kind: Role
     name: project-bucket-object-viewer
     apiGroup: rbac.authorization.k8s.io
   subjects:
   - kind: ServiceAccount
     namespace: foo-service
     name: foo-service-account
   

Ripristinare dall'archiviazione di oggetti al file system sull'archiviazione a blocchi

Allocare un volume permanente

Per ripristinare i file da un endpoint di archiviazione oggetti:

1. Alloca un volume permanente (PV) da utilizzare come target nel ripristino. Utilizza una persistent volume claim (PVC) per allocare il volume, come mostrato nell'esempio seguente:

   apiVersion: v1
   kind: PersistentVolumeClaim
   metadata:
     name: restore-pvc
     namespace: restore-ns
   spec:
     storageClassName: standard-rwo
     accessModes:
   ReadWriteOnce
     resources:
       requests:
         storage: 1Gi # Need sufficient capacity for full restoration.
   

2. Controlla lo stato del PVC:

   kubectl get pvc restore-pvc -n restore-ns
   

   Una volta che la PVC è nello stato Bound, è pronta per essere utilizzata all'interno del pod che la reidrata.

3. Se un set Stateful alla fine utilizza il PV, devi abbinare i PVC di StatefulSet sottoposti a rendering. I pod che StatefulSet produce consumano i volumi idratati. L'esempio seguente mostra i modelli di rivendicazione del volume in un StatefulSet denominato ss.

     volumeClaimTemplates:
     - metadata:
         name: pvc-name
       spec:
         accessModes: [ "ReadWriteOnce" ]
         storageClassName: standard-rwo
         resources:
           requests:
             storage: 1Gi
   

4. Prealloca i PVC con nomi come ss-pvc-name-0 e ss-pvc-name-1 per assicurarti che i pod risultanti utilizzino i volumi preallocati.

Esegui l'idratazione del Persistent Volume (PV)

Dopo che la PVC è stata associata a un PV, avvia Job per popolare il PV:

apiVersion: batch/v1
kind: Job
metadata:
  name: transfer-job
  namespace: transfer
spec:
  template:
    spec:
      serviceAccountName: data-transfer-sa
      volumes:
      - name: data-transfer-restore-volume
        persistentVolumeClaim:
          claimName: restore-pvc
      containers:
      - name: storage-transfer-pod
        image: gcr.io/private-cloud-staging/storage-transfer:latest
        command: /storage-transfer
        args:
        - --src_endpoint=https://your-src-endpoint.com
        - --src_path=/your-src-bucket
        - --src_credentials=transfer/src-secret
        - --dst_path=/restore-pv-mnt-path
        - --src_type=s3
        - --dst_type=local
      volumeMounts:
      - mountPath: /restore-pv-mnt-path
        name: data-transfer-restore-volume

Al termine dell'esecuzione di Job, i dati del bucket di archiviazione oggetti vengono inseriti nel volume. Un pod separato può utilizzare i dati utilizzando gli stessi meccanismi standard per il montaggio di un volume.