Host a static website

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;
publicclass UploadObject{
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"
Storage storage=StorageOptions .newBuilder().setProjectId(projectId).build().getService ();
BlobId blobId=BlobId .of(bucketName,objectName);
BlobInfo blobInfo=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;
class UploadMany{
publicstaticvoiduploadManyFiles(StringbucketName,List<Path>files)throwsIOException{
TransferManager transferManager=TransferManagerConfig .newBuilder().build().getService ();
ParallelUploadConfig parallelUploadConfig=
ParallelUploadConfig .newBuilder().setBucketName(bucketName).build();
List<UploadResult>results=
transferManager.uploadFiles (files,parallelUploadConfig).getUploadResults ();
for(UploadResult result: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;
class UploadDirectory{
publicstaticvoiduploadDirectoryContents(StringbucketName,PathsourceDirectory)
throwsIOException{
TransferManager transferManager=TransferManagerConfig .newBuilder().build().getService ();
ParallelUploadConfig parallelUploadConfig=
ParallelUploadConfig .newBuilder().setBucketName(bucketName).build();
// Create a list to store the file paths
List<Path>filePaths=newArrayList<>();
// Get all files in the directory
// try-with-resource to ensure pathStream is closed
try(Stream<Path>pathStream=Files.walk(sourceDirectory)){
pathStream.filter(Files::isRegularFile).forEach(filePaths::add);
}
List<UploadResult>results=
transferManager.uploadFiles (filePaths,parallelUploadConfig).getUploadResults ();
for(UploadResult result: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 library
const{Storage}=require('@google-cloud/storage');
// Creates a client
conststorage=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 library
const{Storage,TransferManager}=require('@google-cloud/storage');
// Creates a client
conststorage=newStorage();
// Creates a transfer manager client
consttransferManager=newTransferManager (storage.bucket(bucketName));
asyncfunctionuploadManyFilesWithTransferManager(){
// Uploads the files
awaittransferManager.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 library
const{Storage,TransferManager}=require('@google-cloud/storage');
// Creates a client
conststorage=newStorage();
// Creates a transfer manager client
consttransferManager=newTransferManager (storage.bucket(bucketName));
asyncfunctionuploadDirectoryWithTransferManager(){
// Uploads the directory
awaittransferManager.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.cloudimport storage
defupload_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 = 0
 blob.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=8
 fromgoogle.cloud.storageimport Client , transfer_manager
 storage_client = Client()
 bucket = storage_client.bucket (bucket_name)
 results = transfer_manager .upload_many_from_filenames (
 bucket, filenames, source_directory=source_directory, max_workers=workers
 )
 for name, result in zip(filenames, results):
 # The results list is either `None` or an exception for each filename in
 # the input list, in order.
 if isinstance(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=8
 frompathlibimport Path
 fromgoogle.cloud.storageimport Client , transfer_manager
 storage_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 = [path for path in paths if path.is_file()]
 # These paths are relative to the current working directory. Next, make them
 # relative to `directory`
 relative_paths = [path.relative_to(source_directory) for path in file_paths]
 # Finally, convert them all to strings.
 string_paths = [str(path) for path in relative_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
 )
 for name, result in zip(string_paths, results):
 # The results list is either `None` or an exception for each filename in
 # the input list, in order.
 if isinstance(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 .new
bucket=storage.bucketbucket_name,skip_lookup:true
file=bucket.create_file local_file_path,file_name
puts"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 ;
publicclass MakeBucketPublic{
publicstaticvoidmakeBucketPublic(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";
Storage storage=StorageOptions .newBuilder().setProjectId(projectId).build().getService();
Policy originalPolicy=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 library
const{Storage}=require('@google-cloud/storage');
// Creates a client
conststorage=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);
}

fromtypingimport List
fromgoogle.cloudimport storage
defset_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 .new
bucket=storage.bucketbucket_name
bucket.policy do|p|
p.add "roles/storage.objectViewer","allUsers"
end
puts"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 ;
publicclass SetBucketWebsiteInfo{
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";
Storage storage=StorageOptions .newBuilder().setProjectId(projectId).build().getService ();
Bucket bucket=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 library
const{Storage}=require('@google-cloud/storage');
// Creates a client
conststorage=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.cloudimport storage
defdefine_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
 )
 )
 return bucket

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 .new
bucket=storage.bucketbucket_name
bucket.updatedo|b|
b.website_main =main_page_suffix
b.website_404 =not_found_page
end
puts"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