Como criar e gerenciar listas de controle de acesso (ACLs, na sigla em inglês)

Nesta página, você aprenderá como controlar o acesso a intervalos e objetos usando listas de controle de acesso (ACLs, na sigla em inglês). As ACLs são um mecanismo que pode ser usado para definir quem tem acesso a intervalos e objetos, além do nível de acesso dessas pessoas. Para saber mais sobre ACLs, consulte a visão geral.

Para saber mais sobre outras maneiras de controlar o acesso a intervalos e objetos, leia este documento de visão geral.

Antes de começar

Você precisa usar ACLs?

Na maioria dos casos, o Cloud Identity and Access Management (Cloud IAM) é o método recomendado para controlar o acesso aos recursos, porque fornece controle de acesso de nível empresarial a todo o Google Cloud Platform e possibilita que as permissões concedidas a recursos primários, como projetos, sejam herdadas por recursos secundários, como intervalos e objetos. Consulte Como usar as permissões do Cloud IAM para orientações sobre como trabalhar com o Cloud IAM no Cloud Storage.

As ACLs podem ser usadas para personalizar o acesso a objetos individuais de um intervalo, porque as permissões do Cloud IAM são válidas para todos os objetos de um intervalo. No entanto, ainda é necessário usar o Cloud IAM para qualquer acesso comum a todos os objetos de um intervalo porque isso reduz os esforços de microgerenciamento.

Você precisa definir uma ACL?

Dependendo da permissão que você quer que um intervalo ou objeto tenha, talvez não seja necessário definir uma ACL. Os intervalos e objetos são criados com ACLs padrão que podem conter a permissão que você quer que o intervalo ou objeto tenha.

Use as orientações a seguir para decidir se você precisa definir uma ACL.

Em intervalos:

Console

Intervalos novos são criados com a ACL predefinida project-private. Se seu intervalo precisar de uma permissão diferente, defina uma ACL.

gsutil

Blocos novos são adicionados como project-private. Se seu intervalo precisar de uma permissão diferente, defina uma ACL.

API JSON

Por padrão, intervalos novos são adicionados como project-private. Se seu intervalo precisar de uma permissão diferente, defina uma ACL.

API XML

Blocos novos são adicionados como project-private. Se seu intervalo precisar de uma permissão diferente, defina uma ACL.

Conforme mencionado acima, cada intervalo tem uma ACL padrão que é aplicada a todos os objetos nesse intervalo sem uma ACL predefinida ou, se você estiver usando a API JSON, uma ACL especificada na solicitação. Saiba mais em ACLs padrão de objetos.

Em objetos:

Console

No momento do upload, os objetos recebem as mesmas ACLs que o objeto do intervalo, e o usuário que fez o upload é adicionado à ACL como proprietário. Se o objeto precisar de uma permissão diferente, defina uma ACL.

gsutil

Objetos novos são adicionados com a ACL padrão de objetos do intervalo. Ao copiar um objeto já armazenado na nuvem, é possível modificar esse comportamento com a opção -p.

API JSON

Por padrão, objetos novos são adicionados com a ACL padrão de objetos do intervalo.

API XML

Objetos novos são adicionados com a ACL padrão de objetos do intervalo.

Qual interface usar?

Veja nos exemplos a seguir como configurar o controle de acesso usando o Console do Google Cloud Platform, a ferramenta de linha de comando gsutil, as bibliotecas de cliente do Cloud Storage e as APIs XML e JSON. Use estas orientações para escolher qual opção usar:

  • O Console do GCP é adequado para quem não tem muita experiência com controle de acesso e quer apenas modificar as ACLs para objetos individuais.

  • A ferramenta gsutil é adequada para quem não tem muita experiência com controle de acesso e quer modificar ACLs para intervalos e objetos.

  • Se você já tem experiência com bibliotecas de cliente do Cloud Storage, use-as para gerenciar suas ACLs.

  • Para especificar ACLs usando uma API, é necessário ter experiência prévia com solicitações HTTP. É possível usar sua ferramenta ou aplicativo favorito para enviar as solicitações HTTP. Nos exemplos, usamos a ferramenta cURL (em inglês). É possível conseguir tokens de autorização para usar nos exemplos de cURL do OAuth 2.0 Playground (em inglês).

Como definir ACLs

A ferramenta ou API usada para definir e conseguir ACLs determina a sintaxe da ACL usada. As sintaxes de ACL são visualmente diferentes, mas contêm as mesmas informações: entradas que concedem permissões a escopos.

Console

  1. Acesse o navegador do Cloud Storage no Console do GCP.
    Acessar o navegador do Cloud Storage

  2. Navegue até o objeto com a ACL que você quer alterar.

  3. Selecione Editar permissões no menu suspenso do objeto.

    Será exibida uma caixa de diálogo de permissões semelhante a esta:

    Essa captura de tela mostra uma ACL com quatro entradas:

    • Na primeira entrada, todos os proprietários de um projeto específico (com o número de projeto 867489140601) recebem acesso ou permissão de Proprietário para o objeto.
    • Na segunda entrada, todos os editores de um projeto específico (com o número de projeto 867489140601) também recebem acesso/permissão de Proprietário para o objeto.
    • Na terceira entrada, todos os leitores de um projeto específico (com o número de projeto 867489140601) recebem acesso/permissão de Leitor para o objeto.
    • Na quarta entrada, o usuário que fez o upload do objeto recebe acesso/permissão "Proprietário" para o objeto. O usuário que faz o upload do objeto é sempre definido como Proprietário e não pode ser removido.
  4. Clique em Adicionar item.

  5. Escolha o tipo de Entidade que receberá a permissão.

    O campo de Entidade especifica o tipo de usuário que receberá a permissão, por exemplo, um usuário individual ou um grupo. Consulte Escopos de controle de acesso para ver a lista de valores aceitos em Entidade.

  6. Insira um valor em Nome.

    O campo Nome identifica o usuário, grupo ou outro tipo de entidade específico. Consulte Escopos de controle de acesso para ver a lista de valores aceitos em Nome.

    Juntos, Entidade e Nome definem quem recebe a permissão.

  7. Selecione um valor em Acesso.

    O campo Acesso define a permissão que você quer estabelecer no objeto. Consulte Permissões de controle de acesso para ver a lista de valores aceitos em Acesso.

  8. Clique em Salvar.

gsutil

Use gsutil acl para especificar ACLs:

  • Para especificar concessões individuais:

    gsutil acl ch -u [USER_EMAIL]:[PERMISSION] gs://[BUCKET_NAME]

  • Para especificar ACLs pré-configuradas:

    gsutil acl set [CANNED_ACL_NAME] gs://[BUCKET_NAME]

  • Para especificar ACLs no formato JSON:

    gsutil acl set [JSON_FILE] gs://[bucket-name]

    em que [JSON_FILE] contém ACLs especificadas no formato JSON.

Amostras de código

C++

Para mais informações, consulte a documentação de referência da API Cloud Storage para C++.

Veja na amostra a seguir como adicionar uma ACL a um intervalo:

namespace gcs = google::cloud::storage;
using ::google::cloud::StatusOr;
[](gcs::Client client, std::string bucket_name, std::string entity) {
  StatusOr<gcs::BucketAccessControl> patched_acl =
      client.PatchBucketAcl(bucket_name, entity,
                            gcs::BucketAccessControlPatchBuilder().set_role(
                                gcs::BucketAccessControl::ROLE_OWNER()));

  if (!patched_acl) {
    throw std::runtime_error(patched_acl.status().message());
  }

  std::cout << "ACL entry for " << patched_acl->entity() << " in bucket "
            << patched_acl->bucket() << " is now " << *patched_acl << "\n";
}

Veja na amostra a seguir como adicionar uma ACL a um objeto:

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

  if (!patched_acl) {
    throw std::runtime_error(patched_acl.status().message());
  }

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

C#

Para mais informações, consulte a documentação de referência da API Cloud Storage para C#.

Veja na amostra a seguir como adicionar uma ACL a um intervalo:

private void AddBucketOwner(string bucketName, string userEmail)
{
    var storage = StorageClient.Create();
    var bucket = storage.GetBucket(bucketName, new GetBucketOptions()
    {
        Projection = Projection.Full
    });
    if (null == bucket.Acl)
    {
        bucket.Acl = new List<BucketAccessControl>();
    }
    bucket.Acl.Add(new BucketAccessControl()
    {
        Bucket = bucketName,
        Entity = $"user-{userEmail}",
        Role = "OWNER",
    });
    var updatedBucket = storage.UpdateBucket(bucket, new UpdateBucketOptions()
    {
        // Avoid race conditions.
        IfMetagenerationMatch = bucket.Metageneration,
    });
}

