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. Pour obtenir plus d'informations sur les pages Web statiques, notamment des exemples et des conseils, consultez la page Site Web statique : exemples et conseils.

Ce tutoriel s'applique également à l'hébergement d'éléments statiques pour un site Web dynamique.

Objectifs

Au cours de ce tutoriel, vous allez :

  • faire pointer votre domaine vers Cloud Storage à l'aide d'un enregistrement CNAME ;
  • créer un bucket associé à votre domaine ;
  • importer et partager les fichiers de votre site ;
  • tester le site Web.

Coûts

Ce tutoriel utilise le composant facturable suivant de Cloud Platform :

  • Cloud Storage

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

Avant de commencer

  1. Connectez-vous à votre compte Google.

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

  2. Sélectionnez ou créez un projet Google Cloud Platform.

    Accéder à la page "Gérer les ressources"

  3. Assurez-vous que la facturation est activée pour votre projet Google Cloud Platform.

    Découvrir comment activer la facturation

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

    Ce tutoriel utilise le domaine example.com.

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

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

Créer un enregistrement CNAME

Un enregistrement CNAME est un type d'enregistrement DNS. Il dirige le trafic qui demande une URL depuis votre domaine vers les ressources que vous souhaitez diffuser, dans ce cas des objets dans vos buckets Cloud Storage. Pour www.example.com, l'enregistrement CNAME peut contenir les informations suivantes :

NAME                  TYPE     DATA
www.example.com       CNAME    c.storage.googleapis.com.

Pour en savoir plus sur les redirections CNAME, consultez la section URI pour la création d'alias CNAME.

Pour connecter votre domaine à Cloud Storage, procédez comme suit :

  1. Créez un enregistrement CNAME qui pointe vers c.storage.googleapis.com.

    Votre service d'enregistrement de domaine devrait vous permettre d'administrer le domaine, y compris l'ajout d'enregistrements CNAME. Par exemple, si vous utilisez Google Domains, vous trouverez des instructions relatives à l'ajout d'un enregistrement CNAME sur la page d'aide de Google Domains.

Créer un bucket

Créez un bucket dont le nom correspond au CNAME que vous avez créé pour votre domaine.

Par exemple, si vous avez ajouté un enregistrement CNAME faisant pointer www.example.com vers c.storage.googleapis.com., créez un bucket portant le nom "www.example.com".

Pour créer un bucket :

Console

  1. Ouvrez le navigateur Cloud Storage dans la console Google Cloud Platform.
    Ouvrir le navigateur Cloud Storage
  2. Cliquez sur Créer un bucket.

  3. Dans la boîte de dialogue Créer un bucket, spécifiez les éléments suivants :

    • Le nom du bucket

    • La classe de stockage du bucket : Multi-Regional

    • L'emplacement du bucket : US

  4. Cliquez sur Créer.

Si l'opération aboutit, vous êtes dirigé vers la page du bucket, qui affiche un texte de type "Aucun objet dans ce bucket".

gsutil

Exécutez la commande gsutil mb :

gsutil mb gs://www.example.com

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

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

Exemples de code

C++

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

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

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

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

C#

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

private void CreateBucket(string bucketName)
{
    var storage = StorageClient.Create();
    storage.CreateBucket(s_projectId, bucketName);
    Console.WriteLine($"Created {bucketName}.");
}

Go

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

bucket := client.Bucket(bucketName)
if err := bucket.Create(ctx, projectID, &storage.BucketAttrs{
	StorageClass: "COLDLINE",
	Location:     "asia",
}); err != nil {
	return err
}

Java

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

Bucket bucket =
    storage.create(
        BucketInfo.newBuilder(bucketName)
            // See here for possible values: http://g.co/cloud/storage/docs/storage-classes
            .setStorageClass(StorageClass.COLDLINE)
            // Possible values: http://g.co/cloud/storage/docs/bucket-locations#location-mr
            .setLocation("asia")
            .build());

Node.js

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

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

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

/**
 * TODO(developer): Uncomment the following line before running the sample.
 */
// const bucketName = 'Name of a bucket, e.g. my-bucket';

