Documentazione di Oracle Cloud Infrastructure

Concessione dell'accesso dei carichi di lavoro alle risorse OCI

Scopri come utilizzare l'identità di un carico di lavoro in esecuzione su un cluster Kubernetes per concedere al carico di lavoro un accesso con filtro ad altre risorse OCI utilizzando Kubernetes Engine (OKE).

Nota

È possibile utilizzare le identità dei carichi di lavoro solo per concedere l'accesso alle risorse OCI quando si utilizzano cluster avanzati. Vedere Cluster avanzati.

In Kubernetes, un carico di lavoro è un'applicazione in esecuzione su un cluster Kubernetes. Un carico di lavoro può essere un componente dell'applicazione in esecuzione all'interno di un singolo pod o più componenti dell'applicazione in esecuzione all'interno di un set di pod che funzionano insieme. Tutti i pod nel carico di lavoro vengono eseguiti nello stesso spazio di nomi.

Per concedere a tutti i pod di un carico di lavoro l'accesso alle risorse Kubernetes, è possibile specificare che ogni pod del carico di lavoro deve utilizzare lo stesso account di servizio Kubernetes. È quindi possibile concedere le autorizzazioni del ruolo cluster Kubernetes all'account di servizio. È l'account di servizio che associa i pod nel carico di lavoro alle autorizzazioni dei ruoli cluster e concede ai pod l'accesso alle risorse Kubernetes.

In Oracle Cloud Infrastructure, un carico di lavoro in esecuzione su un cluster Kubernetes è considerato una risorsa a pieno titolo. Una risorsa di carico di lavoro è identificata dalla combinazione univoca di cluster, spazio di nomi e account di servizio. Questa combinazione univoca viene definita identità del carico di lavoro. Puoi utilizzare l'identità del carico di lavoro quando definisci i criteri IAM per concedere l'accesso con filtro ad altre risorse OCI, ad esempio i bucket di storage degli oggetti. Inoltre, puoi utilizzare Oracle Cloud Infrastructure Audit per soddisfare i requisiti di compliance monitorando le richieste effettuate dall'identità del carico di lavoro, consentendoti di monitorare e segnalare accessi non autorizzati e attività sospette.

Per concedere a tutti i pod in un carico di lavoro l'accesso alle risorse OCI:

  • Creare uno spazio di nomi per un account di servizio.
  • Creare un account di servizio per l'applicazione da utilizzare.
  • Definire un criterio IAM per concedere l'accesso alle risorse del carico di lavoro ad altre risorse OCI.
  • Scaricare e configurare l'SDK OCI appropriato per la lingua in cui viene scritta l'applicazione.
  • Modificare l'applicazione per specificare:
    • che le richieste di carico di lavoro devono essere autenticate utilizzando il provider di identità del carico di lavoro del motore Kubernetes
    • le risorse OCI a cui accedere
  • Aggiornare la specifica di distribuzione dell'applicazione per specificare che ogni pod nel carico di lavoro deve utilizzare l'account di servizio.

Tenere presente quanto riportato di seguito quando si utilizzano le identità dei carichi di lavoro.

  • Al momento non è possibile utilizzare le identità del carico di lavoro con gruppi dinamici.
  • Puoi utilizzare le identità dei carichi di lavoro solo con un SDK OCI, non con la console o l'API.
  • I seguenti SDK OCI attualmente supportano le identità dei carichi di lavoro:
    • Vai a SDK v65.32.0 (e versioni successive)
    • SDK Java v2.54.0 (e versioni successive)
    • SDK Python v2.111.0 (e versioni successive)
    • SDK .NET v87.3.0 (e versioni successive)
    • SDK Ruby v2.19.0 (e versioni successive)

  • Per garantire un riutilizzo efficiente dei token e ridurre la generazione di token non necessari, creare una sola istanza del provider di identità del carico di lavoro di Kubernetes Engine e riutilizzare questa istanza in tutte le parti dell'applicazione che richiedono l'autenticazione. Ogni istanza gestisce il proprio token inserito nella cache, pertanto la creazione di più istanze comporterà il recupero e la gestione di più token in modo indipendente, con conseguente recupero di token duplicati, caricamento non necessario sul servizio di autenticazione, uso inefficiente delle risorse e tempi di risposta del sistema degradati.

