Créer et gérer des LCA (Liste de contrôle d'accès)

Cette page explique comment contrôler l'accès aux buckets et aux objets à l'aide de listes de contrôle d'accès (LCA). Une liste de contrôle d'accès, ou LCA, est un mécanisme permettant de déterminer qui a accès à vos buckets et objets, et de définir le niveau d'accès accordé. Pour plus d'informations, consultez la section Listes de contrôle d'accès (LCA).

Pour plus d'informations sur les autres méthodes de contrôle des accès aux buckets et aux objets, consultez la section Présentation du contrôle des accès.

Avant de commencer

Devez-vous utiliser des listes de contrôle d'accès ?

Dans la plupart des cas, Cloud IAM (Cloud Identity and Access Management) est la méthode recommandée pour contrôler les accès à vos ressources. En effet, cette méthode fournit un contrôle des accès d'entreprise dans l'ensemble de Google Cloud Platform et permet aux autorisations accordées aux ressources parentes, telles que des projets, d'être transmises aux ressources enfants, telles que des buckets et des objets. Consultez la section Utiliser des autorisations Cloud IAM pour savoir comment utiliser Cloud IAM dans Cloud Storage.

Les autorisations Cloud IAM s'appliquant à tous les objets d'un bucket, vous souhaiterez probablement utiliser les LCA si vous devez personnaliser l'accès à des objets spécifiques d'un bucket. Toutefois, vous devrez quand même faire appel à Cloud IAM pour tout accès commun à l'ensemble des objets d'un bucket, car cet outil permet de limiter la quantité de tâches de gestion très détaillées.

Avez-vous besoin de configurer une liste de contrôle d'accès ?

Selon l'autorisation que vous souhaitez attribuer à un bucket ou à un objet, il n'est peut-être pas nécessaire de configurer une LCA. Les buckets et les objets sont créés avec des listes de contrôle d'accès par défaut pouvant déjà contenir l'autorisation que vous souhaitez attribuer au bucket ou à l'objet.

Utilisez les instructions suivantes pour décider si vous devez configurer une liste de contrôle d'accès.

Sur les buckets :

Console

Les nouveaux buckets sont créés avec la LCA project-private prédéfinie. Si votre bucket nécessite une autorisation différente, configurez une LCA.

gsutil

Les nouveaux buckets sont ajoutés en tant que project-private. Si votre bucket nécessite une autorisation différente,.configurez une LCA.

API JSON

Par défaut, les nouveaux buckets sont ajoutés en tant que project-private. Si votre bucket nécessite une autorisation différente, configurez une LCA.

API XML

Les nouveaux buckets sont ajoutés en tant que project-private. Si votre bucket nécessite une autorisation différente, configurez une LCA.

Comme indiqué ci-dessus, chaque bucket dispose d'une liste de contrôle d'accès aux objets par défaut qui est appliquée à tous les objets importés dans ce bucket s'il n'existe pas de LCA prédéfinie ou si la requête ne spécifie pas de LCA (dans le cas où vous utilisez l'API JSON). Pour plus d'informations, consultez la section Liste de contrôle d'accès aux objets par défaut.

Sur les objets :

Console

Les objets importés se voient attribuer les mêmes LCA que l'objet de bucket, et l'utilisateur ayant importé l'objet est ajouté en tant que propriétaire de la LCA. Si votre objet nécessite une autorisation différente, configurez une liste de contrôle d'accès.

gsutil

Les nouveaux objets sont ajoutés avec la liste de contrôle d'accès aux objets par défaut associée au bucket. Lorsque vous copiez un objet déjà stocké dans le cloud, vous pouvez remplacer ce comportement par l'option -p.

API JSON

Par défaut, les nouveaux objets sont ajoutés avec la LCA associée aux objets par défaut pour le bucket.

API XML

Les nouveaux objets sont ajoutés avec la liste de contrôle d'accès aux objets par défaut associée au bucket.

Quelle interface devez-vous utiliser ?

Les exemples ci-dessous montrent comment configurer le contrôle des accès à l'aide de la console Google Cloud Platform, de l'outil de ligne de commande gsutil, des bibliothèques clientes Cloud Storage et des API XML et JSON. Utilisez ces instructions pour choisir quelle interface utiliser :

  • Si vous débutez avec l'utilisation du contrôle des accès et souhaitez uniquement modifier les LCA associées à des objets individuels, utilisez la console GCP.

  • Si vous débutez avec l'utilisation du contrôle des accès et souhaitez modifier les LCA associées aux buckets et aux objets, utilisez gsutil.

  • Si vous savez utiliser l'une des bibliothèques clientes Cloud Storage, utilisez-la pour gérer vos LCA.

  • Si vous spécifiez des LCA à l'aide d'une API, vous devez savoir comment effectuer des requêtes HTTP. Vous pouvez utiliser l'outil ou l'application de votre choix pour envoyer des requêtes HTTP. Dans les exemples, nous utilisons l'outil cURL. Vous pouvez obtenir des jetons d'autorisation à utiliser dans les exemples cURL du OAuth 2.0 Playground.

Configurer des listes de contrôle d'accès

L'outil ou l'API que vous utilisez pour configurer et obtenir des LCA détermine la syntaxe que vous utilisez. Les syntaxes de LCA ont un aspect différent, mais elles contiennent les mêmes informations de LCA, en d'autres termes, des entrées qui accordent des autorisations à des champs d'application.

Console

  1. Accédez au navigateur Cloud Storage dans la console GCP.
    Accéder au navigateur Cloud Storage

  2. Accédez à l'objet dont vous souhaitez modifier la liste de contrôle d'accès.

  3. Choisissez Modifier les autorisations dans le menu déroulant de l'objet.

    Une boîte de dialogue d'autorisation semblable à celle-ci doit s'afficher :

    Cette capture d'écran montre une LCA avec quatre entrées :

    • Dans la première entrée, tous les propriétaires d'un projet spécifique (celui dont le numéro de projet est le 867489140601) reçoivent l'accès/l'autorisation "Owner" (Propriétaire) pour cet objet.
    • Dans la deuxième entrée, tous les éditeurs d'un projet spécifique (celui dont le numéro de projet est le 867489140601) reçoivent également l'accès/l'autorisation "Owner" (Propriétaire) pour cet objet.
    • Dans la troisième entrée, tous les utilisateurs d'un projet spécifique (celui dont le numéro de projet est 867489140601) reçoivent l'accès/l'autorisation "Reader" (Lecteur) pour cet objet.
    • Dans la quatrième entrée, l'utilisateur qui a importé l'objet reçoit l'accès/l'autorisation "Owner" (Propriétaire) pour cet objet. Les utilisateurs qui ont importé les objets sont toujours définis en tant que propriétaires et ne peuvent pas être supprimés.
  4. Cliquez sur Ajouter un élément.

  5. Choisissez le type d'entité auquel une autorisation doit être accordée.

    Le champ Entité spécifie le type d'objet qui obtient l'autorisation (par exemple, un utilisateur ou un groupe). Consultez la section Champs d'application liés au contrôle des accès pour connaître la liste des valeurs acceptées pour Entité.

  6. Saisissez une valeur dans le champ Nom.

    Le champ Nom identifie un utilisateur, un groupe ou un autre type d'entité spécifique. Consultez la section Champs d'application liés au contrôle des accès pour connaître la liste des valeurs acceptées pour Nom.

    Les champs Entité et Nom définissent à qui s'applique l'autorisation.

  7. Choisissez une valeur dans le champ Accès.

    Le champ Accès définit l'autorisation que vous souhaitez configurer sur l'objet. Consultez la section Autorisations liées au contrôle des accès pour connaître la liste des valeurs acceptées pour Accès.

  8. Cliquez sur Enregistrer.

gsutil

Spécifiez les LCA à l'aide de gsutil acl :

  • Pour spécifier des autorisations individuelles, utilisez la commande suivante :

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

  • Pour spécifier des listes de contrôle d'accès standardisées, utilisez la commande suivante :

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

  • Pour spécifier les listes de contrôle d'accès au format JSON, utilisez la commande suivante :

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

    [JSON_FILE] contient les listes de contrôle d'accès spécifiées au format JSON.

Exemples de code

C++

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage C++.

Dans l'exemple suivant, une LCA est ajoutée à un bucket :

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

L'exemple suivant ajoute une liste de contrôle d'accès à un objet :

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#

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage C#.

Dans l'exemple suivant, une LCA est ajoutée à un bucket :

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,
    });
}

