Usa permisos de IAM

Descripción general

En esta página, se describe cómo controlar el acceso a los buckets y objetos a través de los permisos de Identity and Access Management (IAM). IAM te permite controlar quién tiene acceso a tus buckets, carpetas administradas y objetos.

Para obtener información acerca de otras formas de controlar el acceso a los buckets, las carpetas administradas y los objetos, consulta la Descripción general del control de acceso. Para obtener información acerca de cómo controlar el acceso a objetos individuales en los buckets, consulta Listas de control de acceso.

Usa IAM con buckets

En las siguientes secciones, se muestra cómo completar las tareas básicas de IAM en los buckets.

Funciones obligatorias

Para obtener los permisos que necesitas a fin de configurar y administrar las políticas de IAM para un bucket, pídele a tu administrador que te otorgue el rol de IAM Administrador de almacenamiento (roles/storage.admin) para el bucket.

Esta función contiene los siguientes permisos, que son necesarios a fin de configurar y administrar las políticas de IAM para los buckets:

storage.buckets.get
storage.buckets.getIamPolicy
storage.buckets.setIamPolicy
storage.buckets.update
storage.buckets.list
- Este permiso solo es necesario si planeas usar la consola de Google Cloud para realizar la tarea en esta página.

También puedes obtener estos permisos con roles personalizados.

Agrega un principal a una política a nivel de bucket

Para obtener una lista de los roles asociados con Cloud Storage, consulta Roles de IAM. Para obtener información de las entidades a las que les otorgas roles de IAM, consulta Identificadores principales.

Consola

En la consola de Google Cloud, ve a la página Buckets de Cloud Storage.
Ir a Buckets
En la lista de buckets, haz clic en el nombre del bucket para el que deseas otorgar un rol a una principal.
Selecciona la pestaña Permisos cerca de la parte superior de la página.
Haz clic en el botón Otorgar acceso.

Aparecerá el cuadro de diálogo Agregar principales.
En el campo Nuevas principales, ingresa una o más identidades que necesiten acceso a tu bucket.
Elige un rol (o roles) del menú desplegable Selecciona un rol. Los roles que seleccionas aparecen en el panel con una descripción breve del permiso que otorgan.
Haz clic en Guardar.

Para obtener información acerca de cómo ver detalles de errores acerca de operaciones fallidas de Cloud Storage en la consola de Google Cloud, consulta Solución de problemas.

Línea de comandos

Usa el comando buckets add-iam-policy-binding:

gcloud storage buckets add-iam-policy-binding gs://BUCKET_NAME --member=PRINCIPAL_IDENTIFIER --role=IAM_ROLE

Aquí:

BUCKET_NAME es el nombre del bucket al cual le otorgas acceso principal. Por ejemplo, my-bucket
PRINCIPAL_IDENTIFIER identifica a quién le otorgas acceso al bucket. Por ejemplo, user:jane@gmail.com Para obtener una lista de los formatos de identificador principal, consulta Identificadores de principal.
IAM_ROLE es el rol de IAM que le estás otorgando a la principal. Por ejemplo, roles/storage.objectViewer.

Bibliotecas cliente

C++

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage C++.

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo 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#

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage 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

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage 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

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage 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

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage 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

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage 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

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage 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

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage 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

API de REST

JSON