Veja na amostra a seguir como adicionar uma ACL a um objeto:

private void AddObjectOwner(string bucketName, string objectName,
    string userEmail)
{
    var storage = StorageClient.Create();
    var storageObject = storage.GetObject(bucketName, objectName,
        new GetObjectOptions() { Projection = Projection.Full });
    if (null == storageObject.Acl)
    {
        storageObject.Acl = new List<ObjectAccessControl>();
    }
    storageObject.Acl.Add(new ObjectAccessControl()
    {
        Bucket = bucketName,
        Entity = $"user-{userEmail}",
        Role = "OWNER",
    });
    var updatedObject = storage.UpdateObject(storageObject, new UpdateObjectOptions()
    {
        // Avoid race conditions.
        IfMetagenerationMatch = storageObject.Metageneration,
    });
}

Go

Para mais informações, consulte a documentação de referência da API Cloud Storage para Go.

Veja na amostra a seguir como adicionar uma ACL a um intervalo:

func addBucketACL(client *storage.Client, bucket string) error {
	ctx := context.Background()

	acl := client.Bucket(bucket).ACL()
	if err := acl.Set(ctx, storage.AllAuthenticatedUsers, storage.RoleReader); err != nil {
		return err
	}
	return nil
}

Veja na amostra a seguir como adicionar uma ACL a um objeto:

func addObjectACL(client *storage.Client, bucket, object string) error {
	ctx := context.Background()

	acl := client.Bucket(bucket).Object(object).ACL()
	if err := acl.Set(ctx, storage.AllAuthenticatedUsers, storage.RoleReader); err != nil {
		return err
	}
	return nil
}

Java

Para mais informações, consulte a documentação de referência da API Cloud Storage para Java.

Veja na amostra a seguir como adicionar uma ACL a um intervalo:

Acl acl = storage.createAcl(bucketName, Acl.of(User.ofAllAuthenticatedUsers(), Role.READER));

Veja na amostra a seguir como adicionar uma ACL a um objeto:

BlobId blobId = BlobId.of(bucketName, blobName, blobGeneration);
Acl acl = storage.createAcl(blobId, Acl.of(User.ofAllAuthenticatedUsers(), Role.READER));

Node.js

Para mais informações, consulte a documentação de referência da API Cloud Storage para Node.js.

Veja na amostra a seguir como adicionar uma ACL a um intervalo:

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

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

/**
 * TODO(developer): Uncomment the following line before running the sample.
 */
// const bucketName = 'Name of a bucket, e.g. my-bucket';
// const userEmail = 'Email of user to add, e.g. developer@company.com';

// Makes the user an owner 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.owners.addUser(userEmail);

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

Veja na amostra a seguir como adicionar uma ACL a um objeto:

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

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

/**
 * TODO(developer): Uncomment the following line before running the sample.
 */
// const bucketName = 'Name of a bucket, e.g. my-bucket';
// const filename = 'Name of file to access, e.g. file.txt';
// const userEmail = 'Email of user to add, e.g. developer@company.com';

// Makes the user an owner of the file. 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)
  .file(filename)
  .acl.owners.addUser(userEmail);

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

PHP

Para mais informações, consulte a documentação de referência da API Cloud Storage para PHP.

Veja na amostra a seguir como adicionar uma ACL a um intervalo:

use Google\Cloud\Storage\StorageClient;

/**
 * Add an entity and role to a bucket's ACL.
 *
 * @param string $bucketName the name of your Cloud Storage bucket.
 * @param string $entity The entity to update access controls for.
 * @param string $role The permissions to add for the specified entity. May
 *        be one of 'OWNER', 'READER', or 'WRITER'.
 * @param array $options
 *
 * @return void
 */
function add_bucket_acl($bucketName, $entity, $role, $options = [])
{
    $storage = new StorageClient();
    $bucket = $storage->bucket($bucketName);
    $acl = $bucket->acl();
    $acl->add($entity, $role, $options);
    printf('Added %s (%s) to gs://%s ACL' . PHP_EOL, $entity, $role, $bucketName);
}

Veja na amostra a seguir como adicionar uma ACL a um objeto:

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.
 * @param string $objectName the name of your Cloud Storage object.
 * @param string $entity The entity to update access controls for.
 * @param string $role The permissions to add for the specified entity. May
 *        be one of 'OWNER', 'READER', or 'WRITER'.
 * @param array $options
 *
 * @return void
 */
function add_object_acl($bucketName, $objectName, $entity, $role, $options = [])
{
    $storage = new StorageClient();
    $bucket = $storage->bucket($bucketName);
    $object = $bucket->object($objectName);
    $acl = $object->acl();
    $acl->add($entity, $role, $options);
    printf('Added %s (%s) to gs://%s/%s ACL' . PHP_EOL, $entity, $role, $bucketName, $objectName);
}

Python

Para mais informações, consulte a documentação de referência da API Cloud Storage para Python.

Veja na amostra a seguir como adicionar uma ACL a um intervalo:

def add_bucket_owner(bucket_name, user_email):
    """Adds a user as an owner on the given bucket."""
    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.acl.user(user_email).grant_owner()
    bucket.acl.save()

    print('Added user {} as an owner on bucket {}.'.format(
        user_email, bucket_name))

Veja na amostra a seguir como adicionar uma ACL a um objeto:

def add_blob_owner(bucket_name, blob_name, user_email):
    """Adds a user as an owner on the given blob."""
    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))

Ruby

Para mais informações, consulte a documentação de referência da API Cloud Storage para Ruby.

Veja na amostra a seguir como adicionar uma ACL a um intervalo:

# project_id  = "Your Google Cloud project ID"
# bucket_name = "Your Google Cloud Storage bucket name"
# email       = "Google Cloud Storage ACL Entity email"

require "google/cloud/storage"

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

bucket.acl.add_owner email

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

Veja na amostra a seguir como adicionar uma ACL a um objeto:

# project_id  = "Your Google Cloud project ID"
# bucket_name = "Your Google Cloud Storage 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 project_id: project_id
bucket  = storage.bucket bucket_name
file    = bucket.file file_name

file.acl.add_owner email

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

API JSON

Ao criar um intervalo, é possível especificar a propriedade acl[] em uma solicitação insert. Em um intervalo atual, especifique a propriedade em uma solicitação patch ou solicitação update.

Ao criar um objeto, é possível especificar a propriedade acl[] no corpo da solicitação ou no parâmetro de consulta predefinedAcl em uma solicitação insert. Em um objeto atual, especifique a propriedade ou o parâmetro de consulta predefinedAcl em uma solicitação patch ou solicitação update.

Para definições das propriedades de ACL de intervalo e objeto, consulte os recursos BucketAccessControls e ObjectAccessControls, respectivamente.

Veja no exemplo a seguir diferentes entradas de ACL de intervalo.

