Héberger un site Web statique

Ce tutoriel explique comment configurer un bucket Cloud Storage afin d'héberger un site Web statique pour un domaine dont vous êtes propriétaire. Les pages Web statiques peuvent contenir des technologies côté client telles que HTML, CSS et JavaScript. Elles ne peuvent pas comporter de contenu dynamique, tel que des scripts côté serveur comme PHP.

Cloud Storage n'étant pas compatible avec les domaines personnalisés qui n'acceptent que le protocole HTTPS, ce tutoriel utilise Cloud Storage avec l'équilibrage de charge HTTP(S) pour diffuser du contenu à partir d'un domaine personnalisé via HTTPS. Pour découvrir d'autres façons de diffuser du contenu depuis un domaine personnalisé via HTTPS, consultez la rubrique de dépannage associée. Vous pouvez également diffuser du contenu de domaine personnalisé via HTTP à l'aide de Cloud Storage sans avoir besoin d'un équilibreur de charge.

Pour obtenir des exemples et des conseils sur les pages Web statiques, y compris sur l'hébergement d'éléments statiques pour un site Web dynamique, consultez la page Site Web statique.

Objectifs

Ce tutoriel vous explique comment :

  • créer un bucket ;
  • importer et partager les fichiers de votre site ;
  • configurer un équilibreur de charge et un certificat SSL ;
  • connecter votre équilibreur de charge à votre bucket ;
  • faire pointer votre domaine vers votre équilibreur de charge à l'aide d'un enregistrement A ;
  • tester le site Web.

Coûts

Ce tutoriel utilise les composants facturables suivants de Google Cloud :

  • Cloud Storage
  • Cloud Load Balancing

Pour en savoir plus sur les frais qui peuvent s'appliquer en cas d'hébergement d'un site Web statique, consultez la section Surveiller vos frais de stockage. Pour obtenir plus d'informations sur les coûts liés à Cloud Storage, consultez la page Tarifs de Cloud Storage.

Avant de commencer

  1. Connectez-vous à votre compte Google.

    Si vous n'en possédez pas déjà un, vous devez en créer un.

  2. Dans Google Cloud Console, sur la page de sélection du projet, sélectionnez ou créez un projet Google Cloud.

    Accéder à la page de sélection du projet

  3. Assurez-vous que la facturation est activée pour votre projet Cloud. Découvrez comment vérifier que la facturation est activée pour votre projet.

  4. Prenez un domaine que vous possédez ou gérez. Si vous ne disposez pas d'un domaine, de nombreux services vous permettent d'enregistrer un nouveau domaine, par exemple Google Domains.

    Ce tutoriel utilise le domaine example.com.

  5. Confirmez que vous possédez ou gérez le domaine que vous allez utiliser. Assurez-vous que cette validation porte sur le domaine de premier niveau, tel que example.com, et non sur un sous-domaine, tel que www.example.com.

    Remarque : Si vous êtes propriétaire du domaine que vous associez à un bucket, vous avez peut-être déjà effectué cette étape précédemment. Si vous avez acheté le domaine via Google Domains, la validation est automatique.

  6. Vous devez disposer de quelques fichiers de site Web à diffuser. Ce tutoriel donnera de meilleurs résultats si vous avez au moins une page d'index (index.html) et une page 404 (404.html).
  7. Assurez-vous de disposer d'un rôle de propriétaire ou d'éditeur de projet, ou des rôles Cloud Identity and Access Management suivants : Administrateur des objets Storage et Administrateur réseau.

Créer un bucket

Pour créer un bucket nommé www.example.com, procédez comme suit :

Console

  1. Ouvrez le navigateur Cloud Storage dans Google Cloud Console.
    Ouvrir le navigateur Cloud Storage
  2. Cliquez sur Créer un bucket pour ouvrir le formulaire de création de bucket.

  3. Saisissez les informations relatives à votre bucket et cliquez sur Continuer à chaque étape :

    • Définissez le nom de votre bucket. Nous vous recommandons de le faire correspondre à votre nom de domaine pour faciliter la prochaine étape. Exemple : www.example.com.

    • Sélectionnez le type d'emplacement et l'emplacement de votre bucket. Par exemple, Région et us-east1.

    • Sélectionnez Stockage standard pour la classe de stockage.

    • Sélectionnez Uniforme pour Contrôle des accès.

  4. Cliquez sur Créer.

