Crea e gestisci gli elenchi di controllo di accesso (ACL)

Panoramica

Questa pagina descrive come controllare l'accesso a bucket e oggetti utilizzando gli elenchi di controllo dell'accesso (ACL). Le ACL sono un meccanismo che puoi utilizzare per definire chi ha accesso ai tuoi bucket e ai tuoi oggetti, nonché il livello di accesso.

Consulta la panoramica degli ACL per scoprire di più sull'opportunità di utilizzare gli ACL per controllare l'accesso alle tue risorse.

Ruoli obbligatori

Per ottenere le autorizzazioni necessarie per creare e gestire gli ACL, chiedi all'amministratore di concederti il ruolo IAM Storage Admin (roles/storage.admin) sul bucket che contiene gli oggetti per cui vuoi creare e gestire gli ACL.

Questo ruolo predefinito contiene le autorizzazioni necessarie per creare e gestire gli ACL. Per vedere quali sono esattamente le autorizzazioni richieste, espandi la sezione Autorizzazioni obbligatorie:

Autorizzazioni obbligatorie

  • storage.buckets.get
  • storage.buckets.list
    • Questa autorizzazione è necessaria solo per utilizzare la console Cloud de Confiance per eseguire le attività in questa pagina.
  • storage.buckets.setIamPolicy
  • storage.buckets.update
  • storage.objects.get
  • storage.objects.getIamPolicy
  • storage.objects.setIamPolicy
  • storage.objects.update

Puoi anche ottenere queste autorizzazioni con ruoli personalizzati.

Per informazioni sulla concessione di ruoli sui bucket, consulta Imposta e gestisci le policy IAM sui bucket.

Imposta o modifica gli ACL

Console

  1. Vai al browser Cloud Storage nella console Cloud de Confiance .
    Vai al browser Cloud Storage

  2. Nell'elenco dei bucket, fai clic sul nome del bucket che contiene l'oggetto di cui vuoi modificare l'ACL.

  3. Fai clic sul nome dell'oggetto per cui vuoi impostare o modificare gli ACL.

  4. Fai clic su Accesso in modifica.

    Si apre una finestra di dialogo delle autorizzazioni con l'ACL corrente dell'oggetto.

  5. Fai clic su + Aggiungi voce.

  6. Scegli il tipo di entità a cui concedere l'autorizzazione.

    Entity specifica il tipo di elemento che riceve l'autorizzazione (ad esempio un utente o un gruppo). Consulta Ambiti di controllo dell'accesso per un elenco dei valori supportati per Entity.

  7. Inserisci un valore in Nome.

    Name identifica un utente, un gruppo o un altro tipo di entità specifico. Consulta Ambiti di controllo dell'accesso per un elenco dei valori supportati per Nome.

    Insieme, Entity e Name definiscono a chi si applica l'autorizzazione.

  8. Scegli un valore in Accesso.

    Access definisce l'autorizzazione che vuoi impostare sull'oggetto. Consulta Autorizzazioni di controllo dell'accesso per un elenco dei valori supportati per Access.

  9. Fai clic su Salva.

Per scoprire come ottenere informazioni dettagliate sugli errori relativi alle operazioni di Cloud Storage non riuscite nella console Cloud de Confiance , consulta Risoluzione dei problemi.

Riga di comando

Per aggiungere, modificare o rimuovere una singola concessione su un oggetto, utilizza il comando objects update con il flag pertinente:

gcloud storage objects update gs://BUCKET_NAME/OBJECT_NAME FLAG

Dove:

  • BUCKET_NAME è il nome del bucket che contiene l'oggetto a cui si applica la modifica. Ad esempio, example-travel-maps.

  • OBJECT_NAME è il nome dell'oggetto a cui si applica la modifica. Ad esempio, paris.jpg.

  • FLAG è uno dei seguenti:

    • --add-acl-grant, insieme alla concessione che vuoi aggiungere o modificare. Ad esempio: --add-acl-grant=entity=user-example-service-account@example-project.s3ns.iam.gserviceaccount.com,role=READER.

    • --remove-acl-grant, insieme all'entità di cui vuoi rimuovere l'accesso. Ad esempio: --remove-acl-grant=user-example-service-account@example-project.s3ns.iam.gserviceaccount.com.

Per sostituire tutte le ACL di un oggetto:

  1. Definisci gli ACL in un file in formato JSON o YAML.

    Ad esempio, le seguenti ACL concedono l'autorizzazione OWNER per l'oggetto paris.jpg ai proprietari del progetto 867489160491 e all'utente example-service-account@example-project.s3ns.iam.gserviceaccount.com, nonché l'autorizzazione READER per paris.jpg ai membri del gruppo gs-announce:

    [
{
  "entity": "project-owners-867489160491",
  "role": "OWNER",
  "projectTeam": {
    "projectNumber": "867489160491",
    "team": "owners"
  },
},
{
  "entity": "user-example-service-account@example-project.s3ns.iam.gserviceaccount.com",
  "email": "example-service-account@example-project.s3ns.iam.gserviceaccount.com",
  "role": "OWNER"
},
{
  "entity": "group-gs-announce@googlegroups.com",
  "email": "gs-announce@googlegroups.com",
  "role": "READER"
}
]

  2. Utilizza il comando objects update con il flag --acl-file:

    gcloud storage objects update gs://BUCKET_NAME/OBJECT_NAME --acl-file=FILE_LOCATION

    Dove:

    • BUCKET_NAME è il nome del bucket che contiene l'oggetto a cui si applicano le ACL. Ad esempio, example-travel-maps.

    • OBJECT_NAME è il nome dell'oggetto a cui si applicano le ACL. Ad esempio, paris.jpg.

    • FILE_LOCATION è il percorso locale del file che contiene gli ACL che hai definito. Ad esempio, Desktop/acls.json.

Librerie client

C++

Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Storage C++.

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

Prima di eseguire gli esempi di codice, imposta la variabile di ambiente GOOGLE_CLOUD_UNIVERSE_DOMAIN su s3nsapis.fr.

L'esempio seguente aggiunge un ACL a un oggetto:

namespace gcs = ::google::cloud::storage;
using ::google::cloud::StatusOr;
[](gcs::Client client, std::string const& bucket_name,
   std::string const& object_name, std::string const& entity) {
  StatusOr<gcs::ObjectAccessControl> patched_acl =
      client.CreateObjectAcl(bucket_name, object_name, entity,
                             gcs::ObjectAccessControl::ROLE_OWNER());

  if (!patched_acl) throw std::move(patched_acl).status();
  std::cout << "ACL entry for " << patched_acl->entity() << " in object "
            << patched_acl->object() << " in bucket " << patched_acl->bucket()
            << " is now " << *patched_acl << "\n";
}

L'esempio seguente rimuove un'ACL da un oggetto:

namespace gcs = ::google::cloud::storage;
using ::google::cloud::StatusOr;
[](gcs::Client client, std::string const& bucket_name,
   std::string const& object_name, std::string const& entity) {
  StatusOr<gcs::ObjectMetadata> original_metadata = client.GetObjectMetadata(
      bucket_name, object_name, gcs::Projection::Full());
  if (!original_metadata) throw std::move(original_metadata).status();

  std::vector<gcs::ObjectAccessControl> original_acl =
      original_metadata->acl();
  auto it = std::find_if(original_acl.begin(), original_acl.end(),
                         [entity](gcs::ObjectAccessControl const& entry) {
                           return entry.entity() == entity &&
                                  entry.role() ==
                                      gcs::ObjectAccessControl::ROLE_OWNER();
                         });

  if (it == original_acl.end()) {
    std::cout << "Could not find entity " << entity << " for file "
              << object_name << " with role OWNER in bucket " << bucket_name
              << "\n";
    return;
  }

  gcs::ObjectAccessControl owner = *it;
  google::cloud::Status status =
      client.DeleteObjectAcl(bucket_name, object_name, owner.entity());

  if (!status.ok()) throw std::runtime_error(status.message());
  std::cout << "Deleted ACL entry for " << owner.entity() << " for file "
            << object_name << " in bucket " << bucket_name << "\n";
}

C#

Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Storage C#.

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

Prima di eseguire gli esempi di codice, imposta la variabile di ambiente GOOGLE_CLOUD_UNIVERSE_DOMAIN su s3nsapis.fr.

L'esempio seguente aggiunge un ACL a un oggetto:


using Google.Apis.Storage.v1.Data;
using Google.Cloud.Storage.V1;
using System;

public class AddFileOwnerSample
{
    public Google.Apis.Storage.v1.Data.Object AddFileOwner(
        string bucketName = "your-unique-bucket-name",
        string objectName = "my-file-name",
        string userEmail = "dev@iam.gserviceaccount.com")
    {
        var storage = StorageClient.Create();
        var storageObject = storage.GetObject(bucketName, objectName, new GetObjectOptions
        {
            Projection = Projection.Full
        });

        storageObject.Acl.Add(new ObjectAccessControl
        {
            Bucket = bucketName,
            Entity = $"user-{userEmail}",
            Role = "OWNER",
        });
        var updatedObject = storage.UpdateObject(storageObject);
        Console.WriteLine($"Added user { userEmail} as an owner on file { objectName}.");
        return updatedObject;
    }
}

