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

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.

Hinweis

1. Melden Sie sich bei Ihrem Google Cloud-Konto an. Wenn Sie mit Google Cloud noch nicht vertraut sind, erstellen Sie ein Konto, um die Leistungsfähigkeit unserer Produkte 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.

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

   Hinweis: Wenn Sie die Ressourcen, die Sie in diesem Verfahren erstellen, nicht behalten möchten, erstellen Sie ein Projekt, anstatt ein vorhandenes Projekt auszuwählen. Wenn Sie fertig sind, können Sie das Projekt löschen und dadurch alle mit dem Projekt verknüpften Ressourcen entfernen.

   Zur Projektauswahl

3. Die Abrechnung für das 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. 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.
6. Sie benötigen die folgenden Rollen für die Identitäts- und Zugriffsverwaltung: Storage-Objekt-Administrator und Netzwerkadministrator.
7. (Optional) Sie können Ihrem Cloud Storage-Bucket den gleichen Namen wie Ihre Domain geben. Dazu müssen Sie bestätigen, dass Sie der Inhaber oder Verwalter der Domain sind, 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 die Domain besitzen, die Sie einem Bucket zuordnen, haben Sie diesen Schritt möglicherweise bereits in der Vergangenheit durchgeführt. Wenn Sie Ihre Domain über Google 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 zum Cloud Storage-Browser.
   

   Browser aufrufen

2. Klicken Sie auf Bucket 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 Standardspeicherklasse für Ihre Daten auswählen eine Speicherklasse für den Bucket aus. Die Standardspeicherklasse wird standardmäßig allen in den Bucket hochgeladenen Objekten zugewiesen.

     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 einen Zugriffskontrolle Modell 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.

   • Für Erweiterte Einstellungen (optional), fügen Sie Bucket-Labels hinzu, festlegen Aufbewahrungsrichtlinie und wählen Sie eine Verschlüsselungsmethode.
4. Klicken Sie auf Erstellen.

Informationen zum Abrufen detaillierter Fehlerinformationen zu fehlgeschlagenen Vorgängen im Cloud Storage-Browser finden Sie unter Fehlerbehebung.

gsutil

Führen Sie folgenden Befehl gsutil mb aus:

gsutil mb gs://BUCKET_NAME

Dabei gilt:

• BUCKET_NAME ist der Name, den Sie dem Bucket gemäß den Benennungsanforderungen geben möchten. Beispiel: my-bucket.

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:

• -p: Geben Sie das Projekt an, mit dem der Bucket verknüpft wird. Beispiel: my-project
• -c: Geben Sie die Standardspeicherklasse des Buckets an. Beispiel: NEARLINE
• -l: Geben Sie den Standort des Buckets an. Beispiel: US-EAST1
• -b: Aktivieren Sie den einheitlichen Zugriff auf Bucket-Ebene für Ihren Bucket.

Beispiel:

  gsutil mb -p PROJECT_ID -c STORAGE_CLASS -l BUCKET_LOCATION -b on gs://BUCKET_NAME

Codebeispiele

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.

Auf GitHub ansehen Feedback

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

Auf GitHub ansehen Feedback

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.

Auf GitHub ansehen Feedback

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.

Auf GitHub ansehen Feedback

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.

Auf GitHub ansehen Feedback

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

Auf GitHub ansehen Feedback

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.
 */
function create_bucket_class_location($bucketName)
{
    // $bucketName = 'my-bucket';

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

Auf GitHub ansehen Feedback

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.

Auf GitHub ansehen Feedback

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

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 mit den Einstellungen für den Bucket, der ein name für den Bucket enthalten muss. 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
    },
  }
}

Dabei gilt:

• 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: NEARLINE
3. Verwenden Sie cURL zum Aufrufen der JSON API:

   curl -X POST --data-binary @JSON_FILE_NAME.json \
        -H "Authorization: Bearer OAUTH2_TOKEN" \
        -H "Content-Type: application/json" \
        "https://storage.googleapis.com/storage/v1/b?project=PROJECT_ID"

   Dabei gilt:

   • JSON_FILE_NAME ist der Name der JSON-Datei, die Sie in Schritt 2 erstellt haben.
   • OAUTH2_TOKEN ist das Zugriffstoken, das Sie in Schritt 1 generiert haben.
   • PROJECT_ID ist die ID des Projekts, mit dem Ihr Bucket verknüpft wird. Beispiel: my-project.

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 folgenden Informationen enthält:

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