Si l'opération réussit, la page Informations sur le bucket s'ouvre et affiche le texte "Aucun objet actif dans ce bucket".

Consultez la page Dépannage pour obtenir des informations détaillées sur les erreurs liées aux opérations ayant échoué dans le navigateur Cloud Storage.

gsutil

Exécutez la commande gsutil mb :

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

Si l'opération réussit, la commande renvoie le résultat suivant :

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

Exemples de code

C++

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage C++.

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#

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage C#.

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

Go

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage Go.

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

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage Java.

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

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage Node.js.

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

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage PHP.

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

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage Python.

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

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage Ruby.

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

require "google/cloud/storage"

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

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

API REST

API JSON

  1. Obtenez un jeton d'autorisation d'accès sur la page OAuth 2.0 Playground. Configurez Playground pour utiliser vos propres identifiants OAuth.
  2. Créez un fichier .json qui attribue le nom de votre site Web à la propriété name :

    {
      "name": "www.example.com"
    }
  3. Utilisez cURL pour appeler l'API JSON. Pour www.example.com, procédez comme suit :

    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"

API XML

  1. Obtenez un jeton d'autorisation d'accès sur la page OAuth 2.0 Playground. Configurez Playground pour utiliser vos propres identifiants OAuth.
  2. Utilisez cURL pour appeler l'API XML afin de créer un bucket portant le nom de votre site Web. Pour www.example.com, procédez comme suit :

    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"

Importer les fichiers de votre site

Ajoutez les fichiers que vous souhaitez que votre site Web diffuse dans le bucket :

Console

  1. Ouvrez le navigateur Cloud Storage dans Google Cloud Console.
    Ouvrir le navigateur Cloud Storage
  2. Dans la liste des buckets, cliquez sur le nom de celui que vous avez créé.

    La page Informations sur le bucket s'ouvre avec l'onglet Objets sélectionné.

  3. Cliquez sur le bouton Importer des fichiers.

  4. Dans la boîte de dialogue de sélection de fichier, recherchez le fichier souhaité et sélectionnez-le.

Une fois l'importation terminée, vous devez voir le nom du fichier et des informations relatives à ce dernier.

Consultez la page Dépannage pour obtenir des informations détaillées sur les erreurs liées aux opérations ayant échoué dans le navigateur Cloud Storage.

gsutil

Exécutez la commande gsutil cp pour copier des fichiers dans le bucket. Par exemple, pour copier le fichier index.html à partir de son emplacement actuel (Desktop) :

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

Si l'opération réussit, la commande renvoie le résultat suivant :

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

Exemples de code

C++

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage C++.

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#

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage C#.

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

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage Go.

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

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage Java.

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

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage Node.js.

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

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage PHP.

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

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage Python.

Pour importer un objet, exécutez la méthode Blob.upload_from_file(), Blob.upload_from_filename() ou Blob.upload_from_string().
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

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage Ruby.

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

require "google/cloud/storage"

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

file = bucket.create_file local_file_path, storage_file_path

puts "Uploaded #{file.name}"

API REST

API JSON

  1. Obtenez un jeton d'autorisation d'accès sur la page OAuth 2.0 Playground. Configurez Playground pour utiliser vos propres identifiants OAuth.
  2. Utilisez cURL pour appeler l'API JSON avec une requête d'objet POST : Pour la page d'index de www.example.com, procédez comme suit :

    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"

API XML

  1. Obtenez un jeton d'autorisation d'accès sur la page OAuth 2.0 Playground. Configurez Playground pour utiliser vos propres identifiants OAuth.
  2. Utilisez cURL pour appeler l'API XML avec une requête d'objet PUT : Pour la page d'index de www.example.com, procédez comme suit :

    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"

Partager des fichiers

Pour rendre tous les objets d'un bucket lisibles par tous sur l'Internet public :

Console

  1. Ouvrez le navigateur Cloud Storage dans Google Cloud Console.
    Ouvrir le navigateur Cloud Storage
  2. Dans la liste des buckets, cliquez sur le nom de celui que vous souhaitez rendre public.

  3. Sélectionnez l'onglet Autorisations en haut de la page.

  4. Cliquez sur le bouton Ajouter des membres.

    La boîte de dialogue Ajouter des membres s'affiche.

  5. Dans le champ Nouveaux membres, saisissez allUsers.

  6. Dans la liste déroulante Sélectionner un rôle, sélectionnez le sous-menu Cloud Storage, puis cliquez sur l'option Lecteur des objets Storage.

  7. Cliquez sur Enregistrer.

  8. Cliquez sur Autoriser l'accès public.

