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.

Ce tutoriel utilise Cloud Storage avec l'équilibrage de charge HTTP(S) pour diffuser le contenu 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.

Attention : Ce tutoriel met le contenu à la disposition du public sur Internet. Nous vous recommandons de ne pas diffuser de contenu contenant des données sensibles ou privées de votre bucket Cloud Storage.

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 Cloud Console, sur la page de sélection du projet, sélectionnez ou créez un projet Cloud.

   Remarque : Si vous ne comptez pas conserver les ressources créées dans cette procédure, créez un projet au lieu de sélectionner un projet existant. Après avoir suivi ces étapes, vous pouvez supprimer le projet. Cela entraîne la suppression de toutes les ressources qui lui sont associées.

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

3. Vérifiez que la facturation est activée pour votre projet Google 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.

Remarque : Pour plus d'informations sur la configuration de votre domaine à l'aide de Cloud DNS, consultez l'article Configurer le domaine à l'aide de Cloud DNS.

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

Afficher sur GitHub Commentaires

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

Afficher sur GitHub Commentaires

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.

Afficher sur GitHub Commentaires

ctx := context.Background()
bucket := client.Bucket(bucketName)

ctx, cancel := context.WithTimeout(ctx, time.Second*10)
defer cancel()
if err := bucket.Create(ctx, projectID, &storage.BucketAttrs{
	StorageClass: "COLDLINE",
	Location:     "asia",
}); err != nil {
	return err
}

Java

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

Afficher sur GitHub Commentaires

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.

Afficher sur GitHub Commentaires

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

Afficher sur GitHub Commentaires

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.

Afficher sur GitHub Commentaires

from google.cloud import storage

def create_bucket(bucket_name):
    """Creates a new bucket."""
    # bucket_name = "your-new-bucket-name"

    storage_client = storage.Client()

    bucket = storage_client.create_bucket(bucket_name)

    print("Bucket {} created".format(bucket.name))

Ruby

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

Afficher sur GitHub Commentaires

# 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. Exécutez 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++.

Afficher sur GitHub Commentaires

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

Afficher sur GitHub Commentaires

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.

Afficher sur GitHub Commentaires

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.

Afficher sur GitHub Commentaires

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.

Afficher sur GitHub Commentaires

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

Afficher sur GitHub Commentaires

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

Afficher sur GitHub Commentaires

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.

Afficher sur GitHub Commentaires

# 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. Exécutez 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. Exécutez 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"

Remarque : Si vous migrez un site Web existant ou copiez un grand nombre de fichiers, exécutez la commande gsutil rsync pour déplacer le contenu. Vous pouvez utiliser l'option -R pour copier de manière récursive des arborescences de répertoires. Par exemple, pour synchroniser un répertoire local nommé local-dir avec un bucket, exécutez la commande suivante :

gsutil rsync -R local-dir gs://www.example.com

Partager des fichiers

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

Attention : Avant de rendre votre bucket accessible publiquement, assurez-vous que les fichiers de votre bucket ne contiennent pas d'informations sensibles ou privées.

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

Afficher sur GitHub Commentaires

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.

Afficher sur GitHub Commentaires

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

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.

Remarque : Le rôle roles/storage.objectViewer comprend une autorisation permettant de répertorier les objets du bucket. Si vous ne souhaitez pas accorder ce droit de manière publique, utilisez [roles/storage.legacyObjectReader][13].

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.

   Remarque : Cette option n'est disponible que pour les buckets dont le nom correspond à un format de site Web valide. Si le nom de votre bucket ne correspond pas au format du site Web, utilisez plutôt gsutil.

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.

Remarque : Vous pouvez afficher, modifier ou supprimer ces paramètres dans le menu Modifier la configuration du site Web.

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

Remarque : Vous pouvez modifier ou supprimer ces paramètres à l'aide de commandes gsutil web set supplémentaires, puis afficher ces paramètres avec la commande gsutil web get.

Exemples de code

C++

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

Afficher sur GitHub Commentaires

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.

Afficher sur GitHub Commentaires

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

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. Exécutez 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

Remarque : Vous pouvez modifier ou supprimer ces paramètres à l'aide de requêtes PUT supplémentaires, et les afficher avec une requête GET.

Configurer votre équilibreur de charge et votre certificat SSL

Pour diffuser votre site Web via HTTPS, vous avez besoin d'un certificat SSL. 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 :

   • Protocole : HTTPS
   • Niveau de service réseau : Premium
   • Version IP : IPv4. Si vous préférez le protocole IPv6, consultez la documentation sur la terminaison IPv6 pour en savoir plus.

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 Créer un enregistrement A ou CNAME pour en savoir plus.

Surveiller l'état du certificat SSL (recommandé)

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.

Remarque : Pour rediriger le trafic HTTP vers HTTPS, vous devez configurer un équilibreur de charge HTTP supplémentaire avec un paramètre de redirection dans le mappage d'URL. Pour obtenir des instructions, consultez Configurer la redirection HTTP vers HTTPS pour les équilibreurs de charge HTTP(S) externes.

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 :

Attention : La suppression d'un projet aura les effets suivants :

• Tout le contenu du projet est supprimé. Si vous avez utilisé un projet existant pour ce tutoriel et que vous le supprimez, vous supprimerez également tout autre travail effectué dans le projet.
• Les ID de projets personnalisés sont perdus. Lorsque vous avez créé ce projet, vous avez peut-être créé un ID de projet personnalisé que vous souhaitez utiliser à l'avenir. Pour conserver les URL qui utilisent l'ID de projet, telle qu'une URL appspot.com, supprimez les ressources sélectionnées dans le projet au lieu de supprimer l'ensemble du projet.

Si vous envisagez d'explorer plusieurs tutoriels et guides de démarrage rapide, vous pouvez constater que réutiliser des projets peut vous aider à éviter de dépasser les limites de quotas des projets.

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.

Remarque : Si vous souhaitez uniquement supprimer le bucket que vous avez créé, suivez les instructions figurant sur la page Supprimer des buckets.

Étapes suivantes

• Découvrez comment diffuser votre site Web statique via HTTP.
• Consultez des exemples et des conseils relatifs à l'utilisation de buckets pour héberger un site Web statique.
• Consultez la section de la page "Dépannage" portant sur l'hébergement d'un site Web statique.
• Apprenez-en plus sur l'hébergement d'éléments statiques pour un site Web dynamique.
• Découvrez d'autres solutions de diffusion Web Google Cloud.
• Suivez d'autres tutoriels Google Cloud qui utilisent Cloud Storage.