Créer des buckets de stockage

Cette page montre comment créer des buckets Cloud Storage. Pour obtenir une présentation des buckets, consultez la page Mots clés. Sauf indication contraire dans votre requête, les buckets sont créés dans l'emplacement multirégional US avec la classe de stockage par défaut stockage standard.

Pour créer un bucket de stockage, procédez comme suit :

Console

  1. Ouvrez le navigateur Cloud Storage dans Google Cloud Console.
    Ouvrir le navigateur Cloud Storage
  2. Cliquez sur Create a bucket (Créer un bucket) pour ouvrir le formulaire de création de bucket.

    3. Nouveau bucket

  3. Saisissez les informations sur votre bucket et cliquez sur Continue (Continuer) à chaque étape :
    • Renseignez le champ Name (Nom) conformément aux exigences concernant les noms de buckets.
    • Sélectionnez la Default storage class (classe de stockage par défaut) du bucket. Cette classe de stockage par défaut sera attribuée par défaut à tous les objets importés dans le bucket. Ensuite, sélectionnez l'emplacement (Location) où les données du bucket seront stockées de manière permanente.

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

    • Sélectionnez un modèle Access control (modèle de contrôle des accès) pour déterminer comment contrôler l'accès aux objets du bucket.
    • Vous pouvez également ajouter des étiquettes de buckets, définir une règle de conservation et choisir une méthode de chiffrement.
  4. Cliquez sur Done (OK).

Consultez la page Dépannage pour obtenir des informations détaillées sur les erreurs liées aux opérations ayant échoué dans le navigateur Cloud Storage.

gsutil

Exécutez la commande gsutil mb :

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

Exemple :

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

Exemples de code

C++

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

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

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

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

C#

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


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

public class CreateRegionalBucketSample
{
    /// <summary>
    /// Creates a storage bucket with region.
    /// </summary>
    /// <param name="projectId">The ID of the project to create the buckets in.</param>
    /// <param name="location">The location of the bucket. Object data for objects in the bucket resides in
    /// physical storage within this region. Defaults to US.</param>
    /// <param name="bucketName">The name of the bucket to create.</param>
    /// <param name="storageClass">The bucket's default storage class, used whenever no storageClass is specified
    /// for a newly-created object. This defines how objects in the bucket are stored
    /// and determines the SLA and the cost of storage. Values include MULTI_REGIONAL,
    /// REGIONAL, STANDARD, NEARLINE, COLDLINE, ARCHIVE, and DURABLE_REDUCED_AVAILABILITY.
    /// If this value is not specified when the bucket is created, it will default to
    /// STANDARD.</param>
    public Bucket CreateRegionalBucket(
        string projectId = "your-project-id",
        string bucketName = "your-unique-bucket-name",
        string location = "us-west1",
        string storageClass = "REGIONAL")
    {
        var storage = StorageClient.Create();
        Bucket bucket = new Bucket
        {
            Location = location,
            Name = bucketName,
            StorageClass = storageClass
        };
        var newlyCreatedBucket = storage.CreateBucket(projectId, bucket);
        Console.WriteLine($"Created {bucketName}.");
        return newlyCreatedBucket;
    }
}

Go

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

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

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

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

	ctx, cancel := context.WithTimeout(ctx, time.Second*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.

import com.google.cloud.storage.Bucket;
import com.google.cloud.storage.BucketInfo;
import com.google.cloud.storage.Storage;
import com.google.cloud.storage.StorageClass;
import com.google.cloud.storage.StorageOptions;

public class CreateBucketWithStorageClassAndLocation {
  public static void createBucketWithStorageClassAndLocation(String projectId, String bucketName) {
    // The ID of your GCP project
    // String projectId = "your-project-id";

    // The ID to give your GCS bucket
    // String bucketName = "your-unique-bucket-name";

    Storage storage = StorageOptions.newBuilder().setProjectId(projectId).build().getService();

    // See the StorageClass documentation for other valid storage classes:
    // https://googleapis.dev/java/google-cloud-clients/latest/com/google/cloud/storage/StorageClass.html
    StorageClass storageClass = StorageClass.COLDLINE;

    // See this documentation for other valid locations:
    // http://g.co/cloud/storage/docs/bucket-locations#location-mr
    String location = "ASIA";

    Bucket bucket =
        storage.create(
            BucketInfo.newBuilder(bucketName)
                .setStorageClass(storageClass)
                .setLocation(location)
                .build());

    System.out.println(
        "Created bucket "
            + bucket.getName()
            + " in "
            + bucket.getLocation()
            + " with storage class "
            + bucket.getStorageClass());
  }
}

Node.js

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

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

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

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

async function createBucket() {
  // Creates a new bucket in the Asia region with the coldline default storage
  // class. Leave the second argument blank for default settings.
  //
  // For default values see: https://cloud.google.com/storage/docs/locations and
  // https://cloud.google.com/storage/docs/storage-classes

  const [bucket] = await storage.createBucket(bucketName, {
    location: 'ASIA',
    storageClass: 'COLDLINE',
  });

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

createBucket().catch(console.error);

PHP

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

use Google\Cloud\Storage\StorageClient;

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

Python

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

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.

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 informations suivantes :
    3. {
  "name": "BUCKET_NAME",
  "location": "BUCKET_LOCATION",
  "storageClass": "STORAGE_CLASS"
}

    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 :
    3. <CreateBucketConfiguration>
   <LocationConstraint>BUCKET_LOCATION</LocationConstraint>
   <StorageClass>STORAGE_CLASS</StorageClass>
</CreateBucketConfiguration>

    Où :

  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.

Étapes suivantes