"acl": [
{
"kind": "storage#bucketAccessControl",
"id": "example-bucket/project-owners-123412341234",
"selfLink": "https://www.googleapis.com/storage/v1/b/example-bucket/acl/project-owners-123412341234",
"bucket": "example-bucket",
"entity": "project-owners-123412341234",
"role": "OWNER",
"projectTeam": {
       "projectNumber": "123412341234",
       "team": "owners"
},
"etag": "CDk="
},
{
"kind": "storage#bucketAccessControl",
"id": "example-bucket/project-editors-123412341234",
"selfLink": "https://www.googleapis.com/storage/v1/b/example-bucket/acl/project-editors-123412341234",
"bucket": "example-bucket",
"entity": "project-editors-123412341234",
"role": "OWNER",
"projectTeam": {
     "projectNumber": "123412341234",
     "team": "editors"
},
"etag": "CDk="
},
{
"kind": "storage#bucketAccessControl",
"id": "example-bucket/project-viewers-123412341234",
"selfLink": "https://www.googleapis.com/storage/v1/b/example-bucket/acl/project-viewers-123412341234",
"bucket": "example-bucket",
"entity": "project-viewers-123412341234",
"role": "READER",
"projectTeam": {
     "projectNumber": "123412341234",
     "team": "viewers"
},
"etag": "CDk="
},
{
"kind": "storage#bucketAccessControl",
"id": "example-bucket/group-gs-announce@googlegroups.com",
"selfLink": "https://www.googleapis.com/storage/v1/b/example-bucket/acl/group-gs-announce@googlegroups.com",
"bucket": "example-bucket",
"entity": "group-gs-announce@googlegroups.com",
"role": "READER",
"email": "gs-announce@googlegroups.com",
"etag": "CDk="
},
{
"kind": "storage#bucketAccessControl",
"id": "example-bucket/user-jane@gmail.com",
"selfLink": "https://www.googleapis.com/storage/v1/b/example-bucket/acl/user-jane@gmail.com",
"bucket": "example-bucket",
"entity": "user-jane@gmail.com",
"role": "READER",
"email": "jane@gmail.com",
"etag": "CDk="
},
{
"kind": "storage#bucketAccessControl",
"id": "example-bucket/allUsers",
"selfLink": "https://www.googleapis.com/storage/v1/b/example-bucket/acl/allUsers",
"bucket": "example-bucket",
"entity": "allUsers",
"role": "READER",
"etag": "CDk="
},
{
"kind": "storage#bucketAccessControl",
"id": "example-bucket/allAuthenticatedUsers",
"selfLink": "https://www.googleapis.com/storage/v1/b/example-bucket/acl/allAuthenticatedUsers",
"bucket": "example-bucket",
"entity": "allAuthenticatedUsers",
"role": "READER",
"etag": "CDk="
}
]

API XML

Na API XML, as ACLs estão no formato XML. É necessário anexar um documento XML ao corpo das solicitações para alterar ACLs de intervalos e objetos. Quando são obtidas ACLs de intervalos e objetos, é retornado um documento XML. Esse documento contém as entradas individuais da ACL de intervalo ou de objeto.

  • Depois de criar um intervalo com uma solicitação PUT Bucket, use uma segunda solicitação PUT Bucket com o parâmetro ?acl para alterar a ACL do intervalo.

  • Depois de fazer upload de um objeto com uma solicitação PUT Object, altere a ACL com outra solicitação PUT usando o parâmetro ?acl ou o cabeçalho de solicitação x-googl-acl.

Use a sintaxe de ACL a seguir com a API XML.

Elemento Descrição
AccessControlList Contêiner para elementos Entries e Owner.
Owner Contêiner para elementos DisplayName e ID. Esse elemento não é necessário para objetos, porque um objeto é sempre propriedade do usuário que fez o upload. Esse elemento é usado quando a sintaxe de ACL do Amazon S3 é usada em um cenário de migração.

Amazon Simple Storage Service™ e Amazon S3™ são marcas registradas da Amazon.com, Inc. ou de suas afiliadas nos Estados Unidos e/ou em outros países.
ID ID do proprietário do intervalo no Google Cloud Storage.
DisplayName Não implementado no momento. O valor é sempre uma string vazia.
Entries Contêiner para nenhum ou mais elementos Entry.
Entry Contêiner para elementos Scope e Permission. É necessário que um elemento Entry contenha apenas um Scope e um Permission.
Scope Contêiner para um elemento ID, EmailAddress ou Domain que define o escopo da ACL. Esse elemento precisa ter um atributo type que contenha um dos seguintes valores: UserByID, UserByEmail, GroupByID, GroupByEmail, GroupByDomain, AllUsers ou AllAuthenticatedUsers.
ID Identificador do beneficiário quando a entrada de permissão é especificada por ID.
EmailAddress Identificador do e-mail do beneficiário quando a entrada de permissão é especificada por e-mail.
Domain Identificador do domínio do beneficiário quando a entrada de permissão é especificada por domínio.
Name Elemento opcional que pode ser especificado ou automaticamente adicionado, se o escopo for UserByEmail ou GroupByEmail.
Permission Permissão concedida: READ, WRITE ou FULL_CONTROL.

Lembre-se dos pontos a seguir ao trabalhar com ACLs usando a API XML:

  • Apenas o formato XML descrito acima pode ser usado.
  • Não é possível definir escopos duplicados.

    É possível ter muitas entradas no XML da ACL, mas não entradas com escopos duplicados. Por exemplo, não é possível ter duas entradas com o mesmo elemento de escopo de jane@example.com.

No exemplo a seguir, veja entradas diferentes de ACL de intervalo:

<?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="GroupById">
        <ID>00b4903a9723...</ID>
      </Scope>
      <Permission>FULL_CONTROL</Permission>
    </Entry>
    <Entry>
      <Scope type="GroupById">
        <ID>00b4903a9724...</ID>
      </Scope>
      <Permission>READ</Permission>
    </Entry>
    <Entry>
      <Scope type="GroupByDomain">
        <Domain>example.com</Domain>
      </Scope>
      <Permission>READ</Permission>
    </Entry>
    <Entry>
      <Scope type="GroupByEmail">
        <EmailAddress>gs-announce@googlegroups.com</EmailAddress>
      </Scope>
      <Permission>READ</Permission>
    </Entry>
    <Entry>
      <Scope type="UserByEmail">
        <EmailAddress>jane@gmail.com</EmailAddress>
        <Name>jane</Name>
      </Scope>
      <Permission>READ</Permission>
    </Entry>
    <Entry>
      <Scope type="AllUsers"/>
      <Permission>READ</Permission>
    </Entry>
    <Entry>
      <Scope type="AllAuthenticatedUsers"/>
      <Permission>READ</Permission>
    </Entry>
</Entries>
</AccessControlList>

Como configurar o elemento Name no XML da ACL

Quando uma ACL é recuperada de um intervalo ou objeto, algumas entradas podem ter um elemento <Name> extra anexado. Por exemplo, talvez haja uma entrada semelhante a esta:

<Entry>
    <Scope type="UserByEmail">
      <EmailAddress>jane@gmail.com</EmailAddress>
      <Name>Jane</Name>
    </Scope>
    <Permission>FULL_CONTROL</Permission>
</Entry>

Esses elementos <Name> opcionais são preenchidos em duas circunstâncias:

  1. Quando as ACLs de intervalo ou objeto incluem <Name> como um elemento.

    Ao definir as ACLs, é possível incluir o elemento <Name> com as entradas de ACL. É possível fornecer qualquer valor no elemento <Name>. O Cloud Storage se lembrará desses valores até que a ACL seja removida ou substituída. Isso pode ser útil ao usar identificadores difíceis de serem reconhecidos, como IDs do Google Cloud Storage.

  2. Quando um escopo UserByEmail ou GroupByEmail contém um perfil público do Google.

    Se um desses escopos for usado sem um elemento <Name>, o Cloud Storage verificará se o usuário ou o grupo do Google associado ao endereço de e-mail tem um perfil público do Google com um nome público. Nesse caso, o Cloud Storage preencherá automaticamente o elemento <Name> com o nome público.

Como aplicar uma ACL predefinida

Em vez de especificar toda a ACL, uma entrada por vez (conforme mostrado acima), é possível usar uma ACL predefinida, que aplicará automaticamente várias entradas personalizadas a um cenário específico. É possível aplicar uma ACL predefinida a um intervalo ou a um objeto usando a gsutil, a API JSON ou a API XML.

Em objetos novos

Siga estas etapas para aplicar uma ACL predefinida a um objeto durante o upload:

Console

Não é possível aplicar uma ACL predefinida usando o Console do GCP. Use a gsutil.

gsutil

Use a opção -a com o comando gsutil cp para aplicar a ACL predefinida:

gsutil cp -a [PREDEFINED_ACL] [OBJECT] gs://[BUCKET_NAME]

Por exemplo, para aplicar a ACL predefinida bucket-owner-read durante o upload do objeto paris.jpg para o intervalo example-travel-maps:

gsutil cp -a bucket-owner-read paris.jpg gs://example-travel-maps

API JSON

Use o parâmetro de string de consulta predefinedAcl em uma solicitação insert para aplicar a ACL predefinida.

Por exemplo, para aplicar a ACL predefinida bucketOwnerRead durante o upload do objeto paris.jpg para o intervalo example-travel-maps:

curl -X POST --data-binary @paris.jpg -H "Content-Type: image/jpeg" 
-H "Authorization: Bearer ya29.AHES6ZRVmB7fkLtd1XTmq6mo0S1wqZZi3-Lh_s-6Uw7p8vtgSwg"
"https://www.googleapis.com/upload/storage/v1/b/example-travel-maps/o?name=paris.jpg&predefinedAcl=bucketOwnerRead"