Une fois le partage public effectué, une icône de lien s'affiche pour chaque objet dans la colonne Accès public. Vous pouvez cliquer sur cette icône pour obtenir l'URL de l'objet.

Consultez la page Dépannage pour obtenir des informations détaillées sur les erreurs liées aux opérations ayant échoué dans le navigateur Cloud Storage.

gsutil

Exécutez la commande gsutil iam ch :

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

Exemples de code

C++

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage C++.

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

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

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

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

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

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

Java

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage Java.

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

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage Python.

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

API REST

API JSON

  1. Obtenez un jeton d'autorisation d'accès sur la page OAuth 2.0 Playground. Configurez Playground pour utiliser vos propres identifiants OAuth.
  2. Créez un fichier .json contenant les informations suivantes :

    {
      "bindings":[
        {
          "role": "roles/storage.objectViewer",
          "members":["allUsers"]
        }
      ]
    }
  3. Exécutez cURL pour appeler l'API JSON avec une requête de bucket PUT :

    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"

    Où :

    • JSON_FILE_NAME correspond au nom du fichier que vous avez créé à l'étape 2.
    • OAUTH2_TOKEN correspond au jeton d'accès que vous avez généré à l'étape 1.
    • BUCKET_NAME est le nom du bucket dont vous souhaitez rendre les objets publics. Exemple : my-bucket.

API XML

L'API XML ne permet pas de rendre tous les objets d'un bucket lisibles publiquement. Utilisez plutôt gsutil ou l'API JSON, ou définissez des LCA pour chaque objet individuel.

Pour rendre les objets individuels de votre bucket lisibles publiquement, vous devez passer le mode Contrôle des accès sur Ultraprécis. En règle générale, il est plus simple et plus rapide de rendre accessibles au public tous les fichiers du bucket.

Les visiteurs reçoivent un code de réponse http 403 lorsqu'ils demandent l'URL d'un fichier non public ou inexistant. Consultez la section suivante pour savoir comment ajouter une page d'erreur utilisant un code de réponse http 404.

Attribuer des pages spécialisées (recommandé)

Vous pouvez attribuer un suffixe de page d'index contrôlé par la propriété MainPageSuffix, ainsi qu'une page d'erreur personnalisée contrôlée par la propriété NotFoundPage. Aucun de ces deux éléments n'est strictement obligatoire. Notez toutefois que si vous ne désignez pas de page d'index, aucun contenu n'est diffusé lorsque des utilisateurs accèdent à votre site de premier niveau, par exemple https://www.example.com. Pour en savoir plus sur les propriétés MainPageSuffix et NotFoundPage, consultez Pages spécialisées.

Dans l'exemple suivant, MainPageSuffix est défini sur index.html, et NotFoundPage sur 404.html :

Console

  1. Ouvrez le navigateur Cloud Storage dans Google Cloud Console.
    Ouvrir le navigateur Cloud Storage
  2. Dans la liste des buckets, recherchez celui que vous avez créé.

  3. Cliquez sur le menu déroulant () associé au bucket, puis sélectionnez Modifier la configuration du site Web.

  4. Dans la boîte de dialogue de configuration du site Web, spécifiez la page principale et la page d'erreur.

  5. Cliquez sur Enregistrer.

Consultez la page Dépannage pour obtenir des informations détaillées sur les erreurs liées aux opérations ayant échoué dans le navigateur Cloud Storage.

gsutil

Exécutez la commande gsutil web set pour définir la propriété MainPageSuffix avec l'indicateur -m et la propriété NotFoundPage avec l'indicateur -e :

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

Si l'opération réussit, la commande renvoie le résultat suivant :

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

Exemples de code

C++

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage C++.

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

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage Java.

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

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage Python.

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

API REST

