Statische Website hosten

In dieser Anleitung wird beschrieben, wie Sie einen Cloud Storage-Bucket konfigurieren, um eine statische Website für eine Domain, die Ihnen gehört, zu hosten. Statische Webseiten können clientseitige Technologien wie HTML, CSS und JavaScript enthalten, jedoch keine dynamischen Inhalte wie serverseitige Skripts (z. B. PHP).

Da Cloud Storage allein keine benutzerdefinierten Domains mit HTTPS unterstützt, wird in dieser Anleitung Cloud Storage mit HTTP(S)-Load-Balancing verwendet, um Inhalte aus einer benutzerdefinierten Domain über HTTPS bereitzustellen. Weitere Möglichkeiten zum Bereitstellen von Inhalten aus einer benutzerdefinierten Domain über HTTPS finden Sie im entsprechenden Thema zur Fehlerbehebung. Sie können Cloud Storage auch verwenden, um benutzerdefinierte Domaininhalte über HTTP bereitzustellen. Hierfür ist kein Load-Balancer erforderlich.

Beispiele und Tipps zu statischen Webseiten, etwa zum Hosten statischer Inhalte für eine dynamische Website, finden Sie auf der Seite "Statische Website".

Ziele

In dieser Anleitung wird Folgendes erläutert:

  • Bucket erstellen
  • Dateien in Ihre Website hochladen und freigeben.
  • Load-Balancer und SSL-Zertifikat einrichten.
  • Load-Balancer mit dem Bucket verbinden.
  • Mit einem A-Eintrag einen Verweis der Domain zum Load-Balancer erstellen.
  • Die Website testen.

Kosten

In dieser Anleitung werden die folgenden kostenpflichtigen Komponenten von Google Cloud verwendet:

  • Cloud Storage
  • Cloud Load Balancing

Weitere Informationen zu den Kosten, die beim Hosten einer statischen Website anfallen können, finden Sie unter Gebühren überwachen. Auf der Seite Preise finden Sie weitere Informationen zu Cloud Storage-Kosten.

Hinweis

  1. Melden Sie sich bei Ihrem Google-Konto an.

    Wenn Sie noch kein Konto haben, melden Sie sich hier für ein neues Konto an.

  2. Wählen Sie in der Cloud Console auf der Seite für die Projektauswahl ein Cloud-Projekt aus oder erstellen Sie eines.

    Zur Projektauswahl

  3. Die Abrechnung für das Google Cloud-Projekt muss aktiviert sein. So prüfen Sie, ob die Abrechnung für Ihr Projekt aktiviert ist.

  4. Haben oder verwalten Sie eine Domain? Wenn Sie noch keine Domain haben, können Sie eine neue registrieren. Dazu stehen Ihnen viele Dienste wie Google Domains zur Verfügung.

    In dieser Anleitung wird die Domain example.com verwendet.

  5. Sie müssen der Inhaber oder Verwalter der Domain sein, die Sie verwenden möchten. Verifizieren Sie unbedingt die Top-Level-Domain wie example.com und keine Subdomain wie www.example.com.

    Hinweis: Wenn Sie Inhaber der Domain sind, die Sie einem Bucket zuordnen, haben Sie diesen Schritt möglicherweise bereits in der Vergangenheit ausgeführt. Wenn Sie Ihre Domain über Google Domains erworben haben, erfolgt die Überprüfung automatisch.

  6. Halten Sie einige Websitedateien bereit, die Sie bereitstellen möchten. Für diese Anleitung ist es am besten, wenn Sie mindestens eine Indexseite (index.html) und eine 404-Seite (404.html) haben.
  7. Achten Sie darauf, dass Sie eine Rolle entweder als Inhaber oder Bearbeiter des Projekts oder die folgenden Identity and Access Management-Rollen haben: Storage-Objekt-Administrator und Netzwerkadministrator.

Bucket erstellen

So erstellen Sie einen Bucket mit dem Namen www.example.com:

Console

  1. Öffnen Sie den Cloud Storage-Browser in der Google Cloud Console.
    Zum Cloud Storage-Browser
  2. Klicken Sie auf Bucket erstellen, um das Formular zum Erstellen eines Buckets zu öffnen.

  3. Geben Sie die Bucket-Informationen ein und klicken Sie zum Ausführen der einzelnen Schritte auf Weiter:

    • Legen Sie den Namen des Buckets fest. Wir empfehlen, den gleichen Namen wie für Ihre Domain zu verwenden, um einen späteren Schritt zu erleichtern. Beispiel: www.example.com

    • Wählen Sie den Standorttyp und den Standort des Buckets aus. Beispiel: Region und us-east1.

    • Wählen Sie Standard Storage als Speicherklasse aus.

    • Wählen Sie unter Zugriffssteuerung die Option Einheitlich aus.

  4. Klicken Sie auf Erstellen.

