Configurer l'accès à un récepteur: Cloud Storage

Cloud Storage utilise un compte de service géré par Google, appelé agent de service, pour déplacer des données vers un bucket Cloud Storage. Cet agent de service est créé la première fois que vous appelez googleServiceAccounts.get.

Le bucket de destination n'a pas besoin d'appartenir au même projet que l'agent de service. Les étapes sont les mêmes quel que soit le projet dans lequel se trouve le bucket.

Autorisations utilisateur

Pour accorder les autorisations requises à l'agent de service, vous devez disposer des autorisations appropriées sur le bucket de destination :

storage.buckets.getIamPolicy
storage.buckets.setIamPolicy

Les rôles Propriétaire des anciens buckets Storage (roles/storage.legacyBucketOwner) et Administrateur de l'espace de stockage (roles/storage.admin) fournissent les autorisations requises.

Accorder automatiquement des autorisations dans la console Google Cloud

Si vous utilisez la console Google Cloud pour créer votre transfert et que vous disposez des autorisations répertoriées dans la section Autorisations des utilisateurs, l'agent de service se voit automatiquement attribuer les autorisations requises sur votre bucket de destination.

Vous pouvez ignorer les étapes décrites sur cette page. Si nécessaire, configurez l'accès à votre source, puis créez un transfert.

Autorisations requises

L'agent de service doit disposer des autorisations suivantes pour le bucket de destination :

Autorisation	Description
`storage.buckets.get`	Permet au compte de service d'obtenir l'emplacement du bucket.
`storage.objects.create`	Permet au compte de service d'ajouter des objets au bucket.
`storage.objects.delete`	Permet au compte de service de supprimer des objets du bucket. Obligatoire si vous définissez `overwriteObjectsAlreadyExistingInSink` ou `deleteObjectsUniqueInSink` sur `true`. Notez que si la gestion des versions d'objets est activée sur le bucket de destination, ni `overwriteObjectsAlreadyExistingInSink`, ni `deleteObjectsUniqueInSink` ne suppriment définitivement les objets. À la place, les versions pertinentes des objets actifs sont archivées.
`storage.objects.list`	Permet au compte de service de répertorier les objets présents dans le bucket. Obligatoire si vous définissez `overwriteObjectsAlreadyExistingInSink` sur `false` ou `deleteObjectsUniqueInSink` sur `true`.

Le rôle prédéfini suivant accorde les autorisations requises :

Rédacteur des anciens buckets de l'espace de stockage (roles/storage.legacyBucketWriter)

Tout rôle Cloud Storage marqué comme étant un rôle legacy ne peut être accordé qu'au niveau du bucket.

Pour obtenir une liste complète des rôles Cloud Storage et des autorisations qu'ils comprennent, consultez la page sur les rôles IAM.

Accorder les autorisations requises

Pour accorder le rôle Rédacteur des anciens buckets de l'espace de stockage à l'agent de service, suivez les étapes ci-dessous.

Rechercher l'adresse e-mail de l'agent de service

Accédez à la page de référence googleServiceAccounts.get.

Un panneau interactif s'affiche, intitulé Essayer cette méthode.
Dans le panneau, sous Paramètres des requêtes, saisissez votre ID de projet. Le projet que vous spécifiez ici doit être le projet que vous utilisez pour gérer le service de transfert de stockage, qui peut être différent du projet du bucket de destination.
Cliquez sur Exécuter.

L'adresse e-mail de votre agent de service est renvoyée en tant que valeur de accountEmail. Copiez cette valeur.

L'adresse e-mail de l'agent de service utilise le format project-PROJECT_NUMBER@storage-transfer-service.iam.gserviceaccount.com.

Ajouter l'agent de service à une stratégie au niveau du bucket

Console

Dans la console Google Cloud, accédez à la page Buckets Cloud Storage.

Accéder à la page "Buckets"
Cliquez sur le menu déroulant () associé au bucket pour lequel vous souhaitez accorder un rôle à un compte principal.
Sélectionnez Modifier les autorisations.
Cliquez sur le bouton + Ajouter un compte principal.
Dans le champ Nouveaux comptes principaux, saisissez l'adresse e-mail du compte de votre agent de service.
Sélectionnez Storage Legacy Bucket Writer dans le menu déroulant Sélectionner un rôle.
Cliquez sur Enregistrer.

gsutil

Exécutez la commande gsutil iam ch :

gsutil iam ch \
serviceAccount:YOUR_AGENT_EMAIL:legacyBucketWriter \
gs://BUCKET_NAME

Où :

YOUR_AGENT_EMAIL correspond à l'adresse e-mail de l'agent que vous avez copiée dans Rechercher l'adresse e-mail de l'agent de service.
BUCKET_NAME est le nom du bucket auquel vous accordez l'accès principal. Exemple :my-bucket

Exemples de code

C++