API JSON

  1. Obtenez un jeton d'autorisation d'accès sur la page OAuth 2.0 Playground. Configurez Playground pour utiliser vos propres identifiants OAuth.
  2. Créez un fichier .json qui définit les propriétés mainPageSuffix et notFoundPage d'un objet website sur les pages souhaitées :

    {
      "website":{
        "mainPageSuffix": "index.html",
        "notFoundPage": "404.html"
      }
    }
  3. Exécutez cURL pour appeler l'API JSON avec une requête de bucket PATCH. Pour www.example.com, procédez comme suit :

    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"

API XML

  1. Obtenez un jeton d'autorisation d'accès sur la page OAuth 2.0 Playground. Configurez Playground pour utiliser vos propres identifiants OAuth.
  2. Créez un fichier .xml qui définit les éléments MainPageSuffix et NotFoundPage d'un élément WebsiteConfiguration sur les pages souhaitées :

    <WebsiteConfiguration>
      <MainPageSuffix>index.html</MainPageSuffix>
      <NotFoundPage>404.html</NotFoundPage>
    </WebsiteConfiguration>
  3. Utilisez cURL pour appeler l'API XML avec une requête de bucket PUT et un paramètre de chaîne de requête websiteConfig. Pour www.example.com, procédez comme suit :

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

Configurer votre équilibreur de charge et votre certificat SSL

Cloud Storage n'est pas compatible avec les domaines personnalisés n'acceptant que le protocole HTTPS. Vous devez donc également configurer un certificat SSL associé à un équilibreur de charge HTTPS pour diffuser votre site Web via HTTPS. Cette section explique comment ajouter votre bucket au backend d'un équilibreur de charge et ajouter un nouveau certificat SSL géré par Google à l'interface de l'équilibreur de charge.

  1. Accédez à la page "Équilibrage de charge" dans Google Cloud Console.
    Accéder à la page "Équilibrage de charge"
  2. Dans la section Équilibrage de charge HTTP(S), cliquez sur Démarrer la configuration.
  3. Sélectionnez D'Internet vers mes VM, puis cliquez sur Continuer.
  4. Attribuez un nom à votre équilibreur de charge, tel que example-lb.

Configurer le backend

  1. Cliquez sur Configuration du backend.
  2. Dans la liste déroulante Créer ou sélectionner des services backend et des buckets backend, accédez au sous-menu Buckets backend et cliquez sur l'option Créer un bucket backend.
  3. Choisissez un nom pour le bucket backend, tel que example-bucket.
  4. Cliquez sur Parcourir sous Bucket Cloud Storage.
  5. Sélectionnez le bucket www.example.com, puis cliquez sur Sélectionner.
  6. Cliquez sur Créer.

Configurer des règles d'hôte et des outils de mise en correspondance des chemins

Les règles d'hôte et les outils de mise en correspondance des chemins sont les composants de configuration d'un mappage d'URL de l'équilibreur de charge HTTP(S) externe.

  1. Cliquez sur Règles d'hôte et de chemin d'accès.
  2. Laissez le paramètre Mode défini par défaut sur Règle d'hôte et de chemin d'accès simple pour le bucket backend example-bucket que vous avez créé précédemment.

Configurer l'interface

Cette section vous explique comment configurer le protocole HTTPS et créer un certificat SSL. Vous pouvez également sélectionner un certificat existant ou importer un certificat SSL autogéré.

  1. Cliquez sur Configuration du frontend.
  2. Configurez les valeurs indiquées dans les champs suivants :

  3. Pour le champ Adresse IP :

    1. Dans la liste déroulante, cliquez sur Créer une adresse IP.
    2. Dans la fenêtre pop-up Réserver une nouvelle adresse IP statique, saisissez example-ip comme nom de l'adresse IP.
    3. Cliquez sur Réserver.
  4. Pour Port, sélectionnez 443.

  5. Dans le champ Certificat, sélectionnez Créer un certificat. Le formulaire de création de certificat s'affiche dans un panneau. Ensuite, procédez à la configuration des éléments suivants, comme indiqué :

    • Nom : example-ssl
    • Mode de création : Créer un certificat géré par Google
    • Domaines : www.example.com. Si vous souhaitez diffuser votre contenu via d'autres domaines, tels que le domaine racine example.com, appuyez sur Entrée pour les ajouter sur des lignes supplémentaires. Chaque certificat a une limite de 100 domaines.
  6. Cliquez sur Créer.

  7. Cliquez sur OK.