Bei korrekter Erstellung öffnet sich die Seite Bucket-Details mit dem Text "Dieser Bucket enthält keine Liveobjekte".

Unter Fehlerbehebung erfahren Sie, wie Sie im Cloud Storage-Browser detaillierte Fehlerinformationen zu fehlgeschlagenen Vorgängen abrufen.

gsutil

Führen Sie folgenden gsutil mb-Befehl aus:

gsutil mb -b on gs://www.example.com

Wenn der Vorgang erfolgreich ist, gibt der Befehl Folgendes zurück:

Creating gs://www.example.com/...

Codebeispiele

C++

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage C++ API.

namespace gcs = google::cloud::storage;
using ::google::cloud::StatusOr;
[](gcs::Client client, std::string const& bucket_name) {
  StatusOr<gcs::BucketMetadata> bucket_metadata =
      client.CreateBucket(bucket_name, gcs::BucketMetadata());

  if (!bucket_metadata) {
    throw std::runtime_error(bucket_metadata.status().message());
  }

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

C#

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage C# API.

public static Bucket StorageCreateBucket(string projectId, string bucketName)
{
    var storage = StorageClient.Create();
    var bucket = storage.CreateBucket(projectId, bucketName);
    Console.WriteLine($"Created {bucketName}.");
    return bucket;
}

Go

Weitere Informationen finden Sie in der Referenzdokumentation zur 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: %v", err)
	}
	defer client.Close()

	ctx, cancel := context.WithTimeout(ctx, time.Second*10)
	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: %v", bucketName, err)
	}
	fmt.Fprintf(w, "Created bucket %v in %v with storage class %v\n", bucketName, storageClassAndLocation.Location, storageClassAndLocation.StorageClass)
	return nil
}

Java

Weitere Informationen finden Sie in der Referenzdokumentation zur 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

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage Node.js API.

/**
 * TODO(developer): Uncomment the following line before running the sample.
 */
// const bucketName = 'Name of a bucket, e.g. my-bucket';

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

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

async function createBucket() {
  // Creates a new bucket in the Asia region with the coldline default storage
  // class. Leave the second argument blank for default settings.
  //
  // 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: 'ASIA',
    storageClass: 'COLDLINE',
  });

  console.log(`Bucket ${bucket.name} created.`);
}

createBucket().catch(console.error);

PHP

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage PHP API.

use Google\Cloud\Storage\StorageClient;

/**
 * Create a Cloud Storage Bucket.
 *
 * @param string $bucketName name of the bucket to create.
 * @param string $options options for the new bucket.
 *
 */
function create_bucket($bucketName, $options = [])
{
    $storage = new StorageClient();
    $bucket = $storage->createBucket($bucketName, $options);
    printf('Bucket created: %s' . PHP_EOL, $bucket->name());
}

Python

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage Python API.

from google.cloud import storage