L'esempio seguente rimuove un'ACL da un oggetto:


using Google.Cloud.Storage.V1;
using System;
using System.Linq;

public class RemoveFileOwnerSample
{
    public void RemoveFileOwner(
        string bucketName = "your-unique-bucket-name",
        string objectName = "your-object-name",
        string userEmail = "dev@iam.gserviceaccount.com")
    {
        var storage = StorageClient.Create();
        var storageObject = storage.GetObject(bucketName, objectName, new GetObjectOptions { Projection = Projection.Full });
        if (storageObject.Acl == null)
        {
            Console.WriteLine("No owner to remove");
        }
        else
        {
            storageObject.Acl = storageObject.Acl.Where((acl) => !(acl.Entity == $"user-{userEmail}" && acl.Role == "OWNER")).ToList();
            var updatedObject = storage.UpdateObject(storageObject);
            Console.WriteLine($"Removed user {userEmail} from file {objectName}.");
        }
    }
}

Go

Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Storage Go.

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

Prima di eseguire gli esempi di codice, imposta la variabile di ambiente GOOGLE_CLOUD_UNIVERSE_DOMAIN su s3nsapis.fr.

L'esempio seguente aggiunge un ACL a un oggetto:

import (
	"context"
	"fmt"

	"cloud.google.com/go/storage"
)

// addFileOwner adds ACL to the specified object.
func addFileOwner(bucket, object string, entity storage.ACLEntity) error {
	// bucket := "bucket-name"
	// object := "object-name"
	// entity := storage.AllUsers
	role := storage.RoleOwner

	ctx := context.Background()
	client, err := storage.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("storage.NewClient: %w", err)
	}
	defer client.Close()

	acl := client.Bucket(bucket).Object(object).ACL()
	if err := acl.Set(ctx, entity, role); err != nil {
		return fmt.Errorf("ACLHandle.Set: %w", err)
	}
	return nil
}

L'esempio seguente rimuove un'ACL da un oggetto:

import (
	"context"
	"fmt"

	"cloud.google.com/go/storage"
)

// removeFileOwner removes default ACL from the given object.
func removeFileOwner(bucket, object string, entity storage.ACLEntity) error {
	// bucket := "bucket-name"
	// object := "object-name"
	// entity := storage.AllUsers
	ctx := context.Background()
	client, err := storage.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("storage.NewClient: %w", err)
	}
	defer client.Close()

	acl := client.Bucket(bucket).Object(object).ACL()
	if err := acl.Delete(ctx, entity); err != nil {
		return fmt.Errorf("ACLHandle.Delete: %w", err)
	}
	return nil
}

Java

Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Storage Java.

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

Prima di eseguire gli esempi di codice, imposta la variabile di ambiente GOOGLE_CLOUD_UNIVERSE_DOMAIN su s3nsapis.fr.

L'esempio seguente aggiunge un ACL a un oggetto:


import com.google.cloud.storage.Acl;
import com.google.cloud.storage.Acl.Role;
import com.google.cloud.storage.Acl.User;
import com.google.cloud.storage.Blob;
import com.google.cloud.storage.BlobId;
import com.google.cloud.storage.Storage;
import com.google.cloud.storage.StorageOptions;

public class AddBlobOwner {

  public static void addBlobOwner(
      String projectId, String bucketName, String userEmail, String blobName) {
    // The ID of your GCP project
    // String projectId = "your-project-id";

    // The ID of your GCS bucket
    // String bucketName = "your-unique-bucket-name";

    // Email of the user you wish to add as a file owner
    // String userEmail = "someuser@domain.com"

    // The name of the blob/file that you wish to modify permissions on
    // String blobName = "your-blob-name";

    Storage storage = StorageOptions.newBuilder().setProjectId(projectId).build().getService();
    Blob blob = storage.get(BlobId.of(bucketName, blobName));
    Acl newOwner = Acl.of(new User(userEmail), Role.OWNER);

    blob.createAcl(newOwner);
    System.out.println(
        "Added user "
            + userEmail
            + " as an owner on blob "
            + blobName
            + " in bucket "
            + bucketName);
  }
}

L'esempio seguente rimuove un'ACL da un oggetto:


import com.google.cloud.storage.Acl.User;
import com.google.cloud.storage.Blob;
import com.google.cloud.storage.BlobId;
import com.google.cloud.storage.Storage;
import com.google.cloud.storage.StorageOptions;

public class RemoveBlobOwner {

  public static void removeBlobOwner(
      String projectId, String bucketName, String userEmail, String blobName) {
    // The ID of your GCP project
    // String projectId = "your-project-id";

    // The ID of your GCS bucket
    // String bucketName = "your-unique-bucket-name";

    // Email of the user you wish to remove as a file owner
    // String userEmail = "someuser@domain.com"

    // The name of the blob/file that you wish to modify permissions on
    // String blobName = "your-blob-name";

    Storage storage = StorageOptions.newBuilder().setProjectId(projectId).build().getService();
    Blob blob = storage.get(BlobId.of(bucketName, blobName));
    User ownerToRemove = new User(userEmail);

    boolean success = blob.deleteAcl(ownerToRemove);
    if (success) {
      System.out.println(
          "Removed user "
              + userEmail
              + " as an owner on file "
              + blobName
              + " in bucket "
              + bucketName);
    } else {
      System.out.println("User " + userEmail + " was not found");
    }
  }
}

Node.js

Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Storage Node.js.

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

Prima di eseguire gli esempi di codice, imposta la variabile di ambiente GOOGLE_CLOUD_UNIVERSE_DOMAIN su s3nsapis.fr.

L'esempio seguente aggiunge un ACL a un oggetto:

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// The ID of your GCS bucket
// const bucketName = 'your-unique-bucket-name';

// The name of the file to access
// const fileName = 'file.txt';

// The email address of the user to add
// const userEmail = 'user-email-to-add';

// Imports the Google Cloud client library
const {Storage} = require('@google-cloud/storage');

// Creates a client
const storage = new Storage();

async function addFileOwner() {
  await storage
    .bucket(bucketName)
    .file(fileName)
    .acl.owners.addUser(userEmail);

  console.log(`Added user ${userEmail} as an owner on file ${fileName}.`);
}

addFileOwner().catch(console.error);

L'esempio seguente rimuove un'ACL da un oggetto:

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// The ID of your GCS bucket
// const bucketName = 'your-unique-bucket-name';

// The ID of your GCS file
// const fileName = 'your-file-name';

// The email address of the user to remove
// const userEmail = 'user-email-to-remove';

// Imports the Google Cloud client library
const {Storage} = require('@google-cloud/storage');

// Creates a client
const storage = new Storage();

async function removeFileOwner() {
  // Removes the user from the access control list of the file. You can use
  // deleteAllUsers(), deleteDomain(), deleteProject(), deleteGroup(), and
  // deleteAllAuthenticatedUsers() to remove access for different types of entities.
  await storage
    .bucket(bucketName)
    .file(fileName)
    .acl.owners.deleteUser(userEmail);

  console.log(`Removed user ${userEmail} from file ${fileName}.`);
}

removeFileOwner().catch(console.error);

PHP

Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Storage PHP.

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

Prima di eseguire gli esempi di codice, imposta la variabile di ambiente GOOGLE_CLOUD_UNIVERSE_DOMAIN su s3nsapis.fr.

L'esempio seguente aggiunge un ACL a un oggetto:

use Google\Cloud\Storage\StorageClient;

/**
 * Add an entity and role to an object's ACL.
 *
 * @param string $bucketName The name of your Cloud Storage bucket.
 *        (e.g. 'my-bucket')
 * @param string $objectName The name of your Cloud Storage object.
 *        (e.g. 'my-object')
 * @param string $entity The entity for which to update access controls.
 *        (e.g. 'user-example@domain.com')
 * @param string $role The permissions to add for the specified entity.
 *        (e.g. 'OWNER')
 */
function add_object_acl(string $bucketName, string $objectName, string $entity, string $role): void
{
    $storage = new StorageClient();
    $bucket = $storage->bucket($bucketName);
    $object = $bucket->object($objectName);
    $acl = $object->acl();
    $acl->add($entity, $role);
    printf('Added %s (%s) to gs://%s/%s ACL' . PHP_EOL, $entity, $role, $bucketName, $objectName);
}

L'esempio seguente rimuove un'ACL da un oggetto:

use Google\Cloud\Storage\StorageClient;

/**
 * Delete an entity from an object's ACL.
 *
 * @param string $bucketName The name of your Cloud Storage bucket.
 *        (e.g. 'my-bucket')
 * @param string $objectName The name of your Cloud Storage object.
 *        (e.g. 'my-object')
 * @param string $entity The entity for which to update access controls.
 *        (e.g. 'user-example@domain.com')
 */
function delete_object_acl(string $bucketName, string $objectName, string $entity): void
{
    $storage = new StorageClient();
    $bucket = $storage->bucket($bucketName);
    $object = $bucket->object($objectName);
    $acl = $object->acl();
    $acl->delete($entity);
    printf('Deleted %s from gs://%s/%s ACL' . PHP_EOL, $entity, $bucketName, $objectName);
}