A solicitação será semelhante ao exemplo a seguir:

POST /upload/storage/v1/b/example-travel-maps/o?name=paris.jpg&amppredefinedAcl=bucketOwnerRead HTTP/1.1
Host: www.googleapis.com
Content-Type: image/jpeg
Authorization: Bearer ya29.AHES6ZRVmB7fkLtd1XTmq6mo0S1wqZZi3-Lh_s-6Uw7p8vtgSwg
Content-Length: 12345
Date: Fri, 10 Oct 2014 00:02:38 GMT

API XML

Use o cabeçalho x-goog-acl em uma solicitação Put Object para aplicar a ACL predefinida.

Por exemplo, para aplicar a ACL predefinida bucket-owner-read durante o upload do objeto paris.jpg para o intervalo example-travel-maps:

curl -X PUT --upload-file paris.jpg -H "x-goog-acl: bucket-owner-read" 
-H "Authorization: Bearer ya29.AHES6ZRVmB7fkLtd1XTmq6mo0S1wqZZi3-Lh_s-6Uw7p8vtgSwg"
https://storage.googleapis.com/example-travel-maps/paris.jpg

A solicitação será semelhante ao exemplo a seguir:

PUT /paris.jpg HTTP/1.1
Host: example-travel-maps.storage.googleapis.com
Date: Thu, 09 Oct 2014 23:06:08 GMT
Content-Length: 12345
Content-Type: image/jpg
x-goog-acl: bucket-owner-read
Authorization: Bearer ya29.AHES6ZRVmB7fkLtd1XTmq6mo0S1wqZZi3-Lh_s-6Uw7p8vtgSwg
 
12345 bytes in entity body

Em intervalos ou objetos atuais

Também é possível aplicar uma ACL predefinida a um intervalo ou objeto atual, o que é útil para mudar de uma ACL predefinida para outra ou atualizar ACLs personalizadas para uma predefinida.

Console

Não é possível aplicar uma ACL predefinida usando o Console do GCP. Use a gsutil.

gsutil

Use o comando gsutil acl set para aplicar a ACL predefinida:

gsutil acl set [PREDEFINED_ACL] gs://[BUCKET_NAME]/[OBJECT_NAME]

Por exemplo, para aplicar a ACL predefinida private ao objeto paris.jpg no intervalo example-travel-maps:

gsutil acl set private gs://example-travel-maps/paris.jpg

API JSON

Use o parâmetro de string de consulta predefinedAcl e especifique uma propriedade acl vazia em uma solicitação patch para aplicar a ACL predefinida.

Por exemplo, para aplicar a ACL predefinida private ao objeto paris.jpg no intervalo example-travel-maps:

curl -X PATCH --data '{"acl": []}'  -H "Content-Type: application/json" 
-H "Authorization: Bearer ya29.AHES6ZRVmB7fkLtd1XTmq6mo0S1wqZZi3-Lh_s-6Uw7p8vtgSwg"
https://www.googleapis.com/storage/v1/b/example-travel-maps/o/paris.jpg?predefinedAcl=private

A solicitação será semelhante ao exemplo a seguir:

PATCH /storage/v1/b/example-travel-maps/o/paris.jpg?predefinedAcl=private HTTP/1.1
Host: www.googleapis.com
Content-Type: application/json
Authorization: Bearer ya29.AHES6ZRVmB7fkLtd1XTmq6mo0S1wqZZi3-Lh_s-6Uw7p8vtgSwg
Content-Length: 11
Date: Fri, 10 Oct 2014 18:57:59 GMT

API XML

Use o cabeçalho x-goog-acl com o parâmetro de string de consulta acl em uma solicitação Put Object, mas não inclua um documento XML nela.

Por exemplo, para aplicar a ACL predefinida private ao objeto paris.jpg no intervalo example-travel-maps:

curl -X PUT -H "Content-Length: 0" 
-H "Authorization: Bearer ya29.AHES6ZRVmB7fkLtd1XTmq6mo0S1wqZZi3-Lh_s-6Uw7p8vtgSwg"
-H "x-goog-acl: private" https://storage.googleapis.com/example-travel-maps/paris.jpg?acl

A solicitação será semelhante ao exemplo a seguir:

PUT /paris.jpg?acl HTTP/1.1
Host: example-travel-maps.storage.googleapis.com
Date: Thu, 09 Oct 2014 23:14:59 GMT
Content-Length: 0
x-goog-acl: private
Authorization: Bearer ya29.AHES6ZRVmB7fkLtd1XTmq6mo0S1wqZZi3-Lh_s-6Uw7p8vtgSwg
 
empty entity body

Como definir ACLs padrão de objetos

Para que não seja necessário definir as ACLs toda vez que criar um novo objeto, é possível definir uma ACL padrão de objetos em um intervalo. Depois disso, cada novo objeto adicionado a esse intervalo sem uma ACL aplicada explicitamente passará a usar a ACL padrão. Por exemplo, isso pode ser usado para especificar que apenas um determinado grupo de usuários tenha acesso à maioria dos objetos em um determinado intervalo. É possível alterar a ACL padrão de objetos e, em seguida, adicionar objetos ao intervalo. A ACL padrão de objetos especificada será automaticamente aplicada a esses objetos adicionados, mas é possível atribuir diferentes ACLs a objetos específicos. Nesse caso, a ACL padrão não será aplicada a esses objetos.

Para visualizar e alterar a ACL padrão de objetos de um intervalo:

Console

Não é possível definir ACLs padrão de objetos usando o Console do GCP. Use a gsutil.

gsutil

  1. Use gsutil defacl para recuperar a ACL padrão de objetos:

    gsutil defacl get gs://[BUCKET_NAME]

  2. Use gsutil defacl ch ou gsutil defacl set para modificar a ACL padrão de objetos.

    Por exemplo, o comando a seguir adiciona jane@gmail.com à ACL padrão de objetos do intervalo example-travel-maps:

    gsutil defacl ch -u jane@gmail.com:READER gs://example-travel-maps

    Também é possível especificar a ACL padrão de objetos usando um arquivo. Para mais informações, consulte a ajuda de gsutil defacl.

Amostras de código

C++

Para mais informações, consulte a documentação de referência da API Cloud Storage para C++.

Veja na amostra a seguir como adicionar uma ACL padrão de objetos a um intervalo:

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

  if (!default_object_acl) {
    throw std::runtime_error(default_object_acl.status().message());
  }

  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";
}

Veja na amostra a seguir como excluir uma ACL padrão de objetos de um intervalo:

namespace gcs = google::cloud::storage;
[](gcs::Client client, std::string bucket_name, std::string 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#

Para mais informações, consulte a documentação de referência da API Cloud Storage para C#.

Veja na amostra a seguir como adicionar uma ACL padrão de objetos a um intervalo:

private void AddBucketDefaultOwner(string bucketName, string userEmail)
{
    var storage = StorageClient.Create();
    var bucket = storage.GetBucket(bucketName, new GetBucketOptions()
    {
        Projection = Projection.Full
    });
    if (null == bucket.Acl)
    {
        bucket.Acl = new List<BucketAccessControl>();
    }
    if (null == bucket.DefaultObjectAcl)
    {
        bucket.DefaultObjectAcl = new List<ObjectAccessControl>();
    }
    bucket.DefaultObjectAcl.Add(new ObjectAccessControl()
    {
        Bucket = bucketName,
        Entity = $"user-{userEmail}",
        Role = "OWNER",
    });
    var updatedBucket = storage.UpdateBucket(bucket, new UpdateBucketOptions()
    {
        // Avoid race conditions.
        IfMetagenerationMatch = bucket.Metageneration,
    });
}

Veja na amostra a seguir como excluir uma ACL padrão de objetos de um intervalo:

private void RemoveBucketDefaultOwner(string bucketName, string userEmail)
{
    var storage = StorageClient.Create();
    var bucket = storage.GetBucket(bucketName, new GetBucketOptions()
    {
        Projection = Projection.Full
    });
    if (null == bucket.DefaultObjectAcl)
        return;
    if (null == bucket.Acl)
    {
        bucket.Acl = new List<BucketAccessControl>();
    }
    bucket.DefaultObjectAcl = bucket.DefaultObjectAcl.Where((acl) =>
         !(acl.Entity == $"user-{userEmail}" && acl.Role == "OWNER")
        ).ToList();
    var updatedBucket = storage.UpdateBucket(bucket, new UpdateBucketOptions()
    {
        // Avoid race conditions.
        IfMetagenerationMatch = bucket.Metageneration,
    });
}

Go

Para mais informações, consulte a documentação de referência da API Cloud Storage para Go.

Veja na amostra a seguir como adicionar uma ACL padrão de objetos a um intervalo:

func addDefaultBucketACL(client *storage.Client, bucket string) error {
	ctx := context.Background()

	acl := client.Bucket(bucket).DefaultObjectACL()
	if err := acl.Set(ctx, storage.AllAuthenticatedUsers, storage.RoleReader); err != nil {
		return err
	}
	return nil
}

Veja na amostra a seguir como excluir uma ACL padrão de objetos de um intervalo:

func deleteDefaultBucketACL(client *storage.Client, bucket string) error {
	ctx := context.Background()

	acl := client.Bucket(bucket).DefaultObjectACL()
	if err := acl.Delete(ctx, storage.AllAuthenticatedUsers); err != nil {
		return err
	}
	return nil
}

Java

Para mais informações, consulte a documentação de referência da API Cloud Storage para Java.

Veja na amostra a seguir como adicionar uma ACL padrão de objetos a um intervalo:

Acl acl =
    storage.createDefaultAcl(bucketName, Acl.of(User.ofAllAuthenticatedUsers(), Role.READER));

Veja na amostra a seguir como excluir uma ACL padrão de objetos de um intervalo:

boolean deleted = storage.deleteDefaultAcl(bucketName, User.ofAllAuthenticatedUsers());
if (deleted) {
  // the acl entry was deleted
} else {
  // the acl entry was not found
}

Node.js

Para mais informações, consulte a documentação de referência da API Cloud Storage para Node.js.

Veja na amostra a seguir como adicionar uma ACL padrão de objetos a um intervalo:

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

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

/**
 * TODO(developer): Uncomment the following line before running the sample.
 */
// const bucketName = 'Name of a bucket, e.g. my-bucket';
// const userEmail = 'Email of user to add, e.g. developer@company.com';

// 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}.`);

Veja na amostra a seguir como excluir uma ACL padrão de objetos de um intervalo:

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

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

/**
 * TODO(developer): Uncomment the following line before running the sample.
 */
// const bucketName = 'Name of a bucket, e.g. my-bucket';
// const userEmail = 'Email of user to remove, e.g. developer@company.com';

// 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}.`);

PHP

Para mais informações, consulte a documentação de referência da API Cloud Storage para PHP.

Veja na amostra a seguir como adicionar uma ACL padrão de objetos a um intervalo:

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.
 * @param string $entity The entity to update access controls for.
 * @param string $role The permissions to add for the specified entity. May
 *        be one of 'OWNER', 'READER', or 'WRITER'.
 * @param array $options
 *
 * @return void
 */
function add_bucket_default_acl($bucketName, $entity, $role, $options = [])
{
    $storage = new StorageClient();
    $bucket = $storage->bucket($bucketName);
    $acl = $bucket->defaultAcl();
    $acl->add($entity, $role, $options);
    printf('Added %s (%s) to gs://%s default ACL' . PHP_EOL, $entity, $role, $bucketName);
}

Veja na amostra a seguir como excluir uma ACL padrão de objetos de um intervalo:

use Google\Cloud\Storage\StorageClient;

/**
 * Delete an entity from a bucket's default ACL.
 *
 * @param string $bucketName the name of your Cloud Storage bucket.
 * @param string $entity the name of the entity to remove from the ACL.
 * @param array $options
 *
 * @return void
 */
function delete_bucket_default_acl($bucketName, $entity, $options = [])
{
    $storage = new StorageClient();
    $bucket = $storage->bucket($bucketName);
    $acl = $bucket->defaultAcl();
    $acl->delete($entity, $options);
    printf('Deleted %s from gs://%s default ACL' . PHP_EOL, $entity, $bucketName);
}

Python

Para mais informações, consulte a documentação de referência da API Cloud Storage para Python.

Veja na amostra a seguir como adicionar uma ACL padrão de objetos a um intervalo:

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."""
    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))

Veja na amostra a seguir como excluir uma ACL padrão de objetos de um intervalo:

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."""
    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('Removed user {} from the default acl of bucket {}.'.format(
        user_email, bucket_name))

Ruby

Para mais informações, consulte a documentação de referência da API Cloud Storage para Ruby.

Veja na amostra a seguir como adicionar uma ACL padrão de objetos a um intervalo:

# project_id  = "Your Google Cloud project ID"
# bucket_name = "Your Google Cloud Storage bucket name"
# email       = "Google Cloud Storage ACL Entity email"

require "google/cloud/storage"

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

bucket.default_acl.add_owner email

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

Veja na amostra a seguir como excluir uma ACL padrão de objetos de um intervalo:

# project_id  = "Your Google Cloud project ID"
# bucket_name = "Your Google Cloud Storage bucket name"
# email       = "Google Cloud Storage ACL Entity email"

require "google/cloud/storage"

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

bucket.default_acl.delete email

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

API JSON

  1. Recupere a ACL padrão de objetos por meio de uma solicitação GET. Por exemplo:

    curl -X GET -H "Authorization: Bearer [OAUTH2_TOKEN]" 
    https://www.googleapis.com/storage/v1/b/[BUCKET_NAME]?projection=full

  2. Use uma solicitação patch para substituir a ACL padrão de objetos. Por exemplo, a solicitação a seguir substitui a ACL padrão de objetos por outra especificada em defacls.json no intervalo example-travel-maps:

    curl -X PATCH --data @defacls.json -H "Content-Type: application/json" -H "Authorization: Bearer [OAUTH2_TOKEN]" 
    https://www.googleapis.com/storage/v1/b/example-travel-maps

    Um exemplo de defacls.json:

    {
    "defaultObjectAcl": [
    {
    "email": "jane@gmail.com",
    "entity": "user-jane@gmail.com",
    "role": "READER"
    }
    ]
    }

API XML

  1. Recupere a ACL padrão de objetos com uma solicitação GET no escopo do intervalo e do parâmetro ?defaultObjectAcl. Por exemplo:

    curl -X GET -H "Authorization: Bearer [OAUTH2_TOKEN]" 
    https://storage.googleapis.com/[BUCKET_NAME]?defaultObjectAcl

  2. Use uma solicitação PUT no escopo do intervalo com o parâmetro ?defaultObjectAcl para substituir a ACL padrão de objetos pela especificada em acls.xml. Por exemplo:

    curl -X PUT --data-binary @acls.xml -H "Authorization: Bearer [OAUTH2_TOKEN]" 
    http://storage.googleapis.com/[BUCKET_NAME]?defaultObjectAcl

    Um exemplo de acls.xml:

    <AccessControlList>
    <Entries>
    <Entry>
    <Permission>FULL_CONTROL</Permission>
    <Scope type="GroupByEmail">
    <EmailAddress>travel-companions@googlegroups.com</EmailAddress>
    </Scope>
    </Entry>
    </Entries>
    </AccessControlList>

A sintaxe das ACLs é discutida em Como definir ACLs. Também é possível especificar uma ACL predefinida como a ACL padrão de objetos.

Para definir uma ACL predefinida como a ACL padrão de objetos em um intervalo:

Console

Não é possível definir ACLs padrão de objetos usando o Console do GCP. Use a gsutil.

gsutil

Use o comando gsutil defacl com o nome da ACL predefinida.

Por exemplo, para definir a ACL padrão de objetos como project-private para o intervalo example-travel-maps:

gsutil defacl set project-private gs://example-travel-maps

API JSON

Use uma solicitação PUT e o parâmetro predefinedAcl.

Por exemplo:

curl -X PUT -H "Content-Length: 0" -H "Authorization: Bearer [OAUTH2_TOKEN]" 
https://www.googleapis.com/storage/v1/b/[BUCKET_NAME]?predefinedAcl=private

API XML

Use uma solicitação PUT no escopo do intervalo com o parâmetro ?defaultObjectAcl e o cabeçalho x-goog-acl.

Por exemplo:

curl -X PUT -H "x-goog-acl: project-private" -H "Content-Length: 0" -H "Authorization: Bearer [OAUTH2_TOKEN]" 
http://storage.googleapis.com/[BUCKET_NAME]?defaultObjectAcl

ACLs padrão de objetos para um intervalo recém-criado:

As ACLs padrão de objetos para um intervalo recém-criado são mostradas abaixo. Compare-as com as ACLs padrão de objetos do intervalo para ver se estas foram modificadas.

Console

Não é possível trabalhar com ACLs padrão de objetos usando o Console do GCP. Use a gsutil.

gsutil

No exemplo abaixo, o ID do projeto é "123412341234". O ID do seu projeto será diferente.

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

API JSON

No exemplo abaixo, o ID do projeto é "123412341234". O ID do seu projeto será diferente.

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

No exemplo abaixo, os IDs de papel do projeto começam com "00b4903a97...". Os IDs do seu projeto serão diferentes.

<?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>

Observe que a ACL padrão de objetos de um intervalo recém-criado é equivalente à ACL predefinida projectPrivate.

Como recuperar ACLs

Para receber a ACL de um intervalo ou objeto atual:

Console

  1. Acesse o navegador do Cloud Storage no Console do GCP.
    Acessar o navegador do Cloud Storage

  2. Navegue até o objeto com a ACL que você quer visualizar.

  3. Selecione Editar permissões no menu suspenso do objeto.

    Será exibida uma caixa de diálogo com as permissões do objeto.

gsutil

Use gsutil acl get para retornar a ACL de um objeto.

Por exemplo, para retornar a ACL do objeto paris.jpg no intervalo example-travel-maps:

gsutil acl get gs://example-travel-maps/paris.jpg

Exemplo de resposta:

[
{
    "entity": "project-owners-123412341234",
    "projectTeam": {
      "projectNumber": "123412341234",
      "team": "owners"
    },
    "role": "OWNER"
},
{
    "entity": "project-editors-123412341234",
    "projectTeam": {
      "projectNumber": "123412341234",
      "team": "editors"
    },
    "role": "OWNER"
},
{
    "entity": "project-viewers-123412341234",
    "projectTeam": {
      "projectNumber": "123412341234",
      "team": "viewers"
    },
    "role": "READER"
},
{
    "email": "gs-announce@googlegroups.com",
    "entity": "group-gs-announce@googlegroups.com",
    "role": "READER"
},
{
    "email": "jane@gmail.com",
    "entity": "user-jane@gmail.com",
    "role": "READER"
},
{
    "entity": "allUsers",
    "role": "READER"
},
{
    "entity": "allAuthenticatedUsers",
    "role": "READER"
}
]

Para retornar a ACL de um intervalo:

gsutil acl get gs://[BUCKET_NAME]

Quando a gsutil retorna ACLs de intervalos e objetos com gsutil acl get, elas estão no mesmo formato JSON que pode ser usado para defini-las. As ACLs no formato JSON usam os nomes de propriedade da API JSON, como entity e role.

Consulte a sintaxe da API JSON para mais informações sobre como interpretar a saída ou executar gsutil help acls.

Amostras de código

C++

Para mais informações, consulte a documentação de referência da API Cloud Storage para C++.

Veja na amostra a seguir como retornar uma ACL de intervalo:

namespace gcs = google::cloud::storage;
using ::google::cloud::StatusOr;
[](gcs::Client client, std::string bucket_name) {
  StatusOr<std::vector<gcs::BucketAccessControl>> items =
      client.ListBucketAcl(bucket_name);

  if (!items) {
    throw std::runtime_error(items.status().message());
  }

  std::cout << "ACLs for bucket=" << bucket_name << "\n";
  for (gcs::BucketAccessControl const& acl : *items) {
    std::cout << acl.role() << ":" << acl.entity() << "\n";
  }
}

Veja na amostra a seguir como retornar uma ACL de objeto:

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

  if (!items) {
    throw std::runtime_error(items.status().message());
  }

  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#

Para mais informações, consulte a documentação de referência da API Cloud Storage para C#.

Veja na amostra a seguir como retornar uma ACL de intervalo:

private void PrintBucketAcl(string bucketName)
{
    var storage = StorageClient.Create();
    var bucket = storage.GetBucket(bucketName, new GetBucketOptions()
    {
        Projection = Projection.Full
    });
    if (bucket.Acl != null)
        foreach (var acl in bucket.Acl)
        {
            Console.WriteLine($"{acl.Role}:{acl.Entity}");
        }
}

Veja na amostra a seguir como retornar uma ACL de objeto:

private void PrintObjectAcl(string bucketName, string objectName)
{
    var storage = StorageClient.Create();
    var storageObject = storage.GetObject(bucketName, objectName,
        new GetObjectOptions() { Projection = Projection.Full });
    if (storageObject.Acl != null)
    {
        foreach (var acl in storageObject.Acl)
        {
            Console.WriteLine($"{acl.Role}:{acl.Entity}");
        }
    }
}

Go

Para mais informações, consulte a documentação de referência da API Cloud Storage para Go.

Veja na amostra a seguir como retornar uma ACL de intervalo:

func bucketACL(client *storage.Client, bucket string) error {
	ctx := context.Background()

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

Veja na amostra a seguir como retornar uma ACL de objeto:

func objectACL(client *storage.Client, bucket, object string) error {
	ctx := context.Background()

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

Java

Para mais informações, consulte a documentação de referência da API Cloud Storage para Java.

Veja na amostra a seguir como retornar uma ACL de intervalo:

Acl acl = storage.getAcl(bucketName, User.ofAllAuthenticatedUsers());

Veja na amostra a seguir como retornar uma ACL de objeto:

BlobId blobId = BlobId.of(bucketName, blobName, blobGeneration);
Acl acl = storage.getAcl(blobId, User.ofAllAuthenticatedUsers());

Node.js

Para mais informações, consulte a documentação de referência da API Cloud Storage para Node.js.

Veja na amostra a seguir como retornar uma ACL de intervalo:

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

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

/**
 * TODO(developer): Uncomment the following line before running the sample.
 */
// const bucketName = 'Name of a bucket, e.g. my-bucket';

// Gets the ACL for the bucket
const [acls] = await storage.bucket(bucketName).acl.get();

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

Veja na amostra a seguir como retornar uma ACL de objeto:

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

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

/**
 * TODO(developer): Uncomment the following line before running the sample.
 */
// const bucketName = 'Name of a bucket, e.g. my-bucket';
// const filename = 'File to access, e.g. file.txt';

// 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}`);
});

PHP

Para mais informações, consulte a documentação de referência da API Cloud Storage para PHP.

Veja na amostra a seguir como retornar uma ACL de intervalo:

use Google\Cloud\Storage\StorageClient;

/**
 * Print all entities and roles for a bucket's ACL.
 *
 * @param string $bucketName the name of your Cloud Storage bucket.
 *
 * @return Google\Cloud\Storage\Acl the ACL for the Cloud Storage bucket.
 */
function get_bucket_acl($bucketName)
{
    $storage = new StorageClient();
    $bucket = $storage->bucket($bucketName);
    $acl = $bucket->acl();
    foreach ($acl->get() as $item) {
        printf('%s: %s' . PHP_EOL, $item['entity'], $item['role']);
    }
}

Veja na amostra a seguir como retornar uma ACL de objeto:

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.
 * @param string $objectName the name of your Cloud Storage object.
 *
 * @return void
 */
function get_object_acl($bucketName, $objectName)
{
    $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

Para mais informações, consulte a documentação de referência da API Cloud Storage para Python.

Veja na amostra a seguir como retornar uma ACL de intervalo:

def print_bucket_acl(bucket_name):
    """Prints out a bucket's access control list."""
    storage_client = storage.Client()
    bucket = storage_client.bucket(bucket_name)

    for entry in bucket.acl:
        print('{}: {}'.format(entry['role'], entry['entity']))

Veja na amostra a seguir como retornar uma ACL de objeto:

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('{}: {}'.format(entry['role'], entry['entity']))

Ruby

Para mais informações, consulte a documentação de referência da API Cloud Storage para Ruby.

Veja na amostra a seguir como retornar uma ACL de intervalo:

# project_id  = "Your Google Cloud project ID"
# bucket_name = "Your Google Cloud Storage bucket name"

require "google/cloud/storage"

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

puts "ACL for #{bucket_name}:"

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

bucket.acl.writers.each do |writer|
  puts "WRITER #{writer}"
end

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

Veja na amostra a seguir como retornar uma ACL de objeto:

# project_id  = "Your Google Cloud project ID"
# bucket_name = "Your Google Cloud Storage 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 project_id: project_id
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

API JSON

  1. Verifique se você tem a permissão OWNER no intervalo ou objeto.

  2. Recupere a ACL do intervalo ou do objeto com uma solicitação GET.

    A ACL de objeto é retornada no formato JSON, anexada ao corpo da resposta.

Por exemplo, para retornar a ACL do objeto paris.jpg no intervalo example-travel-maps:

curl -X GET -H "Authorization: Bearer ya29.AHES6ZRVmB7fkLtd1XTmq6mo0S1wqZZi3-Lh_s-6Uw7p8vtgSwg" 
https://www.googleapis.com/storage/v1/b/example-travel-maps/o/paris.jpg?projection=full

Você verá uma resposta semelhante a esta:

{
"kind": "storage#object",
"id": "example-travel-maps/paris.jpg/1412805837131000",
"selfLink": "https://www.googleapis.com/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-jane@gmail.com",
"role": "OWNER",
"email": "jane@gmail.com",
...
},
{
...
"entity": "group-gs-announce@googlegroups.com",
"role": "READER",
"email": "gs-announce@googlegroups.com",
...
}
],
"owner": {
"entity": "user-jane@gmail.com"
},
...
}