Pour savoir comment installer et utiliser la bibliothèque cliente pour Cloud Storage, consultez la section Bibliothèques clientes Cloud Storage. Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage C++.

Pour vous authentifier auprès de Cloud Storage, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

namespace gcs = ::google::cloud::storage;
using ::google::cloud::StatusOr;
[](gcs::Client client, std::string const& bucket_name,
   std::string const& role, std::string const& member) {
  auto policy = client.GetNativeBucketIamPolicy(
      bucket_name, gcs::RequestedPolicyVersion(3));

  if (!policy) throw std::move(policy).status();

  policy->set_version(3);
  for (auto& binding : policy->bindings()) {
    if (binding.role() != role || binding.has_condition()) {
      continue;
    }
    auto& members = binding.members();
    if (std::find(members.begin(), members.end(), member) == members.end()) {
      members.emplace_back(member);
    }
  }

  auto updated = client.SetNativeBucketIamPolicy(bucket_name, *policy);
  if (!updated) throw std::move(updated).status();

  std::cout << "Updated IAM policy bucket " << bucket_name
            << ". The new policy is " << *updated << "\n";
}

C#


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

public class AddBucketIamMemberSample
{
    public Policy AddBucketIamMember(
        string bucketName = "your-unique-bucket-name",
        string role = "roles/storage.objectViewer",
        string member = "serviceAccount:dev@iam.gserviceaccount.com")
    {
        var storage = StorageClient.Create();
        var policy = storage.GetBucketIamPolicy(bucketName, new GetBucketIamPolicyOptions
        {
            RequestedPolicyVersion = 3
        });
        // Set the policy schema version. For more information, please refer to https://cloud.google.com/iam/docs/policies#versions.
        policy.Version = 3;

        Policy.BindingsData bindingToAdd = new Policy.BindingsData
        {
            Role = role,
            Members = new List<string> { member }
        };

        policy.Bindings.Add(bindingToAdd);
        var bucketIamPolicy = storage.SetBucketIamPolicy(bucketName, policy);
        Console.WriteLine($"Added {member} with role {role} " + $"to {bucketName}");
        return bucketIamPolicy;
    }
}

Go

import (
	"context"
	"fmt"
	"io"
	"time"

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

// addBucketIAMMember adds the bucket IAM member to permission role.
func addBucketIAMMember(w io.Writer, bucketName string) error {
	// bucketName := "bucket-name"
	ctx := context.Background()
	client, err := storage.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("storage.NewClient: %w", err)
	}
	defer client.Close()

	ctx, cancel := context.WithTimeout(ctx, time.Second*10)
	defer cancel()

	bucket := client.Bucket(bucketName)
	policy, err := bucket.IAM().Policy(ctx)
	if err != nil {
		return fmt.Errorf("Bucket(%q).IAM().Policy: %w", bucketName, err)
	}
	// Other valid prefixes are "serviceAccount:", "user:"
	// See the documentation for more values.
	// https://cloud.google.com/storage/docs/access-control/iam
	identity := "group:cloud-logs@google.com"
	var role iam.RoleName = "roles/storage.objectViewer"

	policy.Add(identity, role)
	if err := bucket.IAM().SetPolicy(ctx, policy); err != nil {
		return fmt.Errorf("Bucket(%q).IAM().SetPolicy: %w", bucketName, err)
	}
	// NOTE: It may be necessary to retry this operation if IAM policies are
	// being modified concurrently. SetPolicy will return an error if the policy
	// was modified since it was retrieved.
	fmt.Fprintf(w, "Added %v with role %v to %v\n", identity, role, bucketName)
	return nil
}

Java


import com.google.cloud.Binding;
import com.google.cloud.Policy;
import com.google.cloud.storage.Storage;
import com.google.cloud.storage.StorageOptions;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class AddBucketIamMember {
  /** Example of adding a member to the Bucket-level IAM */
  public static void addBucketIamMember(String projectId, String bucketName) {
    // The ID of your GCP project
    // String projectId = "your-project-id";

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

    // For more information please read:
    // https://cloud.google.com/storage/docs/access-control/iam
    Storage storage = StorageOptions.newBuilder().setProjectId(projectId).build().getService();

    Policy originalPolicy =
        storage.getIamPolicy(bucketName, Storage.BucketSourceOption.requestedPolicyVersion(3));

    String role = "roles/storage.objectViewer";
    String member = "group:example@google.com";

    // getBindingsList() returns an ImmutableList and copying over to an ArrayList so it's mutable.
    List<Binding> bindings = new ArrayList(originalPolicy.getBindingsList());

    // Create a new binding using role and member
    Binding.Builder newMemberBindingBuilder = Binding.newBuilder();
    newMemberBindingBuilder.setRole(role).setMembers(Arrays.asList(member));
    bindings.add(newMemberBindingBuilder.build());

    // Update policy to add member
    Policy.Builder updatedPolicyBuilder = originalPolicy.toBuilder();
    updatedPolicyBuilder.setBindings(bindings).setVersion(3);
    Policy updatedPolicy = storage.setIamPolicy(bucketName, updatedPolicyBuilder.build());

    System.out.printf("Added %s with role %s to %s\n", member, role, bucketName);
  }
}