Python

Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Storage Python.

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

Prima di eseguire gli esempi di codice, imposta la variabile di ambiente GOOGLE_CLOUD_UNIVERSE_DOMAIN su s3nsapis.fr.

L'esempio seguente aggiunge un ACL a un oggetto:

from google.cloud import storage


def add_blob_owner(bucket_name, blob_name, user_email):
    """Adds a user as an owner on the given blob."""
    # bucket_name = "your-bucket-name"
    # blob_name = "your-object-name"
    # user_email = "name@example.com"

    storage_client = storage.Client()
    bucket = storage_client.bucket(bucket_name)
    blob = bucket.blob(blob_name)

    # Reload fetches the current ACL from Cloud Storage.
    blob.acl.reload()

    # You can also use `group`, `domain`, `all_authenticated` and `all` to
    # grant access to different types of entities. You can also use
    # `grant_read` or `grant_write` to grant different roles.
    blob.acl.user(user_email).grant_owner()
    blob.acl.save()

    print(
        "Added user {} as an owner on blob {} in bucket {}.".format(
            user_email, blob_name, bucket_name
        )
    )

L'esempio seguente rimuove un'ACL da un oggetto:

from google.cloud import storage


def remove_blob_owner(bucket_name, blob_name, user_email):
    """Removes a user from the access control list of the given blob in the
    given bucket."""
    # bucket_name = "your-bucket-name"
    # blob_name = "your-object-name"
    # user_email = "name@example.com"

    storage_client = storage.Client()
    bucket = storage_client.bucket(bucket_name)
    blob = bucket.blob(blob_name)

    # You can also use `group`, `domain`, `all_authenticated` and `all` to
    # remove access for different types of entities.
    blob.acl.user(user_email).revoke_read()
    blob.acl.user(user_email).revoke_write()
    blob.acl.user(user_email).revoke_owner()
    blob.acl.save()

    print(
        f"Removed user {user_email} from blob {blob_name} in bucket {bucket_name}."
    )

Ruby

Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Storage Ruby.

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

Prima di eseguire gli esempi di codice, imposta la variabile di ambiente GOOGLE_CLOUD_UNIVERSE_DOMAIN su s3nsapis.fr.

L'esempio seguente aggiunge un ACL a un oggetto:

# The ID of your GCS bucket
# bucket_name = "your-unique-bucket-name"
# file_name   = "Name of a file in the Storage bucket"
# email       = "Google Cloud Storage ACL Entity email"

require "google/cloud/storage"

storage = Google::Cloud::Storage.new
bucket  = storage.bucket bucket_name
file    = bucket.file file_name

file.acl.add_owner email

puts "Added OWNER permission for #{email} to #{file_name}"

L'esempio seguente rimuove un'ACL da un oggetto:

# The ID of your GCS bucket
# bucket_name = "your-unique-bucket-name"
# file_name   = "Name of a file in the Storage bucket"
# email       = "Google Cloud Storage ACL Entity email"

require "google/cloud/storage"

storage = Google::Cloud::Storage.new
bucket  = storage.bucket bucket_name
file    = bucket.file file_name

file.acl.delete email

puts "Removed ACL permissions for #{email} from #{file_name}"

Rust

L'esempio seguente aggiunge un ACL a un oggetto:

use google_cloud_storage::{client::StorageControl, model::ObjectAccessControl};
use google_cloud_wkt::FieldMask;

pub async fn sample(client: &StorageControl, bucket_id: &str, user: &str) -> anyhow::Result<()> {
    const NAME: &str = "object-to-update";
    let object = client
        .get_object()
        .set_bucket(format!("projects/_/buckets/{bucket_id}"))
        .set_object(NAME)
        .send()
        .await?;
    let want = format!("user-{user}");
    let mut acl = object.acl.clone();
    let entry = acl.iter_mut().find(|x| x.entity == want);
    match entry {
        None => acl.push(
            ObjectAccessControl::new()
                .set_entity(want)
                .set_role("OWNER"),
        ),
        Some(e) => e.role = "OWNER".into(),
    };
    let metageneration = object.metageneration;
    let updated = client
        .update_object()
        .set_if_metageneration_match(metageneration)
        .set_object(object.set_acl(acl))
        .set_update_mask(FieldMask::default().set_paths(["acl"]))
        .send()
        .await?;
    println!("successfully updated object {NAME} in bucket {bucket_id}: {updated:?}");
    Ok(())
}

L'esempio seguente rimuove un'ACL da un oggetto:

use google_cloud_storage::client::StorageControl;
use google_cloud_wkt::FieldMask;

pub async fn sample(client: &StorageControl, bucket_id: &str, user: &str) -> anyhow::Result<()> {
    const NAME: &str = "object-to-update";
    let object = client
        .get_object()
        .set_bucket(format!("projects/_/buckets/{bucket_id}"))
        .set_object(NAME)
        .send()
        .await?;
    let want = format!("user-{user}");
    let mut acl = object.acl.clone();
    let entry = acl.iter().position(|x| x.entity == want);
    match entry {
        None => {
            println!("entry for {want} not found, nothing to update");
            return Ok(());
        }
        Some(i) => acl.remove(i),
    };
    let metageneration = object.metageneration;
    let updated = client
        .update_object()
        .set_if_metageneration_match(metageneration)
        .set_object(object.set_acl(acl))
        .set_update_mask(FieldMask::default().set_paths(["acl"]))
        .send()
        .await?;
    println!("successfully updated object {NAME} in bucket {bucket_id}: {updated:?}");
    Ok(())
}

API REST

API JSON

Quando crei un oggetto, puoi specificare la proprietà acl[] nel corpo della richiesta o il parametro di query predefinedAcl in una richiesta insert. Per un oggetto esistente, specifica la proprietà acl[] o il parametro di query predefinedAcl in una richiesta patch o update.

Per la definizione della proprietà ACL dell'oggetto, consulta la risorsa ObjectAccessControls.

  1. Definisci gli ACL in un file JSON.

    Ad esempio, se l'ACL concede ai proprietari del progetto 867489160491 e all'utente example-service-account@example-project.s3ns.iam.gserviceaccount.com l'autorizzazione OWNER, oltre a concedere ai membri del gruppo gs-announce l'autorizzazione READER, potresti avere un file denominato acls.json con i seguenti contenuti:

    {
"acl": [
  {
    "entity": "project-owners-867489160491",
    "role": "OWNER",
    "projectTeam": {
      "projectNumber": "867489160491",
      "team": "owners"
    }
  },
  {
    "entity": "user-example-service-account@example-project.s3ns.iam.gserviceaccount.com",
    "role": "OWNER",
    "email": "example-service-account@example-project.s3ns.iam.gserviceaccount.com"
  },
  {
    "entity": "group-gs-announce@googlegroups.com",
    "role": "READER",
    "email": "gs-announce@googlegroups.com"
  }
]
}

  2. Invia una richiesta patch con il file JSON e specifica l'oggetto su cui impostare gli ACL.

Ad esempio, il seguente comando curl applica un payload JSON dal documento acls.json a un oggetto denominato paris.jpg nel bucket example-travel-maps:

curl -X PATCH --data @acls.json -H "Content-Type: application/json" \
    -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    https://storage.s3nsapis.fr/storage/v1/b/example-travel-maps/o/paris.jpg

API XML

Nell'API XML, utilizzi le ACL in formato XML. Devi allegare un documento XML al corpo delle richieste per modificare gli ACL di bucket e oggetti. Quando recuperi gli ACL di bucket e oggetti, viene restituito un documento XML. Il documento XML contiene le singole voci ACL del bucket o dell'oggetto.

  • Dopo aver creato un bucket con una richiesta PUT Bucket, utilizza una seconda richiesta PUT Bucket con il parametro ?acl per modificare l'ACL del bucket.

  • Dopo aver caricato un oggetto con una richiesta PUT Object, modifica l'ACL con un'altra richiesta PUT utilizzando il parametro ?acl o l'intestazione della richiesta x-googl-acl.

Ad esempio, il seguente comando curl applica un payload XML dal documento acls.xml a un oggetto denominato paris.jpg nel bucket example-travel-maps:

curl -X PUT --data-binary @acls.xml \
    -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    https://storage.s3nsapis.fr/example-travel-maps/paris.jpg?acl

Utilizza la seguente sintassi ACL per il documento XML:

Elemento Descrizione
AccessControlList Contenitore per gli elementi Entries e Owner.
Owner Contenitore per gli elementi DisplayName e ID. Questo elemento non è obbligatorio per gli oggetti, poiché un oggetto è sempre di proprietà dell'utente che lo ha caricato. Questo elemento viene utilizzato quando utilizzi la sintassi ACL di Amazon S3 in uno scenario di migrazione.

