Statische Website hosten

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

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

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

Ziele

In dieser Anleitung wird Folgendes erläutert:

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

Kosten

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

Cloud Storage
Cloud Load Balancing

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

Vorbereitung

Melden Sie sich bei Ihrem Google-Konto an.
Wenn Sie noch kein Konto haben, melden Sie sich hier für ein neues Konto an.

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

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

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.
Sie müssen der Inhaber oder Verwalter der Domain sein, die Sie verwenden möchten. Verifizieren Sie unbedingt die Top-Level-Domain wie example.com und keine Subdomain wie www.example.com.
Hinweis: Wenn Sie 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.
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.
Sie benötigen die folgenden Rollen für die Identitäts- und Zugriffsverwaltung: Storage-Objekt-Administrator und Netzwerkadministrator.

Bucket erstellen

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

Console

Öffnen Sie den Cloud Storage-Browser in der Google Cloud Console.
Zum Cloud Storage-Browser
Klicken Sie auf Bucket erstellen, um das Formular zum Erstellen eines Buckets zu öffnen.
Geben Sie die Bucket-Informationen ein und klicken Sie zum Ausführen der einzelnen Schritte auf Weiter:
- Legen Sie den Namen des Buckets fest. Wir empfehlen, den gleichen Namen wie für Ihre Domain zu verwenden, um einen späteren Schritt zu erleichtern. Beispiel: www.example.com
- Wählen Sie den Standorttyp und den Standort des Buckets aus. Beispiel: Region und us-east1.
- Wählen Sie Standard Storage als Speicherklasse aus.
- Wählen Sie unter Zugriffssteuerung die Option Einheitlich aus.
Klicken Sie auf Erstellen.

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

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

gsutil

Führen Sie den Befehl gsutil mb aus:

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

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

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

Codebeispiele

C++

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

Auf GitHub ansehen Feedback

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

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

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

C#

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

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 line before running the sample.
 */
// const bucketName = 'Name of a bucket, e.g. my-bucket';

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

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