L'exemple suivant ajoute une liste de contrôle d'accès à un objet :

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

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage Go.

Dans l'exemple suivant, une LCA est ajoutée à un bucket :

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
}

L'exemple suivant ajoute une liste de contrôle d'accès à un objet :

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

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage Java.

Dans l'exemple suivant, une LCA est ajoutée à un bucket :

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

L'exemple suivant ajoute une liste de contrôle d'accès à un objet :

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

Node.js

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage Node.js.

Dans l'exemple suivant, une LCA est ajoutée à un bucket :

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

L'exemple suivant ajoute une liste de contrôle d'accès à un objet :

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

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage PHP.

Dans l'exemple suivant, une LCA est ajoutée à un bucket :

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

L'exemple suivant ajoute une liste de contrôle d'accès à un objet :

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

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage Python.

Dans l'exemple suivant, une LCA est ajoutée à un bucket :

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

L'exemple suivant ajoute une liste de contrôle d'accès à un objet :

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

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage Ruby.

Dans l'exemple suivant, une LCA est ajoutée à un bucket :

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

L'exemple suivant ajoute une liste de contrôle d'accès à un objet :

# 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

Lors de la création d'un bucket, vous pouvez spécifier la propriété acl[] dans une requête insert. Pour un bucket existant, spécifiez la propriété acl[] dans une requête patch ou update.