// Creates a new bucket in the Asia region with the coldline default storage
// class. Leave the second argument blank for default settings.
//
// For default values see: https://cloud.google.com/storage/docs/locations and
// https://cloud.google.com/storage/docs/storage-classes
await storage.createBucket(bucketName, {
  location: 'ASIA',
  storageClass: 'COLDLINE',
});

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

PHP

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

use Google\Cloud\Storage\StorageClient;

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

Python

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

def create_bucket(bucket_name):
    """Creates a new bucket."""
    storage_client = storage.Client()
    bucket = storage_client.create_bucket(bucket_name)
    print('Bucket {} created'.format(bucket.name))

Ruby

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

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

require "google/cloud/storage"

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

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

API REST

API JSON

  1. Obtenez un jeton d'accès d'autorisation sur la page OAuth 2.0 Playground. Configurez Playground de façon à utiliser vos propres identifiants OAuth.
  2. Créez un fichier .json qui attribue à la propriété name le nom de votre site Web :
  3. {
    "name": "www.example.com"
    }
  4. Exécutez cURL pour appeler l'API JSON. Pour www.example.com, procédez comme suit :
    curl -X POST --data-binary @website-bucket-name.json \
     -H "Authorization: Bearer ya29.AHES6ZRVmB7fkLtd1XTmq6mo0S1wqZZi3-Lh_s-6Uw7p8vtgSwg" \
     -H "Content-Type: application/json" \
     "https://www.googleapis.com/storage/v1/b?project=my-static-website"

API XML

  1. Obtenez un jeton d'accès d'autorisation sur la page OAuth 2.0 Playground. Configurez Playground de façon à utiliser vos propres identifiants OAuth.
  2. Exécutez cURL pour appeler l'API XML afin de créer un bucket avec le nom de votre site Web. Pour www.example.com, procédez comme suit :
    curl -X PUT \
     -H "Authorization: Bearer ya29.AHES6ZRVmB7fkLtd1XTmq6mo0S1wqZZi3-Lh_s-6Uw7p8vtgSwg" \
     -H "x-goog-project-id: my-static-website" \
     "https://storage.googleapis.com/www.example.com"

Importer les fichiers de votre site

Pour ajouter à votre bucket les fichiers que vous souhaitez que votre site Web diffuse :

Console

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

  3. Dans l'onglet Objets, 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 du fichier, sa taille, son type et sa date de dernière modification dans le bucket.

Par exemple, un bucket comportant deux fichiers (index.html et 404.html) apparaît dans la console GCP comme suit :

Exemple de site Web de bucket.
Exemple de bucket configuré en tant que site Web

gsutil

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

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

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

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

Exemples de code

C++

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

namespace gcs = google::cloud::storage;
using ::google::cloud::StatusOr;
[](gcs::Client client, std::string file_name, std::string bucket_name,
   std::string object_name) {
  // Note that the client library automatically computes a hash on the
  // client-side to verify data integrity during transmission.
  StatusOr<gcs::ObjectMetadata> object_metadata = client.UploadFile(
      file_name, bucket_name, object_name, gcs::IfGenerationMatch(0));

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

  std::cout << "Uploaded " << file_name << " to object "
            << object_metadata->name() << " in bucket "
            << object_metadata->bucket()
            << "\nFull metadata: " << *object_metadata << "\n";
}

C#

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

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

Go

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

f, err := os.Open("notes.txt")
if err != nil {
	return err
}
defer f.Close()

wc := client.Bucket(bucket).Object(object).NewWriter(ctx)
if _, err = io.Copy(wc, f); err != nil {
	return err
}
if err := wc.Close(); err != nil {
	return err
}

Java

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

Storage storage = StorageOptions.getDefaultInstance().getService();
BlobId blobId = BlobId.of("bucket", "blob_name");
BlobInfo blobInfo = BlobInfo.newBuilder(blobId).setContentType("text/plain").build();
Blob blob = storage.create(blobInfo, "Hello, Cloud Storage!".getBytes(UTF_8));

Node.js

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

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

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

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

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

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

PHP

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

use Google\Cloud\Storage\StorageClient;

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

Python