Esempio: uso di Go SDK per concedere l'accesso dei carichi di lavoro dell'applicazione alle risorse OCI

Per concedere ai carichi di lavoro dell'applicazione Go in esecuzione su un cluster Kubernetes l'accesso ad altre risorse OCI:

  1. Se non è già stato fatto, attenersi alla procedura per impostare il file di configurazione kubeconfig del cluster e (se necessario) impostare la variabile di ambiente KUBECONFIG in modo che punti al file. Si noti che è necessario impostare il proprio file kubeconfig. Non è possibile accedere a un cluster utilizzando un file kubeconfig impostato da un altro utente. Vedere Impostazione dell'accesso al cluster.
  2. Ottenere l'OCID del cluster (ad esempio, utilizzando la scheda Dettagli cluster nella console).

  3. Creare uno spazio di nomi per l'account di servizio Kubernetes da utilizzare immettendo:

    kubectl create namespace <namespace-name>

    Ad esempio:

    kubectl create namespace finance
  4. Creare un account di servizio Kubernetes per l'applicazione da utilizzare immettendo:
    kubectl create serviceaccount <service-account-name> --namespace <namespace-name>

    Ad esempio:

    kubectl create serviceaccount financeserviceaccount --namespace finance
  5. Definire un criterio IAM per consentire al carico di lavoro di accedere alle risorse OCI necessarie:
    1. Aprire il menu di navigazione e selezionare Identità e sicurezza. In Identità, selezionare Criteri.
    2. Seguire le istruzioni in Per creare un criterio e assegnare un nome al criterio, ad esempio acme-oke-finance-workload-policy.

    3. Immettere un'istruzione criterio per consentire al carico di lavoro di accedere alle risorse OCI necessarie, nel formato seguente:

      Allow any-user to <verb> <resource> in <location> where all {
request.principal.type = 'workload',
request.principal.namespace = '<namespace-name>',
request.principal.service_account = '<service-account-name>',
request.principal.cluster_id = '<cluster-ocid>'}

      Dove:

      • <namespace-name> è il nome dello spazio di nomi creato in precedenza.
      • <service-account-name> è il nome dell'account di servizio creato in precedenza.
      • <cluster-ocid> è l'OCID del cluster ottenuto in precedenza.

      Ad esempio:

      Allow any-user to manage objects in tenancy where all {
request.principal.type = 'workload',
request.principal.namespace = 'finance',
request.principal.service_account = 'financeserviceaccount',
request.principal.cluster_id = 'ocid1.cluster.oc1.iad.aaaaaaaaaf______jrd'}
    4. Fare clic su Crea per creare il nuovo criterio.
  6. Installare l'SDK OCI for Go (vedere SDK for Go).

  7. Nel codice dell'applicazione Go, aggiungere:

    • provider di identità del carico di lavoro del motore Kubernetes (OkeWorkloadIdentityConfigurationProvider)
    • la risorsa OCI a cui accedere

    Ad esempio, lo snippet di codice seguente utilizza l'identità del carico di lavoro per l'autenticazione, crea un bucket nel servizio di storage degli oggetti nell'area Pheonix (PHX) e carica un file nel bucket:

    // ExampleObjectStorage_UploadFile shows how to create a bucket and upload a file using OKE Workload Identity