Lors de la création d'un objet, vous pouvez spécifier la propriété acl[] dans le corps de la requête ou le paramètre de requête predefinedAcl dans une requête insert. Pour un objet existant, spécifiez la propriété acl[] ou le paramètre de requête predefinedAcl dans une requête patch ou update.

Pour obtenir les définitions des propriétés de LCA associées au bucket et à l'objet, consultez les ressources BucketAccessControls et ObjectAccessControls, respectivement.

L'exemple suivant montre différentes entrées de LCA associées à un bucket.

"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

Dans l'API XML, vous utilisez des LCA au format XML. Vous devez joindre un document XML au corps des requêtes de modification des LCA associées aux objets et au bucket. Un document XML est renvoyé lorsque vous obtenez des LCA associées aux objets et au bucket. Le document XML contient les entrées individuelles de LCA associées à des objets ou au bucket.

  • Après la création d'un bucket à l'aide d'une requête de bucket PUT, exécutez une seconde requête de bucket PUT avec le paramètre ?acl pour modifier la LCA associée au bucket.

  • Après avoir importé un objet avec une requête d'objet PUT, remplacez la LCA par une autre requête PUT avec le paramètre ?acl ou l'en-tête de requête x-googl-acl.

Utilisez la syntaxe de LCA suivante pour l'API XML.

Élément Description
AccessControlList Conteneur pour les éléments Entries et Owner.
Owner Conteneur pour les éléments DisplayName et ID. Cet élément n'est pas obligatoire pour les objets puisqu'un objet appartient toujours à l'utilisateur qui l'a importé. Cet élément est utilisé lorsque vous appliquez la syntaxe de LCA Amazon S3 dans un scénario de migration.

Amazon Simple Storage Service™ et Amazon S3™ sont des marques d'Amazon.com, Inc. ou de ses sociétés affiliées aux États-Unis et/ou dans d'autres pays.
ID ID Google Cloud Storage du propriétaire du bucket.
DisplayName Non mis en œuvre actuellement. La valeur correspond toujours à une chaîne vide.
Entries Conteneur pour zéro ou plusieurs éléments Entry.
Entry Conteneur pour les éléments Scope et Permission. Un Entry ne doit contenir qu'un seul élément Scope et qu'un seul élément Permission.
Scope Conteneur pour un élément ID, EmailAddress ou Domain qui définit le champ d'application de la LCA. Cet élément doit avoir un attribut type contenant l'une des valeurs suivantes : UserByID, UserByEmail, GroupByID, GroupByEmail, GroupByDomain, AllUsers ou AllAuthenticatedUsers.
ID Identifiant associé au bénéficiaire lorsque l'entrée d'autorisation est spécifiée par ID.
EmailAddress Identifiant d'adresse e-mail associé au bénéficiaire lorsque l'entrée d'autorisation est spécifiée par adresse e-mail.
Domain Identifiant de domaine associé au bénéficiaire lorsque l'entrée d'autorisation est spécifiée par domaine.
Name Élément facultatif pouvant être spécifié ou pouvant être ajouté automatiquement si le champ d'application correspond à UserByEmail ou GroupByEmail.
Permission Autorisation READ, WRITE ou FULL_CONTROL accordée.

