静的ウェブサイトをホストする

このチュートリアルでは、所有するドメインの静的ウェブサイトをホストするように Cloud Storage バケットを構成します。静的ウェブページには HTML、CSS、JavaScript などのクライアント側の技術を使用できます。PHP のようなサーバー側のスクリプトなどの動的コンテンツを含めることはできません。

Cloud Storage 自体では HTTPS を使用するカスタムドメインをサポートしていません。このチュートリアルでは、Cloud Storage と外部アプリケーションロードバランサを使用して HTTPS を介してカスタムドメインのコンテンツを提供します。カスタムドメインのコンテンツを HTTPS 経由で提供する別の方法については、HTTPS によるサービス提供のトラブルシューティングをご覧ください。また、Cloud Storage を使用して HTTP 経由でカスタムドメインのコンテンツを提供することもできます。この場合、ロードバランサは必要ありません。

静的ウェブページのサンプルやヒント（動的ウェブサイトの静的アセットをホストする方法など）については、静的ウェブサイトのページをご覧ください。

目標

このチュートリアルでは、次の方法について説明します。

バケットを作成する。
サイトのファイルをアップロードして共有する。
ロードバランサと SSL 証明書を設定する。
ロードバランサをバケットに接続する。
A レコードを使用して、ドメインをロードバランサに指定する。
ウェブサイトをテストする。

料金

このチュートリアルでは、課金対象である次の Google Cloud コンポーネントを使用します。

静的ウェブサイトのホスティングで発生する可能性がある料金の詳細については、料金をモニタリングするのヒントをご覧ください。

始める前に

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.

Go to project selector

Make sure that billing is enabled for your Google Cloud project.

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

Go to project selector

Make sure that billing is enabled for your Google Cloud project.

プロジェクトで Compute Engine API を有効にします。
ストレージ管理者と Compute ネットワーク管理者の Identity and Access Management ロールが付与されている必要があります。
自分がオーナーまたは管理者になっているドメインが必要です。既存のドメインがない場合は、Cloud Domains など、新しいドメインを登録できるサービスが多数あります。
このチュートリアルではドメイン example.com を使用します。
提供するウェブサイトのファイルをいくつか用意します。このチュートリアルは、少なくともインデックスページ（index.html）と 404 ページ（404.html）がある場合に最適です。
（省略可）Cloud Storage バケットにドメインと同じ名前を使用する場合は、使用するドメインを所有または管理していることを確認する必要があります。www.example.com などのサブドメインではなく、example.com などのトップレベルドメインを検証していることを確認します。Cloud Domains でドメインを購入した場合、確認は自動的に行われます。

バケットの作成

バケットを作成するには:

コンソール

Google Cloud コンソールで、Cloud Storage の [バケット] ページに移動します。
[バケット] に移動
[+ 作成] をクリックします。
[バケットの作成] ページでユーザーのバケット情報を入力します。次のステップに進むには、[続行] をクリックします。
- [バケットに名前を付ける] で、バケット名の要件を満たす名前を入力します。
- [データの保存場所の選択] で、バケットデータを永続的に保存するロケーションタイプとロケーションを選択します。
- [データのストレージクラスを選択する] で、バケットのデフォルトのストレージクラスを選択するか、バケットのデータの自動ストレージクラス管理について Autoclass を選択します。
  注: 右側の [毎月の費用の見積もり] パネルでは、選択したストレージクラスとロケーション、予想されるデータサイズとオペレーションに基づいてバケットの毎月のコストを見積もります。
- [オブジェクトへのアクセスを制御する方法を選択する] で、バケットで公開アクセスの防止を適用するかどうかを選択して、バケットのオブジェクトのアクセス制御モデルを選択します。
  注: プロジェクトの組織のポリシーによって公開アクセスの防止がすでに適用されている場合、[公開アクセスの防止] の切り替えはロックされています。
- [オブジェクトデータを保護する方法を選択] で、必要に応じて [保護ツール] を構成し、データ暗号化メソッドを選択します。
[作成] をクリックします。

失敗した Cloud Storage オペレーションの詳細なエラー情報を Google Cloud コンソールで確認する方法については、トラブルシューティングをご覧ください。

コマンドライン

In the Google Cloud console, activate Cloud Shell.

Activate Cloud Shell

At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.
開発環境で、gcloud storage buckets create コマンドを実行します。
```
gcloud storage buckets create gs://BUCKET_NAME --location=BUCKET_LOCATION
```
ここで
- BUCKET_NAME は、バケットに付ける名前で、命名要件の対象となります。例: my-bucket
- BUCKET_LOCATION は、バケットのロケーションです。例: us-east1
リクエストが成功すると、コマンドから次のメッセージが返されます。
```
Creating gs://BUCKET_NAME/...
```
次のフラグを設定すると、バケットの作成をより細かくコントロールできます。
- --project: バケットが関連付けられるプロジェクト ID またはプロジェクト番号を指定します。例: my-project
- --default-storage-class: バケットのデフォルトのストレージクラスを指定します。例: STANDARD
- --soft-delete-duration: バケットの削除（復元可能）の保持期間を指定します。例: 2w1d
- --uniform-bucket-level-access: バケットの均一なバケットレベルのアクセスを有効にします。
例:
```
gcloud storage buckets create gs://BUCKET_NAME --project=PROJECT_ID --default-storage-class=STORAGE_CLASS --location=BUCKET_LOCATION --uniform-bucket-level-access
```

クライアントライブラリ

C++

詳細については、Cloud Storage C++ API のリファレンスドキュメントをご覧ください。

