Google utilise la technologie IA pour traduire le contenu dans votre langue préférée. Les traductions générées par IA peuvent contenir des erreurs.

Configurer l'accès à une source : Cloud Storage

Le service de transfert de stockage utilise un agent de service pour déplacer des données depuis un bucket source Cloud Storage. Cet agent de service est créé la première fois que vous appelez googleServiceAccounts.get.

Le bucket source 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 source :

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 Google Cloud console

Si vous utilisez la Google Cloud console 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 source.

Vous pouvez ignorer les étapes décrites sur cette page et passer directement à la création d'un transfert.

Autorisations requises

L'agent de service doit disposer des autorisations suivantes applicables au bucket source :

Autorisation	Description
`storage.buckets.get`	Permet à l'agent de service d'obtenir l'emplacement du bucket.
`storage.objects.list`	Permet à l'agent de service de répertorier les objets présents dans le bucket.
`storage.objects.get`	Permet à l'agent de service de lire les objets dans le bucket.
`storage.objects.create`	Permet à l'agent de service de créer des objets dans le bucket. Obligatoire si le transfert s'effectue vers un système de fichiers. Le service de transfert de stockage crée et remplit deux dossiers dans le bucket source : `cloud-ingest/` contient les informations du système de fichiers, et `storage-transfer/` contient les journaux de transfert.
`storage.objects.delete`	Permet à l'agent de service de supprimer des objets du bucket. Obligatoire si vous définissez `deleteObjectsFromSourceAfterTransfer` sur `true`.
`storage.objects.getIamPolicy`	Permet à l'agent de service de lire les LCA sur les objets sources. Obligatoire si la conservation des LCA d'objet (`ACL_PRESERVE`) est activée.

Les rôles prédéfinis suivants accordent ensemble les autorisations requises :

Au choix :
- Lecteur des objets Storage (roles/storage.objectViewer) si le transfert se fait vers un autre bucket Cloud Storage.
- Créateur des objets de l'espace de stockage (roles/storage.objectCreator) si le transfert concerne un système de fichiers.
Plus un des éléments suivants :
- Rédacteur des anciens buckets Storage (roles/storage.legacyBucketWriter) si une autorisation de suppression d'objet est requise.
- Lecteur des anciens buckets Storage (roles/storage.legacyBucketReader) si l'autorisation de suppression des objets n'est pas requise.
De plus, si vous conservez les LCA d'objet avec ACL_PRESERVE :
- Propriétaire des anciens objets de l'espace de stockage (roles/storage.legacyObjectOwner)

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 les autorisations requises à l'agent de service, procédez comme suit :

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 source.
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 Google Cloud console, accédez à la page Buckets de 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 Object Viewer ou Storage Object Creator dans le menu déroulant Rôle.
Cliquez sur Ajouter un autre rôle.
Sélectionnez Storage Legacy Bucket Writer ou Storage Legacy Bucket Reader.
Cliquez sur Enregistrer.

gcloud

Exécutez la commande gcloud storage buckets add-iam-policy-binding :

gcloud storage buckets add-iam-policy-binding gs://BUCKET_NAME \
--member=serviceAccount:YOUR_AGENT_EMAIL --role=roles/storage.objectViewer

gcloud storage buckets add-iam-policy-binding gs://BUCKET_NAME \
--member=serviceAccount:YOUR_AGENT_EMAIL --role=roles/storage.legacyBucketReader

Remplacez les éléments suivants :

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

Exemples de code

C++

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

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 les bibliothèques clientes.

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

Rust

use google_cloud_iam_v1::model::Binding;
use google_cloud_storage::client::StorageControl;

pub async fn sample(
    client: &StorageControl,
    bucket_id: &str,
    role: &str,
    member: &str,
) -> anyhow::Result<()> {
    let mut policy = client
        .get_iam_policy()
        .set_resource(format!("projects/_/buckets/{bucket_id}"))
        .send()
        .await?;
    policy
        .bindings
        .push(Binding::new().set_role(role).set_members([member]));
    let updated_policy = client
        .set_iam_policy()
        .set_resource(format!("projects/_/buckets/{bucket_id}"))
        .set_policy(policy)
        .send()
        .await?;
    println!(
        "Successfully added binding for {member} to bucket {bucket_id} policy: {updated_policy:?}"
    );
    Ok(())
}

JSON

Vous devez installer et initialiser la gcloud CLI installée et initialisée, ce qui vous permet de générer un jeton d'accès pour l'en-tête Authorization.

Créez un fichier JSON contenant les informations suivantes :

{
"bindings":[
  {
    "role": "roles/storage.objectViewer",
    "members":[
      "YOUR_AGENT_EMAIL"
    ]
  },
  {
    "role": "roles/storage.legacyBucketReader",
    "members":[
      "YOUR_AGENT_EMAIL"
    ]
  }
]
}