Vérifier la configuration

  1. Cliquez sur Vérifier et finaliser.
  2. Examinez la configuration du backend, les règles d'hôte et de chemin d'accès et la configuration du frontend.
  3. Cliquez sur Créer.

Vous devrez peut-être attendre quelques minutes que l'équilibreur de charge soit créé.

Connecter votre domaine à votre équilibreur de charge

Une fois l'équilibreur de charge créé, cliquez sur son nom : example-lb. Notez l'adresse IP associée à l'équilibreur de charge, par exemple 30.90.80.100. Pour faire pointer votre domaine vers votre équilibreur de charge, créez un enregistrement A à l'aide de votre service d'enregistrement de domaine. Si vous avez ajouté plusieurs domaines à votre certificat SSL, vous devez ajouter un enregistrement A pour chacun d'eux, tous pointant vers l'adresse IP de l'équilibreur de charge. Par exemple, pour créer des enregistrements A pour www.example.com et example.com, procédez comme suit :

NAME                  TYPE     DATA
www                   A        30.90.80.100
@                     A        30.90.80.100

Si vous utilisez Google Domains, consultez la page Créer un enregistrement A ou CNAME pour en savoir plus.

Le provisionnement du certificat et la mise à disposition du site via l'équilibreur de charge peuvent prendre entre 60 et 90 minutes. Pour surveiller l'état de votre certificat, procédez comme suit :

Console

  1. Accédez à la page "Équilibrage de charge" dans Google Cloud Console.
    Accéder à la page "Équilibrage de charge"
  2. Cliquez sur le nom de votre équilibreur de charge : example-lb.
  3. Cliquez sur le nom du certificat SSL associé à l'équilibreur de charge : example-ssl.
  4. Les lignes État et État du domaine indiquent l'état du certificat. Les deux éléments doivent être actifs pour que le certificat soit valide pour votre site Web.

gcloud

  1. Pour vérifier l'état du certificat, exécutez la commande suivante :

    gcloud beta compute ssl-certificates describe certificate-name \
      --global \
      --format="get(name,managed.status)"
    
  2. Pour vérifier l'état du domaine, exécutez la commande suivante :

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

Pour en savoir plus sur l'état des certificats, consultez la section Résoudre les problèmes liés aux certificats SSL.

Tester le site Web

Une fois le certificat SSL actif, vérifiez que le contenu est diffusé à partir du bucket en accédant à https://www.example.com/test.html, où test.html est un objet stocké dans un bucket nommé www.example.com. Si vous définissez la propriété MainPageSuffix, https://www.example.com passe à index.html.

Nettoyer

Une fois que vous avez terminé le tutoriel "Héberger un site Web statique", vous pouvez procéder au nettoyage des ressources que vous avez créées sur Google Cloud afin qu'elles ne soient pas comptabilisées dans votre quota et qu'elles ne vous soient pas facturées. Dans les sections suivantes, nous allons voir comment supprimer ou désactiver ces ressources.

Supprimer le projet

Le moyen le plus simple d'empêcher la facturation est de supprimer le projet que vous avez créé pour ce tutoriel.

Pour supprimer le projet :

  1. Dans Cloud Console, accédez à la page Gérer les ressources.

    Accéder à la page Gérer les ressources

  2. Dans la liste des projets, sélectionnez le projet que vous souhaitez supprimer, puis cliquez sur Supprimer .
  3. Dans la boîte de dialogue, saisissez l'ID du projet, puis cliquez sur Arrêter pour supprimer le projet.

Supprimer l'équilibreur de charge et le bucket

Si vous ne souhaitez pas supprimer l'intégralité du projet, supprimez l'équilibreur de charge et le bucket que vous avez créés pour le tutoriel :

  1. Accédez à la page "Équilibrage de charge" dans Google Cloud Console.
    Accéder à la page "Équilibrage de charge"
  2. Cochez la case située à côté de example-lb.
  3. Cliquez sur Supprimer.
  4. (Facultatif) Cochez la case à côté des ressources que vous souhaitez supprimer avec l'équilibreur de charge, telles que le bucket www.example.com ou le certificat SSL example-ssl.
  5. Cliquez sur Supprimer l'équilibreur de charge ou Supprimer l'équilibreur de charge et les ressources sélectionnées.

Étapes suivantes