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 einem externen -Application Load Balancer 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 unter Fehlerbehebung: HTTPS-Bereitstellung. 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“.

Achtung: In dieser Anleitung werden Inhalte für das öffentliche Internet verfügbar gemacht. Wir empfehlen, keine Inhalte bereitzustellen, die vertrauliche oder private Daten aus Ihrem Cloud Storage-Bucket enthalten.

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.

Vorbereitung

1. 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.

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

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

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

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

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

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

6. Aktivieren Sie die Compute Engine API für Ihr Projekt.
7. Sie benötigen die folgenden Rollen für die Identitäts- und Zugriffsverwaltung: Storage-Administrator und Compute-Netzwerkadministrator.
8. Haben oder verwalten Sie eine Domain? Wenn Sie noch keine Domain haben, können Sie eine neue registrieren. Dazu stehen Ihnen viele Dienste wie Cloud Domains zur Verfügung.

   In dieser Anleitung wird die Domain example.com verwendet.

9. 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.
10. (Optional) Wenn Ihr Cloud Storage-Bucket denselben Namen wie Ihre Domain haben soll, müssen Sie bestätigen, dass Sie der Inhaber oder Verwalter der von Ihnen verwendeten Domain sind. Verifizieren Sie unbedingt die Top-Level-Domain wie example.com und keine Subdomain wie www.example.com. Wenn Sie Ihre Domain über Cloud Domains erworben haben, erfolgt die Überprüfung automatisch.

Hinweis: Informationen zum Einrichten Ihrer Domain mit Cloud DNS finden Sie unter Domain mit Cloud DNS einrichten.

Bucket erstellen

So erstellen Sie einen Bucket:

Console

1. Wechseln Sie in der Cloud Console zur Seite Cloud Storage-Buckets.
   

   Buckets aufrufen

2. Klicken Sie auf + Erstellen.
3. Geben Sie auf der Seite Bucket erstellen die Bucket-Informationen ein. Klicken Sie auf Weiter, um mit dem nächsten Schritt fortzufahren.
   • Geben Sie unter Bucket benennen einen Namen ein, der den Anforderungen für Bucket-Namen entspricht.
   • Wählen Sie unter Speicherort für Daten auswählen einen Standorttyp und die Option Standort aus, unter dem die Bucket-Daten dauerhaft gespeichert werden.
   • Wählen Sie unter Speicherklasse für Daten auswählen eine Standardspeicherklasse für den Bucket oder Autoclass für die automatische Speicherklassenverwaltung der Daten Ihres Buckets aus.

     Hinweis: Im Feld Schätzung monatliche Kosten im rechten Bereich finden Sie eine Schätzung der monatlichen Kosten für den Bucket auf der Grundlage der ausgewählten Speicherklasse und des ausgewählten Standorts sowie der erwarteten Datengröße und der erwarteten Vorgänge.

   • Für Wählen Sie aus, wie der Zugriff auf Objekte gesteuert werden soll wählen Sie aus, ob Ihr Bucket Verhinderung des öffentlichen Zugriffs erzwingen soll und wählen Sie ein Modell für die Zugriffssteuerung für die Objekte Ihres Buckets aus.

     Hinweis: Wenn die Verhinderung des öffentlichen Zugriff bereits durch die Organisationsrichtlinie Ihres Projekts erzwungen wird, ist die Schaltfläche Öffentlichen Zugriff verhindern gesperrt.

   • Konfigurieren Sie für Festlegen, wie Objektdaten geschützt werden sollen bei Bedarf Schutztools und wählen Sie eine Methode für die Datenverschlüsselung aus.
4. Klicken Sie auf Erstellen.

Unter Fehlerbehebung erfahren Sie, wie Sie detaillierte Fehlerinformationen zu fehlgeschlagenen Cloud Storage-Vorgängen in der Google Cloud Console abrufen.

Befehlszeile

Hinweis: Cloud Shell stellt eine temporäre virtuelle Maschine bereit. Wenn Sie Objekte in Cloud Storage hochladen oder aus Cloud Storage herunterladen möchten, verwenden Sie eine lokale Entwicklungsumgebung.

1. 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.