Cloud Storage に対する認証を行うには、アプリケーションのデフォルト認証情報を設定します。詳細については、ローカル開発環境の認証の設定をご覧ください。

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<gcs::BucketMetadata> bucket_metadata =
      client.CreateBucket(bucket_name, gcs::BucketMetadata()
                                           .set_storage_class(storage_class)
                                           .set_location(location));
  if (!bucket_metadata) throw std::move(bucket_metadata).status();

  std::cout << "Bucket " << bucket_metadata->name() << " created."
            << "\nFull Metadata: " << *bucket_metadata << "\n";
}

C#

詳細については、Cloud Storage C# API のリファレンスドキュメントをご覧ください。


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

public class CreateRegionalBucketSample
{
    /// <summary>
    /// Creates a storage bucket with region.
    /// </summary>
    /// <param name="projectId">The ID of the project to create the buckets in.</param>
    /// <param name="location">The location of the bucket. Object data for objects in the bucket resides in 
    /// physical storage within this region. Defaults to US.</param>
    /// <param name="bucketName">The name of the bucket to create.</param>
    /// <param name="storageClass">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
    /// STANDARD.</param>
    public Bucket CreateRegionalBucket(
        string projectId = "your-project-id",
        string bucketName = "your-unique-bucket-name",
        string location = "us-west1",
        string storageClass = "REGIONAL")
    {
        var storage = StorageClient.Create();
        Bucket bucket = new Bucket
        {
            Location = location,
            Name = bucketName,
            StorageClass = storageClass
        };
        var newlyCreatedBucket = storage.CreateBucket(projectId, bucket);
        Console.WriteLine($"Created {bucketName}.");
        return newlyCreatedBucket;
    }
}

Go

詳細については、Cloud Storage Go API のリファレンスドキュメントをご覧ください。

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.Background()
	client, err := storage.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("storage.NewClient: %w", err)
	}
	defer client.Close()

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

	storageClassAndLocation := &storage.BucketAttrs{
		StorageClass: "COLDLINE",
		Location:     "asia",
	}
	bucket := client.Bucket(bucketName)
	if err := bucket.Create(ctx, projectID, storageClassAndLocation); err != nil {
		return fmt.Errorf("Bucket(%q).Create: %w", bucketName, err)
	}
	fmt.Fprintf(w, "Created bucket %v in %v with storage class %v\n", bucketName, storageClassAndLocation.Location, storageClassAndLocation.StorageClass)
	return nil
}

Java

詳細については、Cloud Storage Java API のリファレンスドキュメントをご覧ください。

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

    // The ID to give your GCS bucket
    // String bucketName = "your-unique-bucket-name";

    Storage storage = StorageOptions.newBuilder().setProjectId(projectId).build().getService();

    // See the StorageClass documentation for other valid storage classes:
    // https://googleapis.dev/java/google-cloud-clients/latest/com/google/cloud/storage/StorageClass.html
    StorageClass storageClass = StorageClass.COLDLINE;

    // See this documentation for other valid locations:
    // http://g.co/cloud/storage/docs/bucket-locations#location-mr
    String location = "ASIA";

    Bucket bucket =
        storage.create(
            BucketInfo.newBuilder(bucketName)
                .setStorageClass(storageClass)
                .setLocation(location)
                .build());

    System.out.println(
        "Created bucket "
            + bucket.getName()
            + " in "
            + bucket.getLocation()
            + " with storage class "
            + bucket.getStorageClass());
  }
}

Node.js

詳細については、Cloud Storage Node.js API のリファレンスドキュメントをご覧ください。

/**
 * 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 a storage class
// See the StorageClass documentation for other valid storage classes:
// https://googleapis.dev/java/google-cloud-clients/latest/com/google/cloud/storage/StorageClass.html
// const storageClass = 'coldline';

// The name of a location
// See this documentation for other valid locations:
// http://g.co/cloud/storage/docs/locations#location-mr
// const location = 'ASIA';

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

// Creates a client
// The bucket in the sample below will be created in the project associated with this client.
// For more information, please see https://cloud.google.com/docs/authentication/production or https://googleapis.dev/nodejs/storage/latest/Storage.html
const storage = new Storage();

async function createBucketWithStorageClassAndLocation() {
  // For default values see: https://cloud.google.com/storage/docs/locations and
  // https://cloud.google.com/storage/docs/storage-classes
  const [bucket] = await storage.createBucket(bucketName, {
    location,
    [storageClass]: true,
  });

  console.log(
    `${bucket.name} created with ${storageClass} class in ${location}`
  );
}

createBucketWithStorageClassAndLocation().catch(console.error);

PHP

詳細については、Cloud Storage PHP API のリファレンスドキュメントをご覧ください。

use Google\Cloud\Storage\StorageClient;

/**
 * Create a new bucket with a custom default storage class and location.
 *
 * @param string $bucketName The name of your Cloud Storage bucket.
 *        (e.g. 'my-bucket')
 */
function create_bucket_class_location(string $bucketName): void
{
    $storage = new StorageClient();
    $storageClass = 'COLDLINE';
    $location = 'ASIA';
    $bucket = $storage->createBucket($bucketName, [
        'storageClass' => $storageClass,
        'location' => $location,
    ]);

    $objects = $bucket->objects([
        'encryption' => [
            'defaultKmsKeyName' => null,
        ]
    ]);

    printf('Created bucket %s in %s with storage class %s', $bucketName, $storageClass, $location);
}

Python

詳細については、Cloud Storage Python API のリファレンスドキュメントをご覧ください。