Amazon Simple Storage Service™ e Amazon S3™ sono marchi di Amazon.com, Inc. o delle sue società consociate negli Stati Uniti e/o in altri paesi.
ID ID Cloud Storage del proprietario del bucket.
DisplayName Non implementato. Il valore è sempre una stringa vuota.
Entries Contenitore per zero o più elementi Entry.
Entry Contenitore per gli elementi Scope e Permission. Un Entry deve contenere un solo elemento Scope e un solo elemento Permission.
Scope Contenitore per un elemento ID, EmailAddress o Domain che definisce l'ambito dell'ACL. Questo elemento deve avere un attributo type che contenga uno dei seguenti valori: UserByID, UserByEmail, GroupByID, GroupByDomain, AllUsers o AllAuthenticatedUsers.
ID Un identificatore per il beneficiario quando la voce di autorizzazione è specificata tramite ID.
EmailAddress L'identificatore email del beneficiario quando la voce di autorizzazione è specificata tramite email.
Domain L'identificatore di dominio per il beneficiario quando la voce di autorizzazione è specificata per dominio.
Name Elemento facoltativo che può essere specificato.
Permission L'autorizzazione concessa READ, WRITE o FULL_CONTROL.

Quando utilizzi le ACL con l'API XML:

  • Puoi utilizzare solo il formato XML descritto sopra.

  • Non puoi impostare ambiti duplicati.

    Puoi avere molte voci nel file XML dell'ACL, ma non puoi avere voci con ambiti duplicati. Ad esempio, non puoi avere due voci con lo stesso elemento di ambito jane@example.com.

L'esempio seguente mostra diverse voci ACL del bucket:

<?xml version="1.0" encoding="UTF-8"?>
<AccessControlList>
  <Owner>
    <ID>00b4903a9721...</ID>
  </Owner>
  <Entries>
    <Entry>
      <Scope type="GroupById">
        <ID>00b4903a9722...</ID>
      </Scope>
      <Permission>FULL_CONTROL</Permission>
    </Entry>
    <Entry>
      <Scope type="UserByEmail">
        <EmailAddress>example-service-account@example-project.s3ns.iam.gserviceaccount.com</EmailAddress>
        <Name>Jefferson</Name>
      </Scope>
      <Permission>FULL_CONTROL</Permission>
    </Entry>
    <Entry>
      <Scope type="AllUsers"/>
      <Permission>READ</Permission>
    </Entry>
    <Entry>
      <Scope type="AllAuthenticatedUsers"/>
      <Permission>READ</Permission>
    </Entry>
  </Entries>
</AccessControlList>

Imposta l'elemento Name nel file XML ACL

Quando recuperi un ACL da un bucket o un oggetto, potresti notare un elemento <Name> aggiuntivo aggiunto ad alcune delle tue voci. Ad esempio, potresti vedere una voce simile alla seguente:

<Entry>
  <Scope type="UserByEmail">
    <EmailAddress>example-service-account@example-project.s3ns.iam.gserviceaccount.com</EmailAddress>
    <Name>Jefferson</Name>
  </Scope>
  <Permission>FULL_CONTROL</Permission>
</Entry>

Questi elementi <Name> facoltativi vengono compilati quando le ACL del bucket o dell'oggetto includono <Name> come elemento: quando imposti le ACL, puoi scegliere di includere l'elemento <Name> con le voci ACL. Puoi fornire qualsiasi valore nell'elemento <Name> e Cloud Storage memorizza questi valori finché l'ACL non viene rimosso o sostituito. Questo approccio può essere utile se utilizzi identificatori non facilmente identificabili.

Applica un'ACL predefinita

Anziché specificare l'intero ACL una voce alla volta come mostrato in precedenza, puoi utilizzare un ACL predefinito, che applicherà automaticamente un numero di voci personalizzate per uno scenario specifico. Puoi applicare un ACL predefinito a un bucket o a un oggetto utilizzando Google Cloud CLI, l'API JSON o l'API XML.

Sui nuovi oggetti

Per applicare un ACL predefinito a un oggetto durante il caricamento dell'oggetto:

Console

Non puoi applicare un ACL predefinito utilizzando la console Cloud de Confiance . Usa invece gcloud storage.

Riga di comando

Utilizza il comando gcloud storage cp con il flag --predefined-acl:

gcloud storage cp OBJECT gs://BUCKET_NAME --predefined-acl=PREDEFINED_ACL

Ad esempio, per applicare l'ACL predefinita bucketOwnerRead durante il caricamento di un oggetto paris.jpg in un bucket example-travel-maps:

gcloud storage cp paris.jpg gs://example-travel-maps --predefined-acl=bucketOwnerRead

API REST

API JSON

Utilizza il parametro della stringa di query predefinedAcl in una richiesta insert per applicare l'ACL predefinito.

Ad esempio, per applicare l'ACL predefinita bucketOwnerRead durante il caricamento di un oggetto paris.jpg in un bucket example-travel-maps:

curl -X POST --data-binary @paris.jpg -H "Content-Type: image/jpeg" \
    -H "Authorization: Bearer $(gcloud auth print-access-token)"  \
    "https://storage.s3nsapis.fr/upload/storage/v1/b/example-travel-maps/o?name=paris.jpg&predefinedAcl=bucketOwnerRead"

API XML

Utilizza l'intestazione x-goog-acl in una richiesta Put Object per applicare l'ACL predefinito.

Ad esempio, per applicare l'ACL predefinita bucket-owner-read durante il caricamento di un oggetto paris.jpg in un bucket example-travel-maps:

curl -X PUT --upload-file paris.jpg -H "x-goog-acl: bucket-owner-read" \
    -H "Authorization: Bearer $(gcloud auth print-access-token)"  \
    https://storage.s3nsapis.fr/example-travel-maps/paris.jpg

Su bucket o oggetti esistenti

Puoi anche applicare un'ACL predefinita a un bucket o a un oggetto esistente, il che è utile se vuoi passare da un'ACL predefinita a un'altra o se vuoi aggiornare le ACL personalizzate in un'ACL predefinita.

Console

Non puoi applicare un ACL predefinito utilizzando la console Cloud de Confiance . Usa invece gcloud storage.

Riga di comando

Utilizza il comando objects update con il flag --predefined-acl:

gcloud storage objects update gs://BUCKET_NAME/OBJECT_NAME --predefined-acl=PREDEFINED_ACL_NAME

Ad esempio, per applicare l'ACL predefinito private all'oggetto paris.jpg nel bucket example-travel-maps:

gcloud storage objects update gs://example-travel-maps/paris.jpg --predefined-acl=private

API REST

API JSON

Utilizza il parametro della stringa di query predefinedAcl e specifica una proprietà acl vuota in una richiesta patch per applicare l'ACL predefinito.

Ad esempio, per applicare l'ACL predefinito private all'oggetto paris.jpg nel bucket example-travel-maps:

curl -X PATCH --data '{"acl": []}'  -H "Content-Type: application/json" \
    -H "Authorization: Bearer $(gcloud auth print-access-token)"  \
    https://storage.s3nsapis.fr/storage/v1/b/example-travel-maps/o/paris.jpg?predefinedAcl=private

API XML

Utilizza l'intestazione x-goog-acl con il parametro della stringa di query acl in una richiesta Put Object, ma non includere un documento XML nella richiesta.

Ad esempio, per applicare l'ACL predefinito private all'oggetto paris.jpg nel bucket example-travel-maps:

curl -X PUT -H "Content-Length: 0" \
    -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    -H "x-goog-acl: private" \
    https://storage.s3nsapis.fr/example-travel-maps/paris.jpg?acl

Imposta ACL predefiniti degli oggetti

Per evitare di impostare le ACL ogni volta che crei un nuovo oggetto, puoi impostare un'ACL predefinita per gli oggetti su un bucket. In seguito, a ogni nuovo oggetto aggiunto al bucket a cui non è applicato esplicitamente un ACL verrà applicato l'ACL predefinito. Ad esempio, potresti voler specificare che solo un determinato gruppo di utenti ha accesso alla maggior parte degli oggetti in un bucket specifico. Puoi modificare l'ACL predefinita dell'oggetto e poi aggiungere oggetti al bucket. A questi oggetti aggiunti viene applicato automaticamente l'ACL predefinito per gli oggetti che hai specificato. Tuttavia, puoi assegnare ACL diversi a oggetti specifici, nel qual caso a questi oggetti non viene applicato l'ACL predefinito.

Per visualizzare e modificare l'ACL predefinita degli oggetti per un bucket:

Console

Non puoi impostare le ACL predefinite degli oggetti utilizzando la console Cloud de Confiance . Usa invece gcloud storage.

Riga di comando

  1. Utilizza il comando buckets describe con il flag --format per recuperare l'ACL dell'oggetto predefinito per il bucket:

    gcloud storage buckets describe gs://BUCKET_NAME --format="default(default_acl)"

    Dove BUCKET_NAME è il nome del bucket di cui vuoi visualizzare l'ACL predefinita dell'oggetto. Ad esempio, my-bucket.

  2. Utilizza il comando buckets update con il flag desiderato per modificare l'ACL predefinito degli oggetti per il bucket:

    gcloud storage buckets update gs://BUCKET_NAME FLAG

    Dove:

    • BUCKET_NAME è il nome del bucket di cui vuoi modificare l'ACL predefinita dell'oggetto. Ad esempio, my-bucket.

    • FLAG è uno dei seguenti:

      • --add-default-object-acl-grant e un'autorizzazione che vuoi aggiungere all'ACL predefinito complessivo degli oggetti per il bucket.

      • --default-object-acl-file e il percorso di un file locale che definisce una nuova ACL predefinita per gli oggetti del bucket.

      • --predefined-default-object-acl e il nome di un'ACL dell'oggetto predefinita con cui vuoi sostituire l'ACL dell'oggetto predefinita esistente per il bucket.

      • --remove-default-object-acl-grant e un'entità che vuoi rimuovere dall'ACL predefinita complessiva degli oggetti per il bucket.