Lorsque vous utilisez des LCA à l'aide de l'API XML :

  • vous ne pouvez utiliser que le format XML décrit ci-dessus ;
  • vous ne pouvez pas définir des champs d'application en double.

    Vous pouvez disposer de plusieurs entrées dans votre LCA XML, mais vous ne pouvez pas disposer d'entrées avec des champs d'application en double. Par exemple, vous ne pouvez pas avoir deux entrées avec le même élément de champ d'application de jane@example.com.

L'exemple suivant montre différentes entrées de liste de contrôle d'accès associées à un 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="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>

Configurer l'élément "Name" dans une liste de contrôle d'accès XML

Lorsque vous récupérez une LCA à partir d'un bucket ou d'un objet, vous pouvez remarquer un élément <Name> supplémentaire ajouté à certaines de vos entrées. Par exemple, une entrée semblable à ce qui suit peut s'afficher :

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

Ces éléments <Name> facultatifs sont renseignés dans deux cas :

  1. Lorsque les LCA associées au bucket ou aux objets incluent <Name> en tant qu'élément.

    Lorsque vous définissez des LCA, vous pouvez choisir d'inclure l'élément <Name> avec vos entrées LCA. Vous pouvez indiquer n'importe quelle valeur dans l'élément <Name>, et Cloud Storage mémorise ces valeurs jusqu'à ce que la LCA soit supprimée ou remplacée. Cette approche peut être judicieuse si vous utilisez des identifiants difficiles à identifier, tels que les ID Google Cloud Storage.

  2. Lorsqu'un champ d'application UserByEmail ou GroupByEmail contient un profil Google public.

    Si vous utilisez l'un de ces champs d'application, mais ne fournissez pas d'élément <Name>, Cloud Storage vérifie si l'utilisateur ou le groupe Google associé à l'adresse e-mail possède un profil Google public portant un nom public. Si c'est le cas, Cloud Storage renseigne automatiquement l'élément <Name> avec le nom public.

Appliquer une liste de contrôle d'accès prédéfinie

Plutôt que de spécifier l'intégralité d'une liste de contrôle d'accès une entrée à la fois comme indiqué ci-dessus, vous pouvez utiliser une liste de contrôle d'accès prédéfinie qui applique automatiquement un nombre d'entrées personnalisées à un scénario spécifique. Vous pouvez appliquer une liste de contrôle d'accès prédéfinie à un bucket ou à un objet à l'aide de gsutil, de l'API JSON ou de l'API XML.

Sur de nouveaux objets

Pour appliquer une liste de contrôle d'accès prédéfinie à un objet lors de l'importation d'un objet, procédez comme suit :

Console

Vous ne pouvez pas appliquer une LCA prédéfinie à l'aide de la console GCP. Utilisez plutôt gsutil.

gsutil

Utilisez l'option -a avec la commande gsutil cp pour appliquer la LCA prédéfinie :

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

Par exemple, pour appliquer la LCA bucket-owner-read prédéfinie lors de l'importation d'un objet paris.jpg dans un bucket example-travel-maps, exécutez la commande suivante :

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

API JSON

Utilisez le paramètre de chaîne de requête predefinedAcl dans une requête insert pour appliquer la LCA prédéfinie.

Par exemple, pour appliquer la LCA bucketOwnerRead prédéfinie lors de l'importation d'un objet paris.jpg dans un bucket example-travel-maps, exécutez la commande suivante :

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"

La requête se présente comme suit :

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

Utilisez l'en-tête x-goog-acl d'une requête d'objet PUT pour appliquer la LCA prédéfinie.

