Créer des buckets avec l'espace de noms hiérarchique activé

Sur cette page, vous allez découvrir comment créer des buckets avec l'espace de noms hiérarchique activé.

Rôles requis

Pour obtenir l'autorisation nécessaire pour créer un bucket avec l'espace de noms hiérarchique activé, demandez à votre administrateur de vous accorder le rôle IAM Administrateur de l'espace de stockage (roles/storage.admin) sur le projet. Pour en savoir plus sur l'attribution de rôles, consultez la page Gérer l'accès aux projets, aux dossiers et aux organisations.

Ce rôle prédéfini contient l'autorisation storage.buckets.create, qui est nécessaire pour créer un bucket avec l'espace de noms hiérarchique activé.

Vous pouvez également obtenir cette autorisation avec des rôles personnalisés ou d'autres rôles prédéfinis.

Créer un bucket avec l'espace de noms hiérarchique activé

Console

  1. Dans la console Google Cloud , accédez à la page Buckets de 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 des étapes suivantes, cliquez sur Continuer pour passer à l'étape suivante :

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

    2. Dans la section Choisir où stocker 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. Dans la section Choisir comment stocker vos données, procédez comme suit :

      1. Sélectionnez une classe de stockage par défaut pour le bucket ou bien classe automatique pour gérer automatiquement les classes de stockage des données de votre bucket.

      2. Dans la section Optimiser l'espace de stockage pour les charges de travail utilisant beaucoup de données, procédez comme suit :

        1. Pour activer l'espace de noms hiérarchique, sélectionnez Activer l'espace de noms hiérarchique sur ce bucket.

        2. Dans la section Choisissez 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.

        3. Dans la section Choisissez comment protéger les données des objets, procédez comme suit :

          • Sous Protection des données, sélectionnez les options que vous souhaitez définir pour votre bucket.

          • Pour activer la suppression réversible, cliquez sur la flèche de développement  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 de développement  intitulée Chiffrement des données, puis sélectionnez une méthode de chiffrement des données.

      3. Cliquez sur Créer.

      Pour savoir comment obtenir des informations détaillées sur les erreurs liées à l'échec des opérations Cloud Storage dans la console Google Cloud , consultez 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 --uniform-bucket-level-access --enable-hierarchical-namespace

    Où :

    • BUCKET_NAME correspond au nom que vous souhaitez attribuer au bucket, ce nom étant soumis aux exigences relatives à l'attribution de nom. Par exemple, my-bucket.
    • BUCKET_LOCATION est l'emplacement du bucket. Par exemple, us-east1.
    • --uniform-bucket-level-access : activez un accès uniforme au niveau de votre bucket.
    • --enable-hierarchical-namespace : activez l'espace de noms hiérarchique pour le bucket. Vous ne pouvez pas activer l'espace de noms hiérarchique sur un bucket existant.

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

    Creating gs://BUCKET_NAME/...

    Définissez les flags suivants 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é. Par exemple, my-project.
    • --default-storage-class : spécifiez la classe de stockage par défaut du bucket. Par exemple, STANDARD. Pour gérer automatiquement les classes de stockage de vos objets, utilisez plutôt le flag --enable-autoclass. Pour en savoir plus, consultez Classe automatique.

    Pour obtenir la liste complète des options de création de buckets à l'aide de la Google Cloud CLI, consultez les options de buckets create.

    Exemple :

    gcloud storage buckets create gs://BUCKET_NAME --project=PROJECT_ID --default-storage-class=STORAGE_CLASS --location=BUCKET_LOCATION --uniform-bucket-level-access --enable-hierarchical-namespace

    3. Bibliothèques clientes

    C++

    Pour en savoir plus, consultez la documentation de référence de 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 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) {
  auto metadata = client.CreateBucket(
      bucket_name,
      gcs::BucketMetadata()
          .set_hierarchical_namespace(gcs::BucketHierarchicalNamespace{true})
          .set_iam_configuration(gcs::BucketIamConfiguration{
              gcs::UniformBucketLevelAccess{true, {}}, absl::nullopt}));
  if (!metadata) throw std::move(metadata).status();

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

    C#

    Pour en savoir plus, consultez la documentation de référence de 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 Configurer l'authentification pour les bibliothèques clientes. 

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

public class CreateBucketWithHierarchicalNamespaceEnabledSample
{
    public Bucket CreateBucketWithHierarchicalNamespace(
        string projectId = "your-project-id",
        string bucketName = "your-unique-bucket-name")
    {
        var storage = StorageClient.Create();
        var bucket = storage.CreateBucket(projectId,
            new Bucket
            {
                Name = bucketName,
                IamConfiguration = new Bucket.IamConfigurationData
                {
                    UniformBucketLevelAccess = new Bucket.IamConfigurationData.UniformBucketLevelAccessData { Enabled = true }
                },
                HierarchicalNamespace = new Bucket.HierarchicalNamespaceData { Enabled = true }
            });
        Console.WriteLine($"Created {bucketName} with Hierarchical Namespace enabled.");
        return bucket;
    }
}

    Go

    Pour en savoir plus, consultez la documentation de référence de 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 Configurer l'authentification pour les bibliothèques clientes. 

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

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

// createBucketHierarchicalNamespace creates a new bucket with hierarchical
// namespace features enabled.
func createBucketHierarchicalNamespace(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()

	attrs := &storage.BucketAttrs{
		HierarchicalNamespace: &storage.HierarchicalNamespace{
			Enabled: true,
		},
		// Hierarchical namespace buckets must use uniform bucket-level access.
		UniformBucketLevelAccess: storage.UniformBucketLevelAccess{
			Enabled: true,
		},
	}
	bucket := client.Bucket(bucketName)
	if err := bucket.Create(ctx, projectID, attrs); err != nil {
		return fmt.Errorf("Bucket(%q).Create: %w", bucketName, err)
	}
	fmt.Fprintf(w, "Created bucket %v with hierarchical namespace enabled\n", bucketName)
	return nil
}

    Java

    Pour en savoir plus, consultez la documentation de référence de 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 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.BucketInfo.HierarchicalNamespace;
import com.google.cloud.storage.BucketInfo.IamConfiguration;
import com.google.cloud.storage.Storage;
import com.google.cloud.storage.StorageOptions;

public final class CreateHierarchicalNamespaceBucket {

  public static void createHierarchicalNamespaceBucket(String projectId, String bucketName)
      throws Exception {
    // The ID of your GCP project
    // String projectId = "your-project-id";

    // The ID to give your GCS bucket
    // String bucketName = "your-unique-bucket-name";
    StorageOptions storageOptions = StorageOptions.newBuilder().setProjectId(projectId).build();
    try (Storage storage = storageOptions.getService()) {

      BucketInfo bucketInfo =
          BucketInfo.newBuilder(bucketName)
              .setIamConfiguration(
                  // Hierarchical namespace buckets must use uniform bucket-level access.
                  IamConfiguration.newBuilder().setIsUniformBucketLevelAccessEnabled(true).build())
              .setHierarchicalNamespace(HierarchicalNamespace.newBuilder().setEnabled(true).build())
              .build();

      Bucket bucket = storage.create(bucketInfo);

      System.out.printf(
          "Created bucket %s with Hierarchical Namespace enabled.%n", bucket.getName());
    }
  }
}

    Node.js

    Pour en savoir plus, consultez la documentation de référence de 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 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';

// 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 createBucketWithHierarchicalNamespace() {
  const [bucket] = await storage.createBucket(bucketName, {
    iamConfiguration: {
      uniformBucketLevelAccess: {
        enabled: true,
      },
    },
    hierarchicalNamespace: {
      enabled: true,
    },
  });

  console.log(
    `Created '${bucket.name}' with hierarchical namespace enabled.`
  );
}

