Host a static website

          
          

          
          

          
          

          This tutorial describes how to configure a Cloud Storage bucket to host
a static website for a domain you own. Static web pages can contain
client-side technologies such as HTML, CSS, and JavaScript. They cannot contain
dynamic content such as server-side scripts like PHP.


Because Cloud Storage doesn't support custom domains with HTTPS on its own, this
tutorial uses Cloud Storage with HTTP(S) Load Balancing to serve content from
a custom domain over HTTPS. For more ways to serve content from a custom domain
over HTTPS, see the related troubleshooting topic. You can also use
Cloud Storage to serve custom domain content over HTTP, which doesn't
require a load balancer.


For examples and tips on static web pages, including how to host static assets
for a dynamic website, see the Static Website page.



## Objectives
 
This tutorial shows you how to:


- 

- Create a bucket. 

- Upload and share your site's files. 

- Set up a load balancer and SSL certificate. 

- Connect your load balancer to your bucket. 

- Point your domain to your load balancer using an
Arecord. 

- Test the website. 

## Costs
 


This tutorial uses the following billable components of Google Cloud:


See the Monitoring your charges tip for details on what charges
may be incurred when hosting a static website.



## Before you begin
 


- 














- 
 
 
 
 Sign in to your Google Cloud account. If you're new to
 Google Cloud, 
 create an account to evaluate how our products perform in
 real-world scenarios. New customers also get $300 in free credits to
 run, test, and deploy workloads.
 
 
 
 
 
 

 
 

 
 

 
 
 

 
 










 
 
 

- 
 
 

In the Google Cloud console, on the project selector page,
 select or create a Google Cloud project.
 
 
 

 
 
 
 



 
 
 








 

- 
 


 Make sure that billing is enabled for your Cloud project. Learn how to
 check if billing is enabled on a project.

 
 
 


 
 
 
 
 

 
 


- 
 
 

In the Google Cloud console, on the project selector page,
 select or create a Google Cloud project.
 
 
 

 
 
 
 



 
 
 








 

- 
 


 Make sure that billing is enabled for your Cloud project. Learn how to
 check if billing is enabled on a project.

 
 
 


 
 
 
 
 

 
 


- Have a domain that you own or manage. If you don't have an existing domain,
there are many services through which you can register a new domain, such as
Google Domains and
 Cloud Domains.

This tutorial uses the domain
example.com. 