Par exemple, pour appliquer la LCA bucket-owner-read prédéfinie lors de l'importation d'un objet paris.jpg dans un bucket example-travel-maps, exécutez la commande suivante :

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

La requête se présente comme suit :

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

Sur des buckets ou des objets existants

Vous pouvez également appliquer une LCA prédéfinie à un bucket ou à un objet existant. Cette méthode est utile si vous souhaitez passer d'une LCA prédéfinie à une autre ou mettre à jour des LCA personnalisées et les configurer en tant que LCA prédéfinies.

Console

Vous ne pouvez pas appliquer une LCA prédéfinie à l'aide de la console GCP. Utilisez plutôt gsutil.

gsutil

Utilisez la commande gsutil acl set pour appliquer la LCA prédéfinie :

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

Par exemple, pour appliquer la LCA private prédéfinie à l'objet paris.jpg dans le bucket example-travel-maps, exécutez la commande suivante :

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

API JSON

Utilisez le paramètre de chaîne de requête predefinedAcl et spécifiez une propriété acl vide dans une requête patch pour appliquer la LCA prédéfinie.

Par exemple, pour appliquer la LCA private prédéfinie à l'objet paris.jpg dans le bucket example-travel-maps, exécutez la commande suivante :

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

La requête se présente comme suit :

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

Utilisez l'en-tête x-goog-acl avec le paramètre de chaîne de requête acl dans une requête dobjet PUT, mais n'incluez pas de document XML dans votre requête.

Par exemple, pour appliquer la LCA private prédéfinie à l'objet paris.jpg dans le bucket example-travel-maps, exécutez la commande suivante :

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

La requête se présente comme suit :

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

Configurer des listes de contrôle d'accès aux objets

Pour éviter de configurer des LCA chaque fois que vous créez un objet, vous pouvez définir une liste de contrôle d'accès aux objets par défaut sur un bucket. Une fois que vous avez effectué cette opération, la valeur par défaut est appliquée à chaque nouvel objet ajouté à ce bucket auquel aucune LCA n'a été explicitement appliquée. Par exemple, vous pouvez spécifier que seul un groupe d'utilisateurs donné a accès à la plupart des objets d'un bucket particulier. Vous pouvez modifier la liste de contrôle d'accès aux objets par défaut, puis ajouter des objets au bucket. La liste de contrôle d'accès aux objets par défaut que vous avez spécifiée est automatiquement appliquée à ces objets ajoutés. Toutefois, vous pouvez attribuer différentes LCA à des objets spécifiques. Dans ce cas, la LCA par défaut n'est pas appliquée à ces objets.

Pour afficher et modifier la LCA associée aux objets par défaut pour un bucket, exécutez la commande suivante :

Console

Vous ne pouvez pas configurer une liste de contrôle d'accès aux objets par défaut à l'aide de la console GCP. Utilisez plutôt gsutil.

gsutil

  1. Utilisez gsutil defacl pour récupérer la LCA associée aux objets par défaut :

    gsutil defacl get gs://[BUCKET_NAME]

  2. Utilisez gsutil defacl ch ou gsutil defacl set pour modifier la LCA associée aux objets par défaut.

    Par exemple, la commande suivante ajoute jane@gmail.com à la LCA associée aux objets par défaut pour un bucket example-travel-maps :

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

    Vous pouvez également spécifier la liste de contrôle d'accès aux objets par défaut à partir d'un fichier. Pour plus d'informations, consultez l'aide concernant gsutil defacl.

Exemples de code

C++

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage C++.

L'exemple suivant ajoute une liste de contrôle d'accès aux objets par défaut à un bucket :

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

L'exemple suivant supprime une liste de contrôle d'accès aux objets par défaut d'un bucket :

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#

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage C#.

L'exemple suivant ajoute une liste de contrôle d'accès aux objets par défaut à un bucket :

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,
    });
}

L'exemple suivant supprime une liste de contrôle d'accès aux objets par défaut d'un bucket :

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

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage Go.

L'exemple suivant ajoute une liste de contrôle d'accès aux objets par défaut à un bucket :

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
}

L'exemple suivant supprime une liste de contrôle d'accès aux objets par défaut d'un bucket :

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

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage Java.