Librerie client

C++

Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Storage C++.

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

Prima di eseguire gli esempi di codice, imposta la variabile di ambiente GOOGLE_CLOUD_UNIVERSE_DOMAIN su s3nsapis.fr.

L'esempio seguente aggiunge un'ACL predefinita per gli oggetti a un bucket:

namespace gcs = ::google::cloud::storage;
using ::google::cloud::StatusOr;
[](gcs::Client client, std::string const& bucket_name,
   std::string const& entity, std::string const& role) {
  StatusOr<gcs::ObjectAccessControl> default_object_acl =
      client.CreateDefaultObjectAcl(bucket_name, entity, role);
  if (!default_object_acl) throw std::move(default_object_acl).status();

  std::cout << "Role " << default_object_acl->role()
            << " will be granted default to " << default_object_acl->entity()
            << " on any new object created on bucket "
            << default_object_acl->bucket() << "\n"
            << "Full attributes: " << *default_object_acl << "\n";
}

L'esempio seguente elimina un'ACL predefinita di un oggetto da un bucket:

namespace gcs = ::google::cloud::storage;
[](gcs::Client client, std::string const& bucket_name,
   std::string const& entity) {
  google::cloud::Status status =
      client.DeleteDefaultObjectAcl(bucket_name, entity);

  if (!status.ok()) throw std::runtime_error(status.message());
  std::cout << "Deleted ACL entry for " << entity << " in bucket "
            << bucket_name << "\n";
}

C#

Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Storage C#.

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

Prima di eseguire gli esempi di codice, imposta la variabile di ambiente GOOGLE_CLOUD_UNIVERSE_DOMAIN su s3nsapis.fr.

L'esempio seguente stampa l'ACL dell'oggetto predefinito per un bucket:


using Google.Apis.Storage.v1.Data;
using Google.Cloud.Storage.V1;
using System;
using System.Collections.Generic;

public class PrintBucketDefaultAclSample
{
    public IEnumerable<ObjectAccessControl> PrintBucketDefaultAcl(string bucketName = "your-unique-bucket-name")
    {
        var storage = StorageClient.Create();
        var bucket = storage.GetBucket(bucketName, new GetBucketOptions { Projection = Projection.Full });

        foreach (var acl in bucket.DefaultObjectAcl)
        {
            Console.WriteLine($"{acl.Role}:{acl.Entity}");
        }

        return bucket.DefaultObjectAcl;
    }
}

L'esempio seguente aggiunge un'ACL predefinita per gli oggetti a un bucket:


using Google.Apis.Storage.v1.Data;
using Google.Cloud.Storage.V1;
using System;

public class AddBucketDefaultOwnerSample
{
    public Bucket AddBucketDefaultOwner(
        string bucketName = "your-unique-bucket-name",
        string userEmail = "dev@iam.gserviceaccount.com")
    {
        var storage = StorageClient.Create();
        var bucket = storage.GetBucket(bucketName, new GetBucketOptions { Projection = Projection.Full });

        bucket.DefaultObjectAcl.Add(new ObjectAccessControl
        {
            Bucket = bucketName,
            Entity = $"user-{userEmail}",
            Role = "OWNER",
        });
        var updatedBucket = storage.UpdateBucket(bucket);
        Console.WriteLine($"Added user {userEmail} as a default owner on bucket {bucketName}.");
        return updatedBucket;
    }
}

L'esempio seguente elimina un'ACL predefinita di un oggetto da un bucket:


using Google.Cloud.Storage.V1;
using System;
using System.Linq;

public class RemoveBucketDefaultOwnerSample
{
    public void RemoveBucketDefaultOwner(
        string bucketName = "your-unique-bucket-name",
        string userEmail = "user@iam.gserviceaccount.com")
    {
        var storage = StorageClient.Create();
        var bucket = storage.GetBucket(bucketName, new GetBucketOptions { Projection = Projection.Full });
        if (bucket.DefaultObjectAcl == null)
        {
            Console.WriteLine("No default owner to remove");
        }
        else
        {
            bucket.DefaultObjectAcl = bucket.DefaultObjectAcl.Where(acl => !(acl.Entity == $"user-{userEmail}" && acl.Role == "OWNER")).ToList();
            var updatedBucket = storage.UpdateBucket(bucket);
            Console.WriteLine($"Removed user {userEmail} from bucket {bucketName}.");
        }
    }
}

Go

Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Storage Go.

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

Prima di eseguire gli esempi di codice, imposta la variabile di ambiente GOOGLE_CLOUD_UNIVERSE_DOMAIN su s3nsapis.fr.

L'esempio seguente aggiunge un'ACL predefinita per gli oggetti a un bucket:

import (
	"context"
	"fmt"

	"cloud.google.com/go/storage"
)

// addBucketDefaultOwner adds default ACL to the specified bucket.
func addBucketDefaultOwner(bucket string, entity storage.ACLEntity) error {
	// bucket := "bucket-name"
	// entity := storage.AllUsers
	role := storage.RoleOwner

	ctx := context.Background()
	client, err := storage.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("storage.NewClient: %w", err)
	}
	defer client.Close()

	acl := client.Bucket(bucket).DefaultObjectACL()
	if err := acl.Set(ctx, entity, role); err != nil {
		return fmt.Errorf("ACLHandle.Set: %w", err)
	}
	return nil
}

L'esempio seguente elimina un'ACL predefinita di un oggetto da un bucket:

import (
	"context"
	"fmt"

	"cloud.google.com/go/storage"
)

// deleteDefaultBucketACL removes default ACL from a bucket.
func removeBucketDefaultOwner(bucket string, entity storage.ACLEntity) error {
	// bucket := "bucket-name"
	// entity := storage.AllUsers
	ctx := context.Background()
	client, err := storage.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("storage.NewClient: %w", err)
	}
	defer client.Close()

	acl := client.Bucket(bucket).DefaultObjectACL()
	if err := acl.Delete(ctx, entity); err != nil {
		return fmt.Errorf("ACLHandle.Delete: %w", err)
	}
	return nil
}

Java

Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Storage Java.

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

Prima di eseguire gli esempi di codice, imposta la variabile di ambiente GOOGLE_CLOUD_UNIVERSE_DOMAIN su s3nsapis.fr.

L'esempio seguente aggiunge un'ACL predefinita per gli oggetti a un bucket:


import com.google.cloud.storage.Acl;
import com.google.cloud.storage.Acl.Role;
import com.google.cloud.storage.Acl.User;
import com.google.cloud.storage.Bucket;
import com.google.cloud.storage.Storage;
import com.google.cloud.storage.StorageOptions;

public class AddBucketDefaultOwner {

  public static void addBucketDefaultOwner(String bucketName, String userEmail) {

    // The ID of your GCS bucket
    // String bucketName = "your-unique-bucket-name";

    // The email of the user you wish to add as a default owner
    // String userEmail = "someuser@domain.com"

    Storage storage = StorageOptions.newBuilder().build().getService();
    Bucket bucket = storage.get(bucketName);
    Acl newDefaultOwner = Acl.of(new User(userEmail), Role.OWNER);

    bucket.createDefaultAcl(newDefaultOwner);
    System.out.println("Added user " + userEmail + " as an owner on " + bucketName);
  }
}

L'esempio seguente elimina un'ACL predefinita di un oggetto da un bucket:


import com.google.cloud.storage.Acl.User;
import com.google.cloud.storage.Bucket;
import com.google.cloud.storage.Storage;
import com.google.cloud.storage.StorageOptions;

public class RemoveBucketDefaultOwner {

  public static void removeBucketDefaultOwner(String bucketName, String userEmail) {

    // The ID of your GCS bucket
    // String bucketName = "your-unique-bucket-name";

    // The email of the user you wish to remove as a default owner
    // String userEmail = "someuser@domain.com"

    Storage storage = StorageOptions.newBuilder().build().getService();
    Bucket bucket = storage.get(bucketName);
    User userToRemove = new User(userEmail);

    boolean success = bucket.deleteDefaultAcl(userToRemove);
    if (success) {
      System.out.println("Removed user " + userEmail + " as an owner on " + bucketName);
    } else {
      System.out.println("User " + userEmail + " was not found");
    }
  }
}

Node.js

Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Storage Node.js.

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

Prima di eseguire gli esempi di codice, imposta la variabile di ambiente GOOGLE_CLOUD_UNIVERSE_DOMAIN su s3nsapis.fr.

L'esempio seguente aggiunge un'ACL predefinita per gli oggetti a un bucket:

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// The ID of your GCS bucket
// const bucketName = 'your-unique-bucket-name';

// The email address of the user to add
// const userEmail = 'user-email-to-add';

// Imports the Google Cloud client library
const {Storage} = require('@google-cloud/storage');

