namespacegcs=::google::cloud::storage;using::google::cloud::StatusOr;[](gcs::Clientclient,std::stringconst&file_name,std::stringconst&bucket_name,std::stringconst&object_name){// Note that the client library automatically computes a hash on the// client-side to verify data integrity during transmission.StatusOr<gcs::ObjectMetadata>metadata=client.UploadFile(file_name,bucket_name,object_name,gcs::IfGenerationMatch(0));if(!metadata)throwstd::move(metadata).status();std::cout <<"Uploaded " <<file_name <<" to object " <<metadata->name()            <<" in bucket " <<metadata->bucket()            <<"\nFull metadata: " <<*metadata <<"\n";}

usingGoogle.Cloud.Storage.V1;usingSystem;usingSystem.IO;publicclassUploadFileSample{publicvoidUploadFile(stringbucketName="your-unique-bucket-name",stringlocalPath="my-local-path/my-file-name",stringobjectName="my-file-name"){varstorage=StorageClient.Create();usingvarfileStream=File.OpenRead(localPath);storage.UploadObject(bucketName,objectName,null,fileStream);Console.WriteLine($"Uploaded {objectName}.");}}

import("context""fmt""io""os""time""cloud.google.com/go/storage")// uploadFile uploads an object.funcuploadFile(wio.Writer,bucket,objectstring)error{// bucket := "bucket-name"// object := "object-name"ctx:=context.Background()client,err:=storage.NewClient(ctx)iferr!=nil{returnfmt.Errorf("storage.NewClient: %w",err)}deferclient.Close()// Open local file.f,err:=os.Open("notes.txt")iferr!=nil{returnfmt.Errorf("os.Open: %w",err)}deferf.Close()ctx,cancel:=context.WithTimeout(ctx,time.Second*50)defercancel()o:=client.Bucket(bucket).Object(object)// Optional: set a generation-match precondition to avoid potential race// conditions and data corruptions. The request to upload is aborted if the// object's generation number does not match your precondition.// For an object that does not yet exist, set the DoesNotExist precondition.o=o.If(storage.Conditions{DoesNotExist:true})// If the live object already exists in your bucket, set instead a// generation-match precondition using the live object's generation number.// attrs, err := o.Attrs(ctx)// if err != nil {// return fmt.Errorf("object.Attrs: %w", err)// }// o = o.If(storage.Conditions{GenerationMatch: attrs.Generation})// Upload an object with storage.Writer.wc:=o.NewWriter(ctx)if_,err=io.Copy(wc,f);err!=nil{returnfmt.Errorf("io.Copy: %w",err)}iferr:=wc.Close();err!=nil{returnfmt.Errorf("Writer.Close: %w",err)}fmt.Fprintf(w,"Blob %v uploaded.\n",object)returnnil}

importcom.google.cloud.storage.BlobId;importcom.google.cloud.storage.BlobInfo;importcom.google.cloud.storage.Storage;importcom.google.cloud.storage.StorageOptions;importjava.io.IOException;importjava.nio.file.Paths;publicclassUploadObject{publicstaticvoiduploadObject(StringprojectId,StringbucketName,StringobjectName,StringfilePath)throwsIOException{// The ID of your GCP project// String projectId = "your-project-id";// The ID of your GCS bucket// String bucketName = "your-unique-bucket-name";// The ID of your GCS object// String objectName = "your-object-name";// The path to your file to upload// String filePath = "path/to/your/file"Storagestorage=StorageOptions.newBuilder().setProjectId(projectId).build().getService();BlobIdblobId=BlobId.of(bucketName,objectName);BlobInfoblobInfo=BlobInfo.newBuilder(blobId).build();// Optional: set a generation-match precondition to avoid potential race// conditions and data corruptions. The request returns a 412 error if the// preconditions are not met.Storage.BlobWriteOptionprecondition;if(storage.get(bucketName,objectName)==null){// For a target object that does not yet exist, set the DoesNotExist precondition.// This will cause the request to fail if the object is created before the request runs.precondition=Storage.BlobWriteOption.doesNotExist();}else{// If the destination already exists in your bucket, instead set a generation-match// precondition. This will cause the request to fail if the existing object's generation// changes before the request runs.precondition=Storage.BlobWriteOption.generationMatch(storage.get(bucketName,objectName).getGeneration());}storage.createFrom(blobInfo,Paths.get(filePath),precondition);System.out.println("File "+filePath+" uploaded to bucket "+bucketName+" as "+objectName);}}

importcom.google.cloud.storage.transfermanager.ParallelUploadConfig;importcom.google.cloud.storage.transfermanager.TransferManager;importcom.google.cloud.storage.transfermanager.TransferManagerConfig;importcom.google.cloud.storage.transfermanager.UploadResult;importjava.io.IOException;importjava.nio.file.Path;importjava.util.List;classUploadMany{publicstaticvoiduploadManyFiles(StringbucketName,List<Path>files)throwsIOException{TransferManagertransferManager=TransferManagerConfig.newBuilder().build().getService();ParallelUploadConfigparallelUploadConfig=ParallelUploadConfig.newBuilder().setBucketName(bucketName).build();List<UploadResult>results=transferManager.uploadFiles(files,parallelUploadConfig).getUploadResults();for(UploadResultresult:results){System.out.println("Upload for "+result.getInput().getName()+" completed with status "+result.getStatus());}}}

importcom.google.cloud.storage.transfermanager.ParallelUploadConfig;importcom.google.cloud.storage.transfermanager.TransferManager;importcom.google.cloud.storage.transfermanager.TransferManagerConfig;importcom.google.cloud.storage.transfermanager.UploadResult;importjava.io.IOException;importjava.nio.file.Files;importjava.nio.file.Path;importjava.util.ArrayList;importjava.util.List;importjava.util.stream.Stream;classUploadDirectory{publicstaticvoiduploadDirectoryContents(StringbucketName,PathsourceDirectory)throwsIOException{TransferManagertransferManager=TransferManagerConfig.newBuilder().build().getService();ParallelUploadConfigparallelUploadConfig=ParallelUploadConfig.newBuilder().setBucketName(bucketName).build();// Create a list to store the file pathsList<Path>filePaths=newArrayList<>();// Get all files in the directory// try-with-resource to ensure pathStream is closedtry(Stream<Path>pathStream=Files.walk(sourceDirectory)){pathStream.filter(Files::isRegularFile).forEach(filePaths::add);}List<UploadResult>results=transferManager.uploadFiles(filePaths,parallelUploadConfig).getUploadResults();for(UploadResultresult:results){System.out.println("Upload for "+result.getInput().getName()+" completed with status "+result.getStatus());}}}

/** * TODO(developer): Uncomment the following lines before running the sample. */// The ID of your GCS bucket// const bucketName = 'your-unique-bucket-name';// The path to your file to upload// const filePath = 'path/to/your/file';// The new ID for your GCS file// const destFileName = 'your-new-file-name';// Imports the Google Cloud client libraryconst{Storage}=require('@google-cloud/storage');// Creates a clientconststorage=newStorage();asyncfunctionuploadFile(){constoptions={destination:destFileName,// Optional:// Set a generation-match precondition to avoid potential race conditions// and data corruptions. The request to upload is aborted if the object's// generation number does not match your precondition. For a destination// object that does not yet exist, set the ifGenerationMatch precondition to 0// If the destination object already exists in your bucket, set instead a// generation-match precondition using its generation number.preconditionOpts:{ifGenerationMatch:generationMatchPrecondition},};awaitstorage.bucket(bucketName).upload(filePath,options);console.log(`${filePath} uploaded to${bucketName}`);}uploadFile().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 the first GCS file to upload// const firstFilePath = 'your-first-file-name';// The ID of the second GCS file to upload// const secondFilePath = 'your-second-file-name';// Imports the Google Cloud client libraryconst{Storage,TransferManager}=require('@google-cloud/storage');// Creates a clientconststorage=newStorage();// Creates a transfer manager clientconsttransferManager=newTransferManager(storage.bucket(bucketName));asyncfunctionuploadManyFilesWithTransferManager(){// Uploads the filesawaittransferManager.uploadManyFiles([firstFilePath,secondFilePath]);for(constfilePathof[firstFilePath,secondFilePath]){console.log(`${filePath} uploaded to${bucketName}.`);}}uploadManyFilesWithTransferManager().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 local directory to upload// const directoryName = 'your-directory';// Imports the Google Cloud client libraryconst{Storage,TransferManager}=require('@google-cloud/storage');// Creates a clientconststorage=newStorage();// Creates a transfer manager clientconsttransferManager=newTransferManager(storage.bucket(bucketName));asyncfunctionuploadDirectoryWithTransferManager(){// Uploads the directoryawaittransferManager.uploadManyFiles(directoryName);console.log(`${directoryName} uploaded to${bucketName}.`);}uploadDirectoryWithTransferManager().catch(console.error);

use Google\Cloud\Storage\StorageClient;/** * Upload a file. * * @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 $source The path to the file to upload. *        (e.g. '/path/to/your/file') */function upload_object(string $bucketName, string $objectName, string $source): void{    $storage = new StorageClient();    if (!$file = fopen($source, 'r')) {        throw new \InvalidArgumentException('Unable to open file for reading');    }    $bucket = $storage->bucket($bucketName);    $object = $bucket->upload($file, [        'name' => $objectName    ]);    printf('Uploaded %s to gs://%s/%s' . PHP_EOL, basename($source), $bucketName, $objectName);}

fromgoogle.cloudimportstoragedefupload_blob(bucket_name,source_file_name,destination_blob_name):"""Uploads a file to the bucket."""# The ID of your GCS bucket# bucket_name = "your-bucket-name"# The path to your file to upload# source_file_name = "local/path/to/file"# The ID of your GCS object# destination_blob_name = "storage-object-name"storage_client=storage.Client()bucket=storage_client.bucket(bucket_name)blob=bucket.blob(destination_blob_name)# Optional: set a generation-match precondition to avoid potential race conditions# and data corruptions. The request to upload is aborted if the object's# generation number does not match your precondition. For a destination# object that does not yet exist, set the if_generation_match precondition to 0.# If the destination object already exists in your bucket, set instead a# generation-match precondition using its generation number.generation_match_precondition=0blob.upload_from_filename(source_file_name,if_generation_match=generation_match_precondition)print(f"File{source_file_name} uploaded to{destination_blob_name}.")

defupload_many_blobs_with_transfer_manager(bucket_name,filenames,source_directory="",workers=8):"""Upload every file in a list to a bucket, concurrently in a process pool.    Each blob name is derived from the filename, not including the    `source_directory` parameter. For complete control of the blob name for each    file (and other aspects of individual blob metadata), use    transfer_manager.upload_many() instead.    """# The ID of your GCS bucket# bucket_name = "your-bucket-name"# A list (or other iterable) of filenames to upload.# filenames = ["file_1.txt", "file_2.txt"]# The directory on your computer that is the root of all of the files in the# list of filenames. This string is prepended (with os.path.join()) to each# filename to get the full path to the file. Relative paths and absolute# paths are both accepted. This string is not included in the name of the# uploaded blob; it is only used to find the source files. An empty string# means "the current working directory". Note that this parameter allows# directory traversal (e.g. "/", "../") and is not intended for unsanitized# end user input.# source_directory=""# The maximum number of processes to use for the operation. The performance# impact of this value depends on the use case, but smaller files usually# benefit from a higher number of processes. Each additional process occupies# some CPU and memory resources until finished. Threads can be used instead# of processes by passing `worker_type=transfer_manager.THREAD`.# workers=8fromgoogle.cloud.storageimportClient,transfer_managerstorage_client=Client()bucket=storage_client.bucket(bucket_name)results=transfer_manager.upload_many_from_filenames(bucket,filenames,source_directory=source_directory,max_workers=workers)forname,resultinzip(filenames,results):# The results list is either `None` or an exception for each filename in# the input list, in order.ifisinstance(result,Exception):print("Failed to upload{} due to exception:{}".format(name,result))else:print("Uploaded{} to{}.".format(name,bucket.name))

defupload_directory_with_transfer_manager(bucket_name,source_directory,workers=8):"""Upload every file in a directory, including all files in subdirectories.    Each blob name is derived from the filename, not including the `directory`    parameter itself. For complete control of the blob name for each file (and    other aspects of individual blob metadata), use    transfer_manager.upload_many() instead.    """# The ID of your GCS bucket# bucket_name = "your-bucket-name"# The directory on your computer to upload. Files in the directory and its# subdirectories will be uploaded. An empty string means "the current# working directory".# source_directory=""# The maximum number of processes to use for the operation. The performance# impact of this value depends on the use case, but smaller files usually# benefit from a higher number of processes. Each additional process occupies# some CPU and memory resources until finished. Threads can be used instead# of processes by passing `worker_type=transfer_manager.THREAD`.# workers=8frompathlibimportPathfromgoogle.cloud.storageimportClient,transfer_managerstorage_client=Client()bucket=storage_client.bucket(bucket_name)# Generate a list of paths (in string form) relative to the `directory`.# This can be done in a single list comprehension, but is expanded into# multiple lines here for clarity.# First, recursively get all files in `directory` as Path objects.directory_as_path_obj=Path(source_directory)paths=directory_as_path_obj.rglob("*")# Filter so the list only includes files, not directories themselves.file_paths=[pathforpathinpathsifpath.is_file()]# These paths are relative to the current working directory. Next, make them# relative to `directory`relative_paths=[path.relative_to(source_directory)forpathinfile_paths]# Finally, convert them all to strings.string_paths=[str(path)forpathinrelative_paths]print("Found{} files.".format(len(string_paths)))# Start the upload.results=transfer_manager.upload_many_from_filenames(bucket,string_paths,source_directory=source_directory,max_workers=workers)forname,resultinzip(string_paths,results):# The results list is either `None` or an exception for each filename in# the input list, in order.ifisinstance(result,Exception):print("Failed to upload{} due to exception:{}".format(name,result))else:print("Uploaded{} to{}.".format(name,bucket.name))

defupload_filebucket_name:,local_file_path:,file_name:nil# The ID of your GCS bucket# bucket_name = "your-unique-bucket-name"# The path to your file to upload# local_file_path = "/local/path/to/file.txt"# The ID of your GCS object# file_name = "your-file-name"require"google/cloud/storage"storage=Google::Cloud::Storage.newbucket=storage.bucketbucket_name,skip_lookup:truefile=bucket.create_filelocal_file_path,file_nameputs"Uploaded#{local_file_path} as#{file.name} in bucket#{bucket_name}"end

namespacegcs=::google::cloud::storage;using::google::cloud::StatusOr;[](gcs::Clientclient,std::stringconst&bucket_name){autocurrent_policy=client.GetNativeBucketIamPolicy(bucket_name,gcs::RequestedPolicyVersion(3));if(!current_policy)throwstd::move(current_policy).status();current_policy->set_version(3);current_policy->bindings().emplace_back(gcs::NativeIamBinding("roles/storage.objectViewer",{"allUsers"}));autoupdated=client.SetNativeBucketIamPolicy(bucket_name,*current_policy);if(!updated)throwstd::move(updated).status();std::cout <<"Policy successfully updated: " <<*updated <<"\n";}

usingGoogle.Apis.Storage.v1.Data;usingGoogle.Cloud.Storage.V1;usingSystem;usingSystem.Collections.Generic;publicclassMakeBucketPublicSample{publicvoidMakeBucketPublic(stringbucketName="your-unique-bucket-name"){varstorage=StorageClient.Create();Policypolicy=storage.GetBucketIamPolicy(bucketName);policy.Bindings.Add(newPolicy.BindingsData{Role="roles/storage.objectViewer",Members=newList<string>{"allUsers"}});storage.SetBucketIamPolicy(bucketName,policy);Console.WriteLine(bucketName+" is now public ");}}

import("context""fmt""io""cloud.google.com/go/iam""cloud.google.com/go/iam/apiv1/iampb""cloud.google.com/go/storage")// setBucketPublicIAM makes all objects in a bucket publicly readable.funcsetBucketPublicIAM(wio.Writer,bucketNamestring)error{// bucketName := "bucket-name"ctx:=context.Background()client,err:=storage.NewClient(ctx)iferr!=nil{returnfmt.Errorf("storage.NewClient: %w",err)}deferclient.Close()policy,err:=client.Bucket(bucketName).IAM().V3().Policy(ctx)iferr!=nil{returnfmt.Errorf("Bucket(%q).IAM().V3().Policy: %w",bucketName,err)}role:="roles/storage.objectViewer"policy.Bindings=append(policy.Bindings,&iampb.Binding{Role:role,Members:[]string{iam.AllUsers},})iferr:=client.Bucket(bucketName).IAM().V3().SetPolicy(ctx,policy);err!=nil{returnfmt.Errorf("Bucket(%q).IAM().SetPolicy: %w",bucketName,err)}fmt.Fprintf(w,"Bucket %v is now publicly readable\n",bucketName)returnnil}

importcom.google.cloud.Identity;importcom.google.cloud.Policy;importcom.google.cloud.storage.Storage;importcom.google.cloud.storage.StorageOptions;importcom.google.cloud.storage.StorageRoles;publicclassMakeBucketPublic{publicstaticvoidmakeBucketPublic(StringprojectId,StringbucketName){// The ID of your GCP project// String projectId = "your-project-id";// The ID of your GCS bucket// String bucketName = "your-unique-bucket-name";Storagestorage=StorageOptions.newBuilder().setProjectId(projectId).build().getService();PolicyoriginalPolicy=storage.getIamPolicy(bucketName);storage.setIamPolicy(bucketName,originalPolicy.toBuilder().addIdentity(StorageRoles.objectViewer(),Identity.allUsers())// All users can view.build());System.out.println("Bucket "+bucketName+" is now publicly readable");}}

/** * 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 libraryconst{Storage}=require('@google-cloud/storage');// Creates a clientconststorage=newStorage();asyncfunctionmakeBucketPublic(){awaitstorage.bucket(bucketName).makePublic();console.log(`Bucket${bucketName} is now publicly readable`);}makeBucketPublic().catch(console.error);

use Google\Cloud\Storage\StorageClient;/** * Update the specified bucket's IAM configuration to make it publicly accessible. * * @param string $bucketName The name of your Cloud Storage bucket. *        (e.g. 'my-bucket') */function set_bucket_public_iam(string $bucketName): void{    $storage = new StorageClient();    $bucket = $storage->bucket($bucketName);    $policy = $bucket->iam()->policy(['requestedPolicyVersion' => 3]);    $policy['version'] = 3;    $role = 'roles/storage.objectViewer';    $members = ['allUsers'];    $policy['bindings'][] = [        'role' => $role,        'members' => $members    ];    $bucket->iam()->setPolicy($policy);    printf('Bucket %s is now public', $bucketName);}

fromtypingimportListfromgoogle.cloudimportstoragedefset_bucket_public_iam(bucket_name:str="your-bucket-name",members:List[str]=["allUsers"],):"""Set a public IAM Policy to 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)policy.bindings.append({"role":"roles/storage.objectViewer","members":members})bucket.set_iam_policy(policy)print(f"Bucket{bucket.name} is now publicly readable")

defset_bucket_public_iambucket_name:# The ID of your GCS bucket# bucket_name = "your-unique-bucket-name"require"google/cloud/storage"storage=Google::Cloud::Storage.newbucket=storage.bucketbucket_namebucket.policydo|p|p.add"roles/storage.objectViewer","allUsers"endputs"Bucket#{bucket_name} is now publicly readable"end

namespacegcs=::google::cloud::storage;using::google::cloud::StatusOr;[](gcs::Clientclient,std::stringconst&bucket_name,std::stringconst&main_page_suffix,std::stringconst&not_found_page){StatusOr<gcs::BucketMetadata>original=client.GetBucketMetadata(bucket_name);if(!original)throwstd::move(original).status();StatusOr<gcs::BucketMetadata>patched=client.PatchBucket(bucket_name,gcs::BucketMetadataPatchBuilder().SetWebsite(gcs::BucketWebsite{main_page_suffix,not_found_page}),gcs::IfMetagenerationMatch(original->metageneration()));if(!patched)throwstd::move(patched).status();if(!patched->has_website()){std::cout <<"Static website configuration is not set for bucket "              <<patched->name() <<"\n";return;}std::cout <<"Static website configuration successfully set for bucket "            <<patched->name() <<"\nNew main page suffix is: "            <<patched->website().main_page_suffix            <<"\nNew not found page is: "            <<patched->website().not_found_page <<"\n";}

usingGoogle.Apis.Storage.v1.Data;usingGoogle.Cloud.Storage.V1;usingSystem;publicclassBucketWebsiteConfigurationSample{publicBucketBucketWebsiteConfiguration(stringbucketName="your-bucket-name",stringmainPageSuffix="index.html",stringnotFoundPage="404.html"){varstorage=StorageClient.Create();varbucket=storage.GetBucket(bucketName);if(bucket.Website==null){bucket.Website=newBucket.WebsiteData();}bucket.Website.MainPageSuffix=mainPageSuffix;bucket.Website.NotFoundPage=notFoundPage;bucket=storage.UpdateBucket(bucket);Console.WriteLine($"Static website bucket {bucketName} is set up to use {mainPageSuffix} as the index page and {notFoundPage} as the 404 not found page.");returnbucket;}}

import("context""fmt""io""time""cloud.google.com/go/storage")// setBucketWebsiteInfo sets website configuration on a bucket.funcsetBucketWebsiteInfo(wio.Writer,bucketName,indexPage,notFoundPagestring)error{// bucketName := "www.example.com"// indexPage := "index.html"// notFoundPage := "404.html"ctx:=context.Background()client,err:=storage.NewClient(ctx)iferr!=nil{returnfmt.Errorf("storage.NewClient: %w",err)}deferclient.Close()ctx,cancel:=context.WithTimeout(ctx,time.Second*10)defercancel()bucket:=client.Bucket(bucketName)bucketAttrsToUpdate:=storage.BucketAttrsToUpdate{Website:&storage.BucketWebsite{MainPageSuffix:indexPage,NotFoundPage:notFoundPage,},}if_,err:=bucket.Update(ctx,bucketAttrsToUpdate);err!=nil{returnfmt.Errorf("Bucket(%q).Update: %w",bucketName,err)}fmt.Fprintf(w,"Static website bucket %v is set up to use %v as the index page and %v as the 404 page\n",bucketName,indexPage,notFoundPage)returnnil}

importcom.google.cloud.storage.Bucket;importcom.google.cloud.storage.Storage;importcom.google.cloud.storage.StorageOptions;publicclassSetBucketWebsiteInfo{publicstaticvoidsetBucketWesbiteInfo(StringprojectId,StringbucketName,StringindexPage,StringnotFoundPage){// The ID of your GCP project// String projectId = "your-project-id";// The ID of your static website bucket// String bucketName = "www.example.com";// The index page for a static website bucket// String indexPage = "index.html";// The 404 page for a static website bucket// String notFoundPage = "404.html";Storagestorage=StorageOptions.newBuilder().setProjectId(projectId).build().getService();Bucketbucket=storage.get(bucketName);bucket.toBuilder().setIndexPage(indexPage).setNotFoundPage(notFoundPage).build().update();System.out.println("Static website bucket "+bucketName+" is set up to use "+indexPage+" as the index page and "+notFoundPage+" as the 404 page");}}

/** * 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 main page// const mainPageSuffix = 'http://example.com';// The Name of a 404 page// const notFoundPage = 'http://example.com/404.html';// Imports the Google Cloud client libraryconst{Storage}=require('@google-cloud/storage');// Creates a clientconststorage=newStorage();asyncfunctionaddBucketWebsiteConfiguration(){awaitstorage.bucket(bucketName).setMetadata({website:{mainPageSuffix,notFoundPage,},});console.log(`Static website bucket${bucketName} is set up to use${mainPageSuffix} as the index page and${notFoundPage} as the 404 page`);}addBucketWebsiteConfiguration().catch(console.error);

use Google\Cloud\Storage\StorageClient;/** * Update the given bucket's website configuration. * * @param string $bucketName The name of your Cloud Storage bucket. *        (e.g. 'my-bucket') * @param string $indexPageObject the name of an object in the bucket to use as *        (e.g. 'index.html') *     an index page for a static website bucket. * @param string $notFoundPageObject the name of an object in the bucket to use *        (e.g. '404.html') *     as the 404 Not Found page. */function define_bucket_website_configuration(string $bucketName, string $indexPageObject, string $notFoundPageObject): void{    $storage = new StorageClient();    $bucket = $storage->bucket($bucketName);    $bucket->update([        'website' => [            'mainPageSuffix' => $indexPageObject,            'notFoundPage' => $notFoundPageObject        ]    ]);    printf(        'Static website bucket %s is set up to use %s as the index page and %s as the 404 page.',        $bucketName,        $indexPageObject,        $notFoundPageObject    );}

fromgoogle.cloudimportstoragedefdefine_bucket_website_configuration(bucket_name,main_page_suffix,not_found_page):"""Configure website-related properties of bucket"""# bucket_name = "your-bucket-name"# main_page_suffix = "index.html"# not_found_page = "404.html"storage_client=storage.Client()bucket=storage_client.get_bucket(bucket_name)bucket.configure_website(main_page_suffix,not_found_page)bucket.patch()print("Static website bucket{} is set up to use{} as the index page and{} as the 404 page".format(bucket.name,main_page_suffix,not_found_page))returnbucket

defdefine_bucket_website_configurationbucket_name:,main_page_suffix:,not_found_page:# The ID of your static website bucket# bucket_name = "www.example.com"# The index page for a static website bucket# main_page_suffix = "index.html"# The 404 page for a static website bucket# not_found_page = "404.html"require"google/cloud/storage"storage=Google::Cloud::Storage.newbucket=storage.bucketbucket_namebucket.updatedo|b|b.website_main=main_page_suffixb.website_404=not_found_pageendputs"Static website bucket#{bucket_name} is set up to use#{main_page_suffix} as the index page and "\"#{not_found_page} as the 404 page"end