Você também pode usar o método GET do recurso objectAccessControls para retornar entradas individuais na ACL de um objeto.

API XML

  1. Verifique se você tem a permissão FULL_CONTROL no intervalo ou objeto.

  2. Recupere a ACL do intervalo ou objeto usando o parâmetro de string de consulta acl em uma solicitação GET Object.

As ACLs são descritas em XML, anexadas ao corpo da resposta.

Por exemplo, para retornar a ACL do objeto paris.jpg no intervalo example-travel-maps:

curl -X GET -H "Authorization: Bearer ya29.AHES6ZRVmB7fkLtd1XTmq6mo0S1wqZZi3-Lh_s-6Uw7p8vtgSwg" 
https://storage.googleapis.com/example-travel-maps/paris.jpg?acl

Você verá uma resposta semelhante a esta:

<?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>jane@gmail.com</EmailAddress>
    <Name>Jane</Name>
  </Scope>
  <Permission>FULL_CONTROL</Permission>
</Entry>
<Entry>
  <Scope type="GroupByEmail">
    <EmailAddress>gs-announce@googlegroups.com</EmailAddress>
  </Scope>
  <Permission>READ</Permission>
</Entry>
</Entries>
</AccessControlList>

Também é possível usar o método GET em JSON do recurso ObjectAccessControls para retornar uma entrada de ACL específica.