- Have a few website files you want to serve. This tutorial works best if you
 have at least an index page (
index.html) and a 404 page
 (
404.htmln 

- Have the following Identity and Access Management roles:
 Storage Object Admin and
 Network Admin. 


- (Optional) If you want your Cloud Storage bucket to have the same
 name as your domain, you must
 Verify that
 you own or manage the domain that you will be using. Make sure you are
 verifying the top-level domain, such as
example.com, and not a
 subdomain, such as
www.example.com. If you purchased your
 domain through Google Domains, verification is automatic.
 

## Create a bucket


To create a bucket:


 Console

- 

- In the Google Cloud console, go to the Cloud Storage
Browserpage


 

- Click
Create bucket. 

- On the
Create a bucketpage, enter your bucket information. To go to the
 next step, click Continue.



- 

- For
Name your bucket, enter a name that meets the
 bucket name requirements. 

- For
Choose where to store your data, select a
 Location typeand
 Locationwhere the
 bucket data will be permanently stored. 

- For
Choose a default storage class for your data, select a
 storage class
 for the bucket. The default storage class is
 assigned by default to all objects uploaded to the bucket.
 Note:The Monthly cost estimatepanel in the
 right pane estimates the bucket's monthly costs based on your selected storage class and
 location, as well as your expected data size and operations. 

- For
Choose how to control access to objects, select whether or not your bucket
 enforces public access prevention, and
 select an Access controlmodel for your
 bucket's objects.
 Note:If public access prevention is already enforced by your project's
 organization policy,
 the Prevent public accesstoggle is locked. 

- For
Choose how to protect object data, configure Protection toolsif desired,
 and select a Data encryptionmethod. 

- For
- Click
Create.
 

To learn how to get detailed error information about failed operations in the
 Cloud Storage browser, see
 Troubleshooting.

 Command line

Use the
gsutil mb
 command:
gsutil mb gsn
BUCKET_NAME
Where:

- 

is the name you want to give your bucket, subject to naming requirements. For example,
BUCKET_NAME
my-bucket. 

If the request is successful, the command returns the following message:

Creating gsn
BUCKET_NAME

Set the following optional flags to have greater control over the creation
 of your bucket:

- 

-p: Specify the project ID or project number with which your bucket will be associated. For example,
my-project. 

-c: Specify the default storage
 class of your bucket. For example,
NEARLINE. 

-l: Specify the location of your bucket. For example,
US-EAST1. 

-b: Specify the uniform bucket-level access
 setting for your bucket. For example,
ON. 

For a complete list of options for gsutil bucket creation, see mb options.

For example:


 gsutil mb -p


PROJECT_ID-c STORAGE_CLASS-l BUCKET_LOCATION-b on gs BUCKET_NAME
 Code samples
 
 
 
 


 
 

 Cn 
 
 


 
 
 For more information, see the
 
 Cloud Storage C++ API reference documentation.
 

 
 
 
 
 



















 
 
 
 
 







namespace gcs = ::google::cloud::storage;
using ::google::cloud::StatusOr;
gcs::Client client, std::string const& bucket_name,
 std::string const& storage_class, std::string const& location) {
 StatusOr bucket_metadata =
 client.CreateBucket(bucket_name, gcs::BucketMetadatan .set_storage_class(storage_class)
 .set_location(locationn
 if (!bucket_metadata) {
 throw std::runtime_error(bucket_metadata.statusmessagen }

 std::cout << "Bucket " << bucket_metadata->name() << " createdn << nFull Metadata: " << *bucket_metadata << nn}
 C#
 
 
 


 
 
 For more information, see the
 
 Cloud Storage C# API reference documentation.
 

 
 
 
 
 



















 
 
 
 
 








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

public class CreateRegionalBucketSample
{

Creates a storage bucket with region.

The ID of the project to create the buckets inparam>
The location of the bucket. Object data for objects in the bucket resides in 
physical storage within this region. Defaults to USparam>
The name of the bucket to createparam>
The bucket's default storage class, used whenever no storageClass is specified
for a newly-created object. This defines how objects in the bucket are stored
and determines the SLA and the cost of storage. Values include MULTI_REGIONAL,
REGIONAL, STANDARD, NEARLINE, COLDLINE, ARCHIVE, and DURABLE_REDUCED_AVAILABILITY.
If this value is not specified when the bucket is created, it will default to
STANDARDparam>
 public Bucket CreateRegionalBucket(
 string projectId = "your-project-idn string bucketName = "your-unique-bucket-namen string location = "us-west1n string storageClass = "REGIONALn {
 var storage = StorageClient.Createn Bucket bucket = new Bucket
 {
 Location = location,
 Name = bucketName,
 StorageClass = storageClass
 n var newlyCreatedBucket = storage.CreateBucket(projectId, bucketn Console.WriteLineCreated {bucketNamen return newlyCreatedBucket;
 }
}
 Go
 
 
 


 
 
 For more information, see the
 
 Cloud Storage Go API reference documentation.
 

 
 
 
 
 



















 
 
 
 







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

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

// createBucketClassLocation creates a new bucket in the project with Storage class and
// location.
func createBucketClassLocation(w io.Writer, projectID, bucketName string) error {
	// projectID := "my-project-id"

	// bucketName := "bucket-name"
	ctx := context.Backgroundn	client, err := storage.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("storage.NewClient: %v", err)
	}
	defer client.Closen
	ctx, cancel := context.WithTimeout(ctx, time.Second*10)
	defer canceln
	storageClassAndLocation := &storage.BucketAttrs{
		StorageClass: "COLDLINEn		Location: "asian	}
	bucket := client.Bucket(bucketName)
	if err := bucket.Create(ctx, projectID, storageClassAndLocation); err != nil {
		return fmt.Errorf("Bucket(%q).Create: %v", bucketName, err)
	}
	fmt.Fprintf(w, "Created bucket %v in %v with storage class %v
", bucketName, storageClassAndLocation.Location, storageClassAndLocation.StorageClass)
	return nil
}

 Java
 
 
 


 
 
 For more information, see the
 
 Cloud Storage Java API reference documentation.
 

 
 
 
 
 



















 
 
 
 







import com.google.cloud.storage.Bucket;
import com.google.cloud.storage.BucketInfo;
import com.google.cloud.storage.Storage;
import com.google.cloud.storage.StorageClass;
import com.google.cloud.storage.StorageOptions;

public class CreateBucketWithStorageClassAndLocation {
 public static void createBucketWithStorageClassAndLocation(String projectId, String bucketName) {
 // The ID of your GCP project
 // String projectId = "your-project-idn
 // The ID to give your GCS bucket
 // String bucketName = "your-unique-bucket-namen
 Storage storage = StorageOptions.newBuildersetProjectId(projectId).buildgetServicen
 // See the StorageClass documentation for other valid storage classes:
 // httpsgoogleapis.dev/java/google-cloud-clients/latest/com/google/cloud/storage/StorageClass.html
 StorageClass storageClass = StorageClass.COLDLINE;

 // See this documentation for other valid locations:
 // httpg.co/cloud/storage/docs/bucket-locations#location-mr
 String location = "ASIAn
 Bucket bucket =
 storage.create(
 BucketInfo.newBuilder(bucketName)
 .setStorageClass(storageClass)
 .setLocation(location)
 .buildn
 System.out.println(
 "Created bucket "
 + bucket.getNamen + " in "
 + bucket.getLocationn + " with storage class "
 + bucket.getStorageClassn }
}
 Node.js
 
 
 


 
 
 For more information, see the
 
 Cloud Storage Node.js API reference documentation.
 

 
 
 
 
 



















 
 
 
 







n * TODO(developer): Uncomment the following lines before running the sample.
 n// The ID of your GCS bucket
// const bucketName = 'your-unique-bucket-namen
// The name of a storage class
// See the StorageClass documentation for other valid storage classes:
// httpsgoogleapis.dev/java/google-cloud-clients/latest/com/google/cloud/storage/StorageClass.html
// const storageClass = 'coldlinen
// The name of a location
// See this documentation for other valid locations:
// httpg.co/cloud/storage/docs/locations#location-mr
// const location = 'ASIAn
// Imports the Google Cloud client library
const {Storage} = requiregoogle-cloud/storagen
// Creates a client
// The bucket in the sample below will be created in the project associated with this client.
// For more information, please see httpscloud.google.com/docs/authentication/production or httpsgoogleapis.dev/nodejs/storage/latest/Storage.html
const storage = new Storagen
async function createBucketWithStorageClassAndLocation() {
 // For default values see: httpscloud.google.com/storage/docs/locations and
 // httpscloud.google.com/storage/docs/storage-classes
 const [bucket] = await storage.createBucket(bucketName, {
 location,
 [storageClass]: true,
 n
 console.log(
 bucket.name} created with ${storageClass} class in ${locationn n}

createBucketWithStorageClassAndLocationcatch(console.error);
 PHP
 
 
 


 
 
 For more information, see the
 
 Cloud Storage PHP API reference documentation.
 

 
 
 
 
 



















 
 
 
 







use Google\Cloud\Storage\StorageClient;

n * Create a new bucket with a custom default storage class and location.
 *
 * @param string $bucketName The name of your Cloud Storage bucket.
 nfunction create_bucket_class_location($bucketName)
{
 // $bucketName = 'my-bucketn
 $storage = new StorageClientn $storageClass = 'COLDLINEn $location = 'ASIAn $bucket = $storage->createBucket($bucketName, [
 'storageClass' => $storageClass,
 'location' => $location,
 n
 $objects = $bucket->objectsn 'encryption' => [
 'defaultKmsKeyName' => null,
 ]
 n
 printf('Created bucket %s in %s with storage class %s', $bucketName, $storageClass, $locationn}
 Python
 
 
 


 
 
 For more information, see the
 
 Cloud Storage Python API reference documentation.
 

 
 
 
 
 



















 
 
 
 







from google.cloud import storage


def create_bucket_class_location(bucket_namen n Create a new bucket in the US region with the coldline storage
 class
 n # bucket_name = "your-new-bucket-name"

 storage_client = storage.Clientn
 bucket = storage_client.bucket(bucket_name)
 bucket.storage_class = "COLDLINE"
 new_bucket = storage_client.create_bucket(bucket, location="usn
 print(
 "Created bucket {} in {} with storage class format(
 new_bucket.name, new_bucket.location, new_bucket.storage_class
 )
 )
 return new_bucket


 Ruby
 
 
 


 
 
 For more information, see the
 
 Cloud Storage Ruby API reference documentation.
 

 
 
 
 
 



















 
 
 
 







def create_bucket_class_location bucket_name:
 # The ID to give your GCS bucket
 # bucket_name = "your-unique-bucket-name"

 require "google/cloud/storage"

 storage = Google::Cloud::Storage.new

 bucket = storage.create_bucket bucket_name,
 location: "ASIAn storage_class: "COLDLINE"

 puts "Created bucket #{bucket.name} in #{bucket.location} with #{bucket.storage_class} class"
end
 Terraform

You can use a Terraform resource to create a storage bucket.




















 
 
 
 
 







# Create new storage bucket in the US multi-region
# with coldline storage
resource "google_storage_bucket" "static" {
 name = "new-bucket"
 location = "US"
 storage_class = "COLDLINE"

 uniform_bucket_level_access = true
}
 REST APIS

 JSON API

- 

- Get an authorization access token from the
OAuth 2.0 Playground.
Configure the playground to use your own OAuth credentials. For instructions, see
API authentication. 

- Create a .json file that contains the settings for the bucket, which must include a

namefor the bucket. See the
 Buckets:Insert documentation for a
 complete list of settings. The following are common settings to include: 

{
 "name": "

BUCKET_NAMEn "location": " BUCKET_LOCATIONn "storageClass": " STORAGE_CLASSn "iamConfiguration": {
 "uniformBucketLevelAccess": {
 "enabled": true
 n }
}
Where:

- 

is the name you want to give your bucket, subject to naming requirements. For example,
BUCKET_NAME
my-bucket. 

is the location where you want to store your bucket's object data. For example,
BUCKET_LOCATION
US-EAST1. 

is the default storage
 class of your bucket. For example,
STORAGE_CLASS
NEARLINE. 

cURLto call the
 JSON API:

curl -X POST --data-binary @

JSON_FILE_NAME.json n -H "Authorization: Bearer OAUTH2_TOKEN" n -H "Content-Type: application/json" n "httpsstorage.googleapis.com/storage/v1/b?project= PROJECT_IDENTIFIER"
Where:

- 

is name of the JSON file you created in Step 2

JSON_FILE_NAME

is the access token you generated in Step 1

OAUTH2_TOKEN

is the ID or number of the project with which your bucket will be associated. For example,
PROJECT_IDENTIFIER
my-project. 

 XML API

- 

- Get an authorization access token from the
OAuth 2.0 Playground.
Configure the playground to use your own OAuth credentials. For instructions, see
API authentication. 

- Create a .xml file that contains the following information: 


 

BUCKET_LOCATION
  STORAGE_CLASS

Where:

- 

is the location where you want to store your bucket's object data. For example,
BUCKET_LOCATION
US-EAST1. 

is the default storage
 class of your bucket. For example,
STORAGE_CLASS
NEARLINE. 

cURLto call the
 XML API:

curl -X PUT --data-binary @


XML_FILE_NAME.xml n -H "Authorization: Bearer OAUTH2_TOKEN" n -H "x-goog-project-id: PROJECT_ID" n "httpsstorage.googleapis.com/ BUCKET_NAME"
Where:

- 

is name of the XML file you created in Step 2

XML_FILE_NAME

is the access token you generated in Step 1

OAUTH2_TOKEN

is the ID of the project with which your bucket will be associated. For example,
PROJECT_ID
my-project. 

is the name you want to give your bucket, subject to
 naming requirements. For example,
BUCKET_NAME
my-bucket. 

## Upload your site's files


Add the files you want your website to serve to the bucket:

 Console
- 

- In the Google Cloud console, go to the Cloud Storage
Browserpage


 

In the list of buckets, click the name of the bucket that you created.


The
Bucket detailspage opens with the Objectstab selected. 

Click the
Upload filesbutton. 

In the file dialog, browse to the desired file and select it.

After the upload completes, you should see the filename along with file
information displayed in the bucket.


To learn how to get detailed error information about failed operations in the
 Cloud Storage browser, see
 Troubleshooting

 gsutil
Use the
gsutil cp command to copy files to your bucket. For example,
to copy the file
index.html from its current location
Desktop to the
bucket
my-static-assets:
gsutil cp Desktop/index.html gsmy-static-assets


If successful, the command returns:



Copying fileDesktop/index.html [Content-Type=text/htmlnUploading gsmy-static-assets/index.html: 0 B/2.58 KiB
Uploading gsmy-static-assets/index.html: 2.58 KiB/2.58 KiB

 Code samples












 



 




 
 
 




 
 
 
 For more information, see the
 
 Cloud Storage C++ API reference documentation.
 
 The following sample uploads an object from a file: The following sample uploads an object from memory: 
 
 
 For more information, see the
 
 Cloud Storage C# API reference documentation.
 
 The following sample uploads an object from a file: The following sample uploads an object from memory: 
 
 
 For more information, see the
 
 Cloud Storage Go API reference documentation.
 
 The following sample uploads an object from a file: The following sample uploads an object from memory: 
 
 
 For more information, see the
 
 Cloud Storage Java API reference documentation.
 
 The following sample uploads an object from a file: The following sample uploads an object from memory: 
 
 
 For more information, see the
 
 Cloud Storage Node.js API reference documentation.
 
 The following sample uploads an object from a file: The following sample uploads an object from memory: 
 
 
 For more information, see the
 
 Cloud Storage PHP API reference documentation.
 
 The following sample uploads an object from a file: The following sample uploads an object from memory: 
 
 

 For more information, see the
 
 Cloud Storage Python API reference documentation.
 
 The following sample uploads an object from a file: The following sample uploads an object from memory: 
 
 
 For more information, see the
 
 Cloud Storage Ruby API reference documentation.
 
 The following sample uploads an object from a file: The following sample uploads an object from memory:
## Cn 
 
 



namespace gcs = ::google::cloud::storage;
using ::google::cloud::StatusOr;
gcs::Client client, std::string const& file_name,
 std::string const& bucket_name, std::string const& object_name) {
 // Note that the client library automatically computes a hash on the
 // client-side to verify data integrity during transmission.
 StatusOr metadata = client.UploadFile(
 file_name, bucket_name, object_name, gcs::IfGenerationMatch(0n if (!metadata) throw std::runtime_error(metadata.statusmessagen
 std::cout << "Uploaded " << file_name << " to object " << metadata->namen << " in bucket " << metadata->bucketn << nFull metadata: " << *metadata << nn}


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 text = "Lorem ipsum dolor sit ametn std::vector v(100, textn gcs::ObjectWriteStream stream =
 client.WriteObject(bucket_name, object_namen
 std::copy(v.begin v.end std::ostream_iterator(streamn
 stream.Closen
 StatusOr metadata = std::move(stream).metadatan if (!metadata) throw std::runtime_error(metadata.statusmessagen std::cout << "Successfully wrote to object " << metadata->namen << " its size is: " << metadata->sizen << nFull metadata: " << *metadata << nn}
## C#
 
 
 




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

public class UploadFileSample
{
 public void UploadFile(
 string bucketName = "your-unique-bucket-namen string localPath = "my-local-path/my-file-namen string objectName = "my-file-namen {
 var storage = StorageClient.Createn using var fileStream = File.OpenRead(localPathn storage.UploadObject(bucketName, objectName, null, fileStreamn Console.WriteLineUploaded {objectNamen }
}




using Google.Cloud.Storage.V1;
using System;
using System.IO;
using System.Text;

public class UploadObjectFromMemorySample
{
 public void UploadObjectFromMemory(
 string bucketName = "unique-bucket-namen string objectName = "file-namen string contents = "Hello worldn {
 var storage = StorageClient.Createn byte[] byteArray = Encoding.UTF8.GetBytes(contentsn MemoryStream stream = new MemoryStream(byteArrayn storage.UploadObject(bucketName, objectName, "application/octet-stream" , streamn
 Console.WriteLine {objectName} uploaded to bucket {bucketName} with contents: {contentsn }
}

## Go
 
 
 



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

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

// uploadFile uploads an object.
func uploadFile(w io.Writer, bucket, object string) error {
	// bucket := "bucket-name"
	// object := "object-name"
	ctx := context.Backgroundn	client, err := storage.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("storage.NewClient: %v", err)
	}
	defer client.Closen
	// Open local file.
	f, err := os.Open("notes.txtn	if err != nil {
		return fmt.Errorf("os.Open: %v", err)
	}
	defer f.Closen
	ctx, cancel := context.WithTimeout(ctx, time.Second*50)
	defer canceln
	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: truen	// 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: %v", err)
	// }
	// o = o.If(storage.Conditions{GenerationMatch: attrs.Generationn
	// Upload an object with storage.Writer.
	wc := o.NewWriter(ctx)
	if _, err = io.Copy(wc, f); err != nil {
		return fmt.Errorf("io.Copy: %v", err)
	}
	if err := wc.Close err != nil {
		return fmt.Errorf("Writer.Close: %v", err)
	}
	fmt.Fprintf(w, "Blob %v uploadedn", object)
	return nil
}



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

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

// streamFileUpload uploads an object via a stream.
func streamFileUpload(w io.Writer, bucket, object string) error {
	// bucket := "bucket-name"
	// object := "object-name"
	ctx := context.Backgroundn	client, err := storage.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("storage.NewClient: %v", err)
	}
	defer client.Closen
	b := []byte("Hello worldn	buf := bytes.NewBuffer(b)

	ctx, cancel := context.WithTimeout(ctx, time.Second*50)
	defer canceln
	// Upload an object with storage.Writer.
	wc := client.Bucket(bucket).Object(object).NewWriter(ctx)
	wc.ChunkSize = 0 // note retries are not supported for chunk size 0.

	if _, err = io.Copy(wc, buf); err != nil {
		return fmt.Errorf("io.Copy: %v", err)
	}
	// Data can continue to be added to the file until the writer is closed.
	if err := wc.Close err != nil {
		return fmt.Errorf("Writer.Close: %v", err)
	}

	fmt.Fprintf(w, "%v uploaded to %vn", object, bucket)

	return nil
}

## Java
 
 
 




import com.google.cloud.storage.BlobId;
import com.google.cloud.storage.BlobInfo;
import com.google.cloud.storage.Storage;
import com.google.cloud.storage.StorageOptions;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;

public class UploadObject {
 public static void uploadObject(
 String projectId, String bucketName, String objectName, String filePath) throws IOException {
 // The ID of your GCP project
 // String projectId = "your-project-idn
 // The ID of your GCS bucket
 // String bucketName = "your-unique-bucket-namen
 // The ID of your GCS object
 // String objectName = "your-object-namen
 // The path to your file to upload
 // String filePath = "path/to/your/file"

 Storage storage = StorageOptions.newBuildersetProjectId(projectId).buildgetServicen BlobId blobId = BlobId.of(bucketName, objectNamen BlobInfo blobInfo = BlobInfo.newBuilder(blobId).buildn storage.create(blobInfo, Files.readAllBytes(Paths.get(filePathn
 System.out.println(
 "File " + filePath + " uploaded to bucket " + bucketName + " as " + objectNamen }
}



import com.google.cloud.storage.BlobId;
import com.google.cloud.storage.BlobInfo;
import com.google.cloud.storage.Storage;
import com.google.cloud.storage.StorageOptions;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;

public class UploadObjectFromMemory {
 public static void uploadObjectFromMemory(
 String projectId, String bucketName, String objectName, String contents) throws IOException {
 // The ID of your GCP project
 // String projectId = "your-project-idn
 // The ID of your GCS bucket
 // String bucketName = "your-unique-bucket-namen
 // The ID of your GCS object
 // String objectName = "your-object-namen
 // The string of contents you wish to upload
 // String contents = "Hello worldn
 Storage storage = StorageOptions.newBuildersetProjectId(projectId).buildgetServicen BlobId blobId = BlobId.of(bucketName, objectNamen BlobInfo blobInfo = BlobInfo.newBuilder(blobId).buildn byte[] content = contents.getBytes(StandardCharsets.UTF_8n storage.createFrom(blobInfo, new ByteArrayInputStream(contentn
 System.out.println(
 "Object "
 + objectName
 + " uploaded to bucket "
 + bucketName
 + " with contents "
 + contentsn }
}
## Node.js
 
 
 



n * TODO(developer): Uncomment the following lines before running the sample.
 n// The ID of your GCS bucket
// const bucketName = 'your-unique-bucket-namen
// The path to your file to upload
// const filePath = 'path/to/your/filen

// The new ID for your GCS file
// const destFileName = 'your-new-file-namen
// Imports the Google Cloud client library
const {Storage} = requiregoogle-cloud/storagen
// Creates a client
const storage = new Storagen
async function uploadFile() {
 await storage.bucket(bucketName).upload(filePath, {
 destination: destFileName,
 n
 console.logfilePath} uploaded to ${bucketNamen}

uploadFilecatch(console.error);


n * TODO(developer): Uncomment the following lines before running the sample.
 n// The ID of your GCS bucket
// const bucketName = 'your-unique-bucket-namen
// The contents that you want to upload
// const contents = 'these are my contentsn
// The new ID for your GCS file
// const destFileName = 'your-new-file-namen
// Imports the Google Cloud Node.js client library
const {Storage} = requiregoogle-cloud/storagen
// Creates a client
const storage = new Storagen
async function uploadFromMemory() {
 await storage.bucket(bucketName).file(destFileName).save(contentsn
 console.log(
 destFileName} with contents ${contents} uploaded to ${bucketNamen n}

uploadFromMemorycatch(console.error);
## PHP
 
 
 



use Google\Cloud\Storage\StorageClient;

n * Upload a file.
 *
 * @param string $bucketName The name of your Cloud Storage bucket.
 * @param string $objectName The name of your Cloud Storage object.
 * @param string $source The path to the file to upload.
 nfunction upload_object($bucketName, $objectName, $source)
{
 // $bucketName = 'my-bucketn // $objectName = 'my-objectn // $source = '/path/to/your/filen
 $storage = new StorageClientn $file = fopen($source, 'rn $bucket = $storage->bucket($bucketNamen $object = $bucket->upload($file, [
 'name' => $objectName
 n printf('Uploaded %s to gss/%s' . PHP_EOL, basename($source), $bucketName, $objectNamen}


use Google\Cloud\Storage\StorageClient;

n * Upload an object from memory buffer.
 *
 * @param string $bucketName The name of your Cloud Storage bucket.
 * @param string $objectName The name of your Cloud Storage object.
 * @param string $contents The contents to upload to the file.
 nfunction upload_object_from_memory(
 string $bucketName,
 string $objectName,
 string $contents
): void {
 // $bucketName = 'my-bucketn // $objectName = 'my-objectn // $contents = 'these are my contentsn
 $storage = new StorageClientn $stream = fopen('datatext/plain,' . $contents, 'rn $bucket = $storage->bucket($bucketNamen $bucket->upload($stream, [
 'name' => $objectName,
 n printf('Uploaded %s to gss/%s' . PHP_EOL, $contents, $bucketName, $objectNamen}
## Python
 
 
 



from google.cloud import storage



def upload_blob(bucket_name, source_file_name, destination_blob_namen Uploads a file to the bucketn # 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.Clientn bucket = storage_client.bucket(bucket_name)
 blob = bucket.blob(destination_blob_name)

 blob.upload_from_filename(source_file_name)

 print(
 f"File {source_file_name} uploaded to {destination_blob_namen )




from google.cloud import storage


def upload_blob_from_memory(bucket_name, contents, destination_blob_namen Uploads a file to the bucketn
 # The ID of your GCS bucket
 # bucket_name = "your-bucket-name"

 # The contents to upload to the file
 # contents = "these are my contents"

 # The ID of your GCS object
 # destination_blob_name = "storage-object-name"

 storage_client = storage.Clientn bucket = storage_client.bucket(bucket_name)
 blob = bucket.blob(destination_blob_name)

 blob.upload_from_string(contents)

 print(
 f"{destination_blob_name} with contents {contents} uploaded to {bucket_namen )

## Ruby
 
 
 



def upload_file bucket_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.bucket bucket_name, skip_lookup: true

 file = bucket.create_file local_file_path, file_name

 puts "Uploaded #{local_file_path} as #{file.name} in bucket #{bucket_namenend


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

# The ID of your GCS object
# file_name = "your-file-name"

# The contents to upload to your file
# file_content = "Hello, worldn
require "google/cloud/storage"

storage = Google::Cloud::Storage.new
bucket = storage.bucket bucket_name, skip_lookup: true

file = bucket.create_file StringIO.new(file_content), file_name

puts "Uploaded file #{file.name} to bucket #{bucket_name} with content: #{file_content}"

 
 
 For more information, see the
 
 Cloud Storage C++ API reference documentation.
 

 
 
 
 

The following sample uploads an object from a file:
 



















 
 
 
 
 





The following sample uploads an object from memory:
 



















 
 
 
 
 






 
 
 For more information, see the
 
 Cloud Storage C# API reference documentation.
 

 
 
 
 

The following sample uploads an object from a file:
 



















 
 
 
 
 





The following sample uploads an object from memory:
 



















 
 
 
 
 






 
 
 For more information, see the
 
 Cloud Storage Go API reference documentation.
 

 
 
 
 

The following sample uploads an object from a file:
 



















 
 
 
 





The following sample uploads an object from memory:
 



















 
 
 
 






 
 
 For more information, see the
 
 Cloud Storage Java API reference documentation.
 

 
 
 
 

The following sample uploads an object from a file:
 



















 
 
 
 





The following sample uploads an object from memory:
 



















 
 
 
 






 
 
 For more information, see the
 
 Cloud Storage Node.js API reference documentation.
 

 
 
 
 

The following sample uploads an object from a file:
 



















 
 
 
 





The following sample uploads an object from memory:
 



















 
 
 
 






 
 
 For more information, see the
 
 Cloud Storage PHP API reference documentation.
 

 
 
 
 

The following sample uploads an object from a file:
 



















 
 
 
 





The following sample uploads an object from memory:
 



















 
 
 
 






 
 
 For more information, see the
 
 Cloud Storage Python API reference documentation.
 

 
 
 
 

The following sample uploads an object from a file:
 



















 
 
 
 





The following sample uploads an object from memory:
 



















 
 
 
 






 
 
 For more information, see the
 
 Cloud Storage Ruby API reference documentation.
 

 
 
 
 

The following sample uploads an object from a file:
 



















 
 
 
 





The following sample uploads an object from memory:
 



















 
 
 
 





 REST APIs
 JSON API
- 

- Get an authorization access token from the
OAuth 2.0 Playground.
Configure the playground to use your own OAuth credentials. For instructions, see
API authentication. 

Use


cURLto call the JSON API with a

POSTObject request. For the file
index.htmluploaded to
a bucket named
my-static-assets:
curl -X POST --data-binary @index.html n -H "Content-Type: text/html" n -H "Authorization: Bearer ya29.AHES6ZRVmB7fkLtd1XTmq6mo0S1wqZZi3-Lh_s-6Uw7p8vtgSwg" n "httpsstorage.googleapis.com/upload/storage/v1/b/my-static-assets/o?uploadType=media&name=index.html"

 XML API
- 

- Get an authorization access token from the
OAuth 2.0 Playground.
Configure the playground to use your own OAuth credentials. For instructions, see
API authentication. 

Use


cURLto call the XML API with a

PUTObject request. For the file
index.htmluploaded to a
bucket named
my-static-assets:
curl -X PUT --data-binary @index.html n -H "Authorization: Bearer ya29.AHES6ZRVmB7fkLtd1XTmq6mo0S1wqZZi3-Lh_s-6Uw7p8vtgSwg" n -H "Content-Type: text/html" n "httpsstorage.googleapis.com/my-static-assets/index.html"

## Share your files


To make all objects in your bucket readable to anyone on the public internet:

 Console
- 

- In the Google Cloud console, go to the Cloud Storage
Browserpage


 

In the list of buckets, click the name of the bucket that you want to
make public.

Select the
Permissionstab near the top of the page. 

Click the


+ Addbutton

The
Add principalsdialog box appears. 

In the

New principalsfield, enter
allUsers. 

In the
Select a roledrop down, select the Cloud Storage
sub-menu, and click the Storage Object Vieweroption. 

Click
Save. 

Click
Allow public access. 

Once shareda
**link** icon appears for each object in the *public
access* column. You can click this icon to get the URL for the object

To learn how to get detailed error information about failed operations in the
 Cloud Storage browser, see
 Troubleshooting

 gsutil
Use the
gsutil iam ch command:
gsutil iam ch allUsers:objectViewer gsmy-static-assets
 Code samples












 



 




 
 
 




 
 
 
 For more information, see the
 
 Cloud Storage C++ API reference documentation.
 
 
 
 
 For more information, see the
 
 Cloud Storage Go API reference documentation.
 
 
 
 
 For more information, see the
 
 Cloud Storage Java API reference documentation.
 
 
 
 
 For more information, see the
 
 Cloud Storage Node.js API reference documentation.
 
 
 
 
 For more information, see the
 
 Cloud Storage Python API reference documentation.
 
 
 
 
 For more information, see the
 
 Cloud Storage Ruby API reference documentation.
 

## Cn 
 
 



namespace gcs = ::google::cloud::storage;
using ::google::cloud::StatusOr;
gcs::Client client, std::string const& bucket_name) {
 auto current_policy = client.GetNativeBucketIamPolicy(
 bucket_name, gcs::RequestedPolicyVersion(3n
 if (!current_policy) {
 throw std::runtime_error(current_policy.statusmessagen }

 current_policy->set_version(3n current_policy->bindingsemplace_back(
 gcs::NativeIamBinding("roles/storage.objectViewer", {"allUsersn
 auto updated =
 client.SetNativeBucketIamPolicy(bucket_name, *current_policyn if (!updated) throw std::runtime_error(updated.statusmessagen
 std::cout << "Policy successfully updated: " << *updated << nn}
## Go
 
 
 



import (
	"context"
	"fmt"
	"io"

	"cloud.google.com/go/iam"
	"cloud.google.com/go/storage"
	iampb "google.golang.org/genproto/googleapis/iam/v1"
)

// setBucketPublicIAM makes all objects in a bucketreadable.
func setBucketPublicIAM(w io.Writer, bucketName string) error {
	// bucketName := "bucket-name"
	ctx := context.Backgroundn	client, err := storage.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("storage.NewClient: %v", err)
	}
	defer client.Closen
	policy, err := client.Bucket(bucketName).IAMV3Policy(ctx)
	if err != nil {
		return fmt.Errorf("Bucket(%q).IAMV3Policy: %v", bucketName, err)
	}
	role := "roles/storage.objectViewer"
	policy.Bindings = append(policy.Bindings, &iampb.Binding{
		Role: role,
		Members: []string{iam.AllUsersn	n	if err := client.Bucket(bucketName).IAMV3SetPolicy(ctx, policy); err != nil {

		return fmt.Errorf("Bucket(%q).IAMSetPolicy: %v", bucketName, err)
	}
	fmt.Fprintf(w, "Bucket %v is nowreadable
", bucketName)
	return nil
}

## Java
 
 
 



import com.google.cloud.Identity;
import com.google.cloud.Policy;
import com.google.cloud.storage.Storage;
import com.google.cloud.storage.StorageOptions;
import com.google.cloud.storage.StorageRoles;

public class MakeBucketPublic {
 public static void makeBucketPublic(String projectId, String bucketName) {
 // The ID of your GCP project
 // String projectId = "your-project-idn
 // The ID of your GCS bucket
 // String bucketName = "your-unique-bucket-namen
 Storage storage = StorageOptions.newBuildersetProjectId(projectId).buildgetServicen Policy originalPolicy = storage.getIamPolicy(bucketNamen storage.setIamPolicy(
 bucketName,
 originalPolicy
 .toBuildern .addIdentity(StorageRoles.objectViewer Identity.allUsers // All users can view
 .buildn
 System.out.println("Bucket " + bucketName + " is nowreadablen }
}
## Node.js
 
 
 



n * TODO(developer): Uncomment the following lines before running the sample.
 n// The ID of your GCS bucket
// const bucketName = 'your-unique-bucket-namen
// Imports the Google Cloud client library
const {Storage} = requiregoogle-cloud/storagen
// Creates a client
const storage = new Storagen
async function makeBucketPublic() {
 await storage.bucket(bucketName).makePublicn
 console.log(`Bucket ${bucketName} is nowreadablen}

makeBucketPubliccatch(console.error);
## Python
 
 
 



from typing import List

from google.cloud import storage


def set_bucket_public_iam(
 bucket_name: str = "your-bucket-namen members: List[str] = ["allUsersnn Set a public IAM Policy to bucketn # bucket_name = "your-bucket-name"

 storage_client = storage.Clientn 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 nowreadablen

## Ruby
 
 
 



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

 bucket.policy do |p|
 p.add "roles/storage.objectViewer", "allUsers"
 end

 puts "Bucket #{bucket_name} is nowreadable"
end

 
 
 For more information, see the
 
 Cloud Storage C++ API reference documentation.
 

 
 
 
 
 



















 
 
 
 
 






 
 
 For more information, see the
 
 Cloud Storage Go API reference documentation.
 

 
 
 
 
 



















 
 
 
 






 
 
 For more information, see the
 
 Cloud Storage Java API reference documentation.
 

 
 
 
 
 



















 
 
 
 






 
 

 For more information, see the
 
 Cloud Storage Node.js API reference documentation.
 

 
 
 
 
 



















 
 
 
 






 
 
 For more information, see the
 
 Cloud Storage Python API reference documentation.
 

 
 
 
 
 



















 
 
 
 






 
 
 For more information, see the
 
 Cloud Storage Ruby API reference documentation.
 

 
 
 
 
 



















 
 
 
 





 REST APIs
 JSON API
- 

- Get an authorization access token from the
OAuth 2.0 Playground.
Configure the playground to use your own OAuth credentials. For instructions, see
API authentication. 

Create a JSON file that contains the following information:


{
 "bindingsn {
 "role": "roles/storage.objectViewern "membersallUsersn }
 ]
}

Use


cURLto call the JSON API with a

PUTBucket request:
curl -X PUT --data-binary @


JSON_FILE_NAMEn -H "Authorization: Bearer OAUTH2_TOKEN" n -H "Content-Type: application/json" n "httpsstorage.googleapis.com/storage/v1/b/ BUCKET_NAME/iam"
Where:




- 

is the path for the JSON
file that you created in Step 2

JSON_FILE_NAME

is the access token you
created in Step 1

OAUTH2_TOKEN

is the name of the bucket
whose objects you want to make public. For example,

BUCKET_NAME
my-static-assets. 

- 

 XML API
Making all objects in a bucketreadable is not supported by
the XML API. Use gsutil or the JSON API instead, or
set ACLs for each individual object

To make individual objects in your bucketaccessible, you need to
switch your bucket's
**Access control** mode to **Fine-grained Generally,
making all files in your bucketaccessible is easier and faster

Visitors receive a
http 403 response code when requesting the URL for a
non-public or non-existent file. See the next section for information on how to
add an error page that uses a
http 404 response code

## Recommended: Assign specialty pages


You can assign an index page suffix, which is controlled by the
MainPageSuffix
property, and a custom error page, which is controlled by the
NotFoundPage
property. Assigning either is optional, but without an index page, nothing is
served when users access your top-level site, for example,

httpswww.example.com. For more information about the
MainPageSuffix and

NotFoundPage properties, see Specialty pages

In the following sample, the
MainPageSuffix is set to
index.html and

NotFoundPage is set to
404.html:
 Console
- 

- In the Google Cloud console, go to the Cloud Storage
Browserpage


 

In the list of buckets, find the bucket you created.

Click the
Bucket overflowmenu (
)
associated with the bucket and select
Edit website configuration. 

In the website configuration dialog, specify the main page and
error page.

Click
Save. 

To learn how to get detailed error information about failed operations in the
 Cloud Storage browser, see
 Troubleshooting

 gsutil
Use the
gsutil web set command to set the
MainPageSuffix property
with the
-m flag and the
NotFoundPage with the
-e flag:
gsutil web set -m index.html -e 404.html gsmy-static-assets


If successful, the command returns:


Setting website config on gsmy-static-assetsn
 Code samples












 



 




 
 
 




 
 
 
 For more information, see the
 
 Cloud Storage C++ API reference documentation.
 
 
 
 
 For more information, see the
 
 Cloud Storage C# API reference documentation.
 
 
 
 
 For more information, see the
 
 Cloud Storage Go API reference documentation.
 
 
 
 
 For more information, see the
 
 Cloud Storage Java API reference documentation.
 
 
 
 
 For more information, see the
 
 Cloud Storage Node.js API reference documentation.
 
 
 
 
 For more information, see the
 
 Cloud Storage PHP API reference documentation.
 
 
 
 
 For more information, see the
 
 Cloud Storage Python API reference documentation.
 
 
 
 
 For more information, see the
 
 Cloud Storage Ruby API reference documentation.
 

## Cn 
 
 



namespace gcs = ::google::cloud::storage;
using ::google::cloud::StatusOr;
gcs::Client client, std::string const& bucket_name,
 std::string const& main_page_suffix, std::string const& not_found_page) {
 StatusOr original =
 client.GetBucketMetadata(bucket_namen
 if (!original) throw std::runtime_error(original.statusmessagen StatusOr patched_metadata = client.PatchBucket(
 bucket_name,
 gcs::BucketMetadataPatchBuilderSetWebsite(
 gcs::BucketWebsite{main_page_suffix, not_found_pagen gcs::IfMetagenerationMatch(original->metagenerationn
 if (!patched_metadata) {
 throw std::runtime_error(patched_metadata.statusmessagen }

 if (!patched_metadata->has_website {
 std::cout << "Static website configuration is not set for bucket "
 << patched_metadata->name() << nn return;
 }

 std::cout << "Static website configuration successfully set for bucket "
 << patched_metadata->name() << nNew main page suffix is: "
 << patched_metadata->websitemain_page_suffix
 << nNew not found page is: "
 << patched_metadata->websitenot_found_page << nn}
## C#
 
 
 




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

public class BucketWebsiteConfigurationSample
{
 public Bucket BucketWebsiteConfiguration(
 string bucketName = "your-bucket-namen string mainPageSuffix = "index.htmln string notFoundPage = "404.htmln {
 var storage = StorageClient.Createn var bucket = storage.GetBucket(bucketNamen
 if (bucket.Website == null)
 {
 bucket.Website = new Bucket.WebsiteDatan }

 bucket.Website.MainPageSuffix = mainPageSuffix;
 bucket.Website.NotFoundPage = notFoundPage;

 bucket = storage.UpdateBucket(bucketn Console.WriteLineStatic website bucket {bucketName} is set up to use {mainPageSuffix} as the index page and {notFoundPage} as the 404 not found pagen return bucket;
 }
}
## Go
 
 
 



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

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

// setBucketWebsiteInfo sets website configuration on a bucket.
func setBucketWebsiteInfo(w io.Writer, bucketName, indexPage, notFoundPage string) error {
	// bucketName := "www.example.com"
	// indexPage := "index.html"
	// notFoundPage := "404.html"
	ctx := context.Backgroundn	client, err := storage.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("storage.NewClient: %v", err)
	}
	defer client.Closen
	ctx, cancel := context.WithTimeout(ctx, time.Second*10)
	defer canceln
	bucket := client.Bucket(bucketName)
	bucketAttrsToUpdate := storage.BucketAttrsToUpdate{
		Website: &storage.BucketWebsite{
			MainPageSuffix: indexPage,
			NotFoundPage: notFoundPage,
		n	}
	if _, err := bucket.Update(ctx, bucketAttrsToUpdate); err != nil {
		return fmt.Errorf("Bucket(%q).Update: %v", 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
", bucketName, indexPage, notFoundPage)
	return nil
}

## Java
 
 
 



import com.google.cloud.storage.Bucket;
import com.google.cloud.storage.Storage;
import com.google.cloud.storage.StorageOptions;

public class SetBucketWebsiteInfo {
 public static void setBucketWesbiteInfo(
 String projectId, String bucketName, String indexPage, String notFoundPage) {
 // The ID of your GCP project
 // String projectId = "your-project-idn
 // The ID of your static website bucket
 // String bucketName = "www.example.comn
 // The index page for a static website bucket
 // String indexPage = "index.htmln
 // The 404 page for a static website bucket
 // String notFoundPage = "404.htmln
 Storage storage = StorageOptions.newBuildersetProjectId(projectId).buildgetServicen Bucket bucket = storage.get(bucketNamen bucket.toBuildersetIndexPage(indexPage).setNotFoundPage(notFoundPage).buildupdaten
 System.out.println(
 "Static website bucket "
 + bucketName
 + " is set up to use "
 + indexPage
 + " as the index page and "
 + notFoundPage
 + " as the 404 pagen }
}
## Node.js
 
 
 



n * TODO(developer): Uncomment the following lines before running the sample.
 n// The ID of your GCS bucket
// const bucketName = 'your-unique-bucket-namen
// The name of the main page
// const mainPageSuffix = 'httpexample.comn
// The Name of a 404 page

// const notFoundPage = 'httpexample.com/404.htmln
// Imports the Google Cloud client library
const {Storage} = requiregoogle-cloud/storagen
// Creates a client
const storage = new Storagen
async function addBucketWebsiteConfiguration() {
 await storage.bucket(bucketName).setMetadatan website: {
 mainPageSuffix,
 notFoundPage,
 n n
 console.log(
 `Static website bucket ${bucketName} is set up to use ${mainPageSuffix} as the index page and ${notFoundPage} as the 404 page`
 n}

addBucketWebsiteConfigurationcatch(console.error);
## PHP
 
 
 



use Google\Cloud\Storage\StorageClient;

n * Update the given bucket's website configuration.
 *
 * @param string $bucketName The name of your Cloud Storage bucket.
 * @param string $indexPageObject the name of an object in the bucket to use as
 * an index page for a static website bucket.
 * @param string $notFoundPageObject the name of an object in the bucket to use
 * as the 404 Not Found page.
 nfunction define_bucket_website_configuration($bucketName, $indexPageObject, $notFoundPageObject)
{
 // $bucketName = 'my-bucketn // $indexPageObject = 'index.htmln // $notFoundPageObject = '404.htmln
 $storage = new StorageClientn $bucket = $storage->bucket($bucketNamen
 $bucket->updaten 'website' => [
 'mainPageSuffix' => $indexPageObject,
 'notFoundPage' => $notFoundPageObject
 ]
 n
 printf(
 'Static website bucket %s is set up to use %s as the index page and %s as the 404 pagen $bucketName,
 $indexPageObject,
 $notFoundPageObject
 n}
## Python
 
 
 



from google.cloud import storage


def define_bucket_website_configuration(bucket_name, main_page_suffix, not_found_pagen Configure website-related properties of bucketn # bucket_name = "your-bucket-name"
 # main_page_suffix = "index.html"
 # not_found_page = "404.html"

 storage_client = storage.Clientn
 bucket = storage_client.get_bucket(bucket_name)
 bucket.configure_website(main_page_suffix, not_found_page)
 bucket.patchn
 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


## Ruby
 
 
 



def define_bucket_website_configuration bucket_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.bucket bucket_name

 bucket.update do |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 " n not_found_page} as the 404 page"
end

 
 
 For more information, see the
 
 Cloud Storage C++ API reference documentation.
 

 
 
 
 
 



















 
 
 
 
 






 
 
 For more information, see the
 
 Cloud Storage C# API reference documentation.
 

 
 
 
 
 



















 
 
 
 
 






 
 
 For more information, see the
 
 Cloud Storage Go API reference documentation.
 

 
 
 
 
 



















 
 
 
 






 
 
 For more information, see the
 
 Cloud Storage Java API reference documentation.
 

 
 
 
 
 



















 
 
 
 






 
 
 For more information, see the
 
 Cloud Storage Node.js API reference documentation.
 

 
 
 
 
 



















 
 
 
 






 
 
 For more information, see the
 
 Cloud Storage PHP API reference documentation.
 

 
 
 
 
 



















 
 
 
 






 
 
 For more information, see the
 
 Cloud Storage Python API reference documentation.
 

 
 
 
 
 



















 
 
 
 






 
 
 For more information, see the
 
 Cloud Storage Ruby API reference documentation.
 

 
 
 
 
 



















 
 
 
 





 REST APIs
 JSON API
- 

- Get an authorization access token from the
OAuth 2.0 Playground.
Configure the playground to use your own OAuth credentials. For instructions, see
API authentication. 

Create a JSON file that sets the


mainPageSuffixand

notFoundPageproperties in a
websiteobject to the desired pages:
{
 "websiten "mainPageSuffix": "index.htmln "notFoundPage": "404.html"
 }
}

Use


cURLto call the JSON API with a

PATCHBucket request. For the bucket
my-static-assets:
curl -X PATCH --data-binary @web-config.json n -H "Authorization: Bearer ya29.AHES6ZRVmB7fkLtd1XTmq6mo0S1wqZZi3-Lh_s-6Uw7p8vtgSwg" n -H "Content-Type: application/json" n "httpsstorage.googleapis.com/storage/v1/b/my-static-assets"

 XML API
- 

- Get an authorization access token from the
OAuth 2.0 Playground.
Configure the playground to use your own OAuth credentials. For instructions, see
API authentication. 

Create an XML file that sets the


MainPageSuffixand
NotFoundPage
elements in a
WebsiteConfigurationelement to the desired pages:


 index.html
 404.html


Use


cURLto call the XML API with a

PUTBucket request and
websiteConfigquery string
parameter. For my-static-assets:
curl -X PUT --data-binary @web-config.xml n -H "Authorization: Bearer ya29.AHES6ZRVmB7fkLtd1XTmq6mo0S1wqZZi3-Lh_s-6Uw7p8vtgSwg" n httpsstorage.googleapis.com/my-static-assets?websiteConfig

## Set up your load balancer and SSL certificate


Cloud Storage doesn't support custom domains with HTTPS on its own, so you also
need to set up an SSL certificate attached to an HTTPS load balancer
to serve your website through HTTPS. This section shows you how to add your
bucket to a load balancer's backend and how to add a new
Google-managed SSL certificate to the load balancer's front end.


- 

- Go to the Load balancing page in the Google Cloud console


Go to the Load balancing page 

- Under
HTTP(S) load balancing, click Start configuration. 

- Select
From Internet to my VMs or serverless services. 

- Select
Global HTTP(S) Load Balancer. 

Click


Continue

The configuration window for your load balancer appears.

Before continuing with the configuration, give your load balancer a

Name, such as
example-lb. 

 Configure the backend


- 

- Click
Backend configuration. 

- In the
Backend services & backend bucketsdropdown, click Create
a backend bucket. 

- Choose a
Backend bucket name, such as
example-bucket. The name you
choose can be different from the name of the bucket you created earlier. 

- Click
Browse, found in the Cloud Storage bucketfield. 

- Select the
my-static-assetsbucket you created earlier, and click

Select. 

- (Optional) If you want to use Cloud CDN, select the checkbox for

Enable Cloud CDNand configure Cloud CDN as desired. Note that
Cloud CDN may incur additional costs. 

- Click
Create. 

 Configure routing rules


Routing rules are the components of a external HTTP(S) load balancer's URL map. For
this tutorial, you should skip this portion of the load balancer configuration,
because it is automatically set to use the backend you just configured.


 Configure the frontend


This section shows you how to configure the HTTPS protocol and create an SSL
certificate. You can also select an existing certificate or upload a
self-managed SSL certificate.


- 

- Click
Frontend configuration. 

- (Optional) Give your frontend configuration a
Name. 

- For
Protocol, select HTTPS (includes HTTP/2). 

- For
Network Service Tier, select Premium. 

- For
IP version, select IPv4. If you prefer IPv6, see
IPv6 termination for additional information. 

For the


IP addressfield:


- 

- In the dropdown, click
Create IP address. 

- In the
Reserve a new static IP addresspop-up, enter a name, such
as
example-ipfor the
Nameof the IP address. 

- Click
Reserve. 

- In the dropdown, click
For
Port, select 443. 

In the


Certificatefield dropdown, select Create a new certificate.
The certificate creation form appears in a panel. Configure the following:


- 

- Give your certificate a
Name, such as
example-ssl. 

- For
Create mode, select Create Google-managed certificate. 

- For
Domains, enter your website name, such as
www.example.com. If
you want to serve your content through additional domains such as the root
domain
example.com, press
Enterto add them on additional lines.

Each certificate has a limit of 100 domains. 

- Give your certificate a
Click
Create. 

(Optional) If you want Google Cloud to automatically set up a
partial HTTP load balancer for redirecting HTTP traffic, select the
checkbox next to
Enable HTTP to HTTPS redirect. 

Click
Done. 

 Review the configuration


- 

- Click
Review and finalize. 

- Review the
Frontend, Routing rules, and Backend. 

- Click
Create. 

You may need to wait a few minutes for the load balancer to be created.


## Connect your domain to your load balancer


After the load balancer is created, click the name of your load balancer:

example-lb. Note the IP address associated with the load balancer: for
example,
30.90.80.100. To point your domain to your load balancer, create an

A record using your domain registration service. If you added multiple domains
to your SSL certificate, you must add an
A record for each one, all pointing
to the load balancer's IP address. For example, to create
A records for

www.example.com and
example.com:

NAME TYPE DATA
www A 30.90.80.100
@ A 30.90.80.100


If you are using Google Domains, see the
Google Domains Help page for more information.


## Recommended: Monitor the SSL certificate status


It might take up to 60-90 minutes for Google Cloud to provision the certificate
and make the site available through the load balancer. To monitor the status
of your certificate:

 Console
- 

- Go to the Load balancing page in the Google Cloud console


Go to the Load balancing page 

- Click the name of your load balancer:
example-lb. 

- Click the name of the SSL certificate associated with the load balancer:

example-ssl. 

- The
Statusand Domain statusrows show the certificate status. Both
must be active in order for the certificate to be valid for your website. 

 gcloud
- 

To check the certificate status, run the following command:



gcloud beta compute ssl-certificates describe
CERTIFICATE_NAMEn --global n --format="get(name,managed.statusn 

To check the domain status, run the following command:



gcloud beta compute ssl-certificates describe
CERTIFICATE_NAMEn --global n --format="get(managed.domainStatusn 

See Troubleshooting SSL certificates for more information about
certificate status.


## Test the website


Once the SSL certificate is active, verify that content is served from the
bucket by going to
httpswww.example.com/test.html, where
test.html is an
object stored in the bucket that you're using as the backend. If you set the

MainPageSuffix property,
httpswww.example.com goes to
index.html

## Clean up
 
 






























 After you finish the tutorial, you can clean up the resources that you created so that they

 stop using quota and incurring charges. The following sections describe how to delete or turn off
 these resources.





 Delete the project






 The easiest way to eliminate billing is to delete the project that you
 created for the tutorial.



To delete the project:

- 




 






 

- 
 In the Cloud console, go to the
Manage resourcespage.
 
 

- 
 In the project list, select the project that you
 want to delete, and then click
Delete.
 

- 
 In the dialog, type the project ID, and then click

downto delete the project.
 



 

 Delete the load balancer and bucket


If you don't want to delete the entire project, delete the load balancer and
bucket that you created for the tutorial:


- 

- Go to the Load balancing page in the Google Cloud console


Go to the Load balancing page 

- Select the checkbox next to
example-lb. 

- Click
Delete. 

- (Optional) Select the checkbox next to the resources you want to delete along
with the load balancer, such as the
my-static-assetsbucket or the

example-sslSSL certificate. 

- Click
Delete load balanceror Delete load balancer and the selected
resources. 

 Release a reserved IP address


To delete the reserved IP address you used for the tutorial:


- 

In the Cloud console, go to the


External IP addressespage

Go to External IP addresses

Select the checkboxes next to
example-ip. 

Click
Release static address. 

In the confirmation window, click
Delete. 

## What's next
 


- 

- Learn how to serve your static website over HTTP. 

- See examples and tips for using buckets to host a static website. 

- Visit the troubleshooting section for hosting a static website. 

- Learn about hosting static assets for a dynamic website. 

- Learn about other Google Cloud web serving solutions. 

- Try other Google Cloud tutorials that use Cloud Storage. 

## 
 Try it for yourself

 

 
 
 


 If you're new to Google Cloud, create an account to evaluate how
 Cloud Storage performs in real-world
 scenarios. New customers also get $300 in free credits to run, test, and
 deploy workloads.

 
 

 

 





 

 

 

 

 
 
 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 
 
 

 

 

 

 

 

 

 

 

 

 








 
 
 
 
 
 Try Cloud Storage free





        

      
Published date: 03 Jun 2022
      

      

        
        

        

          
          Best VM monitoring tools
        
        

          
          Virtual Private Servers (VPS) Market Strategies, and Economic Impact 2030
        
        

          
          What is a virtual private server? What is VPS hosting?