Dabei gilt:

• 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: NEARLINE
3. Verwenden Sie cURL zum Aufrufen der XML API:

   curl -X PUT --data-binary @XML_FILE_NAME.xml \
        -H "Authorization: Bearer OAUTH2_TOKEN" \
        -H "x-goog-project-id: PROJECT_ID" \
        "https://storage.googleapis.com/BUCKET_NAME"

   Dabei gilt:

   • XML_FILE_NAME ist der Name der XML-Datei, die Sie in Schritt 2 erstellt haben.
   • OAUTH2_TOKEN ist das Zugriffstoken, das Sie in Schritt 1 generiert 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 zum Cloud Storage-Browser.
   

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

Informationen zum Abrufen detaillierter Fehlerinformationen zu fehlgeschlagenen Vorgängen im Cloud Storage-Browser finden Sie unter Fehlerbehebung.

gsutil

Verwenden Sie den Befehl gsutil 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:

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

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

Copying file://Desktop/index.html [Content-Type=text/html]...
Uploading   gs://my-static-assets/index.html:       0 B/2.58 KiB
Uploading   gs://my-static-assets/index.html:       2.58 KiB/2.58 KiB

Codebeispiele

C++

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

Auf GitHub ansehen Feedback

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.

Auf GitHub ansehen Feedback

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.

Auf GitHub ansehen Feedback

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.

Auf GitHub ansehen Feedback

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.

Weitere Informationen zum Hochladen eines Streams, eines Strings oder eines Zwischenspeichers finden Sie unter File.save().

Auf GitHub ansehen Feedback

/**
 * 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() {
  await storage.bucket(bucketName).upload(filePath, {
    destination: destFileName,
  });

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

uploadFile().catch(console.error);

PHP

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

Auf GitHub ansehen Feedback

use Google\Cloud\Storage\StorageClient;

/**
 * Upload a file.
 *
 * @param string $bucketName The name of your Cloud Storage bucket.
 * @param string $objectName The name of your Cloud Storage object.
 * @param string $source The path to the file to upload.
 */
function upload_object($bucketName, $objectName, $source)
{
    // $bucketName = 'my-bucket';
    // $objectName = 'my-object';
    // $source = '/path/to/your/file';

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

Auf GitHub ansehen Feedback

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)

    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.

Auf GitHub ansehen Feedback

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

  file = bucket.create_file local_file_path, file_name

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

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 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 ya29.AHES6ZRVmB7fkLtd1XTmq6mo0S1wqZZi3-Lh_s-6Uw7p8vtgSwg" \
     "https://storage.googleapis.com/upload/storage/v1/b/my-static-assets/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 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 ya29.AHES6ZRVmB7fkLtd1XTmq6mo0S1wqZZi3-Lh_s-6Uw7p8vtgSwg" \
     -H "Content-Type: text/html" \
     "https://storage.googleapis.com/my-static-assets/index.html"

Hinweis: Wenn Sie eine vorhandene Website migrieren oder eine große Anzahl von Dateien kopieren, sollten Sie den Inhalt mit gsutil rsync verschieben. Sie können die Option -R verwenden, um Verzeichnisbäume rekursiv zu kopieren. Zum Synchronisieren eines lokalen Verzeichnisses mit dem Namen local-dir mit einem Bucket mit dem Namen my-static-assets verwenden Sie beispielsweise:

gsutil rsync -R local-dir gs://my-static-assets

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 zum Cloud Storage-Browser.
   

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

Informationen zum Abrufen detaillierter Fehlerinformationen zu fehlgeschlagenen Vorgängen im Cloud Storage-Browser finden Sie unter Fehlerbehebung.

gsutil

Führen Sie den Befehl gsutil iam ch aus:

gsutil iam ch allUsers:objectViewer gs://my-static-assets

Codebeispiele

C++

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

Auf GitHub ansehen Feedback

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::runtime_error(current_policy.status().message());
  }

  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::runtime_error(updated.status().message());

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

Go

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