Obtén un token de autorización de acceso de OAuth 2.0 Playground. Configura Playground para usar tus credenciales de OAuth. Para obtener instrucciones, consulta Autenticación de la API.
Crea un archivo JSON que contenga la siguiente información:
```
{
"bindings":[
  {
    "role": "IAM_ROLE",
    "members":[
      "PRINCIPAL_IDENTIFIER"
    ]
  }
]
}
```
Aquí:
- IAM_ROLE es el rol de IAM que deseas otorgar. Por ejemplo, roles/storage.objectViewer
- PRINCIPAL_IDENTIFIER identifica a quién le otorgas acceso al bucket. Por ejemplo, user:jane@gmail.com Para obtener una lista de los formatos de identificador principal, consulta Identificadores principales.
Usa cURL para llamar a la API de JSON con una solicitud 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"
```
Aquí:
- JSON_FILE_NAME es la ruta de acceso del archivo que creaste en el paso 2.
- OAUTH2_TOKEN es el token de acceso que generaste en el paso 1.
- BUCKET_NAME es el nombre del bucket al que le quieres otorgar acceso al principal. Por ejemplo, my-bucket

Visualiza la política de IAM para un bucket

Consola

En la consola de Google Cloud, ve a la página Buckets de Cloud Storage.
Ir a Buckets
En la lista de buckets, haz clic en el nombre del bucket cuya política deseas ver.
En la página Detalles del bucket, haz clic en la pestaña Permisos.

La política de IAM que se aplica al bucket aparece en la sección Permisos.
Opcional: Usa la barra Filtros para filtrar tus resultados.

Si buscas por principal, tus resultados mostrarán cada rol que se otorga al principal.

Línea de comandos

Usa el comando buckets get-iam-policy:

gcloud storage buckets get-iam-policy gs://BUCKET_NAME

En el ejemplo anterior, BUCKET_NAME es el nombre del bucket cuya política de IAM deseas ver. Por ejemplo, my-bucket

Bibliotecas cliente

C++

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage C++.

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

  if (!policy) throw std::move(policy).status();
  std::cout << "The IAM policy for bucket " << bucket_name << " is "
            << *policy << "\n";
}

C#

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage C#.


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

public class ViewBucketIamMembersSample
{
    public Policy ViewBucketIamMembers(string bucketName = "your-unique-bucket-name")
    {
        var storage = StorageClient.Create();
        var policy = storage.GetBucketIamPolicy(bucketName, new GetBucketIamPolicyOptions
        {
            RequestedPolicyVersion = 3
        });

        foreach (var binding in policy.Bindings)
        {
            Console.WriteLine($"Role: {binding.Role}");
            Console.WriteLine("Members:");
            foreach (var member in binding.Members)
            {
                Console.WriteLine($"{member}");
            }
        }
        return policy;
    }
}

Go

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage Go.

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

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

// getBucketPolicy gets the bucket IAM policy.
func getBucketPolicy(w io.Writer, bucketName string) (*iam.Policy3, error) {
	// bucketName := "bucket-name"
	ctx := context.Background()
	client, err := storage.NewClient(ctx)
	if err != nil {
		return nil, fmt.Errorf("storage.NewClient: %w", err)
	}
	defer client.Close()

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

	policy, err := client.Bucket(bucketName).IAM().V3().Policy(ctx)
	if err != nil {
		return nil, fmt.Errorf("Bucket(%q).IAM().V3().Policy: %w", bucketName, err)
	}
	for _, binding := range policy.Bindings {
		fmt.Fprintf(w, "%q: %q (condition: %v)\n", binding.Role, binding.Members, binding.Condition)
	}
	return policy, nil
}

Java

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage Java.

import com.google.cloud.Binding;
import com.google.cloud.Policy;
import com.google.cloud.storage.Storage;
import com.google.cloud.storage.StorageOptions;

public class ListBucketIamMembers {
  public static void listBucketIamMembers(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 policy =
        storage.getIamPolicy(bucketName, Storage.BucketSourceOption.requestedPolicyVersion(3));

    // Print binding information
    for (Binding binding : policy.getBindingsList()) {
      System.out.printf("Role: %s Members: %s\n", binding.getRole(), binding.getMembers());

      // Print condition if one is set
      boolean bindingIsConditional = binding.getCondition() != null;
      if (bindingIsConditional) {
        System.out.printf("Condition Title: %s\n", binding.getCondition().getTitle());
        System.out.printf("Condition Description: %s\n", binding.getCondition().getDescription());
        System.out.printf("Condition Expression: %s\n", binding.getCondition().getExpression());
      }
    }
  }
}

Node.js

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage Node.js.

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

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

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

async function viewBucketIamMembers() {
  // For more information please read:
  // https://cloud.google.com/storage/docs/access-control/iam
  const results = await storage
    .bucket(bucketName)
    .iam.getPolicy({requestedPolicyVersion: 3});

  const bindings = results[0].bindings;

  console.log(`Bindings for bucket ${bucketName}:`);
  for (const binding of bindings) {
    console.log(`  Role: ${binding.role}`);
    console.log('  Members:');

    const members = binding.members;
    for (const member of members) {
      console.log(`    ${member}`);
    }

    const condition = binding.condition;
    if (condition) {
      console.log('  Condition:');
      console.log(`    Title: ${condition.title}`);
      console.log(`    Description: ${condition.description}`);
      console.log(`    Expression: ${condition.expression}`);
    }
  }
}

viewBucketIamMembers().catch(console.error);

PHP

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage PHP.

use Google\Cloud\Storage\StorageClient;

/**
 * View Bucket IAM members for a given Cloud Storage bucket.
 *
 * @param string $bucketName The name of your Cloud Storage bucket.
 *        (e.g. 'my-bucket')
 */
function view_bucket_iam_members(string $bucketName): void
{
    $storage = new StorageClient();
    $bucket = $storage->bucket($bucketName);

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

    printf('Printing Bucket IAM members for Bucket: %s' . PHP_EOL, $bucketName);
    printf(PHP_EOL);

    foreach ($policy['bindings'] as $binding) {
        printf('Role: %s' . PHP_EOL, $binding['role']);
        printf('Members:' . PHP_EOL);
        foreach ($binding['members'] as $member) {
            printf('  %s' . PHP_EOL, $member);
        }

        if (isset($binding['condition'])) {
            $condition = $binding['condition'];
            printf('  with condition:' . PHP_EOL);
            printf('    Title: %s' . PHP_EOL, $condition['title']);
            printf('    Description: %s' . PHP_EOL, $condition['description']);
            printf('    Expression: %s' . PHP_EOL, $condition['expression']);
        }
        printf(PHP_EOL);
    }
}

Python

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage Python.

from google.cloud import storage


def view_bucket_iam_members(bucket_name):
    """View IAM Policy for a bucket"""
    # bucket_name = "your-bucket-name"

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

    policy = bucket.get_iam_policy(requested_policy_version=3)

    for binding in policy.bindings:
        print(f"Role: {binding['role']}, Members: {binding['members']}")

Ruby

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage Ruby.

def view_bucket_iam_members 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

  policy = bucket.policy requested_policy_version: 3
  policy.bindings.each do |binding|
    puts "Role: #{binding.role}"
    puts "Members: #{binding.members}"

    # if a conditional binding exists print the condition.
    if binding.condition
      puts "Condition Title: #{binding.condition.title}"
      puts "Condition Description: #{binding.condition.description}"
      puts "Condition Expression: #{binding.condition.expression}"
    end
  end
end

API de REST

JSON

Obtén un token de autorización de acceso de OAuth 2.0 Playground. Configura Playground para usar tus credenciales de OAuth. Para obtener instrucciones, consulta Autenticación de la API.
Usa cURL para llamar a la API de JSON con una solicitud GET getIamPolicy:
```
curl -X GET \
-H "Authorization: Bearer OAUTH2_TOKEN" \
"https://storage.googleapis.com/storage/v1/b/BUCKET_NAME/iam"
```
Aquí:
- OAUTH2_TOKEN es el token de acceso que generaste en el paso 1.
- BUCKET_NAME es el nombre del bucket cuya política de IAM deseas ver. Por ejemplo, my-bucket

Quita a un principal de una política de nivel de bucket

Consola

En la consola de Google Cloud, ve a la página Buckets de Cloud Storage.
Ir a Buckets
En la lista de buckets, haz clic en el nombre del bucket del que deseas quitar el rol de una principal.
En la página Detalles del bucket, haz clic en la pestaña Permisos.

La política de IAM que se aplica al bucket aparece en la sección Permisos.
En la pestaña Ver por principales, selecciona la casilla de verificación de la principal que deseas quitar.
Haz clic en el botón Quitar acceso.
En la ventana de superposición que aparece, haz clic en Confirmar.

Para obtener información acerca de cómo ver detalles de errores acerca de operaciones fallidas de Cloud Storage en la consola de Google Cloud, consulta Solución de problemas.

Línea de comandos

Usa el comando buckets remove-iam-policy-binding:

gcloud storage buckets remove-iam-policy-binding  gs://BUCKET_NAME --member=PRINCIPAL_IDENTIFIER --role=IAM_ROLE

Aquí:

BUCKET_NAME es el nombre del bucket al que revocas el acceso. Por ejemplo, my-bucket
PRINCIPAL_IDENTIFIER identifica a quién revocas el acceso. Por ejemplo, user:jane@gmail.com Para obtener una lista de los formatos de identificador principal, consulta Identificadores de principal.
IAM_ROLE es el rol de IAM que estás revocando. Por ejemplo, roles/storage.objectViewer.

Bibliotecas cliente

C++

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage C++.

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);
  std::vector<google::cloud::storage::NativeIamBinding> updated_bindings;
  for (auto& binding : policy->bindings()) {
    auto& members = binding.members();
    if (binding.role() == role && !binding.has_condition()) {
      members.erase(std::remove(members.begin(), members.end(), member),
                    members.end());
    }
    if (!members.empty()) {
      updated_bindings.emplace_back(std::move(binding));
    }
  }
  policy->bindings() = std::move(updated_bindings);

  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#

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage C#.


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

public class RemoveBucketIamMemberSample
{
    public void RemoveBucketIamMember(
        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;

        foreach (var binding in policy.Bindings.Where(c => c.Role == role).ToList())
        {
            // Remove the role/member combo from the IAM policy.
            binding.Members = binding.Members.Where(m => m != member).ToList();
            // Remove role if it contains no members.
            if (binding.Members.Count == 0)
            {
                policy.Bindings.Remove(binding);
            }
        }
        // Set the modified IAM policy to be the current IAM policy.
        storage.SetBucketIamPolicy(bucketName, policy);
        Console.WriteLine($"Removed {member} with role {role} from {bucketName}");
    }
}

Go

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage Go.

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

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

// removeBucketIAMMember removes the bucket IAM member.
func removeBucketIAMMember(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
	// member string, role iam.RoleName
	identity := "group:cloud-logs@google.com"
	var role iam.RoleName = "roles/storage.objectViewer"

	policy.Remove(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, "Removed %v with role %v from %v\n", identity, role, bucketName)
	return nil
}

Java

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage 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.List;

public class RemoveBucketIamMember {
  public static void removeBucketIamMember(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());

    // Remove role-member binding without a condition.
    for (int index = 0; index < bindings.size(); index++) {
      Binding binding = bindings.get(index);
      boolean foundRole = binding.getRole().equals(role);
      boolean foundMember = binding.getMembers().contains(member);
      boolean bindingIsNotConditional = binding.getCondition() == null;

      if (foundRole && foundMember && bindingIsNotConditional) {
        bindings.set(index, binding.toBuilder().removeMembers(member).build());
        break;
      }
    }

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

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

Node.js

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage 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 revoke
// const roleName = 'roles/storage.objectViewer';

// The members to revoke the roles from
// 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 removeBucketIamMember() {
  // 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});

  // Finds and updates the appropriate role-member group, without a condition.
  const index = policy.bindings.findIndex(
    binding => binding.role === roleName && !binding.condition
  );

  const role = policy.bindings[index];
  if (role) {
    role.members = role.members.filter(
      member => members.indexOf(member) === -1
    );

    // Updates the policy object with the new (or empty) role-member group
    if (role.members.length === 0) {
      policy.bindings.splice(index, 1);
    } else {
      policy.bindings.index = role;
    }

    // Updates the bucket's IAM policy
    await bucket.iam.setPolicy(policy);
  } else {
    // No matching role-member group(s) were found
    throw new Error('No matching role-member group(s) found.');
  }

  console.log(
    `Removed the following member(s) with role ${roleName} from ${bucketName}:`
  );
  members.forEach(member => {
    console.log(`  ${member}`);
  });
}

removeBucketIamMember().catch(console.error);

PHP

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage PHP.

use Google\Cloud\Storage\StorageClient;

/**
 * Removes a member / role IAM pair from a given Cloud Storage bucket.
 *
 * @param string $bucketName The name of your Cloud Storage bucket.
 *        (e.g. 'my-bucket')
 * @param string $role The role from which the specified member should be removed.
 *        (e.g. 'roles/storage.objectViewer')
 * @param string $member The member to be removed from the specified role.
 *        (e.g. 'group:example@google.com')
 */
function remove_bucket_iam_member(string $bucketName, string $role, string $member): void
{
    $storage = new StorageClient();
    $bucket = $storage->bucket($bucketName);
    $iam = $bucket->iam();
    $policy = $iam->policy(['requestedPolicyVersion' => 3]);
    $policy['version'] = 3;

    foreach ($policy['bindings'] as $i => $binding) {
        // This example only removes member from bindings without a condition.
        if ($binding['role'] == $role && !isset($binding['condition'])) {
            $key = array_search($member, $binding['members']);
            if ($key !== false) {
                unset($binding['members'][$key]);

                // If the last member is removed from the binding, clean up the
                // binding.
                if (count($binding['members']) == 0) {
                    unset($policy['bindings'][$i]);
                    // Ensure array keys are sequential, otherwise JSON encodes
                    // the array as an object, which fails when calling the API.
                    $policy['bindings'] = array_values($policy['bindings']);
                } else {
                    // Ensure array keys are sequential, otherwise JSON encodes
                    // the array as an object, which fails when calling the API.
                    $binding['members'] = array_values($binding['members']);
                    $policy['bindings'][$i] = $binding;
                }

                $iam->setPolicy($policy);
                printf('User %s removed from role %s for bucket %s' . PHP_EOL, $member, $role, $bucketName);
                return;
            }
        }
    }

    throw new \RuntimeException('No matching role-member group(s) found.');
}

Python

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage Python.

from google.cloud import storage


def remove_bucket_iam_member(bucket_name, role, member):
    """Remove member from bucket 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)

    for binding in policy.bindings:
        print(binding)
        if binding["role"] == role and binding.get("condition") is None:
            binding["members"].discard(member)

    bucket.set_iam_policy(policy)

    print(f"Removed {member} with role {role} from {bucket_name}.")

Ruby

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage Ruby.

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

  # For more information please read: https://cloud.google.com/storage/docs/access-control/iam

  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.each do |binding|
      if binding.role == role && binding.condition.nil?
        binding.members.delete member
      end
    end
  end

  puts "Removed #{member} with role #{role} from #{bucket_name}"
end

API de REST

JSON

Obtén un token de autorización de acceso de OAuth 2.0 Playground. Configura Playground para usar tus credenciales de OAuth. Para obtener instrucciones, consulta Autenticación de la API.
Obtén la política existente aplicada a tu bucket. Para ello, usa cURL para llamar a la API de JSON con una solicitud GET getIamPolicy:
```
curl -X GET \
-H "Authorization: Bearer OAUTH2_TOKEN" \
"https://storage.googleapis.com/storage/v1/b/BUCKET_NAME/iam"
```
Aquí:
- OAUTH2_TOKEN es el token de acceso que generaste en el paso 1.
- BUCKET_NAME es el nombre del bucket cuya política de IAM deseas ver. Por ejemplo, my-bucket
Crea un archivo JSON que contenga la política que recuperaste en el paso anterior.
Edita el archivo JSON para quitar al miembro de la política.
Usa cURL para llamar a la API de JSON con una solicitud 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"
```
Aquí:
- JSON_FILE_NAME es la ruta de acceso del archivo que creaste en el paso 3.
- OAUTH2_TOKEN es el token de acceso que generaste en el paso 1.
- BUCKET_NAME es el nombre del bucket del que deseas quitar el acceso. Por ejemplo, my-bucket