L'exemple suivant ajoute une liste de contrôle d'accès aux objets par défaut à un bucket :

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

L'exemple suivant supprime une liste de contrôle d'accès aux objets par défaut d'un bucket :

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

Node.js

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage Node.js.

L'exemple suivant ajoute une liste de contrôle d'accès aux objets par défaut à un bucket :

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

L'exemple suivant supprime une liste de contrôle d'accès aux objets par défaut d'un bucket :

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

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage PHP.

L'exemple suivant ajoute une liste de contrôle d'accès aux objets par défaut à 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.
 * @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);
}

L'exemple suivant supprime une liste de contrôle d'accès aux objets par défaut d'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.
 * @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

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage Python.

L'exemple suivant ajoute une liste de contrôle d'accès aux objets par défaut à un bucket :

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

L'exemple suivant supprime une liste de contrôle d'accès aux objets par défaut d'un bucket :

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

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage Ruby.

L'exemple suivant ajoute une liste de contrôle d'accès aux objets par défaut à un bucket :

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

L'exemple suivant supprime une liste de contrôle d'accès aux objets par défaut d'un bucket :

# 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. Récupérez la liste de contrôle d'accès aux objets par défaut à l'aide d'une requête GET. Exemple :

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

  2. Exécutez une requête patch pour remplacer la LCA associée aux objets par défaut. Par exemple, la requête suivante remplace la LCA associée aux objets par défaut par la LCA spécifiée dans defacls.json pour un bucket 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

    Exemple de defacls.json :

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

API XML

  1. Récupérez la LCA associée aux objets par défaut avec une requête GET limitée à votre bucket et au paramètre ?defaultObjectAcl. Exemple :

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

  2. Exécutez une requête PUT limitée à votre bucket par le paramètre ?defaultObjectAcl pour remplacer la LCA associée aux objets par défaut par celle spécifiée dans acls.xml. Exemple :

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

    Exemple de acls.xml :

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

La syntaxe des LCA est décrite dans la section Configurer des listes de contrôle d'accès. Vous pouvez également spécifier une LCA prédéfinie en tant que LCA associée aux objets par défaut.

Pour configurer la liste de contrôle d'accès aux objets par défaut associée à un bucket sur une liste de contrôle d'accès prédéfinie :

Console

Vous ne pouvez pas configurer une liste de contrôle d'accès aux objets par défaut à l'aide de la console GCP. Utilisez plutôt gsutil.

gsutil

Utilisez la commande gsutil defacl avec le nom de la LCA prédéfinie.

Par exemple, pour définir la LCA associée aux objets par défaut sur project-private pour le bucket example-travel-maps, exécutez :

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

API JSON

Exécutez une requête PUT avec le paramètre predefinedAcl.

Exemple :

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

Exécutez une requête PUT limitée à votre bucket avec le paramètre ?defaultObjectAcl et l'en-tête x-goog-acl.

Exemple :

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

Listes de contrôle d'accès aux objets associées à un bucket nouvellement créé :

Les LCA associées aux objets par défaut pour un bucket nouvellement créé sont illustrées ci-dessous. Comparez-les aux LCA associées aux objets par défaut de votre bucket pour voir si elles ont été modifiées.

Console

Vous ne pouvez pas utiliser les listes de contrôle d'accès aux objets par défaut à l'aide de la console GCP. Utilisez plutôt gsutil.

gsutil

Dans l'exemple ci-dessous, l'ID de projet est "123412341234". Votre ID de projet sera différent.