2. Führen Sie in Ihrer Entwicklungsumgebung den Befehl gcloud storage buckets create aus:

   gcloud storage buckets create gs://BUCKET_NAME --location=BUCKET_LOCATION

   Wobei:

   • BUCKET_NAME ist der Name, den Sie Ihrem Bucket zuweisen möchten. Beachten Sie dabei die Anforderungen für Bucket-Namen. Beispiel: my-bucket.
   • BUCKET_LOCATION ist der Standort des Buckets. Beispiel: us-east1

   Wenn die Anfrage erfolgreich ist, gibt der Befehl die folgende Meldung zurück:

   Creating gs://BUCKET_NAME/...

   Mit den folgenden optionalen Flags können Sie das Erstellen des Buckets noch genauer steuern:

   • --project: Geben Sie die ID oder Nummer des Projekts an, mit dem der Bucket verknüpft wird. Beispiel: my-project
   • --default-storage-class: Geben Sie die Standardspeicherklasse des Buckets an. Beispiel: STANDARD
   • --soft-delete-duration: Geben Sie die Aufbewahrungsdauer für vorläufiges Löschen des Buckets an. Beispiel: 2w1d
   • --uniform-bucket-level-access: Aktivieren Sie den einheitlichen Zugriff auf Bucket-Ebene für Ihren Bucket.

   Eine vollständige Liste der Optionen für die Erstellung von gcloud-Buckets finden Sie unter buckets create-Optionen.

   Beispiel:

   gcloud storage buckets create gs://BUCKET_NAME --project=PROJECT_ID --default-storage-class=STORAGE_CLASS --location=BUCKET_LOCATION --uniform-bucket-level-access

Clientbibliotheken

Hinweis: Weitere Optionen zum Erstellen eines neuen Buckets finden Sie in der JSON API-Referenz zu bucket.insert.

C++

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

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Storage zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

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#

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

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Storage zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

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

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

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Storage zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

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

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

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Storage zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

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.

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Storage zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