Usa condiciones de IAM en buckets

En las siguientes secciones, se muestra cómo agregar y quitar Condiciones de IAM en los buckets. Para ver las Condiciones de IAM para tu bucket, consulta Visualiza la política de IAM de un bucket. Si quieres obtener más información del uso de las Condiciones de IAM con Cloud Storage, consulta Condiciones.

Debes habilitar el acceso uniforme a nivel de bucket en el bucket antes de agregar condiciones.

Establece una nueva condición en un bucket

Consola

En la consola de Google Cloud, ve a la página Buckets de Cloud Storage.
Ir a Buckets
En la lista de buckets, haz clic en el nombre del bucket al que quieres agregar una condición nueva.
En la página Detalles del bucket, haz clic en la pestaña Permisos.

La política de IAM que se aplica al bucket aparece en la sección Permisos.
Haz clic en + Otorgar acceso.
En Principales nuevos, completa los principales a los que deseas otorgarles acceso a tu bucket.
Para cada rol al que desees aplicar una condición, sigue estos pasos:
1. Selecciona el rol que quieres otorgarles a los principales.
2. Haz clic en Agregar condición para abrir el formulario Editar condición.
3. Completa el Título de la condición. El campo Descripción es opcional.
4. Usa el Creador de condiciones para crear tu condición de forma visual, o usa la pestaña Editor de condiciones para ingresar la expresión CEL.
5. Haz clic en Guardar para regresar al formulario Agregar miembros. Para agregar varios roles, haz clic en Agregar otro rol.
Haz clic en Guardar.

Para obtener información acerca de cómo ver detalles de errores acerca de operaciones fallidas de Cloud Storage en la consola de Google Cloud, consulta Solución de problemas.

Línea de comandos

Crea un archivo JSON o YAML que defina la condición, incluido el title de la condición, la expression lógica basada en atributos para la condición y, de forma opcional, , una description de la condición.

Ten en cuenta que Cloud Storage solo admite los atributos de fecha/hora ,tipo de recurso y nombre del recurso en el expression.
Usa el comandobuckets add-iam-policy-binding con la marca --condition-from-file:

gcloud storage buckets add-iam-policy-binding  gs://BUCKET_NAME --member=PRINCIPAL_IDENTIFIER --role=IAM_ROLE --condition-from-file=CONDITION_FILE

Aquí:

BUCKET_NAME es el nombre del bucket al cual le otorgas acceso principal. Por ejemplo, my-bucket
PRINCIPAL_IDENTIFIER identifica a quién se aplica la condición. Por ejemplo, user:jane@gmail.com Para obtener una lista de los formatos de identificador principal, consulta Identificadores de principal.
IAM_ROLE es el rol de IAM que le estás otorgando a la principal. Por ejemplo, roles/storage.objectViewer
CONDITION_FILE es el archivo que creaste en el paso anterior.

Como alternativa, puedes incluir la condición de forma directa en el comando con la marca --condition en lugar de la marca --condition-from-file.

Bibliotecas cliente

C++

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage C++.

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,
   std::string const& condition_title,
   std::string const& condition_description,
   std::string const& condition_expression) {
  auto policy = client.GetNativeBucketIamPolicy(
      bucket_name, gcs::RequestedPolicyVersion(3));
  if (!policy) throw std::move(policy).status();

  policy->set_version(3);
  policy->bindings().emplace_back(gcs::NativeIamBinding(
      role, {member},
      gcs::NativeExpression(condition_expression, condition_title,
                            condition_description)));

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

  std::cout << "Added member " << member << " with role " << role << " to "
            << bucket_name << ":\n";
  std::cout << "with condition:\n"
            << "\t Title: " << condition_title << "\n"
            << "\t Description: " << condition_description << "\n"
            << "\t Expression: " << condition_expression << "\n";
}

C#

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage C#.


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