Como alterar ACLs

Para alterar a ACL de um objeto ou intervalo atual:

Console

  1. Acesse o navegador do Cloud Storage no Console do GCP.
    Acessar o navegador do Cloud Storage

  2. Navegue até o objeto com a ACL que você quer alterar.

  3. Selecione Editar permissões no menu suspenso do objeto.

    Será exibida uma caixa de diálogo com as permissões do objeto.

O exemplo a seguir mostra como conceder a permissão OWNER à usuária jane@gmail.com e a permissãoREADER aos membros do grupo gs-announce no objeto paris.jpg:

Como configurar uma ACL no objeto paris.jpg.

gsutil

  1. Defina as ACLs em um arquivo.

  2. Transmita o arquivo de ACLs para gsutil acl set e especifique para que objeto as ACLs serão definidas.

Por exemplo, para aplicar as ACLs do arquivo acls.txt em um objeto chamado paris.jpg no intervalo example-travel-maps:

gsutil acl set acl.txt gs://example-travel-maps/paris.jpg

O conteúdo de acl.txt é mostrado abaixo. Essas ACLs concedem aos proprietários do projeto 867489160491 e à usuária jane@gmail.com a permissão OWNER no objeto paris.jpg. Elas também concedem aos membros do grupo gs-announce a permissão READER nesse objeto:

[
{
"entity": "project-owners-867489160491",
"role": "OWNER",
"projectTeam": {
    "projectNumber": "867489160491",
    "team": "owners"
},
},
{
"entity": "user-jane@gmail.com",
"email": "jane@gmail.com",
"role": "OWNER"
},
{
"entity": "group-gs-announce@googlegroups.com",
"email": "gs-announce@googlegroups.com",
"role": "READER"
}
]

Além disso, é possível definir a mesma ACL desse objeto para conceder permissões individuais. Por exemplo, para conceder à usuária jane@gmail.com o acesso READER, use:

gsutil acl ch -u jane@gmail.com:READ gs://example-travel-maps/paris.jpg
.

Amostras de código

C++

Para mais informações, consulte a documentação de referência da API Cloud Storage para C++.

Veja na amostra a seguir como remover uma ACL de um intervalo:

namespace gcs = google::cloud::storage;
using ::google::cloud::StatusOr;
[](gcs::Client client, std::string bucket_name, std::string entity) {
  StatusOr<gcs::BucketMetadata> original_metadata =
      client.GetBucketMetadata(bucket_name, gcs::Projection::Full());

  if (!original_metadata) {
    throw std::runtime_error(original_metadata.status().message());
  }

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

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

  gcs::BucketAccessControl owner = *it;
  google::cloud::Status status =
      client.DeleteBucketAcl(bucket_name, owner.entity());

  if (!status.ok()) {
    throw std::runtime_error(status.message());
  }

  std::cout << "Deleted ACL entry for " << owner.entity() << " in bucket "
            << bucket_name << "\n";
}