from google.cloud import storage


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

    storage_client = storage.Client()

    bucket = storage_client.bucket(bucket_name)
    bucket.storage_class = "COLDLINE"
    new_bucket = storage_client.create_bucket(bucket, location="us")

    print(
        "Created bucket {} in {} with storage class {}".format(
            new_bucket.name, new_bucket.location, new_bucket.storage_class
        )
    )
    return new_bucket

Ruby

詳細については、Cloud Storage Ruby API のリファレンスドキュメントをご覧ください。

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:      "ASIA",
                                  storage_class: "COLDLINE"

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

Terraform

ストレージバケットの作成には Terraform リソースを使用します。

次の例には、インデックスページのサフィックスとカスタムエラーページの割り当てが含まれています。詳しくは、特殊ページを割り当てるをご覧ください。

# Create new storage bucket in the US multi-region
# and settings for main_page_suffix and not_found_page
resource "random_id" "bucket_prefix" {
  byte_length = 8
}

resource "google_storage_bucket" "static_website" {
  name          = "${random_id.bucket_prefix.hex}-static-website-bucket"
  location      = "US"
  storage_class = "STANDARD"
  website {
    main_page_suffix = "index.html"
    not_found_page   = "404.html"
  }
}

REST API

JSON API

Authorization ヘッダーのアクセストークンを生成するには、gcloud CLI のインストールと初期化を行います。

OAuth 2.0 Playground を使用してアクセストークンを作成し、Authorization ヘッダーに含めることもできます。
バケットの設定を含む JSON ファイルを作成します。この設定には、バケットの name を含める必要があります。設定の一覧については、Buckets:Insert のドキュメントをご覧ください。一般的な設定は次のとおりです。

{
  "name": "BUCKET_NAME",
  "location": "BUCKET_LOCATION",
  "storageClass": "STORAGE_CLASS",
  "iamConfiguration": {
    "uniformBucketLevelAccess": {
      "enabled": true
    },
  }
}

ここで

BUCKET_NAME は、バケットに付ける名前で、命名要件の対象となります。例: my-bucket
BUCKET_LOCATION は、バケットのオブジェクトデータを保存するロケーションです。例: US-EAST1
STORAGE_CLASS はバケットのデフォルトのストレージクラスです。例: STANDARD

cURL を使用して JSON API を呼び出します。
```
curl -X POST --data-binary @JSON_FILE_NAME \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json" \
     "https://storage.googleapis.com/storage/v1/b?project=PROJECT_IDENTIFIER"
```
ここで
- JSON_FILE_NAME は手順 2 で作成した JSON ファイルの名前です。
- PROJECT_IDENTIFIER は、バケットが関連付けられているプロジェクトの ID または番号です。例: my-project

XML API

Authorization ヘッダーのアクセストークンを生成するには、gcloud CLI のインストールと初期化を行います。

OAuth 2.0 Playground を使用してアクセストークンを作成し、Authorization ヘッダーに含めることもできます。
バケットの設定を含む XML ファイルを作成します。設定の全一覧については、XML: バケットを作成するのドキュメントをご覧ください。一般的な設定は次のとおりです。

<CreateBucketConfiguration>
   <LocationConstraint>BUCKET_LOCATION</LocationConstraint>
   <StorageClass>STORAGE_CLASS</StorageClass>
</CreateBucketConfiguration>

ここで

BUCKET_LOCATION は、バケットのオブジェクトデータを保存するロケーションです。例: US-EAST1
STORAGE_CLASS はバケットのデフォルトのストレージクラスです。例: STANDARD

cURL を使用して、XML API を呼び出します。
```
curl -X PUT --data-binary @XML_FILE_NAME \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "x-goog-project-id: PROJECT_ID" \
     "https://storage.googleapis.com/BUCKET_NAME"
```
ここで
- XML_FILE_NAME は手順 2 で作成した XML ファイルの名前です。
- PROJECT_ID は、バケットが関連付けられるプロジェクトの ID です。例: my-project
- BUCKET_NAME は、バケットに付ける名前で、命名要件の対象となります。例: my-bucket

サイトのファイルをアップロードする

ウェブサイトから配信するファイルをバケットに追加します。

コンソール

Google Cloud コンソールで、Cloud Storage の [バケット] ページに移動します。
[バケット] に移動
バケットのリストで、作成したバケットをクリックします。

[バケットの詳細] ページが開き、[オブジェクト] タブが選択されています。
[ファイルをアップロード] ボタンをクリックします。
ファイルダイアログで、目的のファイルを参照して選択します。

アップロードが完了すると、ファイル名とファイル情報がバケットに表示されます。

コマンドライン

ファイルをバケットにコピーするには、gcloud storage cp コマンドを使用します。たとえば、ファイル index.html を現在の場所 Desktop からバケット my-static-assets にコピーするには、次のようにします。

gcloud storage cp Desktop/index.html gs://my-static-assets

成功した場合は、次の例のようなレスポンスになります。

Completed files 1/1 | 164.3kiB/164.3kiB

クライアントライブラリ

C++

詳細については、Cloud Storage C++ API のリファレンスドキュメントをご覧ください。

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<gcs::ObjectMetadata> metadata = client.UploadFile(
      file_name, bucket_name, object_name, gcs::IfGenerationMatch(0));
  if (!metadata) throw std::move(metadata).status();

  std::cout << "Uploaded " << file_name << " to object " << metadata->name()
            << " in bucket " << metadata->bucket()
            << "\nFull metadata: " << *metadata << "\n";
}

C#

詳細については、Cloud Storage C# API のリファレンスドキュメントをご覧ください。


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

