创建和管理访问控制列表 (ACL)

namespace gcs = ::google::cloud::storage; using ::google::cloud::StatusOr; [](gcs::Client client, std::string const& bucket_name,    std::string const& object_name, std::string const& entity) {   StatusOr<gcs::ObjectAccessControl> patched_acl =       client.CreateObjectAcl(bucket_name, object_name, entity,                              gcs::ObjectAccessControl::ROLE_OWNER());    if (!patched_acl) throw std::move(patched_acl).status();   std::cout << "ACL entry for " << patched_acl->entity() << " in object "             << patched_acl->object() << " in bucket " << patched_acl->bucket()             << " is now " << *patched_acl << "\n"; }

namespace gcs = ::google::cloud::storage; using ::google::cloud::StatusOr; [](gcs::Client client, std::string const& bucket_name,    std::string const& object_name, std::string const& entity) {   StatusOr<gcs::ObjectMetadata> original_metadata = client.GetObjectMetadata(       bucket_name, object_name, gcs::Projection::Full());   if (!original_metadata) throw std::move(original_metadata).status();    std::vector<gcs::ObjectAccessControl> original_acl =       original_metadata->acl();   auto it = std::find_if(original_acl.begin(), original_acl.end(),                          [entity](gcs::ObjectAccessControl const& entry) {                            return entry.entity() == entity &&                                   entry.role() ==                                       gcs::ObjectAccessControl::ROLE_OWNER();                          });    if (it == original_acl.end()) {     std::cout << "Could not find entity " << entity << " for file "               << object_name << " with role OWNER in bucket " << bucket_name               << "\n";     return;   }    gcs::ObjectAccessControl owner = *it;   google::cloud::Status status =       client.DeleteObjectAcl(bucket_name, object_name, owner.entity());    if (!status.ok()) throw std::runtime_error(status.message());   std::cout << "Deleted ACL entry for " << owner.entity() << " for file "             << object_name << " in bucket " << bucket_name << "\n"; }

 using Google.Apis.Storage.v1.Data; using Google.Cloud.Storage.V1; using System;  public class AddFileOwnerSample {     public Google.Apis.Storage.v1.Data.Object AddFileOwner(         string bucketName = "your-unique-bucket-name",         string objectName = "my-file-name",         string userEmail = "[email protected]")     {         var storage = StorageClient.Create();         var storageObject = storage.GetObject(bucketName, objectName, new GetObjectOptions         {             Projection = Projection.Full         });          storageObject.Acl.Add(new ObjectAccessControl         {             Bucket = bucketName,             Entity = $"user-{userEmail}",             Role = "OWNER",         });         var updatedObject = storage.UpdateObject(storageObject);         Console.WriteLine($"Added user { userEmail} as an owner on file { objectName}.");         return updatedObject;     } }

 using Google.Cloud.Storage.V1; using System; using System.Linq;  public class RemoveFileOwnerSample {     public void RemoveFileOwner(         string bucketName = "your-unique-bucket-name",         string objectName = "your-object-name",         string userEmail = "[email protected]")     {         var storage = StorageClient.Create();         var storageObject = storage.GetObject(bucketName, objectName, new GetObjectOptions { Projection = Projection.Full });         if (storageObject.Acl == null)         {             Console.WriteLine("No owner to remove");         }         else         {             storageObject.Acl = storageObject.Acl.Where((acl) => !(acl.Entity == $"user-{userEmail}" && acl.Role == "OWNER")).ToList();             var updatedObject = storage.UpdateObject(storageObject);             Console.WriteLine($"Removed user {userEmail} from file {objectName}.");         }     } }

import ( 	"context" 	"fmt"  	"cloud.google.com/go/storage" )  // addFileOwner adds ACL to the specified object. func addFileOwner(bucket, object string, entity storage.ACLEntity) error { 	// bucket := "bucket-name" 	// object := "object-name" 	// entity := storage.AllUsers 	role := storage.RoleOwner  	ctx := context.Background() 	client, err := storage.NewClient(ctx) 	if err != nil { 		return fmt.Errorf("storage.NewClient: %w", err) 	} 	defer client.Close()  	acl := client.Bucket(bucket).Object(object).ACL() 	if err := acl.Set(ctx, entity, role); err != nil { 		return fmt.Errorf("ACLHandle.Set: %w", err) 	} 	return nil } 