Veja na amostra a seguir como remover uma ACL de um objeto:

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

  if (!original_metadata) {
    throw std::runtime_error(original_metadata.status().message());
  }

  std::vector<gcs::ObjectAccessControl> original_acl =
      original_metadata->acl();
  auto it = std::find_if(original_acl.begin(), original_acl.end(),
                         [entity](const gcs::ObjectAccessControl& 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#

Para mais informações, consulte a documentação de referência da API Cloud Storage para C#.

Veja na amostra a seguir como remover uma ACL de um intervalo:

private void RemoveBucketOwner(string bucketName, string userEmail)
{
    var storage = StorageClient.Create();
    var bucket = storage.GetBucket(bucketName, new GetBucketOptions()
    {
        Projection = Projection.Full
    });
    if (null == bucket.Acl)
        return;
    bucket.Acl = bucket.Acl.Where((acl) =>
        !(acl.Entity == $"user-{userEmail}" && acl.Role == "OWNER")
        ).ToList();
    var updatedBucket = storage.UpdateBucket(bucket, new UpdateBucketOptions()
    {
        // Avoid race conditions.
        IfMetagenerationMatch = bucket.Metageneration,
    });
}

Veja na amostra a seguir como remover uma ACL de um objeto:

private void RemoveObjectOwner(string bucketName, string objectName,
    string userEmail)
{
    var storage = StorageClient.Create();
    var storageObject = storage.GetObject(bucketName, objectName,
        new GetObjectOptions() { Projection = Projection.Full });
    if (null == storageObject.Acl)
        return;
    storageObject.Acl = storageObject.Acl.Where((acl) =>
        !(acl.Entity == $"user-{userEmail}" && acl.Role == "OWNER")
        ).ToList();
    var updatedObject = storage.UpdateObject(storageObject, new UpdateObjectOptions()
    {
        // Avoid race conditions.
        IfMetagenerationMatch = storageObject.Metageneration,
    });
}

Go

Para mais informações, consulte a documentação de referência da API Cloud Storage para Go.

Veja na amostra a seguir como remover uma ACL de um intervalo:

func deleteBucketACL(client *storage.Client, bucket string) error {
	ctx := context.Background()

	acl := client.Bucket(bucket).ACL()
	if err := acl.Delete(ctx, storage.AllAuthenticatedUsers); err != nil {
		return err
	}
	return nil
}

Veja na amostra a seguir como remover uma ACL de um objeto:

func deleteObjectACL(client *storage.Client, bucket, object string) error {
	ctx := context.Background()

	acl := client.Bucket(bucket).Object(object).ACL()
	if err := acl.Delete(ctx, storage.AllAuthenticatedUsers); err != nil {
		return err
	}
	return nil
}

Java

Para mais informações, consulte a documentação de referência da API Cloud Storage para Java.

Veja na amostra a seguir como remover uma ACL de um intervalo:

boolean deleted = storage.deleteAcl(bucketName, User.ofAllAuthenticatedUsers());
if (deleted) {
  // the acl entry was deleted
} else {
  // the acl entry was not found
}

Veja na amostra a seguir como remover uma ACL de um objeto:

BlobId blobId = BlobId.of(bucketName, blobName, blobGeneration);
boolean deleted = storage.deleteAcl(blobId, User.ofAllAuthenticatedUsers());
if (deleted) {
  // the acl entry was deleted
} else {
  // the acl entry was not found
}

Node.js

Para mais informações, consulte a documentação de referência da API Cloud Storage para Node.js.

Veja na amostra a seguir como remover uma ACL de um intervalo:

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

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

/**
 * TODO(developer): Uncomment the following line before running the sample.
 */
// const bucketName = 'Name of a bucket, e.g. my-bucket';
// const userEmail = 'Email of user to remove, e.g. developer@company.com';

// 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.owners.deleteUser(userEmail);

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

Veja na amostra a seguir como remover uma ACL de um objeto:

async function removeFileOwner(bucketName, filename, userEmail) {
  // Imports the Google Cloud client library
  const {Storage} = require('@google-cloud/storage');

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

  /**
   * TODO(developer): Uncomment the following line before running the sample.
   */
  // const bucketName = 'Name of a bucket, e.g. my-bucket';
  // const filename = 'Name of file to access, e.g. file.txt';
  // const userEmail = 'Email of user to remove, e.g. developer@company.com';

  // 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}.`);

PHP

Para mais informações, consulte a documentação de referência da API Cloud Storage para PHP.

Veja na amostra a seguir como remover uma ACL de um intervalo:

use Google\Cloud\Storage\StorageClient;

/**
 * Delete an entity from a bucket's default ACL.
 *
 * @param string $bucketName the name of your Cloud Storage bucket.
 * @param string $entity the name of the entity to remove from the ACL.
 * @param array $options
 *
 * @return void
 */
function delete_bucket_acl($bucketName, $entity, $options = [])
{
    $storage = new StorageClient();
    $bucket = $storage->bucket($bucketName);
    $acl = $bucket->acl();
    $acl->delete($entity, $options);
    printf('Deleted %s from gs://%s ACL' . PHP_EOL, $entity, $bucketName);
}

Veja na amostra a seguir como remover uma ACL de um objeto:

use Google\Cloud\Storage\StorageClient;

/**
 * Delete an entity from an object's ACL.
 *
 * @param string $bucketName the name of your Cloud Storage bucket.
 * @param string $objectName the name of your Cloud Storage object.
 * @param string $entity The entity to update access controls for.
 * @param array $options
 *
 * @return void
 */
function delete_object_acl($bucketName, $objectName, $entity, $options = [])
{
    $storage = new StorageClient();
    $bucket = $storage->bucket($bucketName);
    $object = $bucket->object($objectName);
    $acl = $object->acl();
    $acl->delete($entity, $options);
    printf('Deleted %s from gs://%s/%s ACL' . PHP_EOL, $entity, $bucketName, $objectName);
}

Python

Para mais informações, consulte a documentação de referência da API Cloud Storage para Python.

Veja na amostra a seguir como remover uma ACL de um intervalo:

def remove_bucket_owner(bucket_name, user_email):
    """Removes a user from the access control list of the given bucket."""
    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.acl.user(user_email).revoke_read()
    bucket.acl.user(user_email).revoke_write()
    bucket.acl.user(user_email).revoke_owner()
    bucket.acl.save()

    print('Removed user {} from bucket {}.'.format(
        user_email, bucket_name))

Veja na amostra a seguir como remover uma ACL de um objeto:

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."""
    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('Removed user {} from blob {} in bucket {}.'.format(
        user_email, blob_name, bucket_name))

Ruby

Para mais informações, consulte a documentação de referência da API Cloud Storage para Ruby.

Veja na amostra a seguir como remover uma ACL de um intervalo:

# project_id  = "Your Google Cloud project ID"
# bucket_name = "Your Google Cloud Storage bucket name"
# email       = "Google Cloud Storage ACL Entity email"

require "google/cloud/storage"

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

bucket.acl.delete email

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

Veja na amostra a seguir como remover uma ACL de um objeto:

# project_id  = "Your Google Cloud project ID"
# bucket_name = "Your Google Cloud Storage 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 project_id: project_id
bucket  = storage.bucket bucket_name
file    = bucket.file file_name

file.acl.delete email

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

API JSON

  1. Defina as ACLs em um arquivo JSON.

  2. Envie uma solicitação patch com o arquivo JSON e especifique o objeto em que as ACLs serão definidas.

Por exemplo, o comando cURL a seguir aplica um payload JSON do documento acls.json a um objeto chamado paris.jpg no intervalo example-travel-maps:

curl -X PATCH --data @acls.json -H "Content-Type: application/json" 
-H "Authorization: Bearer ya29.AHES6ZRVmB7fkLtd1XTmq6mo0S1wqZZi3-Lh_s-6Uw7p8vtgSwg"
https://www.googleapis.com/storage/v1/b/example-travel-maps/o/paris.jpg

Se a ACL conceder aos proprietários do projeto 867489160491 e à usuária jane@gmail.com a permissão OWNER, além de conceder aos membros do grupo gs-announce a permissão READER, a solicitação será semelhante ao exemplo a seguir:

PATCH /storage/v1/b/example-travel-maps/o/paris.jpg HTTP/1.1
Host: www.googleapis.com
Content-Type: application/json
Authorization: Bearer ya29.AHES6ZRVmB7fkLtd1XTmq6mo0S1wqZZi3-Lh_s-6Uw7p8vtgSwg
Content-Length: 597
Date: Wed, 08 Oct 2014 22:37:58 GMT
{
"acl": [
{
"entity": "project-owners-867489160491",
"role": "OWNER",
"projectTeam": {
    "projectNumber": "867489160491",
    "team": "owners"
},
{
"entity": "user-jane@gmail.com",
"role": "OWNER",
"email": "jane@gmail.com"
},
{
"entity": "group-gs-announce@googlegroups.com",
"role": "READER",
"email": "gs-announce@googlegroups.com"
}
]
}

API XML

  1. Defina as ACLs em um documento XML.

  2. Envie uma solicitação PUT Object usando o parâmetro de string de consulta acl e o documento XML correspondente.

O comando cURL a seguir aplica um payload XML do documento acls.xml a um objeto chamado paris.jpg no intervalo example-travel-maps:

curl -X PUT --data-binary @acls.xml 
-H "Authorization: Bearer ya29.AHES6ZRVmB7fkLtd1XTmq6mo0S1wqZZi3-Lh_s-6Uw7p8vtgSwg"
https://storage.googleapis.com/example-travel-maps/paris.jpg?acl

Se a ACL conceder à usuária jane@gmail.com a permissão FULL_CONTROL e aos membros do grupo gs-announce a permissão READ, a solicitação será semelhante ao exemplo a seguir:

PUT /paris.jpg?acl HTTP/1.1
Host: example-travel-maps.storage.googleapis.com
Date: Sat, 20 Feb 2010 08:31:08 GMT
Content-Length: 589
Content-Type=application/xml
Authorization: Bearer ya29.AHES6ZRVmB7fkLtd1XTmq6mo0S1wqZZi3-Lh_s-6Uw7p8vtgSwg
 
<?xml version='1.0' encoding='utf-8'?>
<AccessControlList>
<Owner>
<ID>84fac329bceSAMPLE777d5d22b8SAMPLE77d85ac2SAMPLE2dfcf7c4adf34da46</ID>
</Owner>
<Entries>
<Entry>
<Permission>FULL_CONTROL</Permission>
<Scope type="UserById">
  <ID>84fac329bceSAMPLE777d5d22b8SAMPLE77d85ac2SAMPLE2dfcf7c4adf34da46</ID>
</Scope>
</Entry>
<Entry>
<Scope type="UserByEmail">
  <EmailAddress>jane@gmail.com</EmailAddress>
  <Name>Jane</Name>
</Scope>
<Permission>FULL_CONTROL</Permission>
</Entry>
<Entry>
<Scope type="GroupByEmail">
  <EmailAddress>gs-announce@googlegroups.com</EmailAddress>
</Scope>
<Permission>READ</Permission>
</Entry>
</Entries>
</AccessControlList>

Esta página foi útil? Conte sua opinião sobre:

Enviar comentários sobre…

Precisa de ajuda? Acesse nossa página de suporte.