// Creates a client
const storage = new Storage();

async function addBucketDefaultOwner() {
  // Makes the user an owner in the default ACL of the bucket. You can use
  // addAllUsers(), addDomain(), addProject(), addGroup(), and
  // addAllAuthenticatedUsers() to grant access to different types of entities.
  // You can also use "readers" and "writers" to grant different roles.
  await storage.bucket(bucketName).acl.default.owners.addUser(userEmail);

  console.log(`Added user ${userEmail} as an owner on bucket ${bucketName}.`);
}

addBucketDefaultOwner().catch(console.error);

L'esempio seguente elimina un'ACL predefinita di un oggetto da un bucket:

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// The ID of your GCS bucket
// const bucketName = 'your-unique-bucket-name';

// The email address of the user to remove
// const userEmail = 'user-email-to-remove';

// Imports the Google Cloud client library
const {Storage} = require('@google-cloud/storage');

// Creates a client
const storage = new Storage();

async function removeBucketDefaultOwner() {
  // Removes the user from the access control list of the bucket. You can use
  // deleteAllUsers(), deleteDomain(), deleteProject(), deleteGroup(), and
  // deleteAllAuthenticatedUsers() to remove access for different types of entities.
  await storage.bucket(bucketName).acl.default.owners.deleteUser(userEmail);

  console.log(`Removed user ${userEmail} from bucket ${bucketName}.`);
}

removeBucketDefaultOwner().catch(console.error);

PHP

Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Storage PHP.

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

Prima di eseguire gli esempi di codice, imposta la variabile di ambiente GOOGLE_CLOUD_UNIVERSE_DOMAIN su s3nsapis.fr.

L'esempio seguente aggiunge un'ACL predefinita per gli oggetti a un bucket:

use Google\Cloud\Storage\StorageClient;

/**
 * Add an entity and role to a bucket's default ACL.
 *
 * @param string $bucketName The name of your Cloud Storage bucket.
 *        (e.g. 'my-bucket')
 * @param string $entity The entity for which to update access controls.
 *        (e.g. 'user-example@domain.com')
 * @param string $role The permissions to add for the specified entity.
 *        (e.g. 'OWNER')
 */
function add_bucket_default_acl(string $bucketName, string $entity, string $role): void
{
    $storage = new StorageClient();
    $bucket = $storage->bucket($bucketName);
    $acl = $bucket->defaultAcl();
    $acl->add($entity, $role);
    printf('Added %s (%s) to gs://%s default ACL' . PHP_EOL, $entity, $role, $bucketName);
}

L'esempio seguente elimina un'ACL predefinita di un oggetto da un bucket:

use Google\Cloud\Storage\StorageClient;

/**
 * Delete an entity from a bucket's default ACL.
 *
 * @param string $bucketName The name of your Cloud Storage bucket.
 *        (e.g. 'my-bucket')
 * @param string $entity The entity for which to update access controls.
 *        (e.g. 'user-example@domain.com')
 */
function delete_bucket_default_acl(string $bucketName, string $entity): void
{
    $storage = new StorageClient();
    $bucket = $storage->bucket($bucketName);
    $acl = $bucket->defaultAcl();
    $acl->delete($entity);
    printf('Deleted %s from gs://%s default ACL' . PHP_EOL, $entity, $bucketName);
}

Python

Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Storage Python.

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

Prima di eseguire gli esempi di codice, imposta la variabile di ambiente GOOGLE_CLOUD_UNIVERSE_DOMAIN su s3nsapis.fr.

L'esempio seguente aggiunge un'ACL predefinita per gli oggetti a un bucket:

from google.cloud import storage


def add_bucket_default_owner(bucket_name, user_email):
    """Adds a user as an owner in the given bucket's default object access
    control list."""
    # bucket_name = "your-bucket-name"
    # user_email = "name@example.com"

    storage_client = storage.Client()
    bucket = storage_client.bucket(bucket_name)

    # Reload fetches the current ACL from Cloud Storage.
    bucket.acl.reload()

    # You can also use `group`, `domain`, `all_authenticated` and `all` to
    # grant access to different types of entities. You can also use
    # `grant_read` or `grant_write` to grant different roles.
    bucket.default_object_acl.user(user_email).grant_owner()
    bucket.default_object_acl.save()

    print(
        "Added user {} as an owner in the default acl on bucket {}.".format(
            user_email, bucket_name
        )
    )

L'esempio seguente elimina un'ACL predefinita di un oggetto da un bucket:

from google.cloud import storage


def remove_bucket_default_owner(bucket_name, user_email):
    """Removes a user from the access control list of the given bucket's
    default object access control list."""
    # bucket_name = "your-bucket-name"
    # user_email = "name@example.com"

    storage_client = storage.Client()
    bucket = storage_client.bucket(bucket_name)

    # Reload fetches the current ACL from Cloud Storage.
    bucket.acl.reload()

    # You can also use `group`, `domain`, `all_authenticated` and `all` to
    # remove access for different types of entities.
    bucket.default_object_acl.user(user_email).revoke_read()
    bucket.default_object_acl.user(user_email).revoke_write()
    bucket.default_object_acl.user(user_email).revoke_owner()
    bucket.default_object_acl.save()

    print(
        f"Removed user {user_email} from the default acl of bucket {bucket_name}."
    )

Ruby

Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Storage Ruby.

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

Prima di eseguire gli esempi di codice, imposta la variabile di ambiente GOOGLE_CLOUD_UNIVERSE_DOMAIN su s3nsapis.fr.

L'esempio seguente aggiunge un'ACL predefinita per gli oggetti a un bucket:

# The ID of your GCS bucket
# bucket_name = "your-unique-bucket-name"
# email       = "Google Cloud Storage ACL Entity email"

require "google/cloud/storage"

storage = Google::Cloud::Storage.new
bucket  = storage.bucket bucket_name

bucket.default_acl.add_owner email

puts "Added default OWNER permission for #{email} to #{bucket_name}"

L'esempio seguente elimina un'ACL predefinita di un oggetto da un bucket:

# The ID of your GCS bucket
# bucket_name = "your-unique-bucket-name"
# email       = "Google Cloud Storage ACL Entity email"

require "google/cloud/storage"

storage = Google::Cloud::Storage.new
bucket  = storage.bucket bucket_name

bucket.default_acl.delete email

puts "Removed default ACL permissions for #{email} from #{bucket_name}"

Rust

L'esempio seguente aggiunge un'ACL predefinita per gli oggetti a un bucket:

use google_cloud_storage::client::StorageControl;
use google_cloud_storage::model::ObjectAccessControl;
use google_cloud_wkt::FieldMask;

pub async fn sample(
    client: &StorageControl,
    bucket_id: &str,
    user_email: &str,
) -> anyhow::Result<()> {
    let bucket = client
        .get_bucket()
        .set_name(format!("projects/_/buckets/{bucket_id}"))
        .send()
        .await?;
    let metageneration = bucket.metageneration;
    let mut acls = bucket.default_object_acl.clone();
    acls.push(
        ObjectAccessControl::new()
            .set_entity(format!("user-{}", user_email))
            .set_role("OWNER"),
    );

    let bucket = client
        .update_bucket()
        .set_bucket(bucket.set_default_object_acl(acls))
        .set_if_metageneration_match(metageneration)
        .set_update_mask(FieldMask::default().set_paths(["default_object_acl"]))
        .send()
        .await?;
    println!("Successfully added default owner {user_email} to bucket {bucket_id}");
    println!("{:?}", bucket.default_object_acl);
    Ok(())
}

L'esempio seguente elimina un'ACL predefinita di un oggetto da un bucket:

use google_cloud_storage::client::StorageControl;
use google_cloud_wkt::FieldMask;

pub async fn sample(
    client: &StorageControl,
    bucket_id: &str,
    user_email: &str,
) -> anyhow::Result<()> {
    let bucket = client
        .get_bucket()
        .set_name(format!("projects/_/buckets/{bucket_id}"))
        .send()
        .await?;
    let metageneration = bucket.metageneration;
    let mut acls = bucket.default_object_acl.clone();
    acls.retain(|acl| acl.entity != format!("user-{}", user_email));

    let bucket = client
        .update_bucket()
        .set_bucket(bucket.set_default_object_acl(acls))
        .set_if_metageneration_match(metageneration)
        .set_update_mask(FieldMask::default().set_paths(["default_object_acl"]))
        .send()
        .await?;
    println!("Successfully removed default owner {user_email} from bucket {bucket_id}");
    println!("{:?}", bucket.default_object_acl);
    Ok(())
}

API REST

API JSON

  1. Recupera l'ACL predefinita dell'oggetto con una richiesta GET. Ad esempio:

    curl -X GET -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    https://storage.s3nsapis.fr/storage/v1/b/BUCKET_NAME?projection=full

  2. Utilizza una richiesta patch per sostituire l'ACL predefinito dell'oggetto. Ad esempio, la seguente richiesta sostituisce l'ACL dell'oggetto predefinito con l'ACL specificato in defacls.json per un bucket example-travel-maps:

    curl -X PATCH --data @defacls.json -H "Content-Type: application/json" -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    https://storage.s3nsapis.fr/storage/v1/b/example-travel-maps

    Un esempio di defacls.json:

    {
"defaultObjectAcl": [
  {
    "email": "example-service-account@example-project.s3ns.iam.gserviceaccount.com",
    "entity": "user-example-service-account@example-project.s3ns.iam.gserviceaccount.com",
    "role": "READER"
  }
]
}