[
{
"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

Dans l'exemple ci-dessous, l'ID de projet est "123412341234". Votre ID de projet sera différent.

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

Dans l'exemple ci-dessous, les ID de rôle de projet commencent par "00b4903a97".Vos ID de projet seront différents.

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

Notez que la LCA associée aux objets par défaut pour un bucket nouvellement créé est équivalente à la LCA prédéfinie projectPrivate.

Récupérer des listes de contrôle d'accès

Pour obtenir la liste de contrôle d'accès associée à un bucket ou à un objet existant, procédez comme suit :

Console

  1. Accédez au navigateur Cloud Storage dans la console GCP.
    Accéder au navigateur Cloud Storage

  2. Accédez à l'objet dont vous souhaitez afficher la liste de contrôle d'accès.

  3. Choisissez Modifier les autorisations dans le menu déroulant de l'objet.

    Une boîte de dialogue d'autorisation affichant les autorisations de l'objet doit s'ouvrir.

gsutil

Exécutez la commande gsutil acl get pour afficher la LCA d'un objet.

Par exemple, pour renvoyer la LCA associée à l'objet paris.jpg dans le bucket example-travel-maps, utilisez la commande suivante :

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

Exemple de réponse :

[
{
    "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"
}
]

Pour renvoyer la liste de contrôle d'accès d'un bucket, utilisez la commande suivante :

gsutil acl get gs://[BUCKET_NAME]

Lorsque gsutil renvoie des LCA associées à des buckets et des objets avec gsutil acl get, leur format JSON est identique à celui que vous pouvez utiliser pour les définir. Les LCA au format JSON utilisent les noms de propriété de l'API JSON, tels que entity et role.

Pour plus d'informations sur l'interprétation de la sortie ou l'exécution de gsutil help acls, consultez la syntaxe de l'API JSON.

Exemples de code

C++

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage C++.

L'exemple suivant permet d'obtenir une liste de contrôle d'accès associée à un bucket :

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

L'exemple suivant permet d'obtenir une liste de contrôle d'accès associée à un objet :

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#

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage C#.

L'exemple suivant permet d'obtenir une liste de contrôle d'accès associée à un bucket :

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

L'exemple suivant permet d'obtenir une liste de contrôle d'accès associée à un objet :

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

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage Go.

L'exemple suivant permet d'obtenir une liste de contrôle d'accès associée à un bucket :

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
}

L'exemple suivant permet d'obtenir une liste de contrôle d'accès associée à un objet :

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

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage Java.

L'exemple suivant permet d'obtenir une liste de contrôle d'accès associée à un bucket :

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

L'exemple suivant permet d'obtenir une liste de contrôle d'accès associée à un objet :

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

Node.js

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage Node.js.

L'exemple suivant permet d'obtenir une liste de contrôle d'accès associée à un bucket :

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

L'exemple suivant permet d'obtenir une liste de contrôle d'accès associée à un objet :

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

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage PHP.

L'exemple suivant permet d'obtenir une liste de contrôle d'accès associée à un bucket :

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']);
    }
}

L'exemple suivant permet d'obtenir une liste de contrôle d'accès associée à un objet :

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

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage Python.

L'exemple suivant permet d'obtenir une liste de contrôle d'accès associée à un bucket :

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']))

L'exemple suivant permet d'obtenir une liste de contrôle d'accès associée à un objet :

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

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage Ruby.

L'exemple suivant permet d'obtenir une liste de contrôle d'accès associée à un bucket :

# 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

L'exemple suivant permet d'obtenir une liste de contrôle d'accès associée à un objet :

# 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. Assurez-vous de disposer de l'autorisation OWNER sur le bucket ou l'objet.

  2. Récupérez la LCA associée au bucket ou à l'objet à l'aide d'une requête GET.

    La LCA associée à l'objet est renvoyée au format JSON et jointe au corps de la réponse.

Par exemple, pour renvoyer la LCA associée à l'objet paris.jpg dans l'ensemble example-travel-maps, utilisez la commande suivante :

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

Une réponse semblable aux lignes suivantes doit s'afficher :

{
"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"
},
...
}

Vous pouvez également utiliser la méthode objectAccessControls de la ressource GETpour afficher des entrées individuelles dans une LCA associée à un objet.

API XML

  1. Assurez-vous de disposer de l'autorisation FULL_CONTROL sur le bucket ou l'objet.

  2. Récupérez la LCA associée au bucket ou à l'objet à l'aide du paramètre de chaîne de requête acl dans une requête d'objet GET.

Les LCA sont décrites au format XML et jointes au corps de la réponse.

Par exemple, pour renvoyer la LCA associée à l'objet paris.jpg dans l'ensemble example-travel-maps, utilisez la commande suivante :

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

Une réponse semblable aux lignes suivantes doit s'afficher :

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

Vous pouvez également utiliser la méthode JSON GET de la ressource ObjectAccessControls pour afficher une entrée de LCA spécifique.

