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 :

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.

Avant de commencer

  1. Connectez-vous à votre compte Google Cloud. Si vous débutez sur Google Cloud, créez un compte pour évaluer les performances de nos produits en conditions réelles. Les nouveaux clients bénéficient également de 300 $ de crédits gratuits pour exécuter, tester et déployer des charges de travail.
  2. Dans Google Cloud Console, sur la page de sélection du projet, sélectionnez ou créez un projet Google Cloud.

    Accéder au sélecteur de projet

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

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

    Accéder au sélecteur de projet

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

  6. Activez l'API Compute Engine pour votre projet.
  7. Vous devez disposer des rôles Identity and Access Management suivants : Administrateur des objets Storage et Administrateur réseau Compute.
  8. 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 et Cloud Domains.

    Ce tutoriel utilise le domaine example.com.

  9. 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).
  10. (Facultatif) Si vous souhaitez que votre bucket Cloud Storage ait le même nom que votre domaine, vous devez valider 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. Si vous avez acheté le domaine via Google Domains, la validation est automatique.

Créer un bucket

Pour créer un bucket :

Console

  1. Dans Google Cloud Console, accédez à la page du Navigateur Cloud Storage.

    Accéder à la page du navigateur

  2. Cliquez sur Create bucket (Créer un bucket).
  3. Sur la page Créer un bucket, saisissez les informations concernant votre bucket. Pour passer à l'étape suivante, cliquez sur Continuer.
    • Dans le champ Attribuer un nom au bucket, saisissez un nom qui répond aux exigences de dénomination des buckets.
    • Dans le champ Choisir l'emplacement de stockage de vos données, sélectionnez un Type d'emplacement et un Emplacement où les données du bucket seront stockées de manière permanente.
    • Pour Choisir une classe de stockage par défaut pour vos données, sélectionnez une classe de stockage pour le bucket. La classe de stockage par défaut est attribuée par défaut à tous les objets importés dans le bucket.

      Remarque : Le panneau Monthly cost estimate (Estimation du coût mensuel) du volet de droite donne une estimation des coûts mensuels du bucket en fonction de la classe de stockage et de l'emplacement sélectionnés, ainsi que des opérations et du volume de données attendus.

    • Pour le champ Choisir comment contrôler l'accès aux objets, indiquez si votre bucket s'applique ou non la protection contre l'accès public et sélectionnez un modèle de contrôle d'accès pour les objets de votre bucket.

      Remarque : Si la protection contre l'accès public est déjà appliquée par la règle d'administration de votre projet, le bouton Empêcher l'accès public est verrouillé.

    • Pour choisir comment protéger les données d'objet, configurez les outils de protection si vous le souhaitez, puis sélectionnez une méthode de chiffrement des données.
  4. Cliquez sur Create (Créer).

Pour savoir comment obtenir des informations d'erreur détaillées sur les opérations ayant échoué dans le navigateur Cloud Storage, consultez la page Dépannage.

Ligne de commande

Exécutez la commande gsutil mb :

gsutil mb gs://BUCKET_NAME

Où :

  • BUCKET_NAME correspond au nom que vous souhaitez attribuer au bucket, ce nom étant soumis à des exigences de dénomination. Par exemple, my-bucket.

Si la requête aboutit, la commande renvoie le message suivant :

Creating gs://BUCKET_NAME/...

Définissez les indicateurs facultatifs suivants pour mieux contrôler la création du bucket :

  • -p : spécifiez l'ID ou le numéro du projet auquel le bucket sera associé. Exemple :my-project
  • -c : spécifiez la classe de stockage par défaut du bucket. Par exemple, NEARLINE.
  • -l : spécifiez l'emplacement du bucket. Exemple : US-EAST1.
  • -b : spécifiez le paramètre d'accès uniforme au niveau du bucket pour votre bucket. Exemple : ON.
  • Pour obtenir la liste complète des options de création de buckets gsutil, consultez la page Options Mo.