// Ensure only a single instance of the identity provider is used to optimize token reuse.
// Creating multiple instances may result in redundant token generation for the same workload.

 func ExampleObjectStorage_UploadFile() {
        rp, err := auth.OkeWorkloadIdentityConfigurationProvider()
        if err != nil
        { panic(err) }

        c, clerr := objectstorage.NewObjectStorageClientWithConfigurationProvider(rp)

        c.SetRegion("us-phoenix-1")

        helpers.FatalIfError(clerr)
 
        ctx := context.Background()
        bname := helpers.GetRandomString(8)
        namespace := getNamespace(ctx, c)
         
        createBucket(ctx, c, namespace, bname)
 
        contentlen := 1024 * 1000
        filepath, filesize := helpers.WriteTempFileOfSize(int64(contentlen))    
        filename := path.Base(filepath)
        defer func() {
                os.Remove(filename)
        }()
 
        file, e := os.Open(filepath)
        defer file.Close()
        helpers.FatalIfError(e)
          
        e = putObject(ctx, c, namespace, bname, filename, filesize, file, nil)
        helpers.FatalIfError(e)
 
 
        // Output:
        // get namespace
        // create bucket
        // put object
  8. Aprire la specifica di distribuzione dell'applicazione in un editor di testo e:
    1. Aggiungere serviceAccountName e impostarlo sul nome dell'account di servizio creato in precedenza. Ad esempio, serviceAccountName: financeserviceaccount.
    2. Aggiungere automountServiceAccountToken e impostarlo su true.

    Ad esempio:

    apiVersion: v1
kind: Pod
metadata:
  name: nginx
spec:
 serviceAccountName: financeserviceaccount
 automountServiceAccountToken: true
 containers:
  - name: nginx
    image: nginx:1.14.2
    ports:
     - containerPort: 80
  9. Per distribuire l'applicazione, immettere:
    kubectl create -f <filename>
    Ad esempio:
    kubectl create -f financeworkloadidentity.yaml

Esempio: uso dell'SDK Java per concedere l'accesso dei carichi di lavoro dell'applicazione alle risorse OCI

Per concedere ai carichi di lavoro dell'applicazione Java in esecuzione su un cluster Kubernetes l'accesso ad altre risorse OCI:

  1. Se non è già stato fatto, attenersi alla procedura per impostare il file di configurazione kubeconfig del cluster e (se necessario) impostare la variabile di ambiente KUBECONFIG in modo che punti al file. Si noti che è necessario impostare il proprio file kubeconfig. Non è possibile accedere a un cluster utilizzando un file kubeconfig impostato da un altro utente. Vedere Impostazione dell'accesso al cluster.
  2. Ottenere l'OCID del cluster (ad esempio, utilizzando la scheda Dettagli cluster nella console).

  3. Creare uno spazio di nomi per l'account di servizio Kubernetes da utilizzare immettendo:

    kubectl create namespace <namespace-name>

    Ad esempio:

    kubectl create namespace finance
  4. Creare un account di servizio Kubernetes per l'applicazione da utilizzare immettendo:
    kubectl create serviceaccount <service-account-name> --namespace <namespace-name>

    Ad esempio:

    kubectl create serviceaccount financeserviceaccount --namespace finance
  5. Definire un criterio IAM per consentire al carico di lavoro di accedere alle risorse OCI necessarie:
    1. Aprire il menu di navigazione e selezionare Identità e sicurezza. In Identità, selezionare Criteri.
    2. Seguire le istruzioni in Per creare un criterio e assegnare un nome al criterio, ad esempio acme-oke-finance-workload-policy.

    3. Immettere un'istruzione criterio per consentire al carico di lavoro di accedere alle risorse OCI necessarie, nel formato seguente:

      Allow any-user to <verb> <resource> in <location> where all {
request.principal.type = 'workload',
request.principal.namespace = '<namespace-name>',
request.principal.service_account = '<service-account-name>',
request.principal.cluster_id = '<cluster-ocid>'}

      Dove:

      • <namespace-name> è il nome dello spazio di nomi creato in precedenza.
      • <service-account-name> è il nome dell'account di servizio creato in precedenza.
      • <cluster-ocid> è l'OCID del cluster ottenuto in precedenza.

      Ad esempio:

      Allow any-user to manage objects in tenancy where all {
request.principal.type = 'workload',
request.principal.namespace = 'finance',
request.principal.service_account = 'financeserviceaccount',
request.principal.cluster_id = 'ocid1.cluster.oc1.iad.aaaaaaaaaf______jrd'}
    4. Fare clic su Crea per creare il nuovo criterio.
  6. Installare l'SDK OCI per Java (vedere SDK per Java).
  7. Nel file pom.xml dell'applicazione, aggiungere l'artifact oci-java-sdk-addons-oke-workload-identity come dipendenza:
    <dependency>
<groupId>com.oracle.oci.sdk</groupId>
<artifactId>oci-java-sdk-addons-oke-workload-identity</artifactId>
<version>2.54.0</version>
</dependency>

<dependency>
<groupId>com.oracle.oci.sdk</groupId>
<artifactId>oci-java-sdk-common</artifactId>
<version>2.54.0</version>
</dependency>
    La versione dell'SDK deve essere 2.54.0 o successiva.
  8. Nel codice dell'applicazione Java aggiungere:
    • provider di identità del carico di lavoro del motore Kubernetes (OkeWorkloadIdentityAuthenticationDetailsProvider)
    • la risorsa OCI a cui accedere

    Ad esempio, lo snippet di codice seguente utilizza l'identità del carico di lavoro per l'autenticazione, crea un bucket nel servizio di storage degli oggetti nell'area Pheonix (PHX) e carica un file nel bucket:

    import com.oracle.bmc.Region;
import com.oracle.bmc.auth.AuthenticationDetailsProvider;
import com.oracle.bmc.auth.ConfigFileAuthenticationDetailsProvider;
import com.oracle.bmc.auth.okeworkloadidentity.OkeWorkloadIdentityAuthenticationDetailsProvider;
import com.oracle.bmc.objectstorage.ObjectStorage;
import com.oracle.bmc.objectstorage.ObjectStorageClient;
import com.oracle.bmc.objectstorage.model.BucketSummary;
import com.oracle.bmc.objectstorage.requests.GetNamespaceRequest;
import com.oracle.bmc.objectstorage.requests.GetObjectRequest;
import com.oracle.bmc.objectstorage.requests.ListBucketsRequest;
import com.oracle.bmc.objectstorage.requests.ListBucketsRequest.Builder;
import com.oracle.bmc.objectstorage.responses.GetNamespaceResponse;
import com.oracle.bmc.objectstorage.responses.GetObjectResponse;
import com.oracle.bmc.objectstorage.responses.ListBucketsResponse;

import java.io.InputStream;

public class ObjectStorageSyncExample {

    public static void main(String[] args) throws Exception {
        /* Config the Container Engine for Kubernetes workload identity provider */
        /*Ensure only a single instance of the identity provider is used to optimize token reuse. Creating multiple instances may lead to redundant token generation for the same workload.*/
        final OkeWorkloadIdentityAuthenticationDetailsProvider provider = new OkeWorkloadIdentityAuthenticationDetailsProvider
                .OkeWorkloadIdentityAuthenticationDetailsProviderBuilder()
                .build();

        /* Configure the client to use workload identity provider*/
        ObjectStorage client =
                ObjectStorageClient.builder().region(Region.US_PHOENIX_1).build(provider);

        GetNamespaceResponse namespaceResponse =
                client.getNamespace(GetNamespaceRequest.builder().build());
        String namespaceName = namespaceResponse.getValue();
        System.out.println("Using namespace: " + namespaceName);

        Builder listBucketsBuilder =
                ListBucketsRequest.builder()
                        .namespaceName(namespaceName)
                        .compartmentId("enter tenancy id");

        String nextToken = null;
        do {
            listBucketsBuilder.page(nextToken);
            ListBucketsResponse listBucketsResponse =
                    client.listBuckets(listBucketsBuilder.build());
            for (BucketSummary bucket : listBucketsResponse.getItems()) {
                System.out.println("Found bucket: " + bucket.getName());
            }
            nextToken = listBucketsResponse.getOpcNextPage();
        } while (nextToken != null);

        // fetch the file from the object storage
        String bucketName = null;
        String objectName = null;
        GetObjectResponse getResponse =
                client.getObject(
                        GetObjectRequest.builder()
                                .namespaceName(namespaceName)
                                .bucketName(bucketName)
                                .objectName(objectName)
                                .build());

        // stream contents should match the file uploaded
        try (final InputStream fileStream = getResponse.getInputStream()) {
            // use fileStream
        } // try-with-resources automatically closes fileStream

        client.close();
    }
}
  9. Aprire la specifica di distribuzione dell'applicazione in un editor di testo e:
    1. Aggiungere serviceAccountName e impostarlo sul nome dell'account di servizio creato in precedenza. Ad esempio, serviceAccountName: financeserviceaccount.
    2. Aggiungere automountServiceAccountToken e impostarlo su true.

    Ad esempio:

    apiVersion: v1
kind: Pod
metadata:
  name: nginx
spec:
 serviceAccountName: financeserviceaccount
 automountServiceAccountToken: true
 containers:
  - name: nginx
    image: nginx:1.14.2
    ports:
     - containerPort: 80
  10. Per distribuire l'applicazione, immettere:
    kubectl create -f <filename>
    Ad esempio:
    kubectl create -f financeworkloadidentity.yaml

Esempio: uso dell'SDK Java per concedere ai carichi di lavoro dell'applicazione l'accesso alle risorse OCI in un altro compartimento

Per concedere ai carichi di lavoro dell'applicazione Java in esecuzione su un cluster Kubernetes in un compartimento l'accesso ad altre risorse OCI in un altro compartimento:

  1. Se non è già stato fatto, attenersi alla procedura per impostare il file di configurazione kubeconfig del cluster e (se necessario) impostare la variabile di ambiente KUBECONFIG in modo che punti al file. Si noti che è necessario impostare il proprio file kubeconfig. Non è possibile accedere a un cluster utilizzando un file kubeconfig impostato da un altro utente. Vedere Impostazione dell'accesso al cluster.
  2. Ottenere l'OCID del cluster (ad esempio, utilizzando la scheda Dettagli cluster nella console).
  3. Come amministratore del cluster, creare uno spazio di nomi per l'account di servizio Kubernetes da utilizzare immettendo:
    kubectl create namespace <namespace-name>

    Ad esempio:

    kubectl create namespace finance

  4. Come amministratore del cluster, creare un account di servizio Kubernetes per l'applicazione da utilizzare immettendo:

    kubectl create serviceaccount <service-account-name> --namespace <namespace-name>

    Ad esempio:

    kubectl create serviceaccount financeserviceaccount --namespace finance

  5. L'amministratore della tenancy definisce un criterio IAM per consentire a un amministratore del cluster di associare i carichi di lavoro in esecuzione su un cluster in un compartimento ad altre risorse OCI in un altro compartimento:

    1. Aprire il menu di navigazione e selezionare Identità e sicurezza. In Identità, selezionare Criteri.
    2. Seguire le istruzioni in Per creare un criterio e assegnare un nome al criterio, ad esempio acme-oke-finance-workload-policy.

    3. Immettere le istruzioni dei criteri per consentire a un amministratore del cluster di associare i carichi di lavoro in esecuzione su un cluster in un compartimento ad altre risorse OCI in un compartimento diverso, nel formato seguente:

      Allow group cluster-admins to manage cluster-workload-mappings in compartment <compartment-one>
Allow group cluster-admins to {CLUSTER_WORKLOAD_COMPARTMENT_BIND,CLUSTER_WORKLOAD_COMPARTMENT_UNBIND} in compartment <compartment-two>

      Dove:

      • <compartment-one> è il compartimento a cui appartiene il cluster
      • <compartment-two> è il compartimento a cui appartengono le altre risorse OCI

      Ad esempio:

      Allow group cluster-admins to manage cluster-workload-mappings in compartment finance
Allow group cluster-admins to {CLUSTER_WORKLOAD_COMPARTMENT_BIND,CLUSTER_WORKLOAD_COMPARTMENT_UNBIND} in compartment sales
      Si noti che se un gruppo non si trova nel dominio di identità predefinito, inserire il nome del gruppo prima del nome del dominio di identità nel formato group '<identity-domain-name>'/'group-name'. È anche possibile specificare un gruppo utilizzando il relativo OCID, nel formato group id <group-ocid>.
    4. Fare clic su Crea per creare il nuovo criterio.

  6. L'amministratore del cluster, nel compartimento a cui appartiene il cluster, crea un mapping del carico di lavoro che mappa i carichi di lavoro in esecuzione sul cluster al compartimento a cui appartengono le altre risorse OCI:

    oci ce workload-mapping create --namespace <namespace-name> --mapped-compartment-id <compartment-two-ocid> --cluster-id <cluster-ocid>

    Ad esempio:

    oci ce workload-mapping create --namespace finance --mapped-compartment-id ocid1.compartment.oc1..aaaaaaaaad______fda --cluster-id ocid1.cluster.oc1.iad.aaaaaaaaaf______jrd

  7. L'amministratore della risorsa nel secondo compartimento, definisce un criterio IAM per consentire al carico di lavoro di accedere alle risorse OCI nel compartimento:

    1. Aprire il menu di navigazione e selezionare Identità e sicurezza. In Identità, selezionare Criteri.
    2. Seguire le istruzioni in Per creare un criterio e assegnare un nome al criterio, ad esempio acme-oke-finance-workload-policy.

    3. Immettere un'istruzione criterio per consentire al carico di lavoro di accedere alle risorse OCI necessarie, nel formato seguente:

      Allow any-user to <verb> <resource> in <location> where all {
request.principal.type = 'workload',
request.principal.namespace = '<namespace-name>',
request.principal.service_account = '<service-account-name>',
request.principal.cluster_id = '<cluster-ocid>'}

      Dove:

      • <namespace-name> è il nome dello spazio di nomi creato in precedenza.
      • <service-account-name> è il nome dell'account di servizio creato in precedenza.
      • <cluster-ocid> è l'OCID del cluster ottenuto in precedenza.

      Ad esempio:

      Allow any-user to manage objects in compartment sales where all {
request.principal.type = 'workload',
request.principal.namespace = 'finance',
request.principal.service_account = 'financeserviceaccount',
request.principal.cluster_id = 'ocid1.cluster.oc1.iad.aaaaaaaaaf______jrd'}
    4. Fare clic su Crea per creare il nuovo criterio.
  8. Installare l'SDK OCI per Java (vedere SDK per Java). La versione dell'SDK deve essere 2.66.0 o successiva (o 3.18.0 o successiva).
  9. Nel file pom.xml dell'applicazione, aggiungere l'artifact oci-java-sdk-addons-oke-workload-identity come dipendenza:
    <dependency>
<groupId>com.oracle.oci.sdk</groupId>
<artifactId>oci-java-sdk-addons-oke-workload-identity</artifactId>
<version>2.66.0</version>
</dependency>

<dependency>
<groupId>com.oracle.oci.sdk</groupId>
<artifactId>oci-java-sdk-common</artifactId>
<version>2.66.0</version>
</dependency>
    La versione dell'SDK deve essere 2.66.0 o successiva (o 3.18.0 o successiva).
  10. Nel codice dell'applicazione Java aggiungere:
    • provider di identità del carico di lavoro del motore Kubernetes (OkeWorkloadIdentityAuthenticationDetailsProvider)
    • la risorsa OCI a cui accedere

    Ad esempio, lo snippet di codice seguente utilizza l'identità del carico di lavoro per l'autenticazione, crea un bucket nel servizio di storage degli oggetti nell'area Pheonix (PHX) e carica un file nel bucket:

    import com.oracle.bmc.Region;
import com.oracle.bmc.auth.AuthenticationDetailsProvider;
import com.oracle.bmc.auth.ConfigFileAuthenticationDetailsProvider;
import com.oracle.bmc.auth.okeworkloadidentity.OkeWorkloadIdentityAuthenticationDetailsProvider;
import com.oracle.bmc.objectstorage.ObjectStorage;
import com.oracle.bmc.objectstorage.ObjectStorageClient;
import com.oracle.bmc.objectstorage.model.BucketSummary;
import com.oracle.bmc.objectstorage.requests.GetNamespaceRequest;
import com.oracle.bmc.objectstorage.requests.GetObjectRequest;
import com.oracle.bmc.objectstorage.requests.ListBucketsRequest;
import com.oracle.bmc.objectstorage.requests.ListBucketsRequest.Builder;
import com.oracle.bmc.objectstorage.responses.GetNamespaceResponse;
import com.oracle.bmc.objectstorage.responses.GetObjectResponse;
import com.oracle.bmc.objectstorage.responses.ListBucketsResponse;

import java.io.InputStream;

public class ObjectStorageSyncExample {

    public static void main(String[] args) throws Exception {
        /* Config the Container Engine for Kubernetes workload identity provider */
        /*Ensure only a single instance of the identity provider is used to optimize token reuse. Creating multiple instances may lead to redundant token generation for the same workload.*/
        final OkeWorkloadIdentityAuthenticationDetailsProvider provider = new OkeWorkloadIdentityAuthenticationDetailsProvider
                .OkeWorkloadIdentityAuthenticationDetailsProviderBuilder()
                .build();

        /* Configure the client to use workload identity provider*/
        ObjectStorage client =
                ObjectStorageClient.builder().region(Region.US_PHOENIX_1).build(provider);

        GetNamespaceResponse namespaceResponse =
                client.getNamespace(GetNamespaceRequest.builder().build());
        String namespaceName = namespaceResponse.getValue();
        System.out.println("Using namespace: " + namespaceName);

        Builder listBucketsBuilder =
                ListBucketsRequest.builder()
                        .namespaceName(namespaceName)
                        .compartmentId("enter tenancy id");

        String nextToken = null;
        do {
            listBucketsBuilder.page(nextToken);
            ListBucketsResponse listBucketsResponse =
                    client.listBuckets(listBucketsBuilder.build());
            for (BucketSummary bucket : listBucketsResponse.getItems()) {
                System.out.println("Found bucket: " + bucket.getName());
            }
            nextToken = listBucketsResponse.getOpcNextPage();
        } while (nextToken != null);

        // fetch the file from the object storage
        String bucketName = null;
        String objectName = null;
        GetObjectResponse getResponse =
                client.getObject(
                        GetObjectRequest.builder()
                                .namespaceName(namespaceName)
                                .bucketName(bucketName)
                                .objectName(objectName)
                                .build());

        // stream contents should match the file uploaded
        try (final InputStream fileStream = getResponse.getInputStream()) {
            // use fileStream
        } // try-with-resources automatically closes fileStream

        client.close();
    }
}
  11. Aprire la specifica di distribuzione dell'applicazione in un editor di testo e:
    1. Aggiungere namespace e impostarlo sul nome dello spazio di nomi creato in precedenza. Ad esempio, namespace: finance.
    2. Aggiungere serviceAccountName e impostarlo sul nome dell'account di servizio creato in precedenza. Ad esempio, serviceAccountName: financeserviceaccount.
    3. Aggiungere automountServiceAccountToken e impostarlo su true.

    Ad esempio:

    apiVersion: v1
kind: Pod
metadata:
  name: nginx
  namespace: finance
spec:
  serviceAccountName: financeserviceaccount
  automountServiceAccountToken: true
  containers:
    - name: nginx
      image: nginx:1.14.2
      ports:
        - containerPort: 80
  12. Per distribuire l'applicazione, immettere:
    kubectl create -f <filename>
    Ad esempio:
    kubectl create -f financeworkloadidentity.yaml