public class UploadFileSample
{
    public void UploadFile(
        string bucketName = "your-unique-bucket-name",
        string localPath = "my-local-path/my-file-name",
        string objectName = "my-file-name")
    {
        var storage = StorageClient.Create();
        using var fileStream = File.OpenRead(localPath);
        storage.UploadObject(bucketName, objectName, null, fileStream);
        Console.WriteLine($"Uploaded {objectName}.");
    }
}

Go

詳細については、Cloud Storage Go API のリファレンスドキュメントをご覧ください。

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.Background()
	client, err := storage.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("storage.NewClient: %w", err)
	}
	defer client.Close()

	// Open local file.
	f, err := os.Open("notes.txt")
	if err != nil {
		return fmt.Errorf("os.Open: %w", err)
	}
	defer f.Close()

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

	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 {
		return fmt.Errorf("io.Copy: %w", err)
	}
	if err := wc.Close(); err != nil {
		return fmt.Errorf("Writer.Close: %w", err)
	}
	fmt.Fprintf(w, "Blob %v uploaded.\n", object)
	return nil
}

Java

詳細については、Cloud Storage Java API のリファレンスドキュメントをご覧ください。

次のサンプルでは、単独のオブジェクトをアップロードします。


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.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-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.BlobWriteOption precondition;
    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);
  }
}

次のサンプルでは、複数のオブジェクトを同時にアップロードします。

import com.google.cloud.storage.transfermanager.ParallelUploadConfig;
import com.google.cloud.storage.transfermanager.TransferManager;
import com.google.cloud.storage.transfermanager.TransferManagerConfig;
import com.google.cloud.storage.transfermanager.UploadResult;
import java.io.IOException;
import java.nio.file.Path;
import java.util.List;

class UploadMany {

  public static void uploadManyFiles(String bucketName, List<Path> files) throws IOException {
    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());
    }
  }
}

次のサンプルでは、共通の接頭辞を持つすべてのオブジェクトを同時にアップロードします。

import com.google.cloud.storage.transfermanager.ParallelUploadConfig;
import com.google.cloud.storage.transfermanager.TransferManager;
import com.google.cloud.storage.transfermanager.TransferManagerConfig;
import com.google.cloud.storage.transfermanager.UploadResult;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Stream;

class UploadDirectory {

  public static void uploadDirectoryContents(String bucketName, Path sourceDirectory)
      throws IOException {
    TransferManager transferManager = TransferManagerConfig.newBuilder().build().getService();
    ParallelUploadConfig parallelUploadConfig =
        ParallelUploadConfig.newBuilder().setBucketName(bucketName).build();

    // Create a list to store the file paths
    List<Path> filePaths = new ArrayList<>();
    // 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());
    }
  }
}

Node.js

詳細については、Cloud Storage Node.js API のリファレンスドキュメントをご覧ください。

次のサンプルでは、単独のオブジェクトをアップロードします。

