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.

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.

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.

   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 au sélecteur de projet

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

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

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

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

7. 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).
8. Vous devez disposer des rôles Identity and Access Management suivants : Administrateur des objets Storage et Administrateur réseau.
9. (Facultatif) Vous pouvez attribuer le même nom à votre bucket Cloud Storage que votre domaine. Pour ce faire, vous devez confirmer que vous êtes le propriétaire ou le gestionnaire du domaine que vous utiliserez. 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.

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

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

   • Sous Paramètres avancés (facultatif), ajoutez des libellés de bucket, définissez une règle de conservation et choisissez une méthode de chiffrement.
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.

gsutil

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 options facultatives suivantes pour mieux contrôler la création du bucket :

• -p : spécifiez le projet auquel le bucket sera associé. Par 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. Par exemple, US-EAST1.
• -b : activez un accès uniforme au niveau du bucket pour votre bucket.

Exemple :

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

Exemples de code

Remarque : D'autres options de création d'un bucket sont disponibles dans la documentation de référence de l'API JSON pour bucket.insert.

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

Afficher sur GitHub Commentaires

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.

Afficher sur GitHub Commentaires

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

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

// createBucketClassLocation creates a new bucket in the project with Storage class and
// location.
func createBucketClassLocation(w io.Writer, projectID, bucketName string) error {
	// projectID := "my-project-id"
	// bucketName := "bucket-name"
	ctx := context.Background()
	client, err := storage.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("storage.NewClient: %v", err)
	}
	defer client.Close()

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

	storageClassAndLocation := &storage.BucketAttrs{
		StorageClass: "COLDLINE",
		Location:     "asia",
	}
	bucket := client.Bucket(bucketName)
	if err := bucket.Create(ctx, projectID, storageClassAndLocation); err != nil {
		return fmt.Errorf("Bucket(%q).Create: %v", bucketName, err)
	}
	fmt.Fprintf(w, "Created bucket %v in %v with storage class %v\n", bucketName, storageClassAndLocation.Location, storageClassAndLocation.StorageClass)
	return nil
}

Java

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

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

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

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

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

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

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

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

createBucketWithStorageClassAndLocation().catch(console.error);

PHP

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

Afficher sur GitHub Commentaires

from google.cloud import storage

def create_bucket_class_location(bucket_name):
    """Create a new bucket in specific location with storage class"""
    # bucket_name = "your-new-bucket-name"

    storage_client = storage.Client()

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

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

Ruby

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

Afficher sur GitHub Commentaires

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

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

{
  "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.
3. 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_ID"

   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_ID correspond à l'ID du projet auquel le bucket sera associé. Par exemple, my-project.

API XML

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

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

Où :

• 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.
3. 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. Par 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, 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.

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

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

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

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

Go

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.

Pour plus d'informations sur l'importation d'un flux, d'une chaîne ou d'un tampon, consultez la section File.save().

Afficher sur GitHub Commentaires

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

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

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

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

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

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

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

uploadFile().catch(console.error);

PHP

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 Cloud Storage bucket.
 * @param string $objectName The name of your Cloud Storage object.
 * @param string $source The path to the file to upload.
 */
function upload_object($bucketName, $objectName, $source)
{
    // $bucketName = 'my-bucket';
    // $objectName = 'my-object';
    // $source = '/path/to/your/file';

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

Python

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

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

    blob.upload_from_filename(source_file_name)

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

Ruby

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

Afficher sur GitHub Commentaires

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

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

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

  require "google/cloud/storage"

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

  file = bucket.create_file local_file_path, file_name

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

API REST

API JSON

1. Obtenez un jeton d'autorisation d'accès sur la page OAuth 2.0 Playground. Configurez Playground pour utiliser vos propres identifiants OAuth.

2. Utilisez cURL pour appeler l'API JSON avec une requête d'objet POST : Pour 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.

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"

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 nommé my-static-assets, exécutez la commande suivante :

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

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

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

Afficher sur GitHub Commentaires

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.

Afficher sur GitHub Commentaires

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.

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

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

Afficher sur GitHub Commentaires

from google.cloud import storage

def set_bucket_public_iam(bucket_name):
    """Set a public IAM Policy to bucket"""
    # bucket_name = "your-bucket-name"

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

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

    bucket.set_iam_policy(policy)

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

Ruby

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

Afficher sur GitHub Commentaires

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.

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

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.

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.

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

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

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

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

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

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

Afficher sur GitHub Commentaires

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.

Afficher sur GitHub Commentaires

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.

Afficher sur GitHub Commentaires

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.

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.

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

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

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

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

Configurer le backend

1. Cliquez sur Backend configuration (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 my-static-assets, puis cliquez sur Sélectionner.
6. Si vous souhaitez utiliser Cloud CDN, cochez la case Activer Cloud CDN. Laissez la sélection du mode de cache sur Mettre en cache le contenu statique. Notez que Cloud CDN peut entraîner des coûts supplémentaires.
7. Cliquez sur Create (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.
   Remarque : La réservation d'une nouvelle adresse IP statique engendre des coûts supplémentaires si l'adresse IP n'est pas associée à un règle de transfert. Pour éviter de tels frais, supprimez l'adresse IP statique lorsque vous supprimez l'équilibreur de charge associé.

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 Create (Créer).

7. Cliquez sur OK.

Vérifier la configuration

1. Cliquez sur Review and finalize (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 de l'interface.
3. Cliquez sur Create (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'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, procédez comme suit :

NAME                  TYPE     DATA
www                   A        30.90.80.100
@                     A        30.90.80.100

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

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 le bucket que vous utilisez en tant que backend. 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.

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 :

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

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

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

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

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 gratuits pour exécuter, tester et déployer des charges de travail.

Profiter d'un essai gratuit de Cloud Storage