Pour plus d'informations, consultez la documentation de référence sur 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().
def upload_blob(bucket_name, source_file_name, destination_blob_name):
    """Uploads a file to the bucket."""
    storage_client = storage.Client()
    bucket = storage_client.get_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 plus d'informations, consultez la documentation de référence de l'API Cloud Storage en langage Ruby.

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

require "google/cloud/storage"

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

file = bucket.create_file local_file_path, storage_file_path

puts "Uploaded #{file.name}"

API REST

API JSON

  1. Obtenez un jeton d'accès d'autorisation sur la page OAuth 2.0 Playground. Configurez Playground de façon à utiliser vos propres identifiants OAuth.
  2. Ajoutez les données du fichier au corps de la requête.
  3. Exécutez cURL pour appeler l'API JSON avec une requête d'objet POST. Pour la page d'index de www.example.com, procédez comme suit :
    curl -X POST --data-binary @index.html \
        -H "Content-Type: text/html" \
        -H "Authorization: Bearer ya29.AHES6ZRVmB7fkLtd1XTmq6mo0S1wqZZi3-Lh_s-6Uw7p8vtgSwg" \
        "https://www.googleapis.com/upload/storage/v1/b/www.example.com/o?uploadType=media&name=index.html"

Pour en savoir plus sur l'importation d'objets à l'aide de l'API JSON, consultez la page API JSON : effectuer une importation simple.

API XML

  1. Obtenez un jeton d'accès d'autorisation sur la page OAuth 2.0 Playground. Configurez Playground de façon à utiliser vos propres identifiants OAuth.
  2. Ajoutez les données de l'objet au corps de la requête.
  3. Exécutez cURL pour appeler l'API XML avec une requête d'objet PUT. Pour la page d'index de www.example.com, procédez comme suit :
    curl -X PUT --data-binary @index.html \
        -H "Authorization: Bearer ya29.AHES6ZRVmB7fkLtd1XTmq6mo0S1wqZZi3-Lh_s-6Uw7p8vtgSwg" \
        -H "Content-Type: text/html" \
        "https://storage.googleapis.com/www.example.com/index.html"

Partager des fichiers

Vous pouvez rendre tous les fichiers de votre bucket accessibles au public ou définir des objets individuels de sorte qu'ils soient accessibles via votre site Web. En règle générale, il est plus simple et plus rapide de rendre accessibles tous les fichiers du bucket.

Si vous choisissez de contrôler l'accessibilité de fichiers individuels, vous pouvez définir la liste de contrôle d'accès aux objets par défaut pour votre bucket afin que les fichiers importés par la suite soient partagés par défaut.

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

Vous pouvez attribuer un suffixe de page d'index, contrôlé par la propriété MainPageSuffix, et une page d'erreur personnalisée, contrôlée par la propriété NotFoundPage. L'attribution de l'un ou de l'autre est facultative. Toutefois, sans page d'index, aucun contenu n'est diffusé lorsque des utilisateurs accèdent à votre site de premier niveau, par exemple http://www.example.com.

Pages d'index

Une page d'index (également appelée index de répertoire de serveur Web) est un fichier diffusé aux visiteurs qui demandent une URL sans fichier associé. Lorsque vous attribuez un élément MainPageSuffix, Cloud Storage recherche un fichier portant ce nom dont le préfixe correspond à l'URL demandée par le visiteur.

Par exemple, supposons que vous définissiez l'élément MainPageSuffix de votre site Web statique sur index.html. Supposons également que votre bucket www.example.com ne comporte pas de fichier nommé directory. Dans ce cas, si un utilisateur demande l'URL http://www.example.com/directory, Cloud Storage tente de diffuser le fichier www.example.com/directory/index.html. Si ce fichier n'existe pas non plus, Cloud Storage renvoie une page d'erreur.

L'élément MainPageSuffix contrôle également le fichier diffusé lorsque les utilisateurs demandent le site de premier niveau. En reprenant l'exemple ci-dessus, si un utilisateur demande http://www.example.com, Cloud Storage tente de diffuser le fichier www.example.com/index.html.

Page d'erreur

La page d'erreur est le fichier renvoyé aux visiteurs de votre site statique lorsqu'ils demandent une URL qui ne correspond à aucun fichier existant. Si vous avez attribué un élément MainPageSuffix, Cloud Storage ne renvoie la page d'erreur que s'il n'existe ni fichier portant le nom demandé, ni page d'index applicable.