public class AddBucketConditionalIamBindingSample
{
    /// <summary>
    /// Adds a conditional Iam policy to a bucket.
    /// </summary>
    /// <param name="bucketName">The name of the bucket.</param>
    /// <param name="role">The role that members may assume.</param>
    /// <param name="member">The identifier of the member who may assume the provided role.</param>
    /// <param name="title">Title for the expression.</param>
    /// <param name="description">Description of the expression.</param>
    /// <param name="expression">Describes the conditions that need to be met for the policy to be applied.
    /// It's represented as a string using Common Expression Language syntax.</param>
    public Policy AddBucketConditionalIamBinding(
        string bucketName = "your-unique-bucket-name",
        string role = "roles/storage.objectViewer",
        string member = "serviceAccount:dev@iam.gserviceaccount.com",
        string title = "title",
        string description = "description",
        string expression = "resource.name.startsWith(\"projects/_/buckets/bucket-name/objects/prefix-a-\")")
    {
        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 },
            Condition = new Expr
            {
                Title = title,
                Description = description,
                Expression = expression
            }
        };

        policy.Bindings.Add(bindingToAdd);

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

Go

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage Go.

ctx := context.Background()

ctx, cancel := context.WithTimeout(ctx, time.Second*10)
defer cancel()
bucket := c.Bucket(bucketName)
policy, err := bucket.IAM().V3().Policy(ctx)
if err != nil {
	return err
}

policy.Bindings = append(policy.Bindings, &iampb.Binding{
	Role:    role,
	Members: []string{member},
	Condition: &expr.Expr{
		Title:       title,
		Description: description,
		Expression:  expression,
	},
})