Exemple :

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

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& storage_class, std::string const& location) {
  StatusOr<gcs::BucketMetadata> bucket_metadata =
      client.CreateBucket(bucket_name, gcs::BucketMetadata()
                                           .set_storage_class(storage_class)
                                           .set_location(location));

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

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

C#

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


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

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*30)
	defer cancel()

	storageClassAndLocation := &storage.BucketAttrs{
		StorageClass: "COLDLINE",
		Location:     "asia",
	}
	bucket := client.Bucket(bucketName)
	if err := bucket.Create(ctx, projectID, storageClassAndLocation); err != nil {
		return fmt.Errorf("Bucket(%q).Create: %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 lines before running the sample.
 */
// The ID of your GCS bucket
// const bucketName = 'your-unique-bucket-name';

// The name of a storage class
// See the StorageClass documentation for other valid storage classes:
// https://googleapis.dev/java/google-cloud-clients/latest/com/google/cloud/storage/StorageClass.html
// const storageClass = 'coldline';

// The name of a location
// See this documentation for other valid locations:
// http://g.co/cloud/storage/docs/locations#location-mr
// const location = 'ASIA';

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

// Creates a client
// The bucket in the sample below will be created in the project associated with this client.
// For more information, please see https://cloud.google.com/docs/authentication/production or https://googleapis.dev/nodejs/storage/latest/Storage.html
const storage = new Storage();

async function createBucketWithStorageClassAndLocation() {
  // For default values see: https://cloud.google.com/storage/docs/locations and
  // https://cloud.google.com/storage/docs/storage-classes
  const [bucket] = await storage.createBucket(bucketName, {
    location,
    [storageClass]: true,
  });

  console.log(
    `${bucket.name} created with ${storageClass} class in ${location}`
  );
}

createBucketWithStorageClassAndLocation().catch(console.error);

PHP

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 new bucket with a custom default storage class and location.
 *
 * @param string $bucketName The name of your Cloud Storage bucket.
 */
function create_bucket_class_location($bucketName)
{
    // $bucketName = 'my-bucket';

    $storage = new StorageClient();
    $storageClass = 'COLDLINE';
    $location = 'ASIA';
    $bucket = $storage->createBucket($bucketName, [
        'storageClass' => $storageClass,
        'location' => $location,
    ]);

    $objects = $bucket->objects([
        'encryption' => [
            'defaultKmsKeyName' => null,
        ]
    ]);

    printf('Created bucket %s in %s with storage class %s', $bucketName, $storageClass, $location);
}

Python

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 the US region with the coldline storage
    class
    """
    # bucket_name = "your-new-bucket-name"

    storage_client = storage.Client()

    bucket = storage_client.bucket(bucket_name)
    bucket.storage_class = "COLDLINE"
    new_bucket = storage_client.create_bucket(bucket, location="us")

    print(
        "Created bucket {} in {} with storage class {}".format(
            new_bucket.name, new_bucket.location, new_bucket.storage_class
        )
    )
    return new_bucket

Ruby

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

def create_bucket_class_location bucket_name:
  # The ID to give your GCS bucket
  # bucket_name = "your-unique-bucket-name"

  require "google/cloud/storage"

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

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

Terraform

Vous pouvez utiliser une ressource Terraform pour créer un bucket de stockage.

# Create new storage bucket in the US multi-region
# with coldline storage
resource "google_storage_bucket" "static" {
  name          = "new-bucket"
  location      = "US"
  storage_class = "COLDLINE"

  uniform_bucket_level_access = true
}

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. Pour obtenir des instructions, consultez la page Authentification des API.
  2. Créez un fichier .json contenant les paramètres du bucket, qui doit inclure un name pour le bucket. Consultez la documentation de la section Buckets:Insert pour obtenir la liste complète des paramètres. Les paramètres les plus courants sont les suivants :
  3. {
      "name": "BUCKET_NAME",
      "location": "BUCKET_LOCATION",
      "storageClass": "STORAGE_CLASS",
      "iamConfiguration": {
        "uniformBucketLevelAccess": {
          "enabled": true
        },
      }
    }

    Où :

    • BUCKET_NAME correspond au nom que vous souhaitez attribuer au bucket, ce nom étant soumis à des exigences de dénomination. Par exemple, my-bucket.
    • BUCKET_LOCATION correspond à l'emplacement où vous souhaitez stocker les données d'objets du bucket. Par exemple, US-EAST1.
    • STORAGE_CLASS est la classe de stockage par défaut du bucket. Par exemple, NEARLINE.
  4. Utilisez cURL pour appeler l'API JSON :
    curl -X POST --data-binary @JSON_FILE_NAME.json \
         -H "Authorization: Bearer OAUTH2_TOKEN" \
         -H "Content-Type: application/json" \
         "https://storage.googleapis.com/storage/v1/b?project=PROJECT_IDENTIFIER"

    Où :

    • JSON_FILE_NAME correspond au nom du fichier JSON que vous avez créé à l'étape 2.
    • OAUTH2_TOKEN correspond au jeton d'accès que vous avez généré à l'étape 1.
    • PROJECT_IDENTIFIER correspond à l'ID ou au numéro du projet auquel le bucket sera associé. Exemple :my-project

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. Pour obtenir des instructions, consultez la page Authentification des API.
  2. Créez un fichier .xml contenant les informations suivantes :
  3. <CreateBucketConfiguration>
       <LocationConstraint>BUCKET_LOCATION</LocationConstraint>
       <StorageClass>STORAGE_CLASS</StorageClass>
    </CreateBucketConfiguration>

    Où :

  4. Utilisez cURL pour appeler l'API XML :
    curl -X PUT --data-binary @XML_FILE_NAME.xml \
         -H "Authorization: Bearer OAUTH2_TOKEN" \
         -H "x-goog-project-id: PROJECT_ID" \
         "https://storage.googleapis.com/BUCKET_NAME"

    Où :

    • XML_FILE_NAME correspond au nom du fichier XML que vous avez créé à l'étape 2.
    • OAUTH2_TOKEN correspond au jeton d'accès que vous avez généré à l'étape 1.
    • PROJECT_ID correspond à l'ID du projet auquel le bucket sera associé. Par exemple, my-project.
    • BUCKET_NAME correspond au nom que vous souhaitez attribuer au bucket, ce nom étant soumis à des exigences de dénomination. Exemple : my-bucket.

Importer les fichiers de votre site

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

Console

  1. Dans Google Cloud Console, accédez à la page du Navigateur Cloud Storage.

    Accéder à la page du navigateur

  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, accédez au fichier souhaité et sélectionnez-le.

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

Pour savoir comment obtenir des informations d'erreur détaillées sur les opérations ayant échoué dans le navigateur Cloud Storage, consultez la page Dépannage.

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 vers le bucket my-static-assets :

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

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

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

Exemples de code

C++

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

L'exemple suivant lance l'importation d'un objet à partir d'un fichier :

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

L'exemple suivant lance l'importation d'un objet à partir de la mémoire :

namespace gcs = ::google::cloud::storage;
using ::google::cloud::StatusOr;
[](gcs::Client client, std::string const& bucket_name,
   std::string const& object_name) {
  std::string const text = "Lorem ipsum dolor sit amet";
  std::vector<std::string> v(100, text);
  gcs::ObjectWriteStream stream =
      client.WriteObject(bucket_name, object_name);

  std::copy(v.begin(), v.end(), std::ostream_iterator<std::string>(stream));

  stream.Close();

  StatusOr<gcs::ObjectMetadata> metadata = std::move(stream).metadata();
  if (!metadata) throw std::runtime_error(metadata.status().message());
  std::cout << "Successfully wrote to object " << metadata->name()
            << " its size is: " << metadata->size()
            << "\nFull metadata: " << *metadata << "\n";
}

C#

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

L'exemple suivant lance l'importation d'un objet à partir d'un fichier :


using Google.Cloud.Storage.V1;
using System;
using System.IO;

public class UploadFileSample
{
    public void UploadFile(
        string bucketName = "your-unique-bucket-name",
        string localPath = "my-local-path/my-file-name",
        string objectName = "my-file-name")
    {
        var storage = StorageClient.Create();
        using var fileStream = File.OpenRead(localPath);
        storage.UploadObject(bucketName, objectName, null, fileStream);
        Console.WriteLine($"Uploaded {objectName}.");
    }
}

L'exemple suivant lance l'importation d'un objet à partir de la mémoire :


using Google.Cloud.Storage.V1;
using System;
using System.IO;
using System.Text;

public class UploadObjectFromMemorySample
{
    public void UploadObjectFromMemory(
        string bucketName = "unique-bucket-name",
        string objectName = "file-name",
        string contents = "Hello world!")
    {
        var storage = StorageClient.Create();
        byte[] byteArray = Encoding.UTF8.GetBytes(contents);
        MemoryStream stream = new MemoryStream(byteArray);
        storage.UploadObject(bucketName, objectName, "application/octet-stream" , stream);

        Console.WriteLine($" {objectName} uploaded to bucket {bucketName} with contents: {contents}");
    }
}

Go

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

L'exemple suivant lance l'importation d'un objet à partir d'un fichier :

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

	o := client.Bucket(bucket).Object(object)

	// Optional: set a generation-match precondition to avoid potential race
	// conditions and data corruptions. The request to upload is aborted if the
	// object's generation number does not match your precondition.
	// For an object that does not yet exist, set the DoesNotExist precondition.
	o = o.If(storage.Conditions{DoesNotExist: true})
	// If the live object already exists in your bucket, set instead a
	// generation-match precondition using the live object's generation number.
	// attrs, err := o.Attrs(ctx)
	// if err != nil {
	// 	return fmt.Errorf("object.Attrs: %v", err)
	// }
	// o = o.If(storage.Conditions{GenerationMatch: attrs.Generation})

	// Upload an object with storage.Writer.
	wc := o.NewWriter(ctx)
	if _, err = io.Copy(wc, f); err != nil {
		return fmt.Errorf("io.Copy: %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
}

L'exemple suivant lance l'importation d'un objet à partir de la mémoire :

import (
	"bytes"
	"context"
	"fmt"
	"io"
	"time"

	"cloud.google.com/go/storage"
)

// streamFileUpload uploads an object via a stream.
func streamFileUpload(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()

	b := []byte("Hello world.")
	buf := bytes.NewBuffer(b)

	ctx, cancel := context.WithTimeout(ctx, time.Second*50)
	defer cancel()

	// Upload an object with storage.Writer.
	wc := client.Bucket(bucket).Object(object).NewWriter(ctx)
	wc.ChunkSize = 0 // note retries are not supported for chunk size 0.

	if _, err = io.Copy(wc, buf); err != nil {
		return fmt.Errorf("io.Copy: %v", err)
	}
	// Data can continue to be added to the file until the writer is closed.
	if err := wc.Close(); err != nil {
		return fmt.Errorf("Writer.Close: %v", err)
	}
	fmt.Fprintf(w, "%v uploaded to %v.\n", object, bucket)

	return nil
}

Java

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

L'exemple suivant lance l'importation d'un objet à partir d'un fichier :


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

L'exemple suivant lance l'importation d'un objet à partir de la mémoire :


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.ByteArrayInputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;

public class UploadObjectFromMemory {
  public static void uploadObjectFromMemory(
      String projectId, String bucketName, String objectName, String contents) 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 string of contents you wish to upload
    // String contents = "Hello world!";

    Storage storage = StorageOptions.newBuilder().setProjectId(projectId).build().getService();
    BlobId blobId = BlobId.of(bucketName, objectName);
    BlobInfo blobInfo = BlobInfo.newBuilder(blobId).build();
    byte[] content = contents.getBytes(StandardCharsets.UTF_8);
    storage.createFrom(blobInfo, new ByteArrayInputStream(content));

    System.out.println(
        "Object "
            + objectName
            + " uploaded to bucket "
            + bucketName
            + " with contents "
            + contents);
  }
}

Node.js

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

L'exemple suivant lance l'importation d'un objet à partir d'un fichier :

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// The ID of your GCS bucket
// const bucketName = 'your-unique-bucket-name';

// The path to your file to upload
// const filePath = 'path/to/your/file';

// The new ID for your GCS file
// const destFileName = 'your-new-file-name';

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

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

async function uploadFile() {
  await storage.bucket(bucketName).upload(filePath, {
    destination: destFileName,
  });

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

uploadFile().catch(console.error);

L'exemple suivant lance l'importation d'un objet à partir de la mémoire :

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// The ID of your GCS bucket
// const bucketName = 'your-unique-bucket-name';

// The contents that you want to upload
// const contents = 'these are my contents';

// The new ID for your GCS file
// const destFileName = 'your-new-file-name';

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

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

async function uploadFromMemory() {
  await storage.bucket(bucketName).file(destFileName).save(contents);

  console.log(
    `${destFileName} with contents ${contents} uploaded to ${bucketName}.`
  );
}

uploadFromMemory().catch(console.error);

PHP

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

L'exemple suivant lance l'importation d'un objet à partir d'un fichier :

use Google\Cloud\Storage\StorageClient;

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

    $storage = new StorageClient();
    $file = fopen($source, 'r');
    $bucket = $storage->bucket($bucketName);
    $object = $bucket->upload($file, [
        'name' => $objectName
    ]);
    printf('Uploaded %s to gs://%s/%s' . PHP_EOL, basename($source), $bucketName, $objectName);
}

L'exemple suivant lance l'importation d'un objet à partir de la mémoire :

use Google\Cloud\Storage\StorageClient;

/**
 * Upload an object from memory buffer.
 *
 * @param string $bucketName The name of your Cloud Storage bucket.
 * @param string $objectName The name of your Cloud Storage object.
 * @param string $contents The contents to upload to the file.
 */
function upload_object_from_memory(
    string $bucketName,
    string $objectName,
    string $contents
): void {
    // $bucketName = 'my-bucket';
    // $objectName = 'my-object';
    // $contents = 'these are my contents';

    $storage = new StorageClient();
    $stream = fopen('data://text/plain,' . $contents, 'r');
    $bucket = $storage->bucket($bucketName);
    $bucket->upload($stream, [
        'name' => $objectName,
    ]);
    printf('Uploaded %s to gs://%s/%s' . PHP_EOL, $contents, $bucketName, $objectName);
}

Python

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

L'exemple suivant lance l'importation d'un objet à partir d'un fichier :

from google.cloud import storage

def upload_blob(bucket_name, source_file_name, destination_blob_name):
    """Uploads a file to the bucket."""
    # The ID of your GCS bucket
    # bucket_name = "your-bucket-name"
    # The path to your file to upload
    # source_file_name = "local/path/to/file"
    # The ID of your GCS object
    # destination_blob_name = "storage-object-name"

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

    blob.upload_from_filename(source_file_name)

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

L'exemple suivant lance l'importation d'un objet à partir de la mémoire :

from google.cloud import storage

def upload_blob_from_memory(bucket_name, contents, destination_blob_name):
    """Uploads a file to the bucket."""

    # The ID of your GCS bucket
    # bucket_name = "your-bucket-name"

    # The contents to upload to the file
    # contents = "these are my contents"

    # The ID of your GCS object
    # destination_blob_name = "storage-object-name"

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

    blob.upload_from_string(contents)

    print(
        f"{destination_blob_name} with contents {contents} uploaded to {bucket_name}."
    )

Ruby

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

L'exemple suivant lance l'importation d'un objet à partir d'un fichier :

def upload_file bucket_name:, local_file_path:, file_name: nil
  # The ID of your GCS bucket
  # bucket_name = "your-unique-bucket-name"

  # The path to your file to upload
  # local_file_path = "/local/path/to/file.txt"

  # The ID of your GCS object
  # file_name = "your-file-name"

  require "google/cloud/storage"

  storage = Google::Cloud::Storage.new
  bucket  = storage.bucket bucket_name, skip_lookup: true

  file = bucket.create_file local_file_path, file_name

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

L'exemple suivant lance l'importation d'un objet à partir de la mémoire :

# The ID of your GCS bucket
# bucket_name = "your-unique-bucket-name"

# The ID of your GCS object
# file_name = "your-file-name"

# The contents to upload to your file
# file_content = "Hello, world!"

require "google/cloud/storage"

storage = Google::Cloud::Storage.new
bucket  = storage.bucket bucket_name, skip_lookup: true

file = bucket.create_file StringIO.new(file_content), file_name

puts "Uploaded file #{file.name} to bucket #{bucket_name} with content: #{file_content}"

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. Pour obtenir des instructions, consultez la page Authentification des API.
  2. Utilisez cURL pour appeler l'API JSON avec une requête d'objet POST : Pour le fichier index.html importé dans un bucket nommé my-static-assets :

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

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. Pour obtenir des instructions, consultez la page Authentification des API.
  2. Utilisez cURL pour appeler l'API XML avec une requête d'objet PUT : Pour le fichier index.html importé dans un bucket nommé my-static-assets :

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

Partager des fichiers

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

Console

  1. Dans Google Cloud Console, accédez à la page du Navigateur Cloud Storage.

    Accéder à la page du navigateur

  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.

    La boîte de dialogue Ajouter des entités principales s'affiche.

  5. Dans le champ Nouvelles entités principales, 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.

Pour savoir comment obtenir des informations d'erreur détaillées sur les opérations ayant échoué dans le navigateur Cloud Storage, consultez la page Dépannage.

gsutil

Exécutez la commande gsutil iam ch :

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

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) {
  auto current_policy = client.GetNativeBucketIamPolicy(
      bucket_name, gcs::RequestedPolicyVersion(3));

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

  current_policy->set_version(3);
  current_policy->bindings().emplace_back(
      gcs::NativeIamBinding("roles/storage.objectViewer", {"allUsers"}));

  auto updated =
      client.SetNativeBucketIamPolicy(bucket_name, *current_policy);
  if (!updated) throw std::runtime_error(updated.status().message());

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

Go

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

import (
	"context"
	"fmt"
	"io"

	"cloud.google.com/go/iam"
	"cloud.google.com/go/storage"
	iampb "google.golang.org/genproto/googleapis/iam/v1"
)

// setBucketPublicIAM makes all objects in a bucket publicly readable.
func setBucketPublicIAM(w io.Writer, bucketName string) error {
	// bucketName := "bucket-name"
	ctx := context.Background()
	client, err := storage.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("storage.NewClient: %v", err)
	}
	defer client.Close()

	policy, err := client.Bucket(bucketName).IAM().V3().Policy(ctx)
	if err != nil {
		return fmt.Errorf("Bucket(%q).IAM().V3().Policy: %v", bucketName, err)
	}
	role := "roles/storage.objectViewer"
	policy.Bindings = append(policy.Bindings, &iampb.Binding{
		Role:    role,
		Members: []string{iam.AllUsers},
	})
	if err := client.Bucket(bucketName).IAM().V3().SetPolicy(ctx, policy); err != nil {
		return fmt.Errorf("Bucket(%q).IAM().SetPolicy: %v", bucketName, err)
	}
	fmt.Fprintf(w, "Bucket %v is now publicly readable\n", bucketName)
	return nil
}

Java

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

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.
 */
// The ID of your GCS bucket
// const bucketName = 'your-unique-bucket-name';

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

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

async function makeBucketPublic() {
  await storage.bucket(bucketName).makePublic();

  console.log(`Bucket ${bucketName} is now publicly readable`);
}

makeBucketPublic().catch(console.error);

Python

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

from typing import List

from google.cloud import storage

def set_bucket_public_iam(
    bucket_name: str = "your-bucket-name",
    members: List[str] = ["allUsers"],
):
    """Set a public IAM Policy to bucket"""
    # bucket_name = "your-bucket-name"

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

    policy = bucket.get_iam_policy(requested_policy_version=3)
    policy.bindings.append(
        {"role": "roles/storage.objectViewer", "members": members}
    )

    bucket.set_iam_policy(policy)

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

Ruby

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

def set_bucket_public_iam bucket_name:
  # The ID of your GCS bucket
  # bucket_name = "your-unique-bucket-name"

  require "google/cloud/storage"

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

  bucket.policy do |p|
    p.add "roles/storage.objectViewer", "allUsers"
  end

  puts "Bucket #{bucket_name} is now publicly readable"
end

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. Pour obtenir des instructions, consultez la page Authentification des API.
  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 \
      -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 chemin d'accès au fichier JSON 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-static-assets.

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 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. Dans Google Cloud Console, accédez à la page du Navigateur Cloud Storage.

    Accéder à la page du navigateur

  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.

Pour savoir comment obtenir des informations d'erreur détaillées sur les opérations ayant échoué dans le navigateur Cloud Storage, consultez la page Dépannage.

gsutil

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

gsutil web set -m index.html -e 404.html gs://my-static-assets

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

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

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

C#

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


using Google.Apis.Storage.v1.Data;
using Google.Cloud.Storage.V1;
using System;

public class BucketWebsiteConfigurationSample
{
    public Bucket BucketWebsiteConfiguration(
        string bucketName = "your-bucket-name",
        string mainPageSuffix = "index.html",
        string notFoundPage = "404.html")
    {
        var storage = StorageClient.Create();
        var bucket = storage.GetBucket(bucketName);

        if (bucket.Website == null)
        {
            bucket.Website = new Bucket.WebsiteData();
        }
        bucket.Website.MainPageSuffix = mainPageSuffix;
        bucket.Website.NotFoundPage = notFoundPage;

        bucket = storage.UpdateBucket(bucket);
        Console.WriteLine($"Static website bucket {bucketName} is set up to use {mainPageSuffix} as the index page and {notFoundPage} as the 404 not found page.");
        return bucket;
    }
}

Go

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

// setBucketWebsiteInfo sets website configuration on a bucket.
func setBucketWebsiteInfo(w io.Writer, bucketName, indexPage, notFoundPage string) error {
	// bucketName := "www.example.com"
	// indexPage := "index.html"
	// notFoundPage := "404.html"
	ctx := context.Background()
	client, err := storage.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("storage.NewClient: %v", err)
	}
	defer client.Close()

	ctx, cancel := context.WithTimeout(ctx, time.Second*10)
	defer cancel()

	bucket := client.Bucket(bucketName)
	bucketAttrsToUpdate := storage.BucketAttrsToUpdate{
		Website: &storage.BucketWebsite{
			MainPageSuffix: indexPage,
			NotFoundPage:   notFoundPage,
		},
	}
	if _, err := bucket.Update(ctx, bucketAttrsToUpdate); err != nil {
		return fmt.Errorf("Bucket(%q).Update: %v", bucketName, err)
	}
	fmt.Fprintf(w, "Static website bucket %v is set up to use %v as the index page and %v as the 404 page\n", bucketName, indexPage, notFoundPage)
	return nil
}

Java

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

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.
 */
// The ID of your GCS bucket
// const bucketName = 'your-unique-bucket-name';

// The name of the main page
// const mainPageSuffix = 'http://example.com';

// The Name of a 404 page
// const notFoundPage = 'http://example.com/404.html';

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

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

async function addBucketWebsiteConfiguration() {
  await storage.bucket(bucketName).setMetadata({
    website: {
      mainPageSuffix,
      notFoundPage,
    },
  });

  console.log(
    `Static website bucket ${bucketName} is set up to use ${mainPageSuffix} as the index page and ${notFoundPage} as the 404 page`
  );
}

addBucketWebsiteConfiguration().catch(console.error);

PHP

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

use Google\Cloud\Storage\StorageClient;

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

    $storage = new StorageClient();
    $bucket = $storage->bucket($bucketName);

    $bucket->update([
        'website' => [
            'mainPageSuffix' => $indexPageObject,
            'notFoundPage' => $notFoundPageObject
        ]
    ]);

    printf(
        'Static website bucket %s is set up to use %s as the index page and %s as the 404 page.',
        $bucketName,
        $indexPageObject,
        $notFoundPageObject
    );
}

Python

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

Ruby

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

def define_bucket_website_configuration bucket_name:, main_page_suffix:, not_found_page:
  # The ID of your static website bucket
  # bucket_name = "www.example.com"

  # The index page for a static website bucket
  # main_page_suffix = "index.html"

  # The 404 page for a static website bucket
  # not_found_page = "404.html"

  require "google/cloud/storage"

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

  bucket.update do |b|
    b.website_main = main_page_suffix
    b.website_404 = not_found_page
  end

  puts "Static website bucket #{bucket_name} is set up to use #{main_page_suffix} as the index page and " \
       "#{not_found_page} as the 404 page"
end

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. Pour obtenir des instructions, consultez la page Authentification des API.
  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 le bucket my-static-assets :

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

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. Pour obtenir des instructions, consultez la page Authentification des API.
  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 my-static-assets :

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

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 From Internet to my VMs or serverless services (D'Internet vers mes VM ou mes services sans serveur).
  4. Sélectionnez Équilibreur de charge HTTP(S) global.
  5. Cliquez sur Continuer.

    La fenêtre de configuration de votre équilibreur de charge s'affiche.

  6. Avant de poursuivre la configuration, 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 Services de backend et buckets backend, cliquez sur Créer un bucket backend.
  3. Choisissez un nom de bucket backend, tel que example-bucket. Le nom que vous choisissez peut être différent du nom du bucket que vous avez créé précédemment.
  4. Cliquez sur Browse (Parcourir) dans le champ Cloud Storage bucket (Bucket Cloud Storage).
  5. Sélectionnez le bucket my-static-assets que vous avez créé précédemment, puis cliquez sur Sélectionner.
  6. (Facultatif) Si vous souhaitez utiliser Cloud CDN, cochez la case Activer Cloud CDN et configurez Cloud CDN comme vous le souhaitez. Notez que Cloud CDN peut entraîner des coûts supplémentaires.
  7. Cliquez sur Create (Créer).

Configurer des règles de routage

Les règles de routage sont les composants du mappage d'URL d'un équilibreur de charge HTTP(S) externe. Dans ce tutoriel, vous devez ignorer cette partie de la configuration de l'équilibreur de charge, car elle est automatiquement définie pour utiliser le backend que vous venez de configurer.

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. (Facultatif) Attribuez un nom à la configuration de votre interface.
  3. Sous Protocol (Protocole), sélectionnez HTTPS (includes HTTP/2) (HTTPS (y compris HTTP/2).
  4. Pour Niveau de service réseau, sélectionnez Premium.
  5. Pour Version IP, sélectionnez IPv4. Si vous préférez le protocole IPv6, consultez la documentation sur la terminaison IPv6 pour en savoir plus.
  6. Pour le champ Adresse IP :

    • Dans la liste déroulante, cliquez sur Créer une adresse IP.
    • Dans la fenêtre pop-up Réserver une nouvelle adresse IP statique, saisissez un nom, tel que example-ip pour le nom de l'adresse IP.
    • Cliquez sur Réserver.
  7. Pour Port, sélectionnez 443.

  8. Dans le menu déroulant 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é :

    • Attribuez un nom à votre certificat, tel que example-ssl.
    • Dans le champ Créer un mode, sélectionnez Créer un certificat géré par Google.
    • Pour les Domains (Domaines), saisissez le nom de votre site Web, tel que 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.
  9. Cliquez sur Create (Créer).

  10. (Facultatif) Si vous souhaitez que Google Cloud configure automatiquement un équilibreur de charge HTTP partiel pour rediriger le trafic HTTP, cochez la case Activer la redirection HTTP vers HTTPS.

  11. Cliquez sur OK.

Vérifier la configuration

  1. Cliquez sur Vérifier et finaliser.
  2. Examinez l'interface, les règles de routage et le backend.
  3. Cliquez sur Create (Créer).

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

Connecter un 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'entre eux, pointant tous vers l'adresse IP de l'équilibreur de charge. Par exemple, pour créer des enregistrements A pour www.example.com et example.com :

NAME                  TYPE     DATA
www                   A        30.90.80.100
@                     A        30.90.80.100

Si vous utilisez Google Domains, consultez la page d'aide Google Domains pour obtenir plus d'informations.

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 le bucket que vous utilisez en tant que backend. Si vous définissez la propriété MainPageSuffix, https://www.example.com passe à index.html.

Effectuer un nettoyage

Une fois le tutoriel terminé, vous pouvez procéder au nettoyage des ressources que vous avez créées afin qu'elles ne soient plus comptabilisées dans votre quota et qu'elles ne vous soient plus 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 la 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 my-static-assets 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.

Libérer une adresse IP réservée

Pour supprimer l'adresse IP réservée que vous avez utilisée pour le tutoriel :

  1. Dans la console, accédez à la page Adresses IP externes.

    Accéder à la page "Adresses IP externes"

  2. Cochez les cases situées à côté de example-ip.

  3. Cliquez sur Libérer l'adresse statique.

  4. Dans la fenêtre de confirmation, cliquez sur Supprimer.

Étape suivante

Faites l'essai

Si vous débutez sur Google Cloud, créez un compte pour évaluer les performances de Cloud Storage en conditions réelles. Les nouveaux clients bénéficient également de 300 $ de crédits offerts pour exécuter, tester et déployer des charges de travail.

Profiter d'un essai gratuit de Cloud Storage