async function createBucket() {
  // Creates a new bucket in the Asia region with the coldline default storage
  // class. Leave the second argument blank for default settings.
  //
  // For default values see: https://cloud.google.com/storage/docs/locations and
  // https://cloud.google.com/storage/docs/storage-classes

  const [bucket] = await storage.createBucket(bucketName, {
    location: 'ASIA',
    storageClass: 'COLDLINE',
  });

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

createBucket().catch(console.error);

PHP

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

Auf GitHub ansehen Feedback

use Google\Cloud\Storage\StorageClient;

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

Python

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

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

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.
Erstellen Sie eine .json-Datei, in der Ihr Websitename dem Attribut name zugewiesen wird:
```
{
  "name": "www.example.com"
}
```

Verwenden Sie cURL, um die JSON API aufzurufen: Für www.example.com:

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

XML API

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.

Verwenden Sie cURL, um die XML API aufzurufen und einen Bucket mit Ihrem Websitenamen zu erstellen. Für www.example.com:

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

Dateien meiner Website hochladen

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

Console

Öffnen Sie den Cloud Storage-Browser in der Google Cloud Console.
Zum Cloud Storage-Browser
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.
Klicken Sie auf die Schaltfläche Dateien hochladen.
Gehen Sie im Dateidialogfeld zur gewünschten Datei und wählen Sie sie aus.

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

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

gsutil

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

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

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

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

Codebeispiele

C++

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

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

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

Go

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

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.

Auf GitHub ansehen Feedback

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

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

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

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

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

uploadFile().catch(console.error);

PHP

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

Auf GitHub ansehen Feedback

use Google\Cloud\Storage\StorageClient;

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

Python

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

Verwenden Sie die Methode Blob.upload_from_file(), Blob.upload_from_filename() oder Blob.upload_from_string(), um ein Objekt hochzuladen.

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."""
    # bucket_name = "your-bucket-name"
    # source_file_name = "local/path/to/file"
    # destination_blob_name = "storage-object-name"

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

    blob.upload_from_filename(source_file_name)

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

Ruby

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

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

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.

Verwenden Sie cURL, um die JSON API mit einer POST-Objektanfrage aufzurufen: Für die Indexseite von www.beispiel.de:

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

XML API

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.

Verwenden Sie cURL, um die XML API mit einer PUT-Objektanfrage aufzurufen: Für die Indexseite von www.beispiel.de:

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

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

Console

Öffnen Sie den Cloud Storage-Browser in der Google Cloud Console.
Zum Cloud Storage-Browser
Klicken Sie in der Liste der Buckets auf den Namen des Buckets, den Sie veröffentlichen möchten.
Wählen Sie oben auf der Seite den Tab Berechtigungen aus.
Klicken Sie auf die Schaltfläche Mitglieder hinzufügen.

Das Dialogfeld Mitglieder hinzufügen wird angezeigt.
Geben Sie im Feld Neue Mitglieder den Wert allUsers ein.
Wählen Sie im Drop-down-Menü Rolle auswählen das Untermenü Cloud Storage aus und klicken Sie auf die Option Storage-Objektbetrachter.
Klicken Sie auf Speichern.
Klicken Sie auf Öffentlichen Zugriff erlauben.

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

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

gsutil

Führen Sie den Befehl gsutil iam ch aus:

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

Codebeispiele

C++

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

Auf GitHub ansehen Feedback

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

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

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

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

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

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

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;
using System.Collections.Generic;

public class MakePublicSample
{
    public string MakePublic(
        string bucketName = "your-unique-bucket-name",
        string objectName = "your-object-name")
    {
        var storage = StorageClient.Create();
        var storageObject = storage.GetObject(bucketName, objectName);
        storageObject.Acl ??= new List<ObjectAccessControl>();
        storage.UpdateObject(storageObject, new UpdateObjectOptions { PredefinedAcl = PredefinedObjectAcl.PublicRead });
        Console.WriteLine(objectName + " is now public and can be fetched from " + storageObject.MediaLink);

        return storageObject.MediaLink;
    }
}

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

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, role, member):
    """Set a public IAM Policy to bucket"""
    # bucket_name = "your-bucket-name"
    # role = "IAM role, e.g. roles/storage.objectViewer"
    # member = "IAM identity, e.g. allUsers"

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

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

    bucket.set_iam_policy(policy)

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

REST APIs

JSON API

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.

Erstellen Sie eine JSON-Datei, die die folgenden Informationen enthält:

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

Verwenden Sie cURL, um die JSON API mit einer PUT-Bucket-Anfrage aufzurufen:
```
curl -X PUT --data-binary @JSON_FILE_NAME.json \
  -H "Authorization: Bearer OAUTH2_TOKEN" \
  -H "Content-Type: application/json" \
  "https://storage.googleapis.com/storage/v1/b/BUCKET_NAME/iam"
```
Dabei gilt:
- JSON_FILE_NAME ist der Name der Datei, die Sie in Schritt 2 erstellt haben.
- OAUTH2_TOKEN ist das Zugriffstoken, das Sie in Schritt 1 erstellt haben.
- BUCKET_NAME ist der Name des Buckets, dessen Objekte Sie veröffentlichen möchten. Beispiel: my-bucket

XML API

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

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

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

Empfohlen: Spezialseiten zuweisen

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

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

Console

Öffnen Sie den Cloud Storage-Browser in der Google Cloud Console.
Zum Cloud Storage-Browser
Suchen Sie in der Liste der Buckets den Bucket, den Sie erstellt haben.
Klicken Sie auf das Dreipunkt-Menü () des Buckets und wählen Sie Websitekonfiguration bearbeiten aus.

Hinweis: Diese Option ist nur für Buckets verfügbar, deren Name mit einem gültigen Websitemuster übereinstimmt. Wenn Ihr Bucket-Name nicht mit dem Websitemuster übereinstimmt, verwenden Sie stattdessen gsutil.
Geben Sie im Dialogfeld zur Websitekonfiguration die Hauptseite und die Fehlerseite an.
Klicken Sie auf Speichern.

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

gsutil

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

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

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

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

Codebeispiele

C++

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

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

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

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

REST APIs

JSON API

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

Verwenden Sie cURL, um die JSON API mit einer PATCH-Bucket-Anfrage aufzurufen. Für www.example.com:

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

XML API

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

Verwenden Sie cURL, um die XML API mit einer PUT-Bucket-Anfrage und dem Abfragestringparameter websiteConfig aufzurufen. Für www.example.com:

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

Load-Balancer und SSL-Zertifikat einrichten

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

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

Back-End konfigurieren

Klicken Sie auf Back-End-Konfiguration.
Ö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.
Wählen Sie einen Namen für den Back-End-Bucket aus, z. B. example-bucket.
Klicken Sie unter Cloud Storage-Bucket auf Durchsuchen.
Wählen Sie den Bucket www.example.com aus und klicken Sie auf Auswählen.
Klicken Sie auf Erstellen.

Hostregeln und Pfad-Matcher konfigurieren

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

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

Front-End konfigurieren

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

Klicken Sie auf Front-End-Konfiguration.
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.
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.
Wählen Sie für Port die Option 443 aus.
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.
Klicken Sie auf Erstellen.
Klicken Sie auf Fertig.

Konfiguration prüfen

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

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

Domain mit dem Load-Balancer verbinden

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

NAME                  TYPE     DATA
www                   A        30.90.80.100
@                     A        30.90.80.100

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

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

Öffnen Sie in der Google Cloud Console die Seite „Load-Balancing“.
Zur Seite „Load-Balancing“
Klicken Sie auf den Namen Ihres Load-Balancers: example-lb.
Klicken Sie auf den Namen des SSL-Zertifikats, das dem Load-Balancer zugeordnet ist: example-ssl.
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

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

Führen Sie den folgenden Befehl aus, um den Domainstatus zu prüfen:

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

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

Website testen

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

Bereinigen

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

Projekt löschen

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

So löschen Sie das Projekt:

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.

Wechseln Sie in der Cloud Console zur Seite Ressourcen verwalten.
Zur Seite „Ressourcen verwalten“
Wählen Sie in der Projektliste das Projekt aus, das Sie löschen möchten, und klicken Sie dann auf Löschen.
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:

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

Weitere Informationen

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

Statische Website hosten

Ziele

Kosten

Vorbereitung

Bucket erstellen

Console

gsutil

Codebeispiele

C++

C#

Go

Java

Node.js

PHP

Python

Ruby

REST APIs

JSON API

XML API

Dateien meiner Website hochladen

Console

gsutil

Codebeispiele

C++

C#

Go

Java

Node.js

PHP

Python

Ruby

REST APIs

JSON API

XML API

Dateien freigeben

Console

gsutil

Codebeispiele

C++

C#

Java

Python

REST APIs

JSON API

XML API

Empfohlen: Spezialseiten zuweisen

Console

gsutil

Codebeispiele

C++

Java

Python

REST APIs

JSON API

XML API

Load-Balancer und SSL-Zertifikat einrichten

Back-End konfigurieren

Hostregeln und Pfad-Matcher konfigurieren

Front-End konfigurieren

Konfiguration prüfen

Domain mit dem Load-Balancer verbinden

Empfohlen: Status des SSL-Zertifikats überwachen

Console

gcloud

Website testen

Bereinigen

Projekt löschen

Load-Balancer und Bucket löschen

Weitere Informationen

Jetzt testen