API XML

  1. Recupera l'ACL predefinita dell'oggetto con una richiesta GET limitata al tuo bucket e al parametro ?defaultObjectAcl. Ad esempio:

    curl -X GET -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    https://storage.s3nsapis.fr/BUCKET_NAME?defaultObjectAcl

  2. Utilizza una richiesta PUT con ambito limitato al tuo bucket con il parametro ?defaultObjectAcl per sostituire l'ACL dell'oggetto predefinito con l'ACL specificato in acls.xml. Ad esempio:

    curl -X PUT --data-binary @acls.xml -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    http://storage.s3nsapis.fr/BUCKET_NAME?defaultObjectAcl

    Un esempio di acls.xml:

    <AccessControlList>
  <Entries>
    <Entry>
      <Permission>FULL_CONTROL</Permission>
      <Scope type="UserByEmail">
        <EmailAddress>example-service-account@example-project.s3ns.iam.gserviceaccount.com</EmailAddress>
      </Scope>
    </Entry>
  </Entries>
</AccessControlList>

La sintassi degli ACL è discussa in Impostazione degli ACL. Puoi anche specificare un ACL predefinito come ACL predefinito dell'oggetto.

Per impostare l'ACL predefinito dell'oggetto per un bucket su un ACL predefinito:

Console

Non puoi impostare le ACL predefinite degli oggetti utilizzando la console Cloud de Confiance . Usa invece gcloud storage.

Riga di comando

Utilizza il comando buckets update con il flag --predefined-default-object-acl:

gcloud storage buckets update gs://BUCKET_NAME --predefined-default-object-acl=PREDEFINED_ACL

Dove:

  • BUCKET_NAME è il nome del bucket di cui vuoi modificare l'ACL predefinita dell'oggetto. Ad esempio, my-bucket.

  • PREDEFINED_ACL è il nome di un ACL predefinito valido. Ad esempio, projectPrivate.

API REST

API JSON

Utilizza una richiesta PUT e il parametro predefinedAcl.

Ad esempio:

curl -X PUT -H "Content-Length: 0" -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    https://storage.s3nsapis.fr/storage/v1/b/BUCKET_NAME?predefinedAcl=private

API XML

Utilizza una richiesta PUT con ambito limitato al tuo bucket con il parametro ?defaultObjectAcl e l'intestazione x-goog-acl.

Ad esempio:

curl -X PUT -H "x-goog-acl: project-private" -H "Content-Length: 0" -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    http://storage.s3nsapis.fr/BUCKET_NAME?defaultObjectAcl

ACL degli oggetti predefiniti per i bucket appena creati:

I seguenti esempi mostrano le ACL degli oggetti predefinite che vengono applicate automaticamente ai bucket appena creati quando non specifichi le tue ACL degli oggetti predefinite come parte della richiesta. Per verificare se le ACL predefinite degli oggetti del bucket sono state modificate, confronta le ACL predefinite degli oggetti del bucket con i seguenti esempi.

Console

Non puoi utilizzare le ACL predefinite degli oggetti utilizzando la console Cloud de Confiance . Utilizza invece gcloud storage.

Riga di comando

Nell'esempio seguente, l'ID progetto è "123412341234"; il tuo ID progetto sarà diverso.

defaultObjectAcl:
– entity: project-owners-123412341234
  etag: CAE=
  kind: storage#objectAccessControl
  projectTeam:
    projectNumber: '123412341234'
    team: owners
  role: OWNER
– entity: project-editors-123412341234
  etag: CAE=
  kind: storage#objectAccessControl
  projectTeam:
    projectNumber: '123412341234'
    team: editors
  role: OWNER
– entity: project-viewers-123412341234
  etag: CAE=
  kind: storage#objectAccessControl
  projectTeam:
    projectNumber: '123412341234'
    team: viewers
  role: READER

API REST

API JSON

Nell'esempio seguente, l'ID progetto è "123412341234"; il tuo ID progetto sarà diverso.

"defaultObjectAcl": [
  {
    "kind": "storage#objectAccessControl",
    "entity": "project-owners-123412341234",
    "role": "OWNER",
    "projectTeam": {
      "projectNumber": "123412341234",
      "team": "owners"
    }
  },
  {
    "kind": "storage#objectAccessControl",
    "entity": "project-editors-123412341234",
    "role": "OWNER",
    "projectTeam": {
      "projectNumber": "123412341234",
      "team": "editors"
    }
  },
  {
    "kind": "storage#objectAccessControl",
    "entity": "project-viewers-123412341234",
    "role": "READER",
    "projectTeam": {
      "projectNumber": "123412341234",
      "team": "viewers"
    }
  }
]

API XML

Nell'esempio seguente, gli ID ruolo del progetto iniziano con "00b4903a97…"; gli ID progetto saranno diversi.

<?xml version='1.0' encoding='UTF-8'?>
<AccessControlList>
  <Entries>
    <Entry>
      <Scope type='GroupById'>
        <ID>00b4903a9721...</ID>
      </Scope>
      <Permission>FULL_CONTROL</Permission>
    </Entry>
    <Entry>
      <Scope type='GroupById'>
        <ID>00b4903a9722...</ID>
      </Scope>
      <Permission>FULL_CONTROL</Permission>
    </Entry>
    <Entry>
      <Scope type='GroupById'>
        <ID>00b4903a9723...</ID>
      </Scope>
      <Permission>READ</Permission>
    </Entry>
  </Entries>
</AccessControlList>

Tieni presente che l'ACL predefinita degli oggetti per un bucket appena creato equivale all'ACL projectPrivate predefinita.

Recupero delle ACL

Per ottenere l'ACL di una risorsa esistente:

Console

  1. Vai al browser Cloud Storage nella console Cloud de Confiance .
    Vai al browser Cloud Storage

  2. Vai all'oggetto di cui vuoi visualizzare l'ACL.

  3. Scegli accesso in modifica dal menu a discesa dell'oggetto.

    Dovresti visualizzare una finestra di dialogo con le autorizzazioni dell'oggetto.

Per scoprire come ottenere informazioni dettagliate sugli errori relativi alle operazioni di Cloud Storage non riuscite nella console Cloud de Confiance , consulta Risoluzione dei problemi.

Riga di comando

  1. Utilizza il comando objects describe con il flag --format per recuperare l'ACL di un oggetto:

    gcloud storage objects describe gs://BUCKET_NAME/OBJECT_NAME --format="default(acl)"

    Dove:

    • BUCKET_NAME è il nome del bucket contenente l'oggetto di cui vuoi visualizzare l'ACL. Ad esempio, my-bucket.

    • OBJECT_NAME è il nome dell'oggetto di cui vuoi visualizzare l'ACL. Ad esempio, paris.jpg.

Librerie client

C++

Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Storage C++.

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

Prima di eseguire gli esempi di codice, imposta la variabile di ambiente GOOGLE_CLOUD_UNIVERSE_DOMAIN su s3nsapis.fr.

L'esempio seguente recupera un ACL dell'oggetto:

namespace gcs = ::google::cloud::storage;
using ::google::cloud::StatusOr;
[](gcs::Client client, std::string const& bucket_name,
   std::string const& object_name) {
  StatusOr<std::vector<gcs::ObjectAccessControl>> items =
      client.ListObjectAcl(bucket_name, object_name);

  if (!items) throw std::move(items).status();
  std::cout << "ACLs for object=" << object_name << " in bucket "
            << bucket_name << "\n";
  for (gcs::ObjectAccessControl const& acl : *items) {
    std::cout << acl.role() << ":" << acl.entity() << "\n";
  }
}

C#

Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Storage C#.

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

Prima di eseguire gli esempi di codice, imposta la variabile di ambiente GOOGLE_CLOUD_UNIVERSE_DOMAIN su s3nsapis.fr.

L'esempio seguente recupera un ACL dell'oggetto:


using Google.Apis.Storage.v1.Data;
using Google.Cloud.Storage.V1;
using System;
using System.Collections.Generic;

public class PrintFileAclSample
{
    public IEnumerable<ObjectAccessControl> PrintObjectAcl(
        string bucketName = "your-unique-bucket-name",
        string objectName = "your-object-name")
    {
        var storage = StorageClient.Create();
        var storageObject = storage.GetObject(bucketName, objectName, new GetObjectOptions
        {
            Projection = Projection.Full
        });

        foreach (var acl in storageObject.Acl)
        {
            Console.WriteLine($"{acl.Role}:{acl.Entity}");
        }

        return storageObject.Acl;
    }
}

Go

Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Storage Go.

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

Prima di eseguire gli esempi di codice, imposta la variabile di ambiente GOOGLE_CLOUD_UNIVERSE_DOMAIN su s3nsapis.fr.

L'esempio seguente recupera un ACL dell'oggetto:

import (
	"context"
	"fmt"
	"io"

	"cloud.google.com/go/storage"
)