/**
 * 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

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

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Storage zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

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

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

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Storage zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

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

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

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Storage zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

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

Sie können eine Terraform-Ressource zum Erstellen eines Storage-Buckets verwenden.

Das folgende Beispiel umfasst die Zuweisung eines Indexseitensuffixes und einer benutzerdefinierten Fehlerseite. Weitere Informationen finden Sie unter Spezialseiten zuweisen.

# 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 APIs

JSON API

1. Installieren und initialisieren Sie die dcloud CLI, um ein Zugriffstoken für den Header Authorization zu generieren.

   Alternativ können Sie mit dem OAuth 2.0 Playground ein Zugriffstoken erstellen und in den Header Authorization einfügen.

2. Erstellen Sie eine JSON-Datei mit den Einstellungen für den Bucket, darunter auch ein name für den Bucket. Eine vollständige Liste der Einstellungen finden Sie in der Dokumentation zu Buckets:Insert. Folgende Einstellungen können verwendet werden:

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

Wobei:

• BUCKET_NAME ist der Name, den Sie dem Bucket gemäß den Benennungsanforderungen geben möchten. Beispiel: my-bucket
• BUCKET_LOCATION ist der Standort, an dem Sie die Objektdaten Ihres Buckets speichern möchten. Beispiel: US-EAST1
• STORAGE_CLASS ist die Standardspeicherklasse Ihres Buckets. Beispiel: STANDARD
3. Verwenden Sie cURL zum Aufrufen der 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"

   Wobei:

   • JSON_FILE_NAME ist der Name der JSON-Datei, die Sie in Schritt 2 erstellt haben.
   • PROJECT_IDENTIFIER ist die ID oder Nummer des Projekts, mit dem Ihr Bucket verknüpft wird. Beispiel: my-project

XML API

1. Die gcloud CLI installieren und initialisieren, um ein Zugriffstoken für den Header Authorization zu generieren.

   Alternativ können Sie mit dem OAuth 2.0 Playground ein Zugriffstoken erstellen und in den Header Authorization einfügen.

2. Erstellen Sie eine XML-Datei, die Einstellungen für den Bucket enthält. Eine vollständige Liste der Einstellungen finden Sie in der Dokumentation XML: Bucket erstellen. Folgende Einstellungen können verwendet werden:

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

Wobei:

• BUCKET_LOCATION ist der Standort, an dem Sie die Objektdaten Ihres Buckets speichern möchten. Beispiel: US-EAST1
• STORAGE_CLASS ist die Standardspeicherklasse Ihres Buckets. Beispiel: STANDARD
3. Verwenden Sie cURL zum Aufrufen der 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"

   Wobei:

   • XML_FILE_NAME ist der Name der XML-Datei, die Sie in Schritt 2 erstellt haben.
   • PROJECT_ID ist die ID des Projekts, mit dem Ihr Bucket verknüpft wird. Beispiel: my-project
   • BUCKET_NAME ist der Name, den Sie Ihrem Bucket gemäß den Benennungsanforderungen zuweisen möchten. Beispiel: my-bucket

Dateien meiner Website hochladen

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

Console

1. Wechseln Sie in der Cloud Console zur Seite Cloud Storage-Buckets.
   

   Buckets aufrufen

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. Navigieren 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 detaillierte Fehlerinformationen zu fehlgeschlagenen Cloud Storage-Vorgängen in der Google Cloud Console abrufen.

Befehlszeile

Verwenden Sie den Befehl gcloud storage cp, um Dateien in den Bucket zu kopieren. So kopieren Sie beispielsweise die Datei index.html von ihrem aktuellen Speicherort Desktop in den Bucket my-static-assets:

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

Wenn der Vorgang erfolgreich ausgeführt wurde, sieht die Antwort in etwa so aus:

Completed files 1/1 | 164.3kiB/164.3kiB

Clientbibliotheken

C++

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

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Storage zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

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#

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

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Storage zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

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

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

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Storage zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

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

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

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Storage zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

Im folgenden Beispiel wird ein einzelnes Objekt hochgeladen:

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

Im folgenden Beispiel werden mehrere Objekte gleichzeitig hochgeladen:

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

Im folgenden Beispiel werden alle Objekte mit einem gemeinsamen Präfix gleichzeitig hochgeladen:

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

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

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Storage zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

Im folgenden Beispiel wird ein einzelnes Objekt hochgeladen:

/**
 * 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);

Im folgenden Beispiel werden mehrere Objekte gleichzeitig hochgeladen:

/**
 * 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);

Im folgenden Beispiel werden alle Objekte mit einem gemeinsamen Präfix gleichzeitig hochgeladen:

/**
 * 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

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

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Storage zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

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

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

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Storage zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

Im folgenden Beispiel wird ein einzelnes Objekt hochgeladen:

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

Im folgenden Beispiel werden mehrere Objekte gleichzeitig hochgeladen:

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

Im folgenden Beispiel werden alle Objekte mit einem gemeinsamen Präfix gleichzeitig hochgeladen:

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

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

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Storage zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

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 APIs

JSON API

1. Installieren und initialisieren Sie die dcloud CLI, um ein Zugriffstoken für den Header Authorization zu generieren.

   Alternativ können Sie mit dem OAuth 2.0 Playground ein Zugriffstoken erstellen und in den Header Authorization einfügen.

2. Verwenden Sie cURL, um die JSON API mit einer POST-Objektanfrage aufzurufen: Für die Datei index.html, die in einen Bucket mit dem Namen my-static-assets hochgeladen wurde:

   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

1. Die gcloud CLI installieren und initialisieren, um ein Zugriffstoken für den Header Authorization zu generieren.

   Alternativ können Sie mit dem OAuth 2.0 Playground ein Zugriffstoken erstellen und in den Header Authorization einfügen.

2. Verwenden Sie cURL, um die XML API mit einer PUT-Objektanfrage aufzurufen: Für die Datei index.html, die in einen Bucket mit dem Namen my-static-assets hochgeladen wurde:

   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"

Dateien freigeben

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

Achtung: Bevor Sie den Bucket öffentlich zugänglich machen, sollten Sie sicher sein, dass die Dateien im Bucket keine vertraulichen oder privaten Informationen enthalten.

Console

1. Wechseln Sie in der Cloud Console zur Seite Cloud Storage-Buckets.
   

   Buckets aufrufen

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. Wenn im Bereich Öffentlicher Zugriff Nicht öffentlich angezeigt wird, klicken Sie auf die Schaltfläche Verhinderung des öffentlichen Zugriffs entfernen und dann im angezeigten Dialogfeld auf Bestätigen.

5. Klicken Sie auf die Schaltfläche Zugriff gewähren.

   Das Dialogfeld Hauptkonten hinzufügen wird angezeigt.

6. Geben Sie im Feld Neue Hauptkonten allUsers ein.

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

8. Klicken Sie auf Speichern.

9. 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 detaillierte Fehlerinformationen zu fehlgeschlagenen Cloud Storage-Vorgängen in der Google Cloud Console abrufen.

Befehlszeile

Führen Sie den Befehl buckets add-iam-policy-binding aus:

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

Clientbibliotheken

C++

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

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Storage zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

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#

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

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Storage zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

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

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

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Storage zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

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

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

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Storage zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

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

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

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Storage zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

/**
 * 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

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

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Storage zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

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

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

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Storage zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

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

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

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Storage zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

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 APIs

JSON API

1. Installieren und initialisieren Sie die dcloud CLI, um ein Zugriffstoken für den Header Authorization zu generieren.

   Alternativ können Sie mit dem OAuth 2.0 Playground ein Zugriffstoken erstellen und in den Header Authorization einfügen.

2. Erstellen Sie eine JSON-Datei, die folgende 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 \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json" \
     "https://storage.googleapis.com/storage/v1/b/BUCKET_NAME/iam"

   Dabei gilt:

   • JSON_FILE_NAME ist der Pfad für die JSON-Datei, die Sie in Schritt 2 erstellt haben.
   • BUCKET_NAME ist der Name des Buckets, dessen Objekte Sie veröffentlichen möchten. Beispiel: my-static-assets

XML API

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

Hinweis: roles/storage.objectViewer umfasst Berechtigungen zum Auflisten der Objekte im Bucket. Wenn Sie den Eintrag nicht öffentlich vergeben möchten, verwenden Sie roles/storage.legacyObjectReader.

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 und eine benutzerdefinierte Fehlerseite zuweisen, die als Spezialseiten bezeichnet werden. Beide Zuweisungen sind optional. Wenn Sie jedoch kein Suffix für die Indexseite zuweisen und die entsprechende Indexseite hochladen, wird Nutzern, die auf Ihre Top-Level-Website zugreifen, eine XML-Dokumentstruktur mit einer Liste der öffentlichen Objekte in Ihrem Bucket angezeigt.

Weitere Informationen zum Verhalten von Spezialseiten finden Sie unter Spezialseiten.

Console

1. Wechseln Sie in der Cloud Console zur Seite Cloud Storage-Buckets.
   

   Buckets aufrufen

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.

Hinweis: Sie können diese Einstellungen im Menü Websitekonfiguration bearbeiten ansehen, ändern oder entfernen.

Unter Fehlerbehebung erfahren Sie, wie Sie detaillierte Fehlerinformationen zu fehlgeschlagenen Cloud Storage-Vorgängen in der Google Cloud Console abrufen.

Befehlszeile

Verwenden Sie den buckets update-Befehl mit den Flags --web-main-page-suffix und --web-error-page.

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

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

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

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

Hinweis: Sie können diese Einstellungen mit zusätzlichen buckets update-Befehlen ändern oder entfernen und mit dem buckets describe-Befehl ansehen.

Clientbibliotheken

C++

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

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Storage zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

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#

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

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Storage zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

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

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

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Storage zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

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

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

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Storage zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

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

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

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Storage zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

/**
 * 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

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

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Storage zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

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

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

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Storage zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

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

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

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Storage zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

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 APIs

JSON API

1. Installieren und initialisieren Sie die dcloud CLI, um ein Zugriffstoken für den Header Authorization zu generieren.

   Alternativ können Sie mit dem OAuth 2.0 Playground ein Zugriffstoken erstellen und in den Header Authorization einfügen.

2. Erstellen Sie eine JSON-Datei, die die Attribute mainPageSuffix und notFoundPage in einem website-Objekt auf die gewünschten Seiten festlegt:

   Im folgenden Beispiel ist mainPageSuffix auf index.html und notFoundPage auf 404.html festgelegt:

   {
     "website":{
       "mainPageSuffix": "index.html",
       "notFoundPage": "404.html"
     }
   }

3. Verwenden Sie cURL, um die JSON API mit einer PATCH-Bucket-Anfrage aufzurufen. Für den 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

1. Die gcloud CLI installieren und initialisieren, um ein Zugriffstoken für den Header Authorization zu generieren.

   Alternativ können Sie mit dem OAuth 2.0 Playground ein Zugriffstoken erstellen und in den Header Authorization einfügen.

2. Erstellen Sie eine XML-Datei, die die Elemente MainPageSuffix und NotFoundPage in einem WebsiteConfiguration-Element auf die gewünschten Seiten festlegt.

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

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

Hinweis: Sie können diese Einstellungen mit zusätzlichen PUT-Anfragen ändern oder entfernen und mit einer GET-Anfrage ansehen.

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 Backend eines Load-Balancers hinzufügen und wie Sie ein neues von Google verwaltetes SSL-Zertifikat zum Frontend des Load-Balancers hinzufügen.

Konfiguration starten

1. Rufen Sie in der Google Cloud Console die Seite Load-Balancing auf.

   Load-Balancing aufrufen

2. Klicken Sie auf Load-Balancer erstellen.
3. Wählen Sie unter Typ des Load Balancers die Option Application Load Balancer (HTTP/HTTPS) aus und klicken Sie auf Weiter.
4. Wählen Sie für Öffentlich oder intern die Option Öffentlich (extern) aus und klicken Sie auf Weiter.
5. Wählen Sie unter Globale oder Einzelregion-Bereitstellung die Option Am besten für globale Arbeitslasten aus und klicken Sie auf Weiter.
6. Wählen Sie unter Generation des Load Balancers die Option Klassischer Application Load Balancer aus und klicken Sie auf Weiter.
7. Klicken Sie auf Konfigurieren.

Das Konfigurationsfenster für den Load-Balancer wird angezeigt.

Grundlegende Konfiguration

Bevor Sie mit der Konfiguration fortfahren, geben Sie einen Namen des Load-Balancers ein, z. B. example-lb.

Frontend 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 Frontend-Konfiguration.
2. (Optional) Geben Sie einen Namen für Ihre Frontend-Konfiguration ein.
3. Wählen Sie für Protokoll die Option HTTPS (einschließlich HTTP/2) aus.
4. Setzen Sie die IP-Version auf IPv4. Wenn Sie IPv6 bevorzugen, finden Sie weitere Informationen unter IPv6-Beendigung.

5. Im Feld IP-Adresse:

   • Klicken Sie im Drop-down-Menü auf IP-Adresse erstellen.
   • Geben Sie im Pop-up-Fenster Neue statische IP-Adresse reservieren einen Namen ein, z. B. example-ip als Namen der IP-Adresse.
   • Klicken Sie auf Reservieren.
   Hinweis: Wenn Sie eine neue statische IP-Adresse reservieren, fallen zusätzliche Kosten an, wenn die IP-Adresse nicht an eine Weiterleitungsregel angehängt ist. Um diese Kosten zu vermeiden, löschen Sie die statische IP-Adresse, wenn Sie den zugehörigen Load-Balancer löschen.

6. Wählen Sie für Port die Option 443 aus.

7. Wählen Sie im Drop-down-Menü Zertifikat die Option Neues Zertifikat erstellen aus. Das Formular zur Zertifikaterstellung wird in einem Steuerfeld angezeigt. Nehmen Sie folgende Einstellungen vor:

   • Geben Sie Ihrem Zertifikat einen Namen, z. B. example-ssl.
   • Wählen Sie für Erstellungsmodus die Option Von Google verwaltetes Zertifikat erstellen aus.
   • Geben Sie unter Domains den Namen Ihrer Website ein, z. B. 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.

8. Klicken Sie auf Erstellen.

9. (Optional) Wenn Sie möchten, dass Google Cloud automatisch einen partiellen HTTP-Load-Balancer für die Weiterleitung von HTTP-Traffic einrichtet, markieren Sie das Kästchen neben HTTP-zu-HTTPS-Weiterleitung aktivieren.

10. Klicken Sie auf Fertig.

Backend konfigurieren

1. Klicken Sie auf Backend-Konfiguration.
2. Klicken Sie im Drop-down-Menü Backend-Dienste und Backend-Buckets auf Backend-Bucket erstellen.
3. Wählen Sie einen Backend-Bucket-Namen aus, z. B. example-bucket. Der ausgewählte Name kann sich vom Namen des zuvor erstellten Buckets unterscheiden.
4. Klicken Sie im Feld Cloud Storage-Bucket auf Durchsuchen.
5. Wählen Sie den zuvor erstellten Bucket my-static-assets aus und klicken Sie auf Auswählen.
6. (Optional) Wenn Sie Cloud CDN verwenden möchten, klicken Sie das Kästchen für Cloud CDN aktivieren an und konfigurieren Sie Cloud CDN nach Bedarf. Für Cloud CDN können jedoch zusätzliche Kosten anfallen.
7. Klicken Sie auf Erstellen.

Routingregeln konfigurieren

Routingregeln sind die Komponenten der URL-Zuordnung eines externen Application Load Balancers. Für diese Anleitung sollten Sie diesen Teil der Konfiguration des Load-Balancers überspringen, da er automatisch auf die Verwendung des soeben konfigurierten Back-Ends eingestellt ist.

Konfiguration prüfen

1. Klicken Sie auf Prüfen und abschließen.
2. Überprüfen Sie das Frontend, die Routingregeln und das Backend.
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

Empfohlen: Status des SSL-Zertifikats beobachten

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".
   Gehe zu „Load-Balancing“
2. Klicken Sie auf den Namen des 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.

Befehlszeile

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

   gcloud 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 compute ssl-certificates describe CERTIFICATE_NAME \
     --global \
     --format="get(managed.domainStatus)"
   

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

Website testen

Prüfen Sie nach Aktivierung des SSL-Zertifikats, ob der Inhalt aus dem Bucket bereitgestellt wird. Rufen Sie dazu https://www.example.com/test.html auf, wobei test.html ein Objekt ist, das in dem Bucket gespeichert ist, den Sie als Backend verwenden. Wenn Sie das Attribut MainPageSuffix festlegen, führt https://www.example.com zu index.html.

Bereinigen

Nachdem Sie die Anleitung abgeschlossen haben, können Sie die erstellten Ressourcen bereinigen, damit sie keine Kontingente mehr nutzen und keine Gebühren mehr anfallen. In den folgenden Abschnitten erfahren Sie, wie Sie diese Ressourcen löschen oder deaktivieren.

Projekt löschen

Am einfachsten vermeiden Sie weitere Kosten durch Löschen des für die Anleitung erstellten Projekts.

So löschen Sie das Projekt:

Achtung: Das Löschen von Projekten hat folgende Auswirkungen:

• Alle Inhalte des Projekts werden gelöscht. Wenn Sie für die Aufgaben in diesem Dokument ein bereits bestehendes Projekt verwendet haben und dieses löschen, werden auch alle anderen im Rahmen des Projekts erstellten Daten gelöscht.
• Benutzerdefinierte Projekt-IDs gehen verloren. Beim Erstellen dieses Projekts haben Sie möglicherweise eine benutzerdefinierte Projekt-ID erstellt, die Sie weiterhin verwenden möchten. Damit die URLs, die die Projekt-ID nutzen, z. B. eine appspot.com-URL, erhalten bleiben, sollten Sie ausgewählte Ressourcen innerhalb des Projekts löschen, statt das gesamte Projekt.

Wenn Sie mehrere Architekturen, Anleitungen und Kurzanleitungen durcharbeiten möchten, können Sie die Überschreitung von Projektkontingenten verhindern, indem Sie Projekte wiederverwenden.

1. In the Google Cloud console, go to the Manage resources page.

   Go to Manage resources

2. In the project list, select the project that you want to delete, and then click Delete.
3. In the dialog, type the project ID, and then click Shut down to delete the project.

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".
   Gehe zu „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 my-static-assets oder das SSL-Zertifikat example-ssl.
5. Klicken Sie auf Load-Balancer löschen oder Load-Balancer und ausgewählte Ressourcen löschen.

Hinweis: Wenn Sie nur den Bucket löschen möchten, den Sie erstellt haben, folgen Sie der Anleitung unter Buckets löschen.

Reservierte IP-Adresse freigeben

So löschen Sie die reservierte IP-Adresse, die Sie für diese Anleitung verwendet haben:

1. Rufen Sie in der Google Cloud Console die Seite Externe IP-Adressen auf.

   Zu externen IP-Adressen

2. Klicken Sie auf die Kästchen neben example-ip.

3. Klicken Sie auf Statische Adresse freigeben.

4. Klicken Sie im Bestätigungsfenster auf Löschen.

Nächste Schritte

• Beispiele und Tipps für die Verwendung von Buckets zum Hosten einer statischen Website.
• Fehlerbehebung beim Hosten einer statischen Website
• Statische Inhalte für eine dynamische Website hosten
• Andere Web-Serving-Lösungen von Google Cloud

Überzeugen Sie sich selbst

Wenn Sie mit Google Cloud noch nicht vertraut sind, erstellen Sie ein Konto, um die Leistungsfähigkeit von Cloud Storage in der Praxis sehen und bewerten zu können. Neukunden erhalten außerdem ein Guthaben von 300 $, um Arbeitslasten auszuführen, zu testen und bereitzustellen.

Cloud Storage kostenlos testen