Créer un bucket

Cette page explique comment créer un bucket Cloud Storage. Sauf indication contraire dans votre requête, les buckets sont créés dans l'emplacement multirégional US avec une classe de stockage par défaut Stockage standard et une durée de conservation de la suppression réversible de sept jours.

Rôles requis

Pour obtenir les autorisations requises pour créer un bucket Cloud Storage, demandez à votre administrateur de vous accorder le rôle IAM d'administrateur de l'espace de stockage (roles/storage.admin) sur le projet.

Ce rôle prédéfini contient l'autorisation requise pour créer un bucket. Pour afficher les autorisations exactes requises, développez la section Autorisations requises :

Autorisations requises

  • storage.buckets.create
  • storage.buckets.enableObjectRetention (obligatoire uniquement si vous activez des configurations de conservation d'objets pour le bucket)
  • storage.buckets.list (obligatoire uniquement si vous créez un bucket à l'aide de la console Google Cloud)
  • resourcemanager.projects.get (obligatoire uniquement si vous créez un bucket à l'aide de la console Google Cloud)

Vous pouvez également obtenir ces autorisations avec des rôles personnalisés ou d'autres rôles prédéfinis. Pour connaître les rôles et les autorisations associées, consultez la page Rôles IAM pour Cloud Storage.

Pour savoir comment attribuer des rôles aux projets, consultez la page Gérer l'accès aux projets.

Créer un bucket

Si vous créez un bucket pour la première fois, consultez Découvrir le stockage d'objets avec la console Google Cloud ou Découvrir le stockage d'objets avec l'outil Google Cloud CLI.

Pour créer un bucket avec des paramètres spécifiques ou des configurations avancées, procédez comme suit:

Console

  1. Dans la console Google Cloud, accédez à la page Buckets Cloud Storage.

    Accéder à la page "Buckets"

  2. Cliquez sur Créer.

  3. Sur la page Créer un bucket, saisissez les informations concernant votre bucket. Après chacune de ces étapes, cliquez sur Continuer pour passer à l'étape suivante :

    1. Dans la section Premiers pas, procédez comme suit :

      • Saisissez un nom unique qui répond aux exigences de dénomination des buckets.

      • Pour activer l'espace de noms hiérarchique, cliquez sur la flèche d'expansion pour développer la section Optimiser pour les charges de travail orientées fichiers et à forte intensité de données, puis sélectionnez Activer l'espace de noms hiérarchique sur ce bucket.

      • Pour ajouter une étiquette de bucket, cliquez sur la flèche de développement pour développer la section Étiquettes, puis sur Ajouter une étiquette et spécifiez un élément key et value pour votre étiquette.

    2. Dans la section Choisir l'emplacement de stockage de vos données, procédez comme suit :

      1. Sélectionnez un type d'emplacement.

      2. Utilisez le menu déroulant du type d'emplacement pour sélectionner un emplacement où les données d'objets de votre bucket seront stockées de manière permanente.

        • Si vous sélectionnez le type d'emplacement birégional, vous pouvez également choisir d'activer la réplication turbo à l'aide de la case à cocher correspondante.

      3. Pour configurer la réplication entre buckets, développez la section Configurer la réplication entre buckets, puis procédez comme suit:

        Configurer la réplication entre buckets

        1. Cochez la case à côté de Ajouter une réplication entre buckets via le service de transfert de stockage.
        2. Dans le menu Bucket de destination, sélectionnez un bucket de destination.

        3. Dans la section Paramètres de réplication, cliquez sur Configurer pour configurer les paramètres de la tâche de réplication.

          Le volet Configurer la réplication entre buckets s'affiche.

          • Pour filtrer les objets à répliquer en fonction du préfixe de leur nom, saisissez un préfixe avec lequel vous souhaitez inclure ou exclure des objets, puis cliquez sur Ajouter un préfixe.
          • Pour définir une classe de stockage pour les objets répliqués, sélectionnez une classe de stockage dans le menu Classe de stockage. Si vous ignorez cette étape, les objets répliqués utiliseront la classe de stockage du bucket de destination par défaut.
          • Cliquez sur OK.

    3. Dans la section Choisir une classe de stockage pour vos données, sélectionnez une classe de stockage par défaut pour le bucket, ou bien classe automatique pour une gestion automatique des classes de stockage des données de votre bucket.

    4. Dans la section 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 des accès pour les objets de votre bucket.

    5. Dans la section Choisir comment protéger les données d'objet, procédez comme suit :

      • Sélectionnez l'une des options sous Protection des données que vous souhaitez définir pour votre bucket.

      • Pour activer la suppression réversible, cliquez sur la flèche d'expansion intitulée Règle de suppression réversible, puis spécifiez le nombre de jours pendant lesquels vous souhaitez conserver les objets après leur suppression.

      • Pour choisir comment vos données d'objet seront chiffrées, cliquez sur la flèche d'expansion intitulée Chiffrement des données, puis sélectionnez une méthode de chiffrement des données.

  4. Cliquez sur Créer.

Pour savoir comment obtenir des informations détaillées sur les erreurs liées aux opérations Cloud Storage ayant échoué dans la console Google Cloud, consultez la section Dépannage.

Ligne de commande

  1. In the Google Cloud console, activate Cloud Shell.

    Activate Cloud Shell

    At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

  2. Dans votre environnement de développement, exécutez la commande gcloud storage buckets create :

    gcloud storage buckets create gs://BUCKET_NAME --location=BUCKET_LOCATION

    Où :

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

    • BUCKET_LOCATION est l'emplacement du bucket. Par exemple, US.

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

    Creating gs://BUCKET_NAME/...

    Définissez les options suivantes pour mieux contrôler la création du bucket :

    • --project : spécifiez l'ID ou le numéro du projet auquel le bucket sera associé. Exemple :my-project
    • --default-storage-class : spécifiez la classe de stockage par défaut du bucket. Par exemple, STANDARD.
    • --uniform-bucket-level-access : activez un accès uniforme au niveau du bucket pour votre bucket.
    • --soft-delete-policy: spécifiez la durée de conservation de la suppression réversible, c'est-à-dire le nombre de jours pendant lesquels vous souhaitez conserver les objets après leur suppression. Par exemple, 10d.

    Exemple :

    gcloud storage buckets create gs://BUCKET_NAME --project=PROJECT_ID --default-storage-class=STORAGE_CLASS --location=BUCKET_LOCATION --uniform-bucket-level-access
--soft-delete-policy=RETENTION_DURATION

    Pour obtenir la liste complète des options de création de buckets avec gcloud CLI, consultez les options buckets create.

Bibliothèques clientes

C++

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

Pour vous authentifier auprès de Cloud Storage, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez la page Configurer l'authentification pour les bibliothèques clientes. 

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::move(bucket_metadata).status();

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

Pour vous authentifier auprès de Cloud Storage, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez la page Configurer l'authentification pour les bibliothèques clientes. 


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.

Pour vous authentifier auprès de Cloud Storage, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez la page Configurer l'authentification pour les bibliothèques clientes. 

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: %w", 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: %w", 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.

Pour vous authentifier auprès de Cloud Storage, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez la page Configurer l'authentification pour les bibliothèques clientes. 

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.

Pour vous authentifier auprès de Cloud Storage, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez la page Configurer l'authentification pour les bibliothèques clientes. 

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

Pour vous authentifier auprès de Cloud Storage, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez la page Configurer l'authentification pour les bibliothèques clientes. 

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.
 *        (e.g. 'my-bucket')
 */
function create_bucket_class_location(string $bucketName): void
{
    $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.

Pour vous authentifier auprès de Cloud Storage, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez la page Configurer l'authentification pour les bibliothèques clientes. 

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.

Pour vous authentifier auprès de Cloud Storage, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez la page Configurer l'authentification pour les bibliothèques clientes. 

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 "random_id" "bucket_prefix" {
  byte_length = 8
}

resource "google_storage_bucket" "static" {
  name          = "${random_id.bucket_prefix.hex}-new-bucket"
  location      = "US"
  storage_class = "COLDLINE"

  uniform_bucket_level_access = true
}

API REST

API JSON

  1. Vous devez installer et initialiser gcloud CLI, ce qui vous permet de générer un jeton d'accès pour l'en-tête Authorization.

  2. Créez un fichier JSON contenant les paramètres du bucket, qui doit inclure un name pour le bucket. Consultez la documentation 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. Exemple : my-bucket.

    • BUCKET_LOCATION est l'emplacement où vous souhaitez stocker les données d'objets du bucket. Par exemple, US.

    • STORAGE_CLASS est la classe de stockage par défaut du bucket. Par exemple, STANDARD.

  3. Utilisez cURL pour appeler l'API JSON :

    curl -X POST --data-binary @JSON_FILE_NAME \
 -H "Authorization: Bearer $(gcloud auth print-access-token)" \
 -H "Content-Type: application/json" \
 "https://storage.googleapis.com/storage/v1/b?project=PROJECT_IDENTIFIER"

    Où :

    • JSON_FILE_NAME est le nom du fichier JSON que vous avez créé à l'étape 2.
    • PROJECT_IDENTIFIER est l'ID ou numéro du projet auquel le bucket sera associé. Exemple : my-project.

API XML

  1. Vous devez installer et initialiser gcloud CLI, ce qui vous permet de générer un jeton d'accès pour l'en-tête Authorization.

  2. Créez un fichier XML contenant les paramètres du bucket. Consultez la documentation XML: Créer un bucket pour obtenir la liste complète des paramètres. Les paramètres les plus courants sont les suivants :

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

    Où :

    • STORAGE_CLASS est la classe de stockage par défaut du bucket. Par exemple, STANDARD.

    • BUCKET_LOCATION est l'emplacement où vous souhaitez stocker les données d'objets du bucket. Par exemple, US.

  3. Utilisez cURL pour appeler l'API XML :

    curl -X PUT --data-binary @XML_FILE_NAME \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  -H "x-goog-project-id: PROJECT_ID" \
  "https://storage.googleapis.com/BUCKET_NAME"

    Où :

    • XML_FILE_NAME est le nom du fichier XML que vous avez créé à l'étape 2.
    • PROJECT_ID correspond à l'ID du projet auquel le bucket sera associé. 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.

    Si la requête a abouti, une réponse n'est pas renvoyée.

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

Profiter d'un essai gratuit de Cloud Storage