import ( 	"context" 	"fmt"  	"cloud.google.com/go/storage" )  // removeFileOwner removes default ACL from the given object. func removeFileOwner(bucket, object string, entity storage.ACLEntity) error { 	// bucket := "bucket-name" 	// object := "object-name" 	// entity := storage.AllUsers 	ctx := context.Background() 	client, err := storage.NewClient(ctx) 	if err != nil { 		return fmt.Errorf("storage.NewClient: %w", err) 	} 	defer client.Close()  	acl := client.Bucket(bucket).Object(object).ACL() 	if err := acl.Delete(ctx, entity); err != nil { 		return fmt.Errorf("ACLHandle.Delete: %w", err) 	} 	return nil } 

 import com.google.cloud.storage.Acl; import com.google.cloud.storage.Acl.Role; import com.google.cloud.storage.Acl.User; import com.google.cloud.storage.Blob; import com.google.cloud.storage.BlobId; import com.google.cloud.storage.Storage; import com.google.cloud.storage.StorageOptions;  public class AddBlobOwner {    public static void addBlobOwner(       String projectId, String bucketName, String userEmail, String blobName) {     // The ID of your GCP project     // String projectId = "your-project-id";      // The ID of your GCS bucket     // String bucketName = "your-unique-bucket-name";      // Email of the user you wish to add as a file owner     // String userEmail = "[email protected]"      // The name of the blob/file that you wish to modify permissions on     // String blobName = "your-blob-name";      Storage storage = StorageOptions.newBuilder().setProjectId(projectId).build().getService();     Blob blob = storage.get(BlobId.of(bucketName, blobName));     Acl newOwner = Acl.of(new User(userEmail), Role.OWNER);      blob.createAcl(newOwner);     System.out.println(         "Added user "             + userEmail             + " as an owner on blob "             + blobName             + " in bucket "             + bucketName);   } }

 import com.google.cloud.storage.Acl.User; import com.google.cloud.storage.Blob; import com.google.cloud.storage.BlobId; import com.google.cloud.storage.Storage; import com.google.cloud.storage.StorageOptions;  public class RemoveBlobOwner {    public static void removeBlobOwner(       String projectId, String bucketName, String userEmail, String blobName) {     // The ID of your GCP project     // String projectId = "your-project-id";      // The ID of your GCS bucket     // String bucketName = "your-unique-bucket-name";      // Email of the user you wish to remove as a file owner     // String userEmail = "[email protected]"      // The name of the blob/file that you wish to modify permissions on     // String blobName = "your-blob-name";      Storage storage = StorageOptions.newBuilder().setProjectId(projectId).build().getService();     Blob blob = storage.get(BlobId.of(bucketName, blobName));     User ownerToRemove = new User(userEmail);      boolean success = blob.deleteAcl(ownerToRemove);     if (success) {       System.out.println(           "Removed user "               + userEmail               + " as an owner on file "               + blobName               + " in bucket "               + bucketName);     } else {       System.out.println("User " + userEmail + " was not found");     }   } }

/**  * TODO(developer): Uncomment the following lines before running the sample.  */ // The ID of your GCS bucket // const bucketName = 'your-unique-bucket-name';  // The name of the file to access // const fileName = 'file.txt';  // The email address of the user to add // const userEmail = 'user-email-to-add';  // Imports the Google Cloud client library const {Storage} = require('@google-cloud/storage');  // Creates a client const storage = new Storage();  async function addFileOwner() {   await storage     .bucket(bucketName)     .file(fileName)     .acl.owners.addUser(userEmail);    console.log(`Added user ${userEmail} as an owner on file ${fileName}.`); }  addFileOwner().catch(console.error);

/**  * TODO(developer): Uncomment the following lines before running the sample.  */ // The ID of your GCS bucket // const bucketName = 'your-unique-bucket-name';  // The ID of your GCS file // const fileName = 'your-file-name';  // The email address of the user to remove // const userEmail = 'user-email-to-remove';  // Imports the Google Cloud client library const {Storage} = require('@google-cloud/storage');  // Creates a client const storage = new Storage();  async function removeFileOwner() {   // Removes the user from the access control list of the file. You can use   // deleteAllUsers(), deleteDomain(), deleteProject(), deleteGroup(), and   // deleteAllAuthenticatedUsers() to remove access for different types of entities.   await storage     .bucket(bucketName)     .file(fileName)     .acl.owners.deleteUser(userEmail);    console.log(`Removed user ${userEmail} from file ${fileName}.`); }  removeFileOwner().catch(console.error);

use Google\Cloud\Storage\StorageClient;  /**  * Add an entity and role to an object's ACL.  *  * @param string $bucketName The name of your Cloud Storage bucket.  *        (e.g. 'my-bucket')  * @param string $objectName The name of your Cloud Storage object.  *        (e.g. 'my-object')  * @param string $entity The entity for which to update access controls.  *        (e.g. '[email protected]')  * @param string $role The permissions to add for the specified entity.  *        (e.g. 'OWNER')  */ function add_object_acl(string $bucketName, string $objectName, string $entity, string $role): void {     $storage = new StorageClient();     $bucket = $storage->bucket($bucketName);     $object = $bucket->object($objectName);     $acl = $object->acl();     $acl->add($entity, $role);     printf('Added %s (%s) to gs://%s/%s ACL' . PHP_EOL, $entity, $role, $bucketName, $objectName); }

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

from google.cloud import storage   def add_blob_owner(bucket_name, blob_name, user_email):     """Adds a user as an owner on the given blob."""     # bucket_name = "your-bucket-name"     # blob_name = "your-object-name"     # user_email = "[email protected]"      storage_client = storage.Client()     bucket = storage_client.bucket(bucket_name)     blob = bucket.blob(blob_name)      # Reload fetches the current ACL from Cloud Storage.     blob.acl.reload()      # You can also use `group`, `domain`, `all_authenticated` and `all` to     # grant access to different types of entities. You can also use     # `grant_read` or `grant_write` to grant different roles.     blob.acl.user(user_email).grant_owner()     blob.acl.save()      print(         "Added user {} as an owner on blob {} in bucket {}.".format(             user_email, blob_name, bucket_name         )     )  

from google.cloud import storage   def remove_blob_owner(bucket_name, blob_name, user_email):     """Removes a user from the access control list of the given blob in the     given bucket."""     # bucket_name = "your-bucket-name"     # blob_name = "your-object-name"     # user_email = "[email protected]"      storage_client = storage.Client()     bucket = storage_client.bucket(bucket_name)     blob = bucket.blob(blob_name)      # You can also use `group`, `domain`, `all_authenticated` and `all` to     # remove access for different types of entities.     blob.acl.user(user_email).revoke_read()     blob.acl.user(user_email).revoke_write()     blob.acl.user(user_email).revoke_owner()     blob.acl.save()      print(         f"Removed user {user_email} from blob {blob_name} in bucket {bucket_name}."     )  

# The ID of your GCS bucket # bucket_name = "your-unique-bucket-name" # file_name   = "Name of a file in the Storage bucket" # email       = "Google Cloud Storage ACL Entity email"  require "google/cloud/storage"  storage = Google::Cloud::Storage.new bucket  = storage.bucket bucket_name file    = bucket.file file_name  file.acl.add_owner email  puts "Added OWNER permission for #{email} to #{file_name}"

# The ID of your GCS bucket # bucket_name = "your-unique-bucket-name" # file_name   = "Name of a file in the Storage bucket" # email       = "Google Cloud Storage ACL Entity email"  require "google/cloud/storage"  storage = Google::Cloud::Storage.new bucket  = storage.bucket bucket_name file    = bucket.file file_name  file.acl.delete email  puts "Removed ACL permissions for #{email} from #{file_name}"

namespace gcs = ::google::cloud::storage; using ::google::cloud::StatusOr; [](gcs::Client client, std::string const& bucket_name,    std::string const& entity, std::string const& role) {   StatusOr<gcs::ObjectAccessControl> default_object_acl =       client.CreateDefaultObjectAcl(bucket_name, entity, role);   if (!default_object_acl) throw std::move(default_object_acl).status();    std::cout << "Role " << default_object_acl->role()             << " will be granted default to " << default_object_acl->entity()             << " on any new object created on bucket "             << default_object_acl->bucket() << "\n"             << "Full attributes: " << *default_object_acl << "\n"; }

namespace gcs = ::google::cloud::storage; [](gcs::Client client, std::string const& bucket_name,    std::string const& entity) {   google::cloud::Status status =       client.DeleteDefaultObjectAcl(bucket_name, entity);    if (!status.ok()) throw std::runtime_error(status.message());   std::cout << "Deleted ACL entry for " << entity << " in bucket "             << bucket_name << "\n"; }

 using Google.Apis.Storage.v1.Data; using Google.Cloud.Storage.V1; using System; using System.Collections.Generic;  public class PrintBucketDefaultAclSample {     public IEnumerable<ObjectAccessControl> PrintBucketDefaultAcl(string bucketName = "your-unique-bucket-name")     {         var storage = StorageClient.Create();         var bucket = storage.GetBucket(bucketName, new GetBucketOptions { Projection = Projection.Full });          foreach (var acl in bucket.DefaultObjectAcl)         {             Console.WriteLine($"{acl.Role}:{acl.Entity}");         }          return bucket.DefaultObjectAcl;     } }

 using Google.Apis.Storage.v1.Data; using Google.Cloud.Storage.V1; using System;  public class AddBucketDefaultOwnerSample {     public Bucket AddBucketDefaultOwner(         string bucketName = "your-unique-bucket-name",         string userEmail = "[email protected]")     {         var storage = StorageClient.Create();         var bucket = storage.GetBucket(bucketName, new GetBucketOptions { Projection = Projection.Full });          bucket.DefaultObjectAcl.Add(new ObjectAccessControl         {             Bucket = bucketName,             Entity = $"user-{userEmail}",             Role = "OWNER",         });         var updatedBucket = storage.UpdateBucket(bucket);         Console.WriteLine($"Added user {userEmail} as a default owner on bucket {bucketName}.");         return updatedBucket;     } }

 using Google.Cloud.Storage.V1; using System; using System.Linq;  public class RemoveBucketDefaultOwnerSample {     public void RemoveBucketDefaultOwner(         string bucketName = "your-unique-bucket-name",         string userEmail = "[email protected]")     {         var storage = StorageClient.Create();         var bucket = storage.GetBucket(bucketName, new GetBucketOptions { Projection = Projection.Full });         if (bucket.DefaultObjectAcl == null)         {             Console.WriteLine("No default owner to remove");         }         else         {             bucket.DefaultObjectAcl = bucket.DefaultObjectAcl.Where(acl => !(acl.Entity == $"user-{userEmail}" && acl.Role == "OWNER")).ToList();             var updatedBucket = storage.UpdateBucket(bucket);             Console.WriteLine($"Removed user {userEmail} from bucket {bucketName}.");         }     } }

import ( 	"context" 	"fmt"  	"cloud.google.com/go/storage" )  // addBucketDefaultOwner adds default ACL to the specified bucket. func addBucketDefaultOwner(bucket string, entity storage.ACLEntity) error { 	// bucket := "bucket-name" 	// entity := storage.AllUsers 	role := storage.RoleOwner  	ctx := context.Background() 	client, err := storage.NewClient(ctx) 	if err != nil { 		return fmt.Errorf("storage.NewClient: %w", err) 	} 	defer client.Close()  	acl := client.Bucket(bucket).DefaultObjectACL() 	if err := acl.Set(ctx, entity, role); err != nil { 		return fmt.Errorf("ACLHandle.Set: %w", err) 	} 	return nil } 

import ( 	"context" 	"fmt"  	"cloud.google.com/go/storage" )  // deleteDefaultBucketACL removes default ACL from a bucket. func removeBucketDefaultOwner(bucket string, entity storage.ACLEntity) error { 	// bucket := "bucket-name" 	// entity := storage.AllUsers 	ctx := context.Background() 	client, err := storage.NewClient(ctx) 	if err != nil { 		return fmt.Errorf("storage.NewClient: %w", err) 	} 	defer client.Close()  	acl := client.Bucket(bucket).DefaultObjectACL() 	if err := acl.Delete(ctx, entity); err != nil { 		return fmt.Errorf("ACLHandle.Delete: %w", err) 	} 	return nil } 

 import com.google.cloud.storage.Acl; import com.google.cloud.storage.Acl.Role; import com.google.cloud.storage.Acl.User; import com.google.cloud.storage.Bucket; import com.google.cloud.storage.Storage; import com.google.cloud.storage.StorageOptions;  public class AddBucketDefaultOwner {    public static void addBucketDefaultOwner(String bucketName, String userEmail) {      // The ID of your GCS bucket     // String bucketName = "your-unique-bucket-name";      // The email of the user you wish to add as a default owner     // String userEmail = "[email protected]"      Storage storage = StorageOptions.newBuilder().build().getService();     Bucket bucket = storage.get(bucketName);     Acl newDefaultOwner = Acl.of(new User(userEmail), Role.OWNER);      bucket.createDefaultAcl(newDefaultOwner);     System.out.println("Added user " + userEmail + " as an owner on " + bucketName);   } }

 import com.google.cloud.storage.Acl.User; import com.google.cloud.storage.Bucket; import com.google.cloud.storage.Storage; import com.google.cloud.storage.StorageOptions;  public class RemoveBucketDefaultOwner {    public static void removeBucketDefaultOwner(String bucketName, String userEmail) {      // The ID of your GCS bucket     // String bucketName = "your-unique-bucket-name";      // The email of the user you wish to remove as a default owner     // String userEmail = "[email protected]"      Storage storage = StorageOptions.newBuilder().build().getService();     Bucket bucket = storage.get(bucketName);     User userToRemove = new User(userEmail);      boolean success = bucket.deleteDefaultAcl(userToRemove);     if (success) {       System.out.println("Removed user " + userEmail + " as an owner on " + bucketName);     } else {       System.out.println("User " + userEmail + " was not found");     }   } }

/**  * TODO(developer): Uncomment the following lines before running the sample.  */ // The ID of your GCS bucket // const bucketName = 'your-unique-bucket-name';  // The email address of the user to add // const userEmail = 'user-email-to-add';  // Imports the Google Cloud client library const {Storage} = require('@google-cloud/storage');  // Creates a client const storage = new Storage();  async function addBucketDefaultOwner() {   // Makes the user an owner in the default ACL of the bucket. You can use   // addAllUsers(), addDomain(), addProject(), addGroup(), and   // addAllAuthenticatedUsers() to grant access to different types of entities.   // You can also use "readers" and "writers" to grant different roles.   await storage.bucket(bucketName).acl.default.owners.addUser(userEmail);    console.log(`Added user ${userEmail} as an owner on bucket ${bucketName}.`); }  addBucketDefaultOwner().catch(console.error);

/**  * TODO(developer): Uncomment the following lines before running the sample.  */ // The ID of your GCS bucket // const bucketName = 'your-unique-bucket-name';  // The email address of the user to remove // const userEmail = 'user-email-to-remove';  // Imports the Google Cloud client library const {Storage} = require('@google-cloud/storage');  // Creates a client const storage = new Storage();  async function removeBucketDefaultOwner() {   // Removes the user from the access control list of the bucket. You can use   // deleteAllUsers(), deleteDomain(), deleteProject(), deleteGroup(), and   // deleteAllAuthenticatedUsers() to remove access for different types of entities.   await storage.bucket(bucketName).acl.default.owners.deleteUser(userEmail);    console.log(`Removed user ${userEmail} from bucket ${bucketName}.`); }  removeBucketDefaultOwner().catch(console.error);

use Google\Cloud\Storage\StorageClient;  /**  * Add an entity and role to a bucket's default ACL.  *  * @param string $bucketName The name of your Cloud Storage bucket.  *        (e.g. 'my-bucket')  * @param string $entity The entity for which to update access controls.  *        (e.g. '[email protected]')  * @param string $role The permissions to add for the specified entity.  *        (e.g. 'OWNER')  */ function add_bucket_default_acl(string $bucketName, string $entity, string $role): void {     $storage = new StorageClient();     $bucket = $storage->bucket($bucketName);     $acl = $bucket->defaultAcl();     $acl->add($entity, $role);     printf('Added %s (%s) to gs://%s default ACL' . PHP_EOL, $entity, $role, $bucketName); }

use Google\Cloud\Storage\StorageClient;  /**  * Delete an entity from a bucket's default ACL.  *  * @param string $bucketName The name of your Cloud Storage bucket.  *        (e.g. 'my-bucket')  * @param string $entity The entity for which to update access controls.  *        (e.g. '[email protected]')  */ function delete_bucket_default_acl(string $bucketName, string $entity): void {     $storage = new StorageClient();     $bucket = $storage->bucket($bucketName);     $acl = $bucket->defaultAcl();     $acl->delete($entity);     printf('Deleted %s from gs://%s default ACL' . PHP_EOL, $entity, $bucketName); }

from google.cloud import storage   def add_bucket_default_owner(bucket_name, user_email):     """Adds a user as an owner in the given bucket's default object access     control list."""     # bucket_name = "your-bucket-name"     # user_email = "[email protected]"      storage_client = storage.Client()     bucket = storage_client.bucket(bucket_name)      # Reload fetches the current ACL from Cloud Storage.     bucket.acl.reload()      # You can also use `group`, `domain`, `all_authenticated` and `all` to     # grant access to different types of entities. You can also use     # `grant_read` or `grant_write` to grant different roles.     bucket.default_object_acl.user(user_email).grant_owner()     bucket.default_object_acl.save()      print(         "Added user {} as an owner in the default acl on bucket {}.".format(             user_email, bucket_name         )     )  

from google.cloud import storage   def remove_bucket_default_owner(bucket_name, user_email):     """Removes a user from the access control list of the given bucket's     default object access control list."""     # bucket_name = "your-bucket-name"     # user_email = "[email protected]"      storage_client = storage.Client()     bucket = storage_client.bucket(bucket_name)      # Reload fetches the current ACL from Cloud Storage.     bucket.acl.reload()      # You can also use `group`, `domain`, `all_authenticated` and `all` to     # remove access for different types of entities.     bucket.default_object_acl.user(user_email).revoke_read()     bucket.default_object_acl.user(user_email).revoke_write()     bucket.default_object_acl.user(user_email).revoke_owner()     bucket.default_object_acl.save()      print(         f"Removed user {user_email} from the default acl of bucket {bucket_name}."     )  

# The ID of your GCS bucket # bucket_name = "your-unique-bucket-name" # email       = "Google Cloud Storage ACL Entity email"  require "google/cloud/storage"  storage = Google::Cloud::Storage.new bucket  = storage.bucket bucket_name  bucket.default_acl.add_owner email  puts "Added default OWNER permission for #{email} to #{bucket_name}"

# The ID of your GCS bucket # bucket_name = "your-unique-bucket-name" # email       = "Google Cloud Storage ACL Entity email"  require "google/cloud/storage"  storage = Google::Cloud::Storage.new bucket  = storage.bucket bucket_name  bucket.default_acl.delete email  puts "Removed default ACL permissions for #{email} from #{bucket_name}"

namespace gcs = ::google::cloud::storage; using ::google::cloud::StatusOr; [](gcs::Client client, std::string const& bucket_name,    std::string const& object_name) {   StatusOr<std::vector<gcs::ObjectAccessControl>> items =       client.ListObjectAcl(bucket_name, object_name);    if (!items) throw std::move(items).status();   std::cout << "ACLs for object=" << object_name << " in bucket "             << bucket_name << "\n";   for (gcs::ObjectAccessControl const& acl : *items) {     std::cout << acl.role() << ":" << acl.entity() << "\n";   } }

 using Google.Apis.Storage.v1.Data; using Google.Cloud.Storage.V1; using System; using System.Collections.Generic;  public class PrintFileAclSample {     public IEnumerable<ObjectAccessControl> PrintObjectAcl(         string bucketName = "your-unique-bucket-name",         string objectName = "your-object-name")     {         var storage = StorageClient.Create();         var storageObject = storage.GetObject(bucketName, objectName, new GetObjectOptions         {             Projection = Projection.Full         });          foreach (var acl in storageObject.Acl)         {             Console.WriteLine($"{acl.Role}:{acl.Entity}");         }          return storageObject.Acl;     } }

import ( 	"context" 	"fmt" 	"io"  	"cloud.google.com/go/storage" )  // printFileACL lists ACL of the specified object. func printFileACL(w io.Writer, bucket, object string) error { 	// bucket := "bucket-name" 	// object := "object-name" 	ctx := context.Background() 	client, err := storage.NewClient(ctx) 	if err != nil { 		return fmt.Errorf("storage.NewClient: %w", err) 	} 	defer client.Close()  	rules, err := client.Bucket(bucket).Object(object).ACL().List(ctx) 	if err != nil { 		return fmt.Errorf("ACLHandle.List: %w", err) 	} 	for _, rule := range rules { 		fmt.Fprintf(w, "ACL rule: %v\n", rule) 	} 	return nil } 

 import com.google.cloud.storage.Acl; import com.google.cloud.storage.Blob; import com.google.cloud.storage.BlobId; import com.google.cloud.storage.Storage; import com.google.cloud.storage.StorageOptions; import java.util.List;  public class PrintBlobAcl {    public static void printBlobAcl(String bucketName, String blobName) {      // The ID to give your GCS bucket     // String bucketName = "your-unique-bucket-name";      // The name of the blob/file that you wish to view Acls of     // String blobName = "your-blob-name";      Storage storage = StorageOptions.newBuilder().build().getService();     Blob blob = storage.get(BlobId.of(bucketName, blobName));     List<Acl> blobAcls = blob.getAcl();      for (Acl acl : blobAcls) {        // This will give you the role.       // See https://cloud.google.com/storage/docs/access-control/lists#permissions       String role = acl.getRole().name();        // This will give you the Entity type (i.e. User, Group, Project etc.)       // See https://cloud.google.com/storage/docs/access-control/lists#scopes       String entityType = acl.getEntity().getType().name();        System.out.printf("%s: %s %n", role, entityType);     }   } }

/**  * TODO(developer): Uncomment the following lines before running the sample.  */ // The ID of your GCS bucket // const bucketName = 'your-unique-bucket-name';  // The ID of your GCS file // const fileName = 'your-file-name';  // Imports the Google Cloud client library const {Storage} = require('@google-cloud/storage');  // Creates a client const storage = new Storage();  async function printFileAcl() {   // Gets the ACL for the file   const [acls] = await storage.bucket(bucketName).file(fileName).acl.get();    acls.forEach(acl => {     console.log(`${acl.role}: ${acl.entity}`);   }); }  printFileAcl().catch(console.error);

use Google\Cloud\Storage\StorageClient;  /**  * Print all entities and roles for an object's ACL.  *  * @param string $bucketName The name of your Cloud Storage bucket.  *        (e.g. 'my-bucket')  * @param string $objectName The name of your Cloud Storage object.  *        (e.g. 'my-object')  */ function get_object_acl(string $bucketName, string $objectName): void {     $storage = new StorageClient();     $bucket = $storage->bucket($bucketName);     $object = $bucket->object($objectName);     $acl = $object->acl();     foreach ($acl->get() as $item) {         printf('%s: %s' . PHP_EOL, $item['entity'], $item['role']);     } }

from google.cloud import storage   def print_blob_acl(bucket_name, blob_name):     """Prints out a blob's access control list."""      storage_client = storage.Client()     bucket = storage_client.bucket(bucket_name)     blob = bucket.blob(blob_name)      for entry in blob.acl:         print(f"{entry['role']}: {entry['entity']}")  

# The ID of your GCS bucket # bucket_name = "your-unique-bucket-name" # file_name   = "Name of a file in the Storage bucket" # email       = "Google Cloud Storage ACL Entity email"  require "google/cloud/storage"  storage = Google::Cloud::Storage.new bucket  = storage.bucket bucket_name file    = bucket.file file_name  puts "ACL for #{file_name} in #{bucket_name}:"  file.acl.owners.each do |owner|   puts "OWNER #{owner}" end  file.acl.readers.each do |reader|   puts "READER #{reader}" end