Auf GitHub ansehen Feedback

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: %v", err)
	}
	defer client.Close()

	policy, err := client.Bucket(bucketName).IAM().V3().Policy(ctx)
	if err != nil {
		return fmt.Errorf("Bucket(%q).IAM().V3().Policy: %v", 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: %v", 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.

Auf GitHub ansehen Feedback

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.

Auf GitHub ansehen Feedback

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

Python

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

Auf GitHub ansehen Feedback

from google.cloud import storage

def set_bucket_public_iam(bucket_name):
    """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": {"allUsers"}}
    )

    bucket.set_iam_policy(policy)

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

Ruby

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

Auf GitHub ansehen Feedback

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

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

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.

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 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. Wechseln Sie in der Cloud Console zum Cloud Storage-Browser.
   

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

Informationen zum Abrufen detaillierter Fehlerinformationen zu fehlgeschlagenen Vorgängen im Cloud Storage-Browser finden Sie unter Fehlerbehebung.

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://my-static-assets

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

Setting website config on gs://my-static-assets/...

Hinweis: Sie können diese Einstellungen mit zusätzlichen gsutil web set-Befehlen ändern oder entfernen und mit dem gsutil web get-Befehl ansehen.

Codebeispiele

C++

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

Auf GitHub ansehen Feedback

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

Go

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

Auf GitHub ansehen Feedback

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: %v", 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: %v", bucketName, err)
	}
	fmt.Fprintf(w, "Static website bucket %v is set up to use %v as the index page and %v as the 404 page\n", bucketName, indexPage, notFoundPage)
	return nil
}

Java

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

Auf GitHub ansehen Feedback

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.

Auf GitHub ansehen Feedback

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

Auf GitHub ansehen Feedback

use Google\Cloud\Storage\StorageClient;

/**
 * Update the given bucket's website configuration.
 *
 * @param string $bucketName The name of your Cloud Storage bucket.
 * @param string $indexPageObject the name of an object in the bucket to use as
 *     an index page for a static website bucket.
 * @param string $notFoundPageObject the name of an object in the bucket to use
 *     as the 404 Not Found page.
 */
function define_bucket_website_configuration($bucketName, $indexPageObject, $notFoundPageObject)
{
    // $bucketName = 'my-bucket';
    // $indexPageObject = 'index.html';
    // $notFoundPageObject = '404.html';

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

Auf GitHub ansehen Feedback

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.

Auf GitHub ansehen Feedback

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. 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 den Bucket my-static-assets:

   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/my-static-assets"

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 „my-static-assets”:

   curl -X PUT --data-binary @web-config.xml \
     -H "Authorization: Bearer ya29.AHES6ZRVmB7fkLtd1XTmq6mo0S1wqZZi3-Lh_s-6Uw7p8vtgSwg" \
     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 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 my-static-assets aus und klicken Sie auf Auswählen.
6. Wenn Sie Cloud CDN verwenden möchten, klicken Sie das Kästchen für Cloud CDN aktivieren an. Übernehmen Sie als Auswahl für den Cache-Modus den Wert Statische Inhalte im Cache speichern. Für Cloud CDN können jedoch zusätzliche Kosten anfallen.
7. 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 beim zuvor erstellten Back-End-Bucket example-bucket für Modus 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:

   • Protokoll: HTTPS
   • Netzwerkdienststufe: Premium
   • IP-Version: IPv4. Wenn Sie IPv6 bevorzugen, finden Sie weitere Informationen unter IPv6-Beendigung.

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

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

Wenn Sie Google Domains verwenden, lesen Sie die Informationen auf der Hilfeseite von Google Domains.

Empfohlen: Status des SSL-Zertifikats überwachen

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

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 Back-End verwenden. Wenn Sie das Attribut MainPageSuffix festlegen, führt https://www.example.com zu index.html.

Hinweis: Zur Weiterleitung von Traffic von HTTP zu HTTPS müssen Sie einen zusätzlichen HTTP-Load-Balancer mit einer Weiterleitungseinstellung in der URL-Zuordnung einrichten. Eine Anleitung finden Sie unter HTTP-zu-HTTPS-Weiterleitung für externe HTTP(S)-Load-Balancer einrichten.

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, wenn Sie das zum Ausführen der Anleitung erstellte Projekt löschen.

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 diese Anleitung ein bereits bestehendes Projekt verwendet haben, 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 Anleitungen und Kurzanleitungen durcharbeiten möchten, können Sie die Überschreitung von Projektkontingenten verhindern, wenn Sie Projekte wiederverwenden.

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 Shut down (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 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. Öffnen Sie in der Cloud Console die Seite Externe IP-Adressen.

   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

• Statische Website über HTTP bereitstellen
• 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
• Weitere Anleitungen der Google Cloud Platform mit Cloud Storage

Jetzt testen

Wenn Sie mit Google Cloud noch nicht vertraut sind, erstellen Sie einfach 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