Modifier des listes de contrôle d'accès

Pour modifier la liste de contrôle d'accès associée à un objet ou à un bucket existant, procédez comme suit :

Console

  1. Accédez au navigateur Cloud Storage dans la console GCP.
    Accéder au navigateur Cloud Storage

  2. Accédez à l'objet dont vous souhaitez modifier la liste de contrôle d'accès.

  3. Choisissez Modifier les autorisations dans le menu déroulant de l'objet.

    Une boîte de dialogue d'autorisation affichant les autorisations de l'objet doit s'ouvrir.

L'exemple suivant montre comment accorder l'autorisation OWNER à l'utilisateur jane@gmail.comet l'autorisation READER aux membre du groupe gs-announcesur l'objet paris.jpg :

Définir la LCA sur l'objet

gsutil

  1. Définissez les LCA dans un fichier.

  2. Transmettez le fichier LCA à gsutil acl set, puis spécifiez l'objet sur lequel les LCA doivent être définies.

Par exemple, pour appliquer les LCA à partir du fichier acls.txt sur un objet nommé paris.jpg dans le bucket example-travel-maps, exécutez la commande suivante :

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

Le contenu de acl.txt est affiché ci-dessous. Ces LCA accordent aux propriétaires de projet 867489160491, ainsi qu'à l'utilisateur jane@gmail.com l'autorisation OWNERsur l'objet paris.jpg, et accordent également aux membres du groupe gs-announce l'autorisation READER sur cet objet :

[
{
"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"
}
]

Vous pouvez également définir la même LCA pour cet objet en spécifiant des autorisations individuelles. Par exemple, pour accorder l'accès READER à l'utilisateur jane@gmail.com, exécutez la commande suivante :

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

Exemples de code

C++

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage C++.

L'exemple suivant supprime une LCA d'un bucket :

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

L'exemple suivant permet de supprimer une LCA d'un objet :

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#

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage C#.

L'exemple suivant supprime une LCA d'un bucket :

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,
    });
}

L'exemple suivant permet de supprimer une LCA d'un objet :

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

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage Go.

L'exemple suivant supprime une LCA d'un bucket :

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
}

L'exemple suivant permet de supprimer une LCA d'un objet :

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

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage Java.

L'exemple suivant supprime une LCA d'un bucket :

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

L'exemple suivant permet de supprimer une LCA d'un objet :

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

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage Node.js.

L'exemple suivant supprime une liste de contrôle d'accès d'un bucket :

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

L'exemple suivant permet de supprimer une LCA d'un objet :

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

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage PHP.

L'exemple suivant supprime une LCA d'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.
 * @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);
}

L'exemple suivant permet de supprimer une LCA d'un objet :

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

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage Python.

L'exemple suivant supprime une LCA d'un bucket :

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

L'exemple suivant permet de supprimer une LCA d'un objet :

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

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage Ruby.

L'exemple suivant supprime une LCA d'un bucket :

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

L'exemple suivant permet de supprimer une LCA d'un objet :

# 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. Définissez les LCA dans un fichier JSON.

  2. Envoyez une requête patch avec le fichier JSON et spécifiez l'objet sur lequel définir les LCA.

Par exemple, la commande cURL suivante applique une charge utile JSON du document acls.json à un objet nommé paris.jpg dans le bucket 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

Si la LCA accorde aux propriétaires du projet 867489160491 et à l'utilisateur jane@gmail.com l'autorisation OWNER, et aux membres du groupe gs-announce l'autorisation READER, la requête ressemble à ceci :

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. Définissez les LCA dans un document XML.

  2. Envoyez une requête PUT Object à l'aide du paramètre de chaîne de requête acl et du document XML correspondant.

La commande cURL suivante applique une charge utile XML du document acls.xml à un objet nommé paris.jpg dans le bucket 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

Si la LCA accorde à l'utilisateur jane@gmail.com l'autorisation FULL_CONTROLet aux membres du groupe gs-announce l'autorisation READ, la requête se présente comme suit :

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>

Cette page vous a-t-elle été utile ? Évaluez-la :

Envoyer des commentaires concernant…

Besoin d'aide ? Consultez notre page d'assistance.