def create_bucket_class_location(bucket_name):
    """Create a new bucket in specific location with 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

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage Ruby API.

# bucket_name   = "Name of Google Cloud Storage bucket to create"
# location      = "Location of where to create Cloud Storage bucket"
# storage_class = "Storage class of Cloud Storage bucket"

require "google/cloud/storage"

storage = Google::Cloud::Storage.new
bucket  = storage.create_bucket bucket_name,
                                location:      location,
                                storage_class: storage_class

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

REST APIs

JSON API

  1. Rufen Sie ein Zugriffstoken für die Autorisierung aus dem OAuth 2.0 Playground ab. Konfigurieren Sie den Playground so, dass Ihre eigenen OAuth-Anmeldedaten verwendet werden.
  2. Erstellen Sie eine .json-Datei, in der Ihr Websitename dem Attribut name zugewiesen wird:

    {
      "name": "www.example.com"
    }
  3. Verwenden Sie cURL, um die JSON API aufzurufen: Für www.example.com:

    curl -X POST --data-binary @website-bucket-name.json \
      -H "Authorization: Bearer ya29.AHES6ZRVmB7fkLtd1XTmq6mo0S1wqZZi3-Lh_s-6Uw7p8vtgSwg" \
      -H "Content-Type: application/json" \
      "https://storage.googleapis.com/storage/v1/b?project=my-static-website"

XML API

  1. Rufen Sie ein Zugriffstoken für die Autorisierung aus dem OAuth 2.0 Playground ab. Konfigurieren Sie den Playground so, dass Ihre eigenen OAuth-Anmeldedaten verwendet werden.
  2. Verwenden Sie cURL, um die XML API aufzurufen und einen Bucket mit Ihrem Websitenamen zu erstellen. Für www.example.com:

    curl -X PUT \
      -H "Authorization: Bearer ya29.AHES6ZRVmB7fkLtd1XTmq6mo0S1wqZZi3-Lh_s-6Uw7p8vtgSwg" \
      -H "x-goog-project-id: my-static-website" \
      "https://storage.googleapis.com/www.example.com"

Dateien meiner Website hochladen

Fügen Sie dem Bucket die Dateien hinzu, die Ihre Website bereitstellen soll:

Console

  1. Öffnen Sie den Cloud Storage-Browser in der Google Cloud Console.
    Zum Cloud Storage-Browser
  2. Klicken Sie in der Liste der Buckets auf den Namen des Buckets, den Sie erstellt haben.

    Die Seite Bucket-Details wird geöffnet und der Tab Objekte ist ausgewählt.

  3. Klicken Sie auf die Schaltfläche Dateien hochladen.

  4. Gehen Sie im Dateidialogfeld zur gewünschten Datei und wählen Sie sie aus.

Wenn der Upload abgeschlossen ist, sollten Sie im Bucket den Dateinamen und Informationen zur Datei sehen.

Unter Fehlerbehebung erfahren Sie, wie Sie im Cloud Storage-Browser detaillierte Fehlerinformationen zu fehlgeschlagenen Vorgängen abrufen.

gsutil

Verwenden Sie den Befehl gsutil cp, um Dateien in den Bucket zu kopieren. Kopieren Sie beispielsweise die Datei index.html aus ihrem aktuellen Speicherort Desktop:

gsutil cp Desktop/index.html gs://www.example.com

Wenn der Vorgang erfolgreich ist, gibt der Befehl Folgendes zurück:

Copying file://Desktop/index.html [Content-Type=text/html]...
Uploading   gs://www.example.com/index.html:       0 B/2.58 KiB
Uploading   gs://www.example.com/index.html:       2.58 KiB/2.58 KiB

Codebeispiele

C++

Weitere Informationen finden Sie in der Referenzdokumentation zur 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::runtime_error(metadata.status().message());

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

C#

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage C# API.

private void UploadFile(string bucketName, string localPath,
    string objectName = null)
{
    var storage = StorageClient.Create();
    using (var f = File.OpenRead(localPath))
    {
        objectName = objectName ?? Path.GetFileName(localPath);
        storage.UploadObject(bucketName, objectName, null, f);
        Console.WriteLine($"Uploaded {objectName}.");
    }
}

Go

Weitere Informationen finden Sie in der Referenzdokumentation zur 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: %v", err)
	}
	defer client.Close()

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

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

	// Upload an object with storage.Writer.
	wc := client.Bucket(bucket).Object(object).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 uploaded.\n", object)
	return nil
}

Java

Weitere Informationen finden Sie in der Referenzdokumentation zur 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.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-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();
    storage.create(blobInfo, Files.readAllBytes(Paths.get(filePath)));

    System.out.println(
        "File " + filePath + " uploaded to bucket " + bucketName + " as " + objectName);
  }
}

Node.js

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage Node.js API.

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// const bucketName = 'Name of a bucket, e.g. my-bucket';
// const filename = 'Local file to upload, e.g. ./local/path/to/file.txt';

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

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

async function uploadFile() {
  // Uploads a local file to the bucket
  await storage.bucket(bucketName).upload(filename, {
    // Support for HTTP requests made with `Accept-Encoding: gzip`
    gzip: true,
    // By setting the option `destination`, you can change the name of the
    // object you are uploading to a bucket.
    metadata: {
      // Enable long-lived HTTP caching headers
      // Use only if the contents of the file will never change
      // (If the contents will change, use cacheControl: 'no-cache')
      cacheControl: 'public, max-age=31536000',
    },
  });

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

uploadFile().catch(console.error);

PHP

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage PHP API.

use Google\Cloud\Storage\StorageClient;

/**
 * Upload a file.
 *
 * @param string $bucketName the name of your Google Cloud bucket.
 * @param string $objectName the name of the object.
 * @param string $source the path to the file to upload.
 *
 * @return Psr\Http\Message\StreamInterface
 */
function upload_object($bucketName, $objectName, $source)
{
    $storage = new StorageClient();
    $file = fopen($source, 'r');
    $bucket = $storage->bucket($bucketName);
    $object = $bucket->upload($file, [
        'name' => $objectName
    ]);
    printf('Uploaded %s to gs://%s/%s' . PHP_EOL, basename($source), $bucketName, $objectName);
}

Python

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage Python API.

Verwenden Sie die Methode Blob.upload_from_file(), Blob.upload_from_filename() oder Blob.upload_from_string(), um ein Objekt hochzuladen.
from google.cloud import storage

def upload_blob(bucket_name, source_file_name, destination_blob_name):
    """Uploads a file to the bucket."""
    # bucket_name = "your-bucket-name"
    # source_file_name = "local/path/to/file"
    # destination_blob_name = "storage-object-name"

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

    blob.upload_from_filename(source_file_name)

    print(
        "File {} uploaded to {}.".format(
            source_file_name, destination_blob_name
        )
    )

Ruby

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage Ruby API.

# bucket_name       = "Your Google Cloud Storage bucket name"
# local_file_path   = "Path to local file to upload"
# storage_file_path = "Path to store the file in Google Cloud Storage"

require "google/cloud/storage"

storage = Google::Cloud::Storage.new
bucket  = storage.bucket bucket_name

file = bucket.create_file local_file_path, storage_file_path

puts "Uploaded #{file.name}"

REST APIs

JSON API

  1. Rufen Sie ein Zugriffstoken für die Autorisierung aus dem OAuth 2.0 Playground ab. Konfigurieren Sie den Playground so, dass Ihre eigenen OAuth-Anmeldedaten verwendet werden.
  2. Verwenden Sie cURL, um die JSON API mit einer POST-Objektanfrage aufzurufen: Für die Indexseite von www.example.com:

    curl -X POST --data-binary @index.html \
      -H "Content-Type: text/html" \
      -H "Authorization: Bearer ya29.AHES6ZRVmB7fkLtd1XTmq6mo0S1wqZZi3-Lh_s-6Uw7p8vtgSwg" \
      "https://storage.googleapis.com/upload/storage/v1/b/www.example.com/o?uploadType=media&name=index.html"

XML API

  1. Rufen Sie ein Zugriffstoken für die Autorisierung aus dem OAuth 2.0 Playground ab. Konfigurieren Sie den Playground so, dass Ihre eigenen OAuth-Anmeldedaten verwendet werden.
  2. Verwenden Sie cURL, um die XML API mit einer PUT-Objektanfrage aufzurufen: Für die Indexseite von www.example.com:

    curl -X PUT --data-binary @index.html \
      -H "Authorization: Bearer ya29.AHES6ZRVmB7fkLtd1XTmq6mo0S1wqZZi3-Lh_s-6Uw7p8vtgSwg" \
      -H "Content-Type: text/html" \
      "https://storage.googleapis.com/www.example.com/index.html"

Dateien freigeben

So machen Sie alle Objekte in einem Bucket für alle Nutzer im öffentlichen Internet lesbar:

Console

  1. Öffnen Sie den Cloud Storage-Browser in der Google Cloud Console.
    Zum Cloud Storage-Browser
  2. Klicken Sie in der Liste der Buckets auf den Namen des Buckets, den Sie veröffentlichen möchten.

  3. Wählen Sie oben auf der Seite den Tab Berechtigungen aus.

  4. Klicken Sie auf die Schaltfläche Mitglieder hinzufügen.

    Das Dialogfeld Mitglieder hinzufügen wird angezeigt.

  5. Geben Sie im Feld Neue Mitglieder den Wert allUsers ein.

  6. Wählen Sie im Drop-down-Menü Rolle auswählen das Untermenü Cloud Storage aus und klicken Sie auf die Option Storage-Objektbetrachter.

  7. Klicken Sie auf Speichern.

  8. Klicken Sie auf Öffentlichen Zugriff erlauben.

Sobald das Objekt öffentlich freigegeben ist, wird in der Spalte für den öffentlichen Zugriff ein Link-Symbol angezeigt. Wenn Sie auf dieses Symbol klicken, erhalten Sie die URL für das Objekt.

Unter Fehlerbehebung erfahren Sie, wie Sie im Cloud Storage-Browser detaillierte Fehlerinformationen zu fehlgeschlagenen Vorgängen abrufen.

gsutil

Führen Sie den Befehl gsutil iam ch aus:

gsutil iam ch allUsers:objectViewer gs://www.example.com

Codebeispiele

C++

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage C++ API.

namespace gcs = google::cloud::storage;
using google::cloud::StatusOr;
[](gcs::Client client, std::string const& bucket_name) {
  StatusOr<google::cloud::IamPolicy> current_policy =
      client.GetBucketIamPolicy(bucket_name);

  if (!current_policy) {
    throw std::runtime_error(current_policy.status().message());
  }

  current_policy->bindings.AddMember("roles/storage.objectViewer",
                                     "allUsers");

  // Update the policy. Note the use of `gcs::IfMatchEtag` to implement
  // optimistic concurrency control.
  StatusOr<google::cloud::IamPolicy> updated_policy =
      client.SetBucketIamPolicy(bucket_name, *current_policy,
                                gcs::IfMatchEtag(current_policy->etag));

  if (!updated_policy) {
    throw std::runtime_error(current_policy.status().message());
  }

  auto role = updated_policy->bindings.find("roles/storage.objectViewer");
  if (role == updated_policy->bindings.end()) {
    std::cout << "Cannot find 'roles/storage.objectViewer' in the updated"
              << " policy. This can happen if another application updates"
              << " the IAM policy at the same time. Please retry the"
              << " operation.\n";
    return;
  }
  auto member = role->second.find("allUsers");
  if (member == role->second.end()) {
    std::cout << "'allUsers' is not a member of the"
              << " 'roles/storage.objectViewer' role in the updated"
              << " policy. This can happen if another application updates"
              << " the IAM policy at the same time. Please retry the"
              << " operation.\n";
    return;
  }
  std::cout << "IamPolicy successfully updated for bucket " << bucket_name
            << '\n';
}

Java

Weitere Informationen finden Sie in der Referenzdokumentation zur 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");
  }
}

Python

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage Python API.

from google.cloud import storage

def set_bucket_public_iam(bucket_name, role, member):
    """Set a public IAM Policy to bucket"""
    # bucket_name = "your-bucket-name"
    # role = "IAM role, e.g. roles/storage.objectViewer"
    # member = "IAM identity, e.g. allUsers"

    storage_client = storage.Client()
    bucket = storage_client.bucket(bucket_name)

    policy = bucket.get_iam_policy(requested_policy_version=3)
    policy.bindings.append({"role": role, "members": {member}})

    bucket.set_iam_policy(policy)

    print("Bucket {} is now publicly readable".format(bucket.name))

REST APIs

JSON API

  1. Rufen Sie ein Zugriffstoken für die Autorisierung aus dem OAuth 2.0 Playground ab. Konfigurieren Sie den Playground so, dass Ihre eigenen OAuth-Anmeldedaten verwendet werden.
  2. Erstellen Sie eine JSON-Datei, die die folgenden Informationen enthält:

    {
      "bindings":[
        {
          "role": "roles/storage.objectViewer",
          "members":["allUsers"]
        }
      ]
    }
  3. Verwenden Sie cURL, um die JSON API mit einer PUT-Bucket-Anfrage aufzurufen:

    curl -X PUT --data-binary @JSON_FILE_NAME.json \
      -H "Authorization: Bearer OAUTH2_TOKEN" \
      -H "Content-Type: application/json" \
      "https://storage.googleapis.com/storage/v1/b/BUCKET_NAME/iam"

    Dabei gilt:

    • JSON_FILE_NAME ist der Name der Datei, die Sie in Schritt 2 erstellt haben.
    • OAUTH2_TOKEN ist das Zugriffstoken, das Sie in Schritt 1 erstellt haben.
    • BUCKET_NAME ist der Name des Buckets, dessen Objekte Sie veröffentlichen möchten. Beispiel: my-bucket

XML API

Die öffentliche Freigabe aller Objekte in einem Bucket wird von der XML API nicht unterstützt. Verwenden Sie stattdessen gsutil oder die JSON API oder legen Sie ACLs für jedes einzelne Objekt fest.

Wenn Sie einzelne Objekte im Bucket öffentlich zugänglich machen möchten, müssen Sie den Modus der Zugriffssteuerung des Buckets auf Detailgenau umstellen. Generell geht es einfacher und schneller, alle Dateien im Bucket öffentlich zugänglich zu machen.

Besucher erhalten einen http 403-Antwortcode, wenn sie die URL für eine nicht öffentliche oder nicht vorhandene Datei anfordern. Informationen zum Einfügen einer Fehlerseite mit einem http 404-Antwortcode finden Sie im nächsten Abschnitt.

Empfohlen: Spezialseiten zuweisen

Sie können ein Indexseitensuffix zuweisen, das vom Attribut MainPageSuffix und einer benutzerdefinierten Fehlerseite gesteuert wird, die wiederum vom Attribut NotFoundPage gesteuert wird. Beide Zuweisungen sind optional. Ohne eine Indexseite wird jedoch nichts angezeigt, wenn Nutzer auf Ihre Top-Level-Website (z. B. https://www.example.com) zugreifen. Weitere Informationen zu den Attributen MainPageSuffix und NotFoundPage finden Sie unter Spezialseiten.

Im folgenden Beispiel ist MainPageSuffix auf index.html und NotFoundPage auf 404.html festgelegt:

Console

  1. Öffnen Sie den Cloud Storage-Browser in der Google Cloud Console.
    Zum Cloud Storage-Browser
  2. Suchen Sie in der Liste der Buckets den Bucket, den Sie erstellt haben.

  3. Klicken Sie auf das Dreipunkt-Menü () des Buckets und wählen Sie Websitekonfiguration bearbeiten aus.

  4. Geben Sie im Dialogfeld zur Websitekonfiguration die Hauptseite und die Fehlerseite an.

  5. Klicken Sie auf Speichern.

Unter Fehlerbehebung erfahren Sie, wie Sie im Cloud Storage-Browser detaillierte Fehlerinformationen zu fehlgeschlagenen Vorgängen abrufen.

gsutil

Verwenden Sie den Befehl gsutil web set, um das Attribut MainPageSuffix mit dem Flag -m und NotFoundPage mit dem Flag -e festzulegen:

gsutil web set -m index.html -e 404.html gs://www.example.com

Wenn der Vorgang erfolgreich ist, gibt der Befehl Folgendes zurück:

Setting website config on gs://www.example.com/...

Codebeispiele

C++

Weitere Informationen finden Sie in der Referenzdokumentation zur 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::runtime_error(original.status().message());
  StatusOr<gcs::BucketMetadata> patched_metadata = client.PatchBucket(
      bucket_name,
      gcs::BucketMetadataPatchBuilder().SetWebsite(
          gcs::BucketWebsite{main_page_suffix, not_found_page}),
      gcs::IfMetagenerationMatch(original->metageneration()));

  if (!patched_metadata) {
    throw std::runtime_error(patched_metadata.status().message());
  }

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

  std::cout << "Static website configuration successfully set for bucket "
            << patched_metadata->name() << "\nNew main page suffix is: "
            << patched_metadata->website().main_page_suffix
            << "\nNew not found page is: "
            << patched_metadata->website().not_found_page << "\n";
}

Java

Weitere Informationen finden Sie in der Referenzdokumentation zur 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");
  }
}

Python

Weitere Informationen finden Sie in der Referenzdokumentation zur 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

REST APIs

JSON API

  1. Rufen Sie ein Zugriffstoken für die Autorisierung aus dem OAuth 2.0 Playground ab. Konfigurieren Sie den Playground so, dass Ihre eigenen OAuth-Anmeldedaten verwendet werden.
  2. Erstellen Sie eine .json-Datei, die die Attribute mainPageSuffix und notFoundPage in einem website-Objekt auf die gewünschten Seiten festlegt:

    {
      "website":{
        "mainPageSuffix": "index.html",
        "notFoundPage": "404.html"
      }
    }
  3. Verwenden Sie cURL, um die JSON API mit einer PATCH-Bucket-Anfrage aufzurufen. Für www.example.com:

    curl -X PATCH --data-binary @web-config.json \
      -H "Authorization: Bearer ya29.AHES6ZRVmB7fkLtd1XTmq6mo0S1wqZZi3-Lh_s-6Uw7p8vtgSwg" \
      -H "Content-Type: application/json" \
      "https://storage.googleapis.com/storage/v1/b/www.example.com"

XML API

  1. Rufen Sie ein Zugriffstoken für die Autorisierung aus dem OAuth 2.0 Playground ab. Konfigurieren Sie den Playground so, dass Ihre eigenen OAuth-Anmeldedaten verwendet werden.
  2. Erstellen Sie eine .xml-Datei, die die Elemente MainPageSuffix und NotFoundPage in einem WebsiteConfiguration-Element auf die gewünschten Seiten festlegt:

    <WebsiteConfiguration>
      <MainPageSuffix>index.html</MainPageSuffix>
      <NotFoundPage>404.html</NotFoundPage>
    </WebsiteConfiguration>
  3. Verwenden Sie cURL, um die XML API mit einer PUT-Bucket-Anfrage und dem Abfragestringparameter websiteConfig aufzurufen. Für www.example.com:

    curl -X PUT --data-binary @web-config.xml \
      -H "Authorization: Bearer ya29.AHES6ZRVmB7fkLtd1XTmq6mo0S1wqZZi3-Lh_s-6Uw7p8vtgSwg" \
      https://storage.googleapis.com/www.example.com?websiteConfig

Load-Balancer und SSL-Zertifikat einrichten

Da Cloud Storage allein keine benutzerdefinierten Domains mit HTTPS unterstützt, müssen Sie auch ein SSL-Zertifikat einrichten, das an einen HTTPS-Load-Balancer angehängt ist, um Ihre Website über HTTPS bereitzustellen. In diesem Abschnitt wird beschrieben, wie Sie Ihren Bucket zum Back-End eines Load-Balancers hinzufügen und wie Sie ein neues von Google verwaltetes SSL-Zertifikat zum Front-End des Load-Balancers hinzufügen.

  1. Öffnen Sie in der Google Cloud Console die Seite "Load-Balancing".
    Zur Seite "Load-Balancing"
  2. Klicken Sie unter HTTP(S)-Load-Balancing auf Konfiguration starten.
  3. Wählen Sie Vom Internet zu meinen VMs aus und klicken Sie auf Weiter.
  4. Geben Sie dem Load-Balancer einen Namen, z. B. example-lb.

Back-End konfigurieren

  1. Klicken Sie auf Back-End-Konfiguration.
  2. Öffnen Sie im Drop-down-Menü Back-End-Dienste und Back-End-Buckets erstellen oder auswählen das Untermenü Back-End-Buckets und klicken Sie auf die Option Back-End-Bucket erstellen.
  3. Wählen Sie einen Namen für den Back-End-Bucket aus, z. B. example-bucket.
  4. Klicken Sie unter Cloud Storage-Bucket auf Durchsuchen.
  5. Wählen Sie den Bucket www.example.com aus und klicken Sie auf Auswählen.
  6. Klicken Sie auf Erstellen.

Hostregeln und Pfad-Matcher konfigurieren

Hostregeln und Pfad-Matcher sind Konfigurationskomponenten der URL-Zuordnung eines externen HTTP(S)-Load-Balancers.

  1. Klicken Sie auf Host- und Pfadregeln.
  2. Übernehmen Sie bei dem zuvor erstellten Back-End-Bucket example-bucket für Mode die Standardeinstellung Einfache Host- und Pfadregel.

Front-End konfigurieren

In diesem Abschnitt wird beschrieben, wie Sie das HTTPS-Protokoll konfigurieren und ein SSL-Zertifikat erstellen. Sie können auch ein vorhandenes Zertifikat auswählen oder ein selbstverwaltetes SSL-Zertifikat hochladen.

  1. Klicken Sie auf Front-End-Konfiguration.
  2. Konfigurieren Sie die Werte der folgenden Felder:

  3. Im Feld IP-Adresse:

    1. Klicken Sie im Drop-down-Menü auf IP-Adresse erstellen.
    2. Geben Sie im Pop-up-Fenster Neue statische IP-Adresse reservieren als Name der IP-Adresse example-ip ein.
    3. Klicken Sie auf Reservieren.
  4. Wählen Sie für Port die Option 443 aus.

  5. Wählen Sie im Feld Zertifikat die Option Neues Zertifikat erstellen aus. Das Formular zur Zertifikaterstellung wird in einem Steuerfeld angezeigt. Nehmen Sie folgende Einstellungen vor:

    • Name: example-ssl
    • Erstellungsmodus: Von Google verwaltetes Zertifikat erstellen
    • Domains: www.example.com. Wenn Sie Ihre Inhalte über zusätzliche Domains wie die Stammdomain example.com bereitstellen möchten, drücken Sie die Eingabetaste, um sie in weiteren Zeilen hinzuzufügen. Jedes Zertifikat hat ein Limit von 100 Domains.
  6. Klicken Sie auf Erstellen.

  7. Klicken Sie auf Fertig.

Konfiguration prüfen

  1. Klicken Sie auf Prüfen und abschließen.
  2. Prüfen Sie die Back-End-Konfiguration, die Host- und Pfadregeln und die Front-End-Konfiguration.
  3. Klicken Sie auf Erstellen.

Möglicherweise müssen Sie einige Minuten warten, bis der Load-Balancer erstellt wurde.

Domain mit dem Load-Balancer verbinden

Klicken Sie nach der Erstellung des Load-Balancers auf dessen Namen: example-lb. Notieren Sie die mit dem Load-Balancer verknüpfte IP-Adresse, z. B. 30.90.80.100. Wenn Sie Ihre Domain auf den Load-Balancer verweisen möchten, erstellen Sie mit Ihrem Domain-Registrierungsdienst einen A-Eintrag. Wenn Sie Ihrem SSL-Zertifikat mehrere Domains hinzugefügt haben, müssen Sie für jede Domain einen A-Eintrag hinzufügen, der auf die IP-Adresse des Load-Balancers verweist. So erstellen Sie beispielsweise A-Einträge für www.example.com und example.com:

NAME                  TYPE     DATA
www                   A        30.90.80.100
@                     A        30.90.80.100

Weitere Informationen zur Verwendung von Google Domains finden Sie unter A- oder CNAME-Einträge erstellen.

Es kann 60 bis 90 Minuten dauern, bis Google Cloud das Zertifikat bereitstellt und die Website über den Load-Balancer verfügbar macht. So überwachen Sie den Status Ihres Zertifikats:

Console

  1. Öffnen Sie in der Google Cloud Console die Seite "Load-Balancing".
    Zur Seite "Load-Balancing"
  2. Klicken Sie auf den Namen Ihres Load-Balancers: example-lb.
  3. Klicken Sie auf den Namen des SSL-Zertifikats, das dem Load-Balancer zugeordnet ist: example-ssl.
  4. In den Zeilen Status und Domainstatus wird der Status des Zertifikats angezeigt. Beide müssen aktiv sein, damit das Zertifikat für Ihre Website gültig ist.

gcloud

  1. Führen Sie den folgenden Befehl aus, um den Zertifikatstatus zu prüfen:

    gcloud beta compute ssl-certificates describe certificate-name \
      --global \
      --format="get(name,managed.status)"
    
  2. Führen Sie den folgenden Befehl aus, um den Domainstatus zu prüfen:

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

Weitere Informationen zum Zertifikatstatus finden Sie unter Fehlerbehebung bei SSL-Zertifikaten.

Website testen

Sobald das SSL-Zertifikat aktiv ist, prüfen Sie, ob Inhalte aus dem Bucket bereitgestellt werden. Rufen Sie dazu https://www.example.com/test.html auf, wobei test.html ein Objekt ist, das in einem Bucket namens www.example.com gespeichert ist. Wenn Sie das Attribut MainPageSuffix festlegen, führt https://www.example.com zu index.html.

Bereinigen

Nachdem Sie die Anleitung zum Hosten einer statischen Website abgeschlossen haben, können Sie die Ressourcen, die Sie in Google Cloud erstellt haben, bereinigen, damit diese keine kostenpflichtigen Kontingente verbrauchen. In den folgenden Abschnitten erfahren Sie, wie Sie diese Ressourcen löschen oder deaktivieren.

Projekt löschen

Am einfachsten vermeiden Sie weitere Kosten, wenn Sie das zum Ausführen der Anleitung erstellte Projekt löschen.

So löschen Sie das Projekt:

  1. Wechseln Sie in der Cloud Console zur Seite Ressourcen verwalten.

    Zur Seite "Ressourcen verwalten"

  2. Wählen Sie in der Projektliste das Projekt aus, das Sie löschen möchten, und klicken Sie dann auf Löschen .
  3. Geben Sie im Dialogfeld die Projekt-ID ein und klicken Sie auf Beenden, um das Projekt zu löschen.

Load-Balancer und Bucket löschen

Wenn Sie nicht das gesamte Projekt löschen möchten, löschen Sie den Load-Balancer und den Bucket, den Sie für die Anleitung erstellt haben:

  1. Öffnen Sie in der Google Cloud Console die Seite "Load-Balancing".
    Zur Seite "Load-Balancing"
  2. Klicken Sie das Kästchen neben example-lb an.
  3. Klicken Sie auf Löschen.
  4. Optional: Klicken Sie das Kästchen neben den Ressourcen an, die Sie zusammen mit dem Load-Balancer löschen möchten, z. B. den Bucket www.example.com oder das SSL-Zertifikat example-ssl.
  5. Klicken Sie auf Load-Balancer löschen oder Load-Balancer und ausgewählte Ressourcen löschen.

Weitere Informationen