// printFileACL lists ACL of the specified object.
func printFileACL(w io.Writer, bucket, object string) error {
	// bucket := "bucket-name"
	// object := "object-name"
	ctx := context.Background()
	client, err := storage.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("storage.NewClient: %w", err)
	}
	defer client.Close()

	rules, err := client.Bucket(bucket).Object(object).ACL().List(ctx)
	if err != nil {
		return fmt.Errorf("ACLHandle.List: %w", err)
	}
	for _, rule := range rules {
		fmt.Fprintf(w, "ACL rule: %v\n", rule)
	}
	return nil
}

Java

Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Storage Java.

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

Prima di eseguire gli esempi di codice, imposta la variabile di ambiente GOOGLE_CLOUD_UNIVERSE_DOMAIN su s3nsapis.fr.

L'esempio seguente recupera un ACL dell'oggetto:


import com.google.cloud.storage.Acl;
import com.google.cloud.storage.Blob;
import com.google.cloud.storage.BlobId;
import com.google.cloud.storage.Storage;
import com.google.cloud.storage.StorageOptions;
import java.util.List;

public class PrintBlobAcl {

  public static void printBlobAcl(String bucketName, String blobName) {

    // The ID to give your GCS bucket
    // String bucketName = "your-unique-bucket-name";

    // The name of the blob/file that you wish to view Acls of
    // String blobName = "your-blob-name";

    Storage storage = StorageOptions.newBuilder().build().getService();
    Blob blob = storage.get(BlobId.of(bucketName, blobName));
    List<Acl> blobAcls = blob.getAcl();

    for (Acl acl : blobAcls) {

      // This will give you the role.
      // See https://cloud.google.com/storage/docs/access-control/lists#permissions
      String role = acl.getRole().name();

      // This will give you the Entity type (i.e. User, Group, Project etc.)
      // See https://cloud.google.com/storage/docs/access-control/lists#scopes
      String entityType = acl.getEntity().getType().name();

      System.out.printf("%s: %s %n", role, entityType);
    }
  }
}

Node.js

Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Storage Node.js.

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

Prima di eseguire gli esempi di codice, imposta la variabile di ambiente GOOGLE_CLOUD_UNIVERSE_DOMAIN su s3nsapis.fr.

L'esempio seguente recupera un ACL dell'oggetto:

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// The ID of your GCS bucket
// const bucketName = 'your-unique-bucket-name';

// The ID of your GCS file
// const fileName = 'your-file-name';

// Imports the Google Cloud client library
const {Storage} = require('@google-cloud/storage');

// Creates a client
const storage = new Storage();

async function printFileAcl() {
  // Gets the ACL for the file
  const [acls] = await storage.bucket(bucketName).file(fileName).acl.get();

  acls.forEach(acl => {
    console.log(`${acl.role}: ${acl.entity}`);
  });
}

printFileAcl().catch(console.error);

PHP

Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Storage PHP.

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

Prima di eseguire gli esempi di codice, imposta la variabile di ambiente GOOGLE_CLOUD_UNIVERSE_DOMAIN su s3nsapis.fr.

L'esempio seguente recupera un ACL dell'oggetto:

use Google\Cloud\Storage\StorageClient;

/**
 * Print all entities and roles for an object's ACL.
 *
 * @param string $bucketName The name of your Cloud Storage bucket.
 *        (e.g. 'my-bucket')
 * @param string $objectName The name of your Cloud Storage object.
 *        (e.g. 'my-object')
 */
function get_object_acl(string $bucketName, string $objectName): void
{
    $storage = new StorageClient();
    $bucket = $storage->bucket($bucketName);
    $object = $bucket->object($objectName);
    $acl = $object->acl();
    foreach ($acl->get() as $item) {
        printf('%s: %s' . PHP_EOL, $item['entity'], $item['role']);
    }
}

Python

Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Storage Python.

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

Prima di eseguire gli esempi di codice, imposta la variabile di ambiente GOOGLE_CLOUD_UNIVERSE_DOMAIN su s3nsapis.fr.

L'esempio seguente recupera un ACL dell'oggetto:

from google.cloud import storage


def print_blob_acl(bucket_name, blob_name):
    """Prints out a blob's access control list."""

    storage_client = storage.Client()
    bucket = storage_client.bucket(bucket_name)
    blob = bucket.blob(blob_name)

    for entry in blob.acl:
        print(f"{entry['role']}: {entry['entity']}")

Ruby

Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Storage Ruby.

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

Prima di eseguire gli esempi di codice, imposta la variabile di ambiente GOOGLE_CLOUD_UNIVERSE_DOMAIN su s3nsapis.fr.

L'esempio seguente recupera un ACL dell'oggetto:

# The ID of your GCS bucket
# bucket_name = "your-unique-bucket-name"
# file_name   = "Name of a file in the Storage bucket"
# email       = "Google Cloud Storage ACL Entity email"

require "google/cloud/storage"

storage = Google::Cloud::Storage.new
bucket  = storage.bucket bucket_name
file    = bucket.file file_name

puts "ACL for #{file_name} in #{bucket_name}:"

file.acl.owners.each do |owner|
  puts "OWNER #{owner}"
end

file.acl.readers.each do |reader|
  puts "READER #{reader}"
end

Rust

L'esempio seguente recupera un ACL dell'oggetto:

use google_cloud_storage::client::StorageControl;

pub async fn sample(client: &StorageControl, bucket_id: &str) -> anyhow::Result<()> {
    const NAME: &str = "object-to-read";
    let object = client
        .get_object()
        .set_bucket(format!("projects/_/buckets/{bucket_id}"))
        .set_object(NAME)
        .send()
        .await?;

    println!(
        "Object {NAME} in bucket {bucket_id} has the following ACL: {:?}",
        object.acl
    );
    Ok(())
}

API REST

API JSON

  1. Assicurati di disporre dell'autorizzazione OWNER per l'oggetto.

  2. Recupera l'ACL dell'oggetto con una richiesta GET.

    L'ACL dell'oggetto viene restituita in formato JSON, allegata al corpo della risposta.

Ad esempio, per restituire l'ACL per l'oggetto paris.jpg nel bucket example-travel-maps:

curl -X GET -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    https://storage.s3nsapis.fr/storage/v1/b/example-travel-maps/o/paris.jpg?projection=full

Dovresti visualizzare una risposta simile alla seguente:

{
  "kind": "storage#object",
  "id": "example-travel-maps/paris.jpg/1412805837131000",
  "selfLink": "https://www.s3nsapis.fr/storage/v1/b/example-travel-maps/o/paris.jpg",
  "name": "paris.jpg",
    "bucket": "example-travel-maps",
  ...
  "acl": [
    {
      ...
      "entity": "project-owners-867489160491",
      "role": "OWNER",
      "projectTeam": {
        "projectNumber": "867489160491",
        "team": "owners"
      },
      ...
    },
    {
      ...
      "entity": "user-example-service-account@example-project.s3ns.iam.gserviceaccount.com",
      "role": "OWNER",
      "email": "example-service-account@example-project.s3ns.iam.gserviceaccount.com",
      ...
    },
    {
      ...
      "entity": "group-gs-announce@googlegroups.com",
      "role": "READER",
      "email": "gs-announce@googlegroups.com",
      ...
    }
    ],
  "owner": {
    "entity": "user-example-service-account@example-project.s3ns.iam.gserviceaccount.com"
  },
  ...
}

Puoi anche utilizzare il metodo GET della risorsa objectAccessControls per restituire singole voci nell'ACL di un oggetto.

API XML

  1. Assicurati di disporre dell'autorizzazione FULL_CONTROL per il bucket o l'oggetto.

  2. Recupera l'ACL del bucket o dell'oggetto utilizzando il parametro della stringa di query acl in una richiesta GET Object.

Le ACL sono descritte in XML, allegato al corpo della risposta.

Ad esempio, per restituire l'ACL per l'oggetto paris.jpg nel bucket example-travel-maps:

curl -X GET -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    https://storage.s3nsapis.fr/example-travel-maps/paris.jpg?acl

Dovresti visualizzare una risposta simile alla seguente:

<?xml version="1.0" encoding="UTF-8"?>
<AccessControlList>
  <Owner>
    <ID>84fac329bceSAMPLE777d5d22b8SAMPLE77d85ac2SAMPLE2dfcf7c4adf34da46</ID>
    <Name>Owner Name</Name>
  </Owner>
  <Entries>
    <Entry>
      <Scope type="UserById">
        <ID>84fac329bceSAMPLE777d5d22b8SAMPLE77d85ac2SAMPLE2dfcf7c4adf34da46</ID>
        <Name>Name</Name>
      </Scope>
      <Permission>FULL_CONTROL</Permission>
    </Entry>
    <Entry>
      <Scope type="UserByEmail">
        <EmailAddress>example-service-account@example-project.s3ns.iam.gserviceaccount.com</EmailAddress>
        <Name>Jefferson</Name>
      </Scope>
      <Permission>FULL_CONTROL</Permission>
    </Entry>
  </Entries>
</AccessControlList>

Puoi anche utilizzare il metodo JSON GET della risorsa ObjectAccessControls per restituire una voce ACL specifica.

Passaggi successivi