Node.js

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

// The role to grant
// const roleName = 'roles/storage.objectViewer';

// The members to grant the new role to
// const members = [
//   'user:jdoe@example.com',
//   'group:admins@example.com',
// ];

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

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

async function addBucketIamMember() {
  // Get a reference to a Google Cloud Storage bucket
  const bucket = storage.bucket(bucketName);

  // For more information please read:
  // https://cloud.google.com/storage/docs/access-control/iam
  const [policy] = await bucket.iam.getPolicy({requestedPolicyVersion: 3});

  // Adds the new roles to the bucket's IAM policy
  policy.bindings.push({
    role: roleName,
    members: members,
  });

  // Updates the bucket's IAM policy
  await bucket.iam.setPolicy(policy);

  console.log(
    `Added the following member(s) with role ${roleName} to ${bucketName}:`
  );

  members.forEach(member => {
    console.log(`  ${member}`);
  });
}

addBucketIamMember().catch(console.error);

PHP

use Google\Cloud\Storage\StorageClient;

/**
 * Adds a new member / role IAM pair to a given Cloud Storage bucket.
 *
 * @param string $bucketName The name of your Cloud Storage bucket.
 *        (e.g. 'my-bucket')
 * @param string $role The role to which the given member should be added.
 *        (e.g. 'roles/storage.objectViewer')
 * @param string[] $members The member(s) to be added to the role.
 *        (e.g. ['group:example@google.com'])
 */
function add_bucket_iam_member(string $bucketName, string $role, array $members): void
{
    $storage = new StorageClient();
    $bucket = $storage->bucket($bucketName);

    $policy = $bucket->iam()->policy(['requestedPolicyVersion' => 3]);
    $policy['version'] = 3;

    $policy['bindings'][] = [
        'role' => $role,
        'members' => $members
    ];

    $bucket->iam()->setPolicy($policy);

    printf('Added the following member(s) to role %s for bucket %s' . PHP_EOL, $role, $bucketName);
    foreach ($members as $member) {
        printf('    %s' . PHP_EOL, $member);
    }
}

Python

from google.cloud import storage

def add_bucket_iam_member(bucket_name, role, member):
    """Add a new member to an IAM Policy"""
    # bucket_name = "your-bucket-name"
    # role = "IAM role, e.g., roles/storage.objectViewer"
    # member = "IAM identity, e.g., user: name@example.com"

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

    policy = bucket.get_iam_policy(requested_policy_version=3)

    policy.bindings.append({"role": role, "members": {member}})

    bucket.set_iam_policy(policy)

    print(f"Added {member} with role {role} to {bucket_name}.")

Ruby

def add_bucket_iam_member bucket_name:
  # The ID of your GCS bucket
  # bucket_name = "your-unique-bucket-name"

  require "google/cloud/storage"

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

  role   = "roles/storage.objectViewer"
  member = "group:example@google.com"

  bucket.policy requested_policy_version: 3 do |policy|
    policy.bindings.insert role: role, members: [member]
  end

  puts "Added #{member} with role #{role} to #{bucket_name}"
end

JSON

Faites en sorte que la gcloud CLI soit installée et initialisée afin de générer un jeton d'accès pour l'en-tête Authorization.

Vous pouvez également créer un jeton d'accès à l'aide de OAuth 2.0 Playground et l'inclure dans l'en-tête Authorization.
Créez un fichier JSON contenant les informations suivantes :
```
{
"bindings":[
  {
    "role": "roles/storage.legacyBucketWriter",
    "members":[
      "YOUR_AGENT_EMAIL"
    ]
  }
]
}
```
Où :
- YOUR_AGENT_EMAIL correspond à l'adresse e-mail de l'agent que vous avez copiée dans Rechercher l'adresse e-mail de l'agent de service.
Exécutez cURL pour appeler l'API JSON avec une requête PUT setIamPolicy :
```
curl -X PUT --data-binary @JSON_FILE_NAME \
-H "Authorization: Bearer OAUTH2_TOKEN" \
-H "Content-Type: application/json" \
"https://storage.googleapis.com/storage/v1/b/BUCKET_NAME/iam"
```
Où :
- JSON_FILE_NAME correspond au chemin d'accès au fichier que vous avez créé à l'étape 2.
- OAUTH2_TOKEN correspond au jeton d'accès que vous avez généré à l'étape 1.
- BUCKET_NAME correspond au nom du bucket pour lequel vous voulez accorder l'accès au compte principal. Exemple :my-bucket

Pour en savoir plus sur l'attribution de rôles IAM aux ressources Cloud Storage, consultez la documentation IAM de Cloud Storage.