createBucketWithHierarchicalNamespace().catch(console.error);

    PHP

    Pour en savoir plus, consultez la documentation de référence de 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 Configurer l'authentification pour les bibliothèques clientes. 

    use Google\Cloud\Storage\StorageClient;

/**
 * Create a new bucket with Hierarchical Namespace enabled.
 *
 * @param string $bucketName The name of your Cloud Storage bucket.
 *        (e.g. 'my-bucket')
 */
function create_bucket_hierarchical_namespace(string $bucketName): void
{
    $storage = new StorageClient();
    $bucket = $storage->createBucket($bucketName, [
        'hierarchicalNamespace' => ['enabled' => true],
        'iamConfiguration' => ['uniformBucketLevelAccess' => ['enabled' => true]]
    ]);

    printf('Created bucket %s with Hierarchical Namespace enabled.', $bucket->name());
}

    Python

    Pour en savoir plus, consultez la documentation de référence de 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 Configurer l'authentification pour les bibliothèques clientes. 

    from google.cloud import storage


def create_bucket_hierarchical_namespace(bucket_name):
    """Creates a bucket with hierarchical namespace enabled."""
    # The ID of your GCS bucket
    # bucket_name = "your-bucket-name"

    storage_client = storage.Client()
    bucket = storage_client.bucket(bucket_name)
    bucket.iam_configuration.uniform_bucket_level_access_enabled = True
    bucket.hierarchical_namespace_enabled = True
    bucket.create()

    print(f"Created bucket {bucket_name} with hierarchical namespace enabled.")

    Ruby

    Pour en savoir plus, consultez la documentation de référence de 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 Configurer l'authentification pour les bibliothèques clientes. 

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

  require "google/cloud/storage"

  storage = Google::Cloud::Storage.new

  hierarchical_namespace = Google::Apis::StorageV1::Bucket::HierarchicalNamespace.new enabled: true

  storage.create_bucket bucket_name do |b|
    b.uniform_bucket_level_access = true
    b.hierarchical_namespace = hierarchical_namespace
  end

  puts "Created bucket #{bucket_name} with Hierarchical Namespace enabled."
end

    API REST

    API JSON

    1. Vous devez installer et initialiser la gcloud CLI afin 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 de la section Buckets: Insert pour obtenir la liste complète des paramètres. Les paramètres les plus courants sont les suivants :
      3. {
  "name": "BUCKET_NAME",
  "location": "BUCKET_LOCATION",
  "storageClass": "STORAGE_CLASS",
  "hierarchicalNamespace": {
    "enabled": "BOOLEAN"
  },
  "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, STANDARD.
      • hierarchicalNamespace.enabled est défini sur TRUE pour activer l'espace de noms hiérarchique sur votre bucket. Remarque : Vous ne pouvez pas activer l'espace de noms hiérarchique sur un bucket existant.
    3. uniformBucketLevelAccess.enabled est défini sur TRUE pour activer l'accès uniforme au niveau de votre bucket.
    4. 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 qui contient les paramètres du bucket.
      • PROJECT_IDENTIFIER est l'ID ou le numéro du projet auquel le bucket sera associé. Par exemple, my-project.

Étapes suivantes

Faites l'essai

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

Profiter d'un essai gratuit de Cloud Storage