if err := bucket.IAM().V3().SetPolicy(ctx, policy); err != nil {
	return 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.

Java

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage Java.


import com.google.cloud.Binding;
import com.google.cloud.Condition;
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 AddBucketIamConditionalBinding {
  /** Example of adding a conditional binding to the Bucket-level IAM */
  public static void addBucketIamConditionalBinding(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";

    // Create a condition
    String conditionTitle = "Title";
    String conditionDescription = "Description";
    String conditionExpression =
        "resource.name.startsWith(\"projects/_/buckets/bucket-name/objects/prefix-a-\")";
    Condition.Builder conditionBuilder = Condition.newBuilder();
    conditionBuilder.setTitle(conditionTitle);
    conditionBuilder.setDescription(conditionDescription);
    conditionBuilder.setExpression(conditionExpression);

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

    // Add condition to a binding
    Binding.Builder newBindingBuilder =
        Binding.newBuilder()
            .setRole(role)
            .setMembers(Arrays.asList(member))
            .setCondition(conditionBuilder.build());
    bindings.add(newBindingBuilder.build());

    // Update policy with new conditional binding
    Policy.Builder updatedPolicyBuilder = originalPolicy.toBuilder();
    updatedPolicyBuilder.setBindings(bindings).setVersion(3);

    storage.setIamPolicy(bucketName, updatedPolicyBuilder.build());

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

Node.js

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage 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',
// ];

// Create a condition
// const title = 'Title';
// const description = 'Description';
// const expression = 'resource.name.startsWith(\"projects/_/buckets/bucket-name/objects/prefix-a-\")';

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

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

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

  // Gets and updates the bucket's IAM policy
  const [policy] = await bucket.iam.getPolicy({requestedPolicyVersion: 3});

  // Set the policy's version to 3 to use condition in bindings.
  policy.version = 3;

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

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

  console.log('with condition:');
  console.log(`  Title: ${title}`);
  console.log(`  Description: ${description}`);
  console.log(`  Expression: ${expression}`);
}

addBucketConditionalBinding().catch(console.error);

PHP

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage PHP.

use Google\Cloud\Storage\StorageClient;

/**
 * Adds a conditional IAM binding to a bucket's IAM policy.
 *
 * @param string $bucketName The name of your Cloud Storage bucket.
 *        (e.g. 'my-bucket')
 * @param string $role The role that will be given to members in this binding.
 *        (e.g. 'roles/storage.objectViewer')
 * @param string[] $members The member(s) associated with this binding.
 *        (e.g. ['group:example@google.com'])
 * @param string $title The title of the condition. (e.g. 'Title')
 * @param string $description The description of the condition.
 *        (e.g. 'Condition Description')
 * @param string $expression The condition specified in CEL expression language.
 *        (e.g. 'resource.name.startsWith("projects/_/buckets/bucket-name/objects/prefix-a-")')
 *
 * To see how to express a condition in CEL, visit:
 * @see https://cloud.google.com/storage/docs/access-control/iam#conditions.
 */
function add_bucket_conditional_iam_binding(string $bucketName, string $role, array $members, string $title, string $description, string $expression): void
{
    $storage = new StorageClient();
    $bucket = $storage->bucket($bucketName);

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

    $policy['version'] = 3;

    $policy['bindings'][] = [
        'role' => $role,
        'members' => $members,
        'condition' => [
            'title' => $title,
            'description' => $description,
            'expression' => $expression,
        ],
    ];

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

    printf('Added the following member(s) with role %s to %s:' . PHP_EOL, $role, $bucketName);
    foreach ($members as $member) {
        printf('    %s' . PHP_EOL, $member);
    }
    printf('with condition:' . PHP_EOL);
    printf('    Title: %s' . PHP_EOL, $title);
    printf('    Description: %s' . PHP_EOL, $description);
    printf('    Expression: %s' . PHP_EOL, $expression);
}

Python

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage Python.

from google.cloud import storage


def add_bucket_conditional_iam_binding(
    bucket_name, role, title, description, expression, members
):
    """Add a conditional IAM binding to a bucket's IAM policy."""
    # bucket_name = "your-bucket-name"
    # role = "IAM role, e.g. roles/storage.objectViewer"
    # members = {"IAM identity, e.g. user: name@example.com}"
    # title = "Condition title."
    # description = "Condition description."
    # expression = "Condition expression."

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

    policy = bucket.get_iam_policy(requested_policy_version=3)

    # Set the policy's version to 3 to use condition in bindings.
    policy.version = 3

    policy.bindings.append(
        {
            "role": role,
            "members": members,
            "condition": {
                "title": title,
                "description": description,
                "expression": expression,
            },
        }
    )

    bucket.set_iam_policy(policy)

    print(f"Added the following member(s) with role {role} to {bucket_name}:")

    for member in members:
        print(f"    {member}")

    print("with condition:")
    print(f"    Title: {title}")
    print(f"    Description: {description}")
    print(f"    Expression: {expression}")

Ruby

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage Ruby.

def add_bucket_conditional_iam_binding 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"
  title       = "Title"
  description = "Description"
  expression  = "resource.name.startsWith(\"projects/_/buckets/bucket-name/objects/prefix-a-\")"

  bucket.policy requested_policy_version: 3 do |policy|
    policy.version = 3
    policy.bindings.insert(
      role:      role,
      members:   member,
      condition: {
        title:       title,
        description: description,
        expression:  expression
      }
    )
  end

  puts "Added #{member} with role #{role} to #{bucket_name} with condition #{title} #{description} #{expression}"
end

API de REST

JSON

Obtén un token de autorización de acceso de OAuth 2.0 Playground. Configura Playground para usar tus credenciales de OAuth. Para obtener instrucciones, consulta Autenticación de la API.
Usa una solicitud GET getIamPolicy para guardar la política de IAM del bucket en un archivo JSON temporal:
```
curl \
'https://storage.googleapis.com/storage/v1/b/BUCKET_NAME/iam' \
--header 'Authorization: Bearer OAUTH2_TOKEN' > tmp-policy.json
```
Aquí:
- OAUTH2_TOKEN es el token de acceso que generaste en el paso 1.
Edita el archivo tmp-policy.json en un editor de texto para agregar condiciones nuevas a las vinculaciones en la política de IAM:
```
{
    "version": VERSION,
    "bindings": [
      {
        "role": "IAM_ROLE",
        "members": [
          "PRINCIPAL_IDENTIFIER"
        ],
        "condition": {
          "title": "TITLE",
          "description": "DESCRIPTION",
          "expression": "EXPRESSION"
        }
      }
    ],
    "etag": "ETAG"
}
```
Aquí:
- VERSION es la versión de la política de IAM, que debe ser 3 para los buckets con Condiciones de IAM.
- IAM_ROLE es el rol al que se aplica la condición. Por ejemplo, roles/storage.objectViewer
- PRINCIPAL_IDENTIFIER identifica a quién se aplica la condición. Por ejemplo, user:jane@gmail.com Para obtener una lista de los formatos de identificador principal, consulta Identificadores de principal.
- TITLE es el título de la condición. Por ejemplo, expires in 2019.
- DESCRIPTION es una descripción opcional de la condición. Por ejemplo, Permission revoked on New Year's
- EXPRESSION es una expresión lógica basada en atributos. Por ejemplo, request.time < timestamp(\"2019-01-01T00:00:00Z\"). Si quieres obtener más ejemplos de expresiones, consulta la referencia de atributos para las Condiciones. Ten en cuenta que Cloud Storage solo admite los atributos de fecha y hora, tipo de recurso y nombre de recurso.
No modifiques ETAG.

Usa una solicitud PUT setIamPolicy para establecer la política de IAM modificada en el bucket:

curl -X PUT --data-binary @tmp-policy.json \
-H "Authorization: Bearer OAUTH2_TOKEN" \
-H "Content-Type: application/json" \
"https://storage.googleapis.com/storage/v1/b/BUCKET_NAME/iam"

Aquí:

OAUTH2_TOKEN es el token de acceso que generaste en el paso 1.

Quita una condición de un bucket

Consola

En la consola de Google Cloud, ve a la página Buckets de Cloud Storage.
Ir a Buckets
En la lista de buckets, haz clic en el nombre del bucket al que deseas quitar una condición.
En la página Detalles del bucket, haz clic en la pestaña Permisos.

La política de IAM que se aplica al bucket aparece en la sección Permisos.
Haz clic en el ícono Editar del principal asociado con la condición.
En la superposición Editar acceso que aparece, haz clic en el nombre de la condición que deseas borrar.
En la superposición Editar condición que aparece, haz clic en Borrar y, luego, en Confirmar.
Haz clic en Guardar.

Para obtener información acerca de cómo ver detalles de errores acerca de operaciones fallidas de Cloud Storage en la consola de Google Cloud, consulta Solución de problemas.

Línea de comandos

Usa el comando buckets get-iam-policy para guardar la política de IAM del bucket en un archivo JSON temporal.
```
gcloud storage buckets get-iam-policy gs://BUCKET_NAME > tmp-policy.json
```
Edita el archivo tmp-policy.json en un editor de texto para quitar las condiciones de la política de IAM.
Usa buckets set-iam-policy para establecer la política de IAM modificada en el bucket.
```
gcloud storage buckets set-iam-policy gs://BUCKET_NAME tmp-policy.json
```

Muestras de código

C++

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage C++.

namespace gcs = ::google::cloud::storage;
using ::google::cloud::StatusOr;
[](gcs::Client client, std::string const& bucket_name,
   std::string const& role, std::string const& condition_title,
   std::string const& condition_description,
   std::string const& condition_expression) {
  auto policy = client.GetNativeBucketIamPolicy(
      bucket_name, gcs::RequestedPolicyVersion(3));
  if (!policy) throw std::move(policy).status();

  policy->set_version(3);
  auto& bindings = policy->bindings();
  auto e = std::remove_if(
      bindings.begin(), bindings.end(),
      [role, condition_title, condition_description,
       condition_expression](gcs::NativeIamBinding b) {
        return (b.role() == role && b.has_condition() &&
                b.condition().title() == condition_title &&
                b.condition().description() == condition_description &&
                b.condition().expression() == condition_expression);
      });
  if (e == bindings.end()) {
    std::cout << "No matching binding group found.\n";
    return;
  }
  bindings.erase(e);
  auto updated = client.SetNativeBucketIamPolicy(bucket_name, *policy);
  if (!updated) throw std::move(updated).status();

  std::cout << "Conditional binding was removed.\n";
}

C#

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage C#.


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

public class RemoveBucketConditionalIamBindingSample
{
    public Policy RemoveBucketConditionalIamBinding(
        string bucketName = "your-unique-bucket-name",
        string role = "roles/storage.objectViewer",
        string title = "title",
        string description = "description",
        string expression = "resource.name.startsWith(\"projects/_/buckets/bucket-name/objects/prefix-a-\")")
    {
        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;

        var bindingsToRemove = policy.Bindings.Where(binding => binding.Role == role
              && binding.Condition != null
              && binding.Condition.Title == title
              && binding.Condition.Description == description
              && binding.Condition.Expression == expression).ToList();
        if (bindingsToRemove.Count() > 0)
        {
            foreach (var binding in bindingsToRemove)
            {
                policy.Bindings.Remove(binding);
            }
            // Set the modified IAM policy to be the current IAM policy.
            policy = storage.SetBucketIamPolicy(bucketName, policy);
            Console.WriteLine("Conditional Binding was removed.");
        }
        else
        {
            Console.WriteLine("No matching conditional binding found.");
        }
        return policy;
    }
}

Go

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage Go.

ctx := context.Background()

ctx, cancel := context.WithTimeout(ctx, time.Second*10)
defer cancel()
bucket := c.Bucket(bucketName)
policy, err := bucket.IAM().V3().Policy(ctx)
if err != nil {
	return err
}

// Find the index of the binding matching inputs
i := -1
for j, binding := range policy.Bindings {
	if binding.Role == role && binding.Condition != nil {
		condition := binding.Condition
		if condition.Title == title &&
			condition.Description == description &&
			condition.Expression == expression {
			i = j
		}
	}
}

if i == -1 {
	return errors.New("No matching binding group found.")
}

// Get a slice of the bindings, removing the binding at index i
policy.Bindings = append(policy.Bindings[:i], policy.Bindings[i+1:]...)

if err := bucket.IAM().V3().SetPolicy(ctx, policy); err != nil {
	return 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.

Java

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage Java.


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

public class RemoveBucketIamConditionalBinding {
  /** Example of removing a conditional binding to the Bucket-level IAM */
  public static void removeBucketIamConditionalBinding(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";

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

    // Create a condition to compare against
    Condition.Builder conditionBuilder = Condition.newBuilder();
    conditionBuilder.setTitle("Title");
    conditionBuilder.setDescription("Description");
    conditionBuilder.setExpression(
        "resource.name.startsWith(\"projects/_/buckets/bucket-name/objects/prefix-a-\")");

    Iterator iterator = bindings.iterator();
    while (iterator.hasNext()) {
      Binding binding = (Binding) iterator.next();
      boolean foundRole = binding.getRole().equals(role);
      boolean conditionsEqual = conditionBuilder.build().equals(binding.getCondition());

      // Remove condition when the role and condition are equal
      if (foundRole && conditionsEqual) {
        iterator.remove();
        break;
      }
    }

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

    System.out.println("Conditional Binding was removed.");
  }
}

Node.js

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage 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',
// ];

// Create a condition
// const title = 'Title';
// const description = 'Description';
// const expression = 'resource.name.startsWith(\"projects/_/buckets/bucket-name/objects/prefix-a-\")';

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

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

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

  // Gets and updates the bucket's IAM policy
  const [policy] = await bucket.iam.getPolicy({requestedPolicyVersion: 3});

  // Set the policy's version to 3 to use condition in bindings.
  policy.version = 3;

  // Finds and removes the appropriate role-member group with specific condition.
  const index = policy.bindings.findIndex(
    binding =>
      binding.role === roleName &&
      binding.condition &&
      binding.condition.title === title &&
      binding.condition.description === description &&
      binding.condition.expression === expression
  );

  const binding = policy.bindings[index];
  if (binding) {
    policy.bindings.splice(index, 1);

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

    console.log('Conditional Binding was removed.');
  } else {
    // No matching role-member group with specific condition were found
    throw new Error('No matching binding group found.');
  }
}

removeBucketConditionalBinding().catch(console.error);

PHP

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage PHP.

use Google\Cloud\Storage\StorageClient;

/**
 * Removes a conditional IAM binding from a bucket's IAM policy.
 *
 * To see how to express a condition in CEL, visit:
 * @see https://cloud.google.com/storage/docs/access-control/iam#conditions.
 *
 * @param string $bucketName The name of your Cloud Storage bucket.
 *        (e.g. 'my-bucket')
 * @param string $role the role that will be given to members in this binding.
 *        (e.g. 'roles/storage.objectViewer')
 * @param string $title The title of the condition. (e.g. 'Title')
 * @param string $description The description of the condition.
 *        (e.g. 'Condition Description')
 * @param string $expression Te condition specified in CEL expression language.
 *        (e.g. 'resource.name.startsWith("projects/_/buckets/bucket-name/objects/prefix-a-")')
 */
function remove_bucket_conditional_iam_binding(string $bucketName, string $role, string $title, string $description, string $expression): void
{
    $storage = new StorageClient();
    $bucket = $storage->bucket($bucketName);

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

    $policy['version'] = 3;

    $key_of_conditional_binding = null;
    foreach ($policy['bindings'] as $key => $binding) {
        if ($binding['role'] == $role && isset($binding['condition'])) {
            $condition = $binding['condition'];
            if ($condition['title'] == $title
                 && $condition['description'] == $description
                 && $condition['expression'] == $expression) {
                $key_of_conditional_binding = $key;
                break;
            }
        }
    }

    if ($key_of_conditional_binding != null) {
        unset($policy['bindings'][$key_of_conditional_binding]);
        // Ensure array keys are sequential, otherwise JSON encodes
        // the array as an object, which fails when calling the API.
        $policy['bindings'] = array_values($policy['bindings']);
        $bucket->iam()->setPolicy($policy);
        print('Conditional Binding was removed.' . PHP_EOL);
    } else {
        print('No matching conditional binding found.' . PHP_EOL);
    }
}

Python

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage Python.

from google.cloud import storage


def remove_bucket_conditional_iam_binding(
    bucket_name, role, title, description, expression
):
    """Remove a conditional IAM binding from a bucket's IAM policy."""
    # bucket_name = "your-bucket-name"
    # role = "IAM role, e.g. roles/storage.objectViewer"
    # title = "Condition title."
    # description = "Condition description."
    # expression = "Condition expression."

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

    policy = bucket.get_iam_policy(requested_policy_version=3)

    # Set the policy's version to 3 to use condition in bindings.
    policy.version = 3

    condition = {
        "title": title,
        "description": description,
        "expression": expression,
    }
    policy.bindings = [
        binding
        for binding in policy.bindings
        if not (binding["role"] == role and binding.get("condition") == condition)
    ]

    bucket.set_iam_policy(policy)

    print("Conditional Binding was removed.")

Ruby

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage Ruby.

def remove_bucket_conditional_iam_binding 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"
  title       = "Title"
  description = "Description"
  expression  = "resource.name.startsWith(\"projects/_/buckets/bucket-name/objects/prefix-a-\")"

  bucket.policy requested_policy_version: 3 do |policy|
    policy.version = 3

    binding_to_remove = nil
    policy.bindings.each do |b|
      condition = {
        title:       title,
        description: description,
        expression:  expression
      }
      if (b.role == role) && (b.condition &&
        b.condition.title == title &&
        b.condition.description == description &&
        b.condition.expression == expression)
        binding_to_remove = b
      end
    end
    if binding_to_remove
      policy.bindings.remove binding_to_remove
      puts "Conditional Binding was removed."
    else
      puts "No matching conditional binding found."
    end
  end
end

API de REST

JSON

Obtén un token de autorización de acceso de OAuth 2.0 Playground. Configura Playground para usar tus credenciales de OAuth. Para obtener instrucciones, consulta Autenticación de la API.
Usa una solicitud GET getIamPolicy para guardar la política de IAM del bucket en un archivo JSON temporal:
```
curl \
'https://storage.googleapis.com/storage/v1/b/BUCKET_NAME/iam' \
--header 'Authorization: Bearer OAUTH2_TOKEN' > tmp-policy.json
```
Aquí:
- BUCKET_NAME es el nombre del bucket al que le otorgas acceso. Por ejemplo, my-bucket
- OAUTH2_TOKEN es el token de acceso que generaste en el paso 1.
Edita el archivo tmp-policy.json en un editor de texto para quitar las condiciones de la política de IAM.
Usa una solicitud PUT setIamPolicy para establecer la política de IAM modificada en el bucket:
```
curl -X PUT --data-binary @tmp-policy.json \
-H "Authorization: Bearer OAUTH2_TOKEN" \
-H "Content-Type: application/json" \
"https://storage.googleapis.com/storage/v1/b/BUCKET_NAME/iam"
```
Aquí:
- OAUTH2_TOKEN es el token de acceso que generaste en el paso 1.
- BUCKET_NAME es el nombre del bucket cuya política de IAM deseas modificar. Por ejemplo, my-bucket

Usa IAM con carpetas administradas

En las siguientes secciones, se muestra cómo completar las tareas básicas de IAM en las carpetas administradas.

Funciones obligatorias

Para obtener los permisos que necesitas para configurar y administrar las políticas de IAM para las carpetas administradas, pídele a tu administrador que te otorgue el rol de IAM de propietario de buckets heredados de almacenamiento (roles/storage.legacyBucketOwner) para el bucket que contiene las carpetas administradas.

Esta función contiene los siguientes permisos, que son necesarios para configurar y administrar las políticas de IAM para las carpetas administradas:

storage.managedfolders.getIamPolicy
storage.managedfolders.setIamPolicy

También puedes obtener estos permisos con roles personalizados.

Para obtener más información acerca de cómo otorgar roles para los buckets, consulta Usa IAM con buckets.

Configura una política de IAM en una carpeta administrada

Console

En la consola de Google Cloud, ve a la página Buckets de Cloud Storage.
Ir a Buckets
En la lista de buckets, haz clic en el nombre del bucket que contiene la carpeta administrada en la que deseas establecer una política de IAM.
En la página Detalles del bucket , haz clic en el ícono Más opciones en el panel Folder browser junto a la carpeta administrada en la que deseas establecer una política de IAM.

Si la carpeta para la que deseas controlar el acceso es una carpeta simulada, sigue los pasos que se indican en Crea una carpeta administrada para convertir primero la carpeta simulada en una administrada.
Haz clic en acceso de edición.
En el panel Permissions for MANAGED_FOLDER_NAME, haz clic en Agregar principal .
En el campo Principales nuevas, ingresa la principal a la que deseas otorgar acceso. Para obtener más información sobre las principales que puedes incluir, consulta Descripción general de IAM.
En la sección Asignar roles, usa el menú desplegable Seleccionar un rol para especificar el nivel de acceso que deseas otorgar a la principal.
Haz clic en Guardar.

Línea de comandos

Crea un archivo JSON que contenga la siguiente información:
```
{
  "bindings":[
    {
      "role": "IAM_ROLE",
      "members":[
        "PRINCIPAL_IDENTIFIER"
      ]
    }
  ]
}
```
Aquí:
- IAM_ROLE es el rol de IAM que deseas otorgar. Por ejemplo, roles/storage.objectViewer.
- PRINCIPAL_IDENTIFIER identifica a quién le otorgas acceso a la carpeta administrada. Por ejemplo, user:jane@gmail.com Para obtener una lista de los formatos de identificador principal, consulta Identificadores principales.
Usa el comando gcloud storage managed-folders set-iam-policy:
```
gcloud storage managed-folders set-iam-policy gs://BUCKET_NAME/MANAGED_FOLDER_NAME POLICY_FILE
```
Aquí:
- BUCKET_NAME es el nombre del bucket que contiene la carpeta administrada a la que deseas aplicar la política de IAM. Por ejemplo, my-bucket
- MANAGED_FOLDER_NAME es el nombre de la carpeta administrada a la que deseas aplicar la política de IAM. Por ejemplo, my-managed-folder/
- POLICY_FILE es la ruta de acceso al archivo JSON que creaste en el paso 1.

APIs de REST

JSON

Obtén un token de autorización de acceso de OAuth 2.0 Playground. Configura Playground para usar tus credenciales de OAuth. Para obtener instrucciones, consulta Autenticación de la API.
Crea un archivo JSON que contenga la siguiente información:
```
{
  "bindings":[
    {
      "role": "IAM_ROLE",
      "members":[
        "PRINCIPAL_IDENTIFIER"
      ]
    }
  ]
}
```
Aquí:
- IAM_ROLE es el rol de IAM que deseas otorgar. Por ejemplo, roles/storage.objectViewer.
- PRINCIPAL_IDENTIFIER identifica a quién le otorgas acceso a la carpeta administrada. Por ejemplo, user:jane@gmail.com Para obtener una lista de los formatos de identificador principal, consulta Identificadores principales.
Usa cURL para llamar a la API de JSON con una solicitud PUT setIamPolicy:
```
curl -X PUT --data-binary @POLICY_FILE \
  -H "Authorization: Bearer OAUTH2_TOKEN" \
  -H "Content-Type: application/json" \
  "https://storage.googleapis.com/storage/v1/b/BUCKET_NAME/managedFolders/MANAGED_FOLDER_NAME/iam"
```
Aquí:
- POLICY_FILE es la ruta de acceso al archivo de política de JSON que creaste en el paso 2.
- OAUTH2_TOKEN es el token de acceso que generaste en el paso 1.
- BUCKET_NAME es el nombre del bucket que contiene la carpeta administrada a la que deseas aplicar la política de IAM. Por ejemplo, my-bucket.
- MANAGED_FOLDER_NAME es el nombre de la carpeta administrada a la que le quieres otorgar acceso a la principal. Por ejemplo, my-managed-folder/

Visualiza la política de IAM para una carpeta administrada

Console

En la consola de Google Cloud, ve a la página Buckets de Cloud Storage.
Ir a Buckets
En la lista de buckets, haz clic en el nombre del bucket que contiene la carpeta administrada para la que deseas ver las políticas de IAM.
En la página Detalles del bucket , haz clic en el ícono Más opciones en el panel Folder browser junto a la carpeta administrada para la que deseas ver la política de IAM.
Haz clic en acceso de edición.

En el panel Permissions for FOLDER_NAME, se muestran los permisos de la carpeta administrada, incluidos la principal, el rol, los roles heredados y las condiciones de IAM.

Línea de comandos

Usa el comando gcloud storage managed-folder get-iam-policy:

gcloud storage managed-folders get-iam-policy gs://BUCKET_NAME/MANAGED_FOLDER_NAME

Donde:

BUCKET_NAME es el nombre del bucket que contiene la carpeta administrada cuya política de IAM deseas ver. Por ejemplo, my-bucket
MANAGED_FOLDER_NAME es el nombre de la carpeta administrada cuya política de IAM deseas ver. Por ejemplo, my-managed-folder/

APIs de REST

JSON

Obtén un token de autorización de acceso de OAuth 2.0 Playground. Configura Playground para usar tus credenciales de OAuth. Para obtener instrucciones, consulta Autenticación de la API.
Usa cURL para llamar a la API de JSON con una solicitud GET getIamPolicy:
```
curl -X GET \
-H "Authorization: Bearer OAUTH2_TOKEN" \
"https://storage.googleapis.com/storage/v1/b/BUCKET_NAME/managedFolders/MANAGED_FOLDER_NAME/iam"
```
Aquí:
- OAUTH2_TOKEN es el token de acceso que generaste en el paso 1.
- BUCKET_NAME es el nombre del bucket que contiene la carpeta administrada cuya política de IAM deseas ver. Por ejemplo, my-bucket.
- MANAGED_FOLDER_NAME es el nombre de la carpeta administrada cuya política de IAM deseas ver. Por ejemplo, my-managed-folder/.

Quita una principal de una política de carpeta administrada

No puedes quitar principales de las políticas de IAM heredadas a través de los siguientes pasos. Para quitar una principal de una política heredada, identifica el recurso que tiene la política y quita la principal del recurso. Por ejemplo, una principal puede tener el rol de usuario de objetos de almacenamiento (roles/storage.objectUser) en el bucket que contiene la carpeta administrada. Para quitar la principal, debes quitarla de la política a nivel del bucket.

Console

En la consola de Google Cloud, ve a la página Buckets de Cloud Storage.
Ir a Buckets
En la lista de buckets, haz clic en el nombre del bucket que contiene la carpeta administrada para la que deseas ver las políticas de IAM.
En la página Detalles del bucket , haz clic en el ícono Más opciones en el panel Folder browser junto al carpeta administrada para la que deseas quitar una principal.
Haz clic en acceso de edición.
En el panel Permissions for FOLDER_NAME, ingresa el nombre de la principal en el campo Filtro.
Haz clic en el ícono Borrar para borrar la principal.

Cloud Storage borra la principal de tu carpeta administrada.

Línea de comandos

Usa el comando gcloud storage managed-folder remove-iam-policy-binding:

gcloud storage managed-folders remove-iam-policy-binding  gs://BUCKET_NAME/MANAGED_FOLDER_NAME --member=PRINCIPAL_IDENTIFIER --role=IAM_ROLE

Aquí:

BUCKET_NAME es el nombre del bucket que contiene la carpeta administrada a la que le revocas el acceso. Por ejemplo, my-bucket.
MANAGED_FOLDER_NAME es el nombre de la carpeta administrada cuya política de IAM deseas quitar. Por ejemplo, my-managed-folder/.
PRINCIPAL_IDENTIFIER identifica a quién le revocas el acceso. Por ejemplo, user:jane@gmail.com Para obtener una lista de los formatos de identificador principal, consulta Identificadores de principal.
IAM_ROLE es el rol de IAM que estás revocando. Por ejemplo, roles/storage.objectViewer.

APIs de REST

JSON

Obtén un token de autorización de acceso de OAuth 2.0 Playground. Configura Playground para usar tus credenciales de OAuth. Para obtener instrucciones, consulta Autenticación de la API.
Obtén la política existente aplicada a tu carpeta administrada. Para ello, usa cURL para llamar a la API de JSON con una solicitud GET getIamPolicy:
```
curl -X GET \
-H "Authorization: Bearer OAUTH2_TOKEN" \
"https://storage.googleapis.com/storage/v1/b/BUCKET_NAME/managedFolders/MANAGED_FOLDER_NAME/iam"
```
Aquí:
- OAUTH2_TOKEN es el token de acceso que generaste en el paso 1.
- BUCKET_NAME es el nombre del bucket que contiene la carpeta administrada a la que le revocas el acceso. Por ejemplo, my-bucket.
- MANAGED_FOLDER_NAME es el nombre de la carpeta administrada cuya política de IAM deseas quitar. Por ejemplo, my-managed-folder/.
Crea un archivo JSON que contenga la política que recuperaste en el paso anterior.
Edita el archivo JSON para quitar al miembro de la política.
Usa cURL para llamar a la API de JSON con una solicitud 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/managedFolders/MANAGED_FOLDER_NAME/iam"
```
Aquí:
- JSON_FILE_NAME es la ruta de acceso del archivo que creaste en el paso 3.
- OAUTH2_TOKEN es el token de acceso que generaste en el paso 1.
- BUCKET_NAME es el nombre del bucket que contiene la carpeta administrada a la que le revocas el acceso. Por ejemplo, my-bucket.
- MANAGED_FOLDER_NAME es el nombre de la carpeta administrada cuya política de IAM deseas quitar. Por ejemplo, my-managed-folder/.

Usa condiciones de IAM en carpetas administradas

En las siguientes secciones, se muestra cómo agregar y quitar condiciones de IAM en las carpetas administradas. Si deseas ver las condiciones de IAM para tus carpetas administradas, consulta Visualiza la política de IAM para una carpeta administrada. Si quieres obtener más información acerca del uso de las Condiciones de IAM con Cloud Storage, consulta Condiciones.

Debes habilitar el acceso uniforme a nivel del bucket en el bucket antes de agregar condiciones a las carpetas administradas.

Establece una nueva condición en una carpeta administrada

Línea de comandos

Crea un archivo JSON o YAML que defina la condición, incluido el title de la condición, la expression lógica basada en atributos para la condición y, de forma opcional, , una description de la condición.

Ten en cuenta que Cloud Storage solo admite los atributos de fecha/hora ,tipo de recurso y nombre del recurso en el expression.
Usa el comando gcloud storage managed-folders add-iam-policy-binding con la marca --condition-from-file:

gcloud storage managed-folders add-iam-policy-binding  gs://BUCKET_NAME/MANAGED_FOLDER_NAME --member=PRINCIPAL_IDENTIFIER --role=IAM_ROLE --condition-from-file=CONDITION_FILE

Donde:

BUCKET_NAME es el nombre del bucket que contiene la carpeta administrada a la que le otorgas acceso a la principal. Por ejemplo, my-bucket.
MANAGED_FOLDER_NAME es el nombre de la carpeta administrada a la que le otorgas acceso a la principal. Por ejemplo, my-managed-folder/.
PRINCIPAL_IDENTIFIER identifica a quién se aplica la condición. Por ejemplo, user:jane@gmail.com Para obtener una lista de los formatos de identificador principal, consulta Identificadores de principal.
IAM_ROLE es el rol de IAM que le estás otorgando a la principal. Por ejemplo, roles/storage.objectViewer
CONDITION_FILE es el archivo que creaste en el paso anterior.

Como alternativa, puedes incluir la condición de forma directa en el comando con la marca --condition en lugar de la marca --condition-from-file.

APIs de REST

JSON

Obtén un token de autorización de acceso de OAuth 2.0 Playground. Configura Playground para usar tus credenciales de OAuth. Para obtener instrucciones, consulta Autenticación de la API.
Usa una solicitud GET getIamPolicy para guardar la política de IAM de la carpeta administrada en un archivo JSON temporal:
```
curl \
'https://storage.googleapis.com/storage/v1/b/BUCKET_NAME/managedFolders/MANAGED_FOLDER_NAMEiam' \
--header 'Authorization: Bearer OAUTH2_TOKEN' > tmp-policy.json
```
Donde:
- OAUTH2_TOKEN es el token de acceso que generaste en el paso 1.
- BUCKET_NAME es el nombre del bucket que contiene la carpeta administrada en la que deseas establecer una condición de IAM.
- MANAGED_FOLDER_NAME es el nombre de la carpeta administrada en la que deseas establecer una condición de IAM.
Edita el archivo tmp-policy.json en un editor de texto para agregar condiciones nuevas a las vinculaciones en la política de IAM:
```
{
    "version": VERSION,
    "bindings": [
      {
        "role": "IAM_ROLE",
        "members": [
          "PRINCIPAL_IDENTIFIER"
        ],
        "condition": {
          "title": "TITLE",
          "description": "DESCRIPTION",
          "expression": "EXPRESSION"
        }
      }
    ],
    "etag": "ETAG"
}
```
Donde:
- VERSION es la versión de la política de IAM, que debe ser 3 para las carpetas administradas con condiciones de IAM.
- IAM_ROLE es el rol al que se aplica la condición. Por ejemplo, roles/storage.objectViewer
- PRINCIPAL_IDENTIFIER identifica a quién se aplica la condición. Por ejemplo, user:jane@gmail.com Para obtener una lista de los formatos de identificador principal, consulta Identificadores de principal.
- TITLE es el título de la condición. Por ejemplo, expires in 2019.
- DESCRIPTION es una descripción opcional de la condición. Por ejemplo, Permission revoked on New Year's
- EXPRESSION es una expresión lógica basada en atributos. Por ejemplo, request.time < timestamp(\"2019-01-01T00:00:00Z\"). Si quieres obtener más ejemplos de expresiones, consulta la referencia de atributos para las Condiciones. Ten en cuenta que Cloud Storage solo admite los atributos de fecha y hora, tipo de recurso y nombre de recurso.
No modifiques ETAG.
Usa una solicitud PUT setIamPolicy para establecer la política de IAM modificada en el bucket:
```
curl -X PUT --data-binary @tmp-policy.json \
-H "Authorization: Bearer OAUTH2_TOKEN" \
-H "Content-Type: application/json" \
"https://storage.googleapis.com/storage/v1/b/BUCKET_NAME/managedFoldersMANAGED_FOLDER_NAME/iam"
```
Aquí:
- OAUTH2_TOKEN es el token de acceso que generaste en el paso 1.
- BUCKET_NAME es el nombre del bucket que contiene la carpeta administrada en la que deseas establecer una condición de IAM.
- MANAGED_FOLDER_NAME es el nombre de la carpeta administrada en la que deseas establecer una condición de IAM.

Quita una condición de una carpeta administrada

Línea de comandos

Usa el comando gcloud storage managed-folders get-iam-policy para guardar la política de IAM de la carpeta administrada en un archivo JSON temporal.
```
gcloud storage managed-folders get-iam-policy gs://BUCKET_NAME/MANAGED_FOLDER_NAME > tmp-policy.json
```
Edita el archivo tmp-policy.json en un editor de texto para quitar las condiciones de la política de IAM.
Usa el comando gcloud storage managed-folders set-iam-policy para establecer la política de IAM modificada en la carpeta administrada.
```
gcloud storage managed-folders set-iam-policy gs://BUCKET_NAME/MANAGED_FOLDER_NAME tmp-policy.json
```

APIs de REST

JSON

Obtén un token de autorización de acceso de OAuth 2.0 Playground. Configura Playground para usar tus credenciales de OAuth. Para obtener instrucciones, consulta Autenticación de la API.
Usa una solicitud GET getIamPolicy para guardar la política de IAM de la carpeta administrada en un archivo JSON temporal:
```
curl \
'https://storage.googleapis.com/storage/v1/b/BUCKET_NAME/managedFolders/MANAGED_FOLDER_NAMEiam' \
--header 'Authorization: Bearer OAUTH2_TOKEN' > tmp-policy.json
```
Donde:
- BUCKET_NAME es el nombre del bucket que contiene la carpeta administrada a la que le cambias el acceso. Por ejemplo, my-bucket.
- MANAGED_FOLDER_NAME es el nombre de la carpeta administrada a la que le cambias el acceso. Por ejemplo, my-managed-folder/.
- OAUTH2_TOKEN es el token de acceso que generaste en el paso 1.
Edita el archivo tmp-policy.json en un editor de texto para quitar las condiciones de la política de IAM.
Usa una solicitud PUT setIamPolicy para establecer la política de IAM modificada en la carpeta administrada:
```
curl -X PUT --data-binary @tmp-policy.json \
-H "Authorization: Bearer OAUTH2_TOKEN" \
-H "Content-Type: application/json" \
"https://storage.googleapis.com/storage/v1/b/BUCKET_NAME/managedFolders/MANAGED_FOLDER_NAMEiam"
```
Donde:
- OAUTH2_TOKEN es el token de acceso que generaste en el paso 1.
- BUCKET_NAME es el nombre del bucket que contiene la carpeta administrada a la que le cambias el acceso. Por ejemplo, my-bucket.
- MANAGED_FOLDER_NAME es el nombre de la carpeta administrada a la que le cambias el acceso. Por ejemplo, my-managed-folder/.

Usa IAM con proyectos

Consulta Administra el acceso a proyectos, carpetas y organizaciones para obtener guías sobre cómo otorgar y revocar roles de IAM a nivel de proyecto y superior.

Prácticas recomendadas

Debes establecer el mínimo permiso posible que otorgue al principal el acceso requerido. Por ejemplo, si un miembro del equipo solo necesita leer los objetos almacenados en un bucket, selecciona el rol Visualizador de objetos de almacenamiento. De manera similar, si el miembro del equipo necesita el control total de los objetos en el bucket (pero no el control del bucket mismo), selecciona Administrador de objetos de almacenamiento.

Próximos pasos

Aprende cómo compartir tus datos de forma pública.
Consulta Ejemplos de colaboración y uso compartido específicos.
Obtén información de las prácticas recomendadas para usar IAM.
Obtén más información acerca de cómo usar las recomendaciones de roles para los buckets.
Para solucionar problemas de operaciones fallidas relacionadas con los roles y los permisos de IAM, consulta Solución de problemas.