En cas de renvoi d'une page d'erreur, le code de réponse HTTP est 404. La propriété contrôlant le fichier qui sert de page d'erreur est NotFoundPage. Si vous ne définissez pas NotFoundPage, les utilisateurs reçoivent une page d'erreur générique.

Définir MainPageSuffix et NotFoundPage

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

Console

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

  3. Cliquez sur l'icône Autres actions Icône "Autres actions". à côté du bucket, puis sélectionnez Modifier la configuration du site Web.

  4. Dans la boîte de dialogue Configuration du site Web, remplissez les champs Page principale et Page 404 (non trouvée).

  5. Cliquez sur Enregistrer.

gsutil

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

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

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

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

API REST

API JSON

  1. Obtenez un jeton d'accès d'autorisation sur la page OAuth 2.0 Playground. Configurez Playground de façon à utiliser vos propres identifiants OAuth.
  2. Créez un fichier .json qui définit les propriétés mainPageSuffix et notFoundPage d'un objet website sur les pages souhaitées :
    {
    "website":{
    "mainPageSuffix": "index.html",
    "notFoundPage": "404.html"
    }
    }
  3. Exécutez cURL pour appeler l'API JSON avec une requête de bucket PATCH. Pour www.example.com, procédez comme suit :
    curl -X PATCH --data-binary @web-config.json \
     -H "Authorization: Bearer ya29.AHES6ZRVmB7fkLtd1XTmq6mo0S1wqZZi3-Lh_s-6Uw7p8vtgSwg" \
     -H "Content-Type: application/json" \
     "https://www.googleapis.com/storage/v1/b/www.example.com"

API XML

  1. Obtenez un jeton d'accès d'autorisation sur la page OAuth 2.0 Playground. Configurez Playground de façon à utiliser vos propres identifiants OAuth.
  2. Créez un fichier .xml qui définit les éléments MainPageSuffix et NotFoundPage d'un élément WebsiteConfiguration sur les pages souhaitées :
    <WebsiteConfiguration>
    <MainPageSuffix>index.html</MainPageSuffix>
    <NotFoundPage>404.html</NotFoundPage>
    </WebsiteConfiguration>
  3. Exécutez cURL pour appeler l'API XML avec une requête de bucket PUT et un paramètre de chaîne de requête websiteConfig. Pour www.example.com, procédez comme suit :
    curl -X PUT --data-binary @web-config.xml \
        -H "Authorization: Bearer ya29.AHES6ZRVmB7fkLtd1XTmq6mo0S1wqZZi3-Lh_s-6Uw7p8vtgSwg" \
        https://storage.googleapis.com/www.example.com?websiteConfig

Tester le site Web

Vérifiez que le contenu est diffusé à partir du bucket en demandant le nom de domaine dans un navigateur. Pour ce faire, vous pouvez employer un chemin d'accès à un objet ou juste le nom de domaine, si vous définissez la propriété MainPageSuffix.

Par exemple, si vous avez un objet nommé test.html stocké dans un bucket nommé www.example.com, vérifiez qu'il est accessible en accédant à www.example.com/test.html dans votre navigateur.

Effectuer un nettoyage

Après avoir terminé le tutoriel consacré à l'hébergement d'un site Web statique, vous pouvez nettoyer les ressources que vous avez créées sur GCP afin qu'elles ne consomment pas de quota supplémentaire et ne vous soient pas facturées. Dans les sections suivantes, nous allons voir comment supprimer ou désactiver ces ressources.

Supprimer le projet

Le moyen le plus simple d'éviter la facturation consiste à supprimer le projet que vous avez créé pour le tutoriel.

Pour supprimer le projet :

  1. Dans la console GCP, accédez à la page "Projets".

    Accéder à la page Projets

  2. Dans la liste des projets, sélectionnez celui 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 le bucket

Si vous ne souhaitez pas supprimer l'intégralité du projet, contentez-vous de supprimer le bucket que vous avez utilisé pour héberger le site Web :