/**
 * 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
const storage = new Storage();

async function uploadFile() {
  const options = {
    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},
  };

  await storage.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 download
// const firstFilePath = 'your-first-file-name';

// The ID of the second GCS file to download
// const secondFilePath = 'your-second-file-name';

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

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

// Creates a transfer manager client
const transferManager = new TransferManager(storage.bucket(bucketName));

async function uploadManyFilesWithTransferManager() {
  // Uploads the files
  await transferManager.uploadManyFiles([firstFilePath, secondFilePath]);

  for (const filePath of [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
const storage = new Storage();

// Creates a transfer manager client
const transferManager = new TransferManager(storage.bucket(bucketName));

async function uploadDirectoryWithTransferManager() {
  // Uploads the directory
  await transferManager.uploadManyFiles(directoryName);

  console.log(`${directoryName} uploaded to ${bucketName}.`);
}

uploadDirectoryWithTransferManager().catch(console.error);

PHP

詳細については、Cloud Storage PHP API のリファレンスドキュメントをご覧ください。

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

Python

詳細については、Cloud Storage Python API のリファレンスドキュメントをご覧ください。

次のサンプルでは、単独のオブジェクトをアップロードします。

from google.cloud import storage


def upload_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}."
    )

次のサンプルでは、複数のオブジェクトを同時にアップロードします。

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

    from google.cloud.storage import 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))

次のサンプルでは、共通の接頭辞を持つすべてのオブジェクトを同時にアップロードします。

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

    from pathlib import Path

    from google.cloud.storage import 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))

Ruby

詳細については、Cloud Storage Ruby API のリファレンスドキュメントをご覧ください。

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_name}"
end

Terraform

# Upload a simple index.html page to the bucket
resource "google_storage_bucket_object" "indexpage" {
  name         = "index.html"
  content      = "<html><body>Hello World!</body></html>"
  content_type = "text/html"
  bucket       = google_storage_bucket.static_website.id
}

# Upload a simple 404 / error page to the bucket
resource "google_storage_bucket_object" "errorpage" {
  name         = "404.html"
  content      = "<html><body>404!</body></html>"
  content_type = "text/html"
  bucket       = google_storage_bucket.static_website.id
}

REST API

JSON API

Authorization ヘッダーのアクセストークンを生成するには、gcloud CLI のインストールと初期化を行います。

OAuth 2.0 Playground を使用してアクセストークンを作成し、Authorization ヘッダーに含めることもできます。

cURL を使用して、POST Object リクエストで JSON API を呼び出します。ファイル index.html が my-static-assets という名前のバケットにアップロードされているとします。

curl -X POST --data-binary @index.html \
  -H "Content-Type: text/html" \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  "https://storage.googleapis.com/upload/storage/v1/b/my-static-assets/o?uploadType=media&name=index.html"

XML API

Authorization ヘッダーのアクセストークンを生成するには、gcloud CLI のインストールと初期化を行います。

OAuth 2.0 Playground を使用してアクセストークンを作成し、Authorization ヘッダーに含めることもできます。
cURL を使用して、PUT Object リクエストで XML API を呼び出します。ファイル index.html が my-static-assets という名前のバケットにアップロードされているとします。
```
curl -X PUT --data-binary @index.html \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  -H "Content-Type: text/html" \
  "https://storage.googleapis.com/my-static-assets/index.html"
```

公共のインターネット上で誰もがバケット内のすべてのオブジェクトを閲覧できるようにするには:

コンソール

Google Cloud コンソールで、Cloud Storage の [バケット] ページに移動します。
[バケット] に移動
バケットのリストで、公開するバケットの名前をクリックします。
ページ上部にある [権限] タブを選択します。
[公開アクセス] ペインで [非公開] と表示された場合は、[公開アクセス防止を削除] ボタンをクリックし、表示されたダイアログで [確認] をクリックします。
[ アクセス権を付与] ボタンをクリックします。

[プリンシパルの追加] ダイアログボックスが表示されます。
[新しいプリンシパル] フィールドに「allUsers」と入力します。
[ロールを選択] プルダウンで [Cloud Storage] サブメニューを選択し、[ストレージオブジェクト閲覧者] オプションをクリックします。
[保存] をクリックします。
[一般公開アクセスを許可] をクリックします。

公開の状態で共有されると、[公開アクセス] 列に各オブジェクトのリンクアイコンが表示されます。このアイコンをクリックすると、オブジェクトの URL を取得できます。

コマンドライン

buckets add-iam-policy-binding コマンドを使用します。

gcloud storage buckets add-iam-policy-binding  gs://my-static-assets --member=allUsers --role=roles/storage.objectViewer

クライアントライブラリ

C++

詳細については、Cloud Storage C++ API のリファレンスドキュメントをご覧ください。

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(3));
  if (!current_policy) throw std::move(current_policy).status();

  current_policy->set_version(3);
  current_policy->bindings().emplace_back(
      gcs::NativeIamBinding("roles/storage.objectViewer", {"allUsers"}));

  auto updated =
      client.SetNativeBucketIamPolicy(bucket_name, *current_policy);
  if (!updated) throw std::move(updated).status();

  std::cout << "Policy successfully updated: " << *updated << "\n";
}

C#

詳細については、Cloud Storage C# API のリファレンスドキュメントをご覧ください。


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

public class MakeBucketPublicSample
{
    public void MakeBucketPublic(string bucketName = "your-unique-bucket-name")
    {
        var storage = StorageClient.Create();

        Policy policy = storage.GetBucketIamPolicy(bucketName);

        policy.Bindings.Add(new Policy.BindingsData
        {
            Role = "roles/storage.objectViewer",
            Members = new List<string> { "allUsers" }
        });

        storage.SetBucketIamPolicy(bucketName, policy);
        Console.WriteLine(bucketName + " is now public ");
    }
}

Go

詳細については、Cloud Storage Go API のリファレンスドキュメントをご覧ください。

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 bucket publicly readable.
func setBucketPublicIAM(w io.Writer, bucketName string) error {
	// bucketName := "bucket-name"
	ctx := context.Background()
	client, err := storage.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("storage.NewClient: %w", err)
	}
	defer client.Close()

	policy, err := client.Bucket(bucketName).IAM().V3().Policy(ctx)
	if err != nil {
		return fmt.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},
	})
	if err := client.Bucket(bucketName).IAM().V3().SetPolicy(ctx, policy); err != nil {
		return fmt.Errorf("Bucket(%q).IAM().SetPolicy: %w", bucketName, err)
	}
	fmt.Fprintf(w, "Bucket %v is now publicly readable\n", bucketName)
	return nil
}

Java

詳細については、Cloud Storage Java API のリファレンスドキュメントをご覧ください。

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

Node.js

詳細については、Cloud Storage Node.js API のリファレンスドキュメントをご覧ください。

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

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

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

async function makeBucketPublic() {
  await storage.bucket(bucketName).makePublic();

  console.log(`Bucket ${bucketName} is now publicly readable`);
}

makeBucketPublic().catch(console.error);

PHP

詳細については、Cloud Storage PHP API のリファレンスドキュメントをご覧ください。

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

Python

詳細については、Cloud Storage Python API のリファレンスドキュメントをご覧ください。

from typing import List

from google.cloud import storage


def set_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")

Ruby

詳細については、Cloud Storage Ruby API のリファレンスドキュメントをご覧ください。

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 now publicly readable"
end

Terraform

# Make bucket public by granting allUsers READER access
resource "google_storage_bucket_access_control" "public_rule" {
  bucket = google_storage_bucket.static_website.id
  role   = "READER"
  entity = "allUsers"
}

REST API

JSON API

Authorization ヘッダーのアクセストークンを生成するには、gcloud CLI のインストールと初期化を行います。

OAuth 2.0 Playground を使用してアクセストークンを作成し、Authorization ヘッダーに含めることもできます。

次の情報が含まれる JSON ファイルを作成します。

{
  "bindings":[
    {
      "role": "roles/storage.objectViewer",
      "members":["allUsers"]
    }
  ]
}

cURL を使用して JSON API を呼び出し、PUT Bucket リクエストを行います。
```
curl -X PUT --data-binary @JSON_FILE_NAME \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  -H "Content-Type: application/json" \
  "https://storage.googleapis.com/storage/v1/b/BUCKET_NAME/iam"
```
ここで
- JSON_FILE_NAME は、手順 2 で作成した JSON ファイルのパスです。
- BUCKET_NAME は、オブジェクトを公開するバケットの名前です。例: my-static-assets

XML API

XML API では、バケット内のすべてのオブジェクトを公開して読み取り可能にすることはできません。Google Cloud コンソールまたは gcloud storage を使用するか、個々のオブジェクトに ACL を設定します。

バケット内の個々のオブジェクトを公開するには、バケットのアクセス制御モードをきめ細かい管理に切り替える必要があります。一般に、バケット内のすべてのファイルを一般公開するほう簡単で迅速です。

非公開または存在しないファイルの URL をリクエストすると、サイト訪問者は http 403 レスポンスコードを受け取ります。http 404 レスポンスコードを使用するエラーページを追加する方法については、次のセクションをご覧ください。

推奨: 特殊ページを割り当てる

インデックスページのサフィックスとカスタムエラーページ（特殊ページ）を割り当てることができます。どちらの割り当ても任意ですが、インデックスページのサフィックスを割り当てずに、対応するインデックスページをアップロードした場合、最上位のサイトにアクセスするユーザーには、バケット内の公開オブジェクトのリストを含む XML ドキュメントツリーが提供されます。

特殊ページの動作の詳細については、特殊ページをご覧ください。

コンソール

Google Cloud コンソールで、Cloud Storage の [バケット] ページに移動します。
[バケット] に移動
バケットのリストで、作成したバケットを見つけます。
バケットに関連付けられたバケットオーバーフロー メニュー（）をクリックし、[ウェブサイトの構成を編集] を選択します。
ウェブサイト構成ダイアログで、メインページとエラーページを指定します。
[保存] をクリックします。

コマンドライン

--web-main-page-suffix フラグと --web-error-page フラグを指定して、buckets update コマンドを使用します。

次のサンプルでは、MainPageSuffix を index.html に設定し、NotFoundPage を 404.html に設定します。

gcloud storage buckets update gs://my-static-assets --web-main-page-suffix=index.html --web-error-page=404.html

成功した場合、次の内容が返されます。

Updating gs://www.example.com/...
  Completed 1

クライアントライブラリ

C++

詳細については、Cloud Storage C++ API のリファレンスドキュメントをご覧ください。

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<gcs::BucketMetadata> original =
      client.GetBucketMetadata(bucket_name);

  if (!original) throw std::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) throw std::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";
}

C#

詳細については、Cloud Storage C# API のリファレンスドキュメントをご覧ください。


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

public class BucketWebsiteConfigurationSample
{
    public Bucket BucketWebsiteConfiguration(
        string bucketName = "your-bucket-name",
        string mainPageSuffix = "index.html",
        string notFoundPage = "404.html")
    {
        var storage = StorageClient.Create();
        var bucket = storage.GetBucket(bucketName);

        if (bucket.Website == null)
        {
            bucket.Website = new Bucket.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.");
        return bucket;
    }
}

Go

詳細については、Cloud Storage Go API のリファレンスドキュメントをご覧ください。

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.Background()
	client, err := storage.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("storage.NewClient: %w", err)
	}
	defer client.Close()

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

	bucket := client.Bucket(bucketName)
	bucketAttrsToUpdate := storage.BucketAttrsToUpdate{
		Website: &storage.BucketWebsite{
			MainPageSuffix: indexPage,
			NotFoundPage:   notFoundPage,
		},
	}
	if _, err := bucket.Update(ctx, bucketAttrsToUpdate); err != nil {
		return fmt.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)
	return nil
}

Java

詳細については、Cloud Storage Java API のリファレンスドキュメントをご覧ください。

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

Node.js

詳細については、Cloud Storage Node.js API のリファレンスドキュメントをご覧ください。

/**
 * 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
const storage = new Storage();

async function addBucketWebsiteConfiguration() {
  await storage.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);

PHP

詳細については、Cloud Storage PHP API のリファレンスドキュメントをご覧ください。

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

Python

詳細については、Cloud Storage Python API のリファレンスドキュメントをご覧ください。

from google.cloud import storage


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

Ruby

詳細については、Cloud Storage Ruby API のリファレンスドキュメントをご覧ください。

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 " \
       "#{not_found_page} as the 404 page"
end

REST API

JSON API

Authorization ヘッダーのアクセストークンを生成するには、gcloud CLI のインストールと初期化を行います。

OAuth 2.0 Playground を使用してアクセストークンを作成し、Authorization ヘッダーに含めることもできます。
JSON ファイルを作成して、website オブジェクトの mainPageSuffix プロパティと notFoundPage プロパティを目的のページに設定します。

次のサンプルでは、mainPageSuffix を index.html に設定し、notFoundPage を 404.html に設定します。
```
{
  "website":{
    "mainPageSuffix": "index.html",
    "notFoundPage": "404.html"
  }
}
```

cURL を使用して JSON API を呼び出し、PATCH Bucket リクエストを行います。バケット my-static-assets の場合は、次のようにします。

curl -X PATCH --data-binary @web-config.json \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  -H "Content-Type: application/json" \
  "https://storage.googleapis.com/storage/v1/b/my-static-assets"

XML API

Authorization ヘッダーのアクセストークンを生成するには、gcloud CLI のインストールと初期化を行います。

OAuth 2.0 Playground を使用してアクセストークンを作成し、Authorization ヘッダーに含めることもできます。
XML ファイルを作成し、WebsiteConfiguration 要素の MainPageSuffix 要素と NotFoundPage 要素を目的のページに設定します。

次のサンプルでは、MainPageSuffix を index.html に設定し、NotFoundPage を 404.html に設定します。
```
<WebsiteConfiguration>
  <MainPageSuffix>index.html</MainPageSuffix>
  <NotFoundPage>404.html</NotFoundPage>
</WebsiteConfiguration>
```

cURL を使用して、PUT Bucket リクエストと websiteConfig クエリ文字列パラメータを含めた XML API を呼び出します。my-static-assets の場合:

curl -X PUT --data-binary @web-config.xml \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  https://storage.googleapis.com/my-static-assets?websiteConfig

ロードバランサと SSL 証明書を設定する

Cloud Storage 自体では HTTPS を使用するカスタムドメインをサポートしていません。HTTPS 経由でウェブサイトを提供するには、HTTPS ロードバランサに関連付けられた SSL 証明書を設定する必要があります。このセクションでは、ロードバランサのバックエンドにバケットを追加する方法と、ロードバランサのフロントエンドに新しい Google マネージド SSL 証明書を追加する方法について説明します。

構成を開始する

Google Cloud コンソールで、[ロードバランシング] ページに移動します。

[ロードバランシング] に移動
[ロードバランサを作成] をクリックします。
[ロードバランサの種類] で [アプリケーションロードバランサ（HTTP / HTTPS）] を選択し、[次へ] をクリックします。
[インターネット接続または内部] で [インターネット接続（外部）] を選択し、[次へ] をクリックします。
[グローバルまたはシングルリージョンのデプロイ] で [グローバルワークロードに最適] を選択し、[次へ] をクリックします。
[ロードバランサの世代] で [従来のアプリケーションロードバランサ] を選択し、[次へ] をクリックします。
[構成] をクリックします。

ロードバランサの構成ウィンドウが表示されます。

基本構成

構成を続行する前に、ロードバランサ名（example-lb など）を入力します。

フロントエンドを構成する

このセクションでは、HTTPS プロトコルを構成し、SSL 証明書を作成する方法について説明します。既存の証明書を選択することも、セルフマネージド SSL 証明書をアップロードすることもできます。

[フロントエンドの構成] をクリックします。
（省略可）フロントエンドの構成に名前を付けます。
[プロトコル] で、[HTTPS（HTTP/2 を含む）] を選択します。
[IP バージョン] で [IPv4] を選択します。IPv6 を使用する場合は、IPv6 終端をご覧ください。
[IP アドレス] フィールドで次の操作を行います。
- プルダウンで [IP アドレスを作成] をクリックします。
- [新しい静的 IP アドレスの予約] ポップアップで、IP アドレスの名前として「example-ip」などの名前を入力します。
- [予約] をクリックします。
注: IP アドレスが転送ルールに接続されていない場合、新しい静的 IP アドレスを予約すると、追加費用が発生します。このような費用を回避するには、関連するロードバランサを削除するときに静的 IP アドレスも削除してください。
[ポート] で [443] を選択します。
[証明書] フィールドのプルダウンで、[新しい証明書を作成] を選択します。パネルに証明書作成フォームが表示されます。以下の構成を行います。
- 証明書に名前を付けます（example-ssl など）。
- [作成モード] で [Google マネージドの証明書を作成する] を選択します。
- [ドメイン] にウェブサイトの名前（www.example.com など）を入力します。ルートドメイン example.com など、追加ドメイン経由でコンテンツを配信する場合は、Enter キーを押して追加行にドメインを追加します。各証明書の上限は 100 ドメインです。
[作成] をクリックします。
（省略可）Google Cloud によって部分的な HTTP ロードバランサを自動的に設定し、HTTP トラフィックをリダイレクトする場合は、[HTTP から HTTPS へのリダイレクトを有効にする] チェックボックスを選択します。
[完了] をクリックします。

バックエンドを構成する

[バックエンドの構成] をクリックします。
[バックエンドサービスとバックエンドバケット] プルダウンで [バックエンドバケットを作成] をクリックします。
バックエンドバケット名を選択します（example-bucket など）。以前に作成したバケットの名前と異なる名前も選択できます。
[Cloud Storage バケット] フィールド内の [参照] をクリックします。
前に作成した my-static-assets バケットを選択し、[選択] をクリックします。
（省略可）Cloud CDN を使用する場合は、[Cloud CDN を有効にする] チェックボックスをオンにし、必要に応じて Cloud CDN を構成します。Cloud CDN を使用すると、追加費用が発生する可能性があります。
[作成] をクリックします。

ルーティングルールを構成する

ルーティングルールは、外部アプリケーションロードバランサの URL マップの構成要素です。このチュートリアルでは、ロードバランサの構成のこの部分をスキップします。これは、構成したバックエンドを使用するように自動的に構成されているためです。

構成を確認する

[確認と完了] をクリックします。
[フロントエンド]、[ルーティングルール]、[バックエンド] を確認します。
[作成] をクリックします。

ロードバランサの作成に数分かかることがあります。

ドメインをロードバランサに接続する

ロードバランサが作成されたら、ロードバランサの名前（example-lb）をクリックします。ロードバランサに関連付けられた IP アドレスをメモします（例: 30.90.80.100）。ドメインをロードバランサに指定するには、ドメイン登録サービスを使用して A レコードを作成します。SSL 証明書に複数のドメインを追加する場合は、それぞれについて A レコードを追加して、すべてがロードバランサの IP アドレスを指す必要があります。たとえば、www.example.com と example.com に A レコードを作成するには、次のようにします。

NAME                  TYPE     DATA
www                   A        30.90.80.100
@                     A        30.90.80.100

推奨: SSL 証明書のステータスをモニタリングする

Google Cloud が証明書をプロビジョニングし、ロードバランサ経由でサイトが利用可能になるまでに最大で 60～90 分かかることがあります。証明書のステータスをモニタリングするには:

コンソール

Google Cloud コンソールの [ロードバランシング] ページに移動します。
[ロードバランシング] に移動
ロードバランサの名前（example-lb）をクリックします。
ロードバランサに関連付けられている SSL 証明書の名前（example-ssl）をクリックします。
[ステータス] 行と [ドメインステータス] 行に証明書のステータスが表示されます。ウェブサイトで証明書を有効にするには、両方が有効である必要があります。

コマンドライン

証明書のステータスを確認するには、次のコマンドを実行します。

gcloud compute ssl-certificates describe CERTIFICATE_NAME \
  --global \
  --format="get(name,managed.status)"

ドメインのステータスを確認するには、次のコマンドを実行します。

gcloud compute ssl-certificates describe CERTIFICATE_NAME \
  --global \
  --format="get(managed.domainStatus)"

証明書のステータスの詳細については、SSL 証明書のトラブルシューティングをご覧ください。

ウェブサイトをテストする

SSL 証明書がアクティブになったら https://www.example.com/test.html に移動し、コンテンツがバケットから配信されていることを確認します。ここで、test.html は、バックエンドとして使用するバケットに保存されているオブジェクトです。MainPageSuffix プロパティを設定すると、https://www.example.com が index.html に移動します。

クリーンアップ

チュートリアルが終了したら、作成したリソースをクリーンアップして、割り当ての使用を停止し、課金されないようにできます。以下のセクションで、リソースを削除または無効にする方法を説明します。

プロジェクトを削除する

課金をなくす最も簡単な方法は、チュートリアル用に作成したプロジェクトを削除することです。

プロジェクトを削除するには:

注意: プロジェクトを削除すると、次のような影響があります。

プロジェクト内のすべてのものが削除されます。このドキュメントのタスクで既存のプロジェクトを使用した場合、それを削除すると、そのプロジェクトで行った他の作業もすべて削除されます。
カスタムプロジェクト ID が失われます。このプロジェクトを作成したときに、将来使用するカスタムプロジェクト ID を作成した可能性があります。そのプロジェクト ID を使用した URL（たとえば、appspot.com）を保持するには、プロジェクト全体ではなくプロジェクト内の選択したリソースだけを削除します。

複数のアーキテクチャ、チュートリアル、クイックスタートを実施する予定がある場合は、プロジェクトを再利用すると、プロジェクトの割り当て上限を超えないようにすることができます。

In the Google Cloud console, go to the Manage resources page.
Go to Manage resources
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 Shut down to delete the project.

ロードバランサとバケットの削除

プロジェクト全体を削除しない場合は、このチュートリアル用に作成したロードバランサとバケットを削除します。

Google Cloud コンソールの [ロードバランシング] ページに移動します。
[ロードバランシング] に移動
example-lb の横のチェックボックスをオンにします。
[削除] をクリックします。
（省略可）my-static-assets バケットや example-ssl SSL 証明書など、ロードバランサと一緒に削除するリソースのチェックボックスをオンにします。
[ロードバランサを削除] または [ロードバランサと選択したリソースを削除] をクリックします。

予約済みの IP アドレスを解放する

チュートリアルで使用した予約済み IP アドレスを削除するには:

Google Cloud コンソールで、[外部 IP アドレス] ページに移動します。

[外部 IP アドレス] に移動
example-ip の横にあるチェックボックスを選択します。
[静的アドレスを予約] をクリックします。
確認ウィンドウで [削除] をクリックします。

次のステップ

使ってみる

Google Cloud を初めて使用する場合は、アカウントを作成して、実際のシナリオでの Cloud Storage のパフォーマンスを評価してください。新規のお客様には、ワークロードの実行、テスト、デプロイができる無料クレジット $300 分を差し上げます。

Cloud Storage を無料で試す

静的ウェブサイトをホストする

目標

料金

始める前に

バケットの作成

コンソール

コマンドライン

クライアント ライブラリ

C++

C#

Go

Java

Node.js

PHP

Python

Ruby

Terraform

REST API

JSON API

XML API

サイトのファイルをアップロードする

コンソール

コマンドライン

クライアント ライブラリ

C++

C#

Go

Java

Node.js

PHP

Python

Ruby

Terraform

REST API

JSON API

XML API

ファイルを共有する

コンソール

コマンドライン

クライアント ライブラリ

C++

C#

Go

Java

Node.js

PHP

Python

Ruby

Terraform

REST API

JSON API

XML API

推奨: 特殊ページを割り当てる

コンソール

コマンドライン

クライアント ライブラリ

C++

C#

Go

Java

Node.js

PHP

Python

Ruby

REST API

JSON API

XML API

ロードバランサと SSL 証明書を設定する

構成を開始する

基本構成

フロントエンドを構成する

バックエンドを構成する

ルーティング ルールを構成する

構成を確認する

ドメインをロードバランサに接続する

推奨: SSL 証明書のステータスをモニタリングする

コンソール

コマンドライン

ウェブサイトをテストする

クリーンアップ

クライアントライブラリ

クライアントライブラリ

クライアントライブラリ

クライアントライブラリ

ルーティングルールを構成する