Console

  1. Ouvrez le navigateur Cloud Storage dans la console Google Cloud Platform.
    Ouvrir le navigateur Cloud Storage
  2. Cochez la case correspondant au bucket que vous souhaitez supprimer.

  3. Cliquez sur Supprimer.

  4. Dans la fenêtre qui apparaît en superposition, cliquez sur Supprimer pour confirmer que vous souhaitez supprimer le bucket et son contenu.

gsutil

Exécutez la commande gsutil rm avec l'indicateur -r pour supprimer le bucket et son contenu :

gsutil rm -r gs://www.example.com

La réponse se présente comme suit :

Removing gs://www.example.com/...

Exemples de code

C++

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

namespace gcs = google::cloud::storage;
[](gcs::Client client, std::string bucket_name) {
  google::cloud::Status status = client.DeleteBucket(bucket_name);

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

  std::cout << "The bucket " << bucket_name << " was deleted successfully.\n";
}

C#

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

private void DeleteBucket(string bucketName)
{
    var storage = StorageClient.Create();
    storage.DeleteBucket(bucketName);
    Console.WriteLine($"Deleted {bucketName}.");
}

Go

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

if err := client.Bucket(bucketName).Delete(ctx); err != nil {
	return err
}

Java

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

boolean deleted = bucket.delete(BucketSourceOption.metagenerationMatch());
if (deleted) {
  // the bucket was deleted
} else {
  // the bucket was not found
}

Node.js

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

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

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

/**
 * TODO(developer): Uncomment the following line before running the sample.
 */
// const bucketName = 'Name of a bucket, e.g. my-bucket';

// Deletes the bucket
await storage.bucket(bucketName).delete();

console.log(`Bucket ${bucketName} deleted.`);

PHP

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

use Google\Cloud\Storage\StorageClient;

/**
 * Delete a Cloud Storage Bucket.
 *
 * @param string $bucketName the name of the bucket to delete.
 *
 * @return void
 */
function delete_bucket($bucketName)
{
    $storage = new StorageClient();
    $bucket = $storage->bucket($bucketName);
    $bucket->delete();
    printf('Bucket deleted: %s' . PHP_EOL, $bucket->name());
}

Python

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

def delete_bucket(bucket_name):
    """Deletes a bucket. The bucket must be empty."""
    storage_client = storage.Client()
    bucket = storage_client.get_bucket(bucket_name)
    bucket.delete()
    print('Bucket {} deleted'.format(bucket.name))

Ruby

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

# project_id  = "Your Google Cloud project ID"
# bucket_name = "Name of your Google Cloud Storage bucket to delete"

require "google/cloud/storage"

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

bucket.delete

puts "Deleted bucket: #{bucket.name}"

API REST

API JSON

Notez que le bucket doit être vide pour que vous puissiez le supprimer.

  1. Obtenez un jeton d'accès d'autorisation sur la page OAuth 2.0 Playground. Configurez Playground de façon à utiliser vos propres identifiants OAuth.
  2. Exécutez cURL pour appeler l'API JSON, en remplaçant les éléments entre crochets ([VALUES_IN_BRACKETS]) par les valeurs appropriées :
    curl -X DELETE -H "Authorization: Bearer [OAUTH2_TOKEN]" \
        "https://www.googleapis.com/storage/v1/b/www.example.com"

Si la requête aboutit, la réponse contient un code d'état 204.

Pour plus d'informations, consultez la page de référence JSON Buckets : delete.

API XML

Notez que le bucket doit être vide pour que vous puissiez le supprimer.

  1. Obtenez un jeton d'accès d'autorisation sur la page OAuth 2.0 Playground. Configurez Playground de façon à utiliser vos propres identifiants OAuth.
  2. Exécutez cURL pour appeler l'API XML, en remplaçant les éléments entre crochets ([VALUES_IN_BRACKETS]) par les valeurs appropriées :
    curl -X DELETE -H "Authorization: Bearer [OAUTH2_TOKEN]" \
        "https://storage.googleapis.com/www.example.com"

Pour en savoir plus, consultez la page de la documentation de référence de l'API XML relative à la méthode DELETE Bucket.

Étapes suivantes

Cette page vous a-t-elle été utile ? Évaluez-la :

Envoyer des commentaires concernant…

Besoin d'aide ? Consultez notre page d'assistance.