Créer une instance

Une instance Bigtable est un conteneur pour les clusters Bigtable. Une instance comportant plusieurs clusters utilise la réplication. Vous pouvez créer des clusters dans un maximum de huit régions, avec autant de clusters dans chaque région qu'il y a de zones.

Cette page vous explique comment créer une instance. Avant de lire cette page, vous devez avoir lu la présentation de Bigtable. Nous vous recommandons également de lire la présentation des instances, clusters et nœuds.

Avant de commencer

Préparez votre environnement :

  1. Sign in to your Google Account.

    If you don't already have one, sign up for a new account.

  2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  3. Verify that billing is enabled for your Google Cloud project.

  4. Enable the Cloud Bigtable API, Cloud Bigtable Admin API APIs.

    Enable the APIs

  5. Install the Google Cloud CLI.

  6. Si vous utilisez un fournisseur d'identité (IdP) externe, vous devez d'abord vous connecter à gcloud CLI avec votre identité fédérée.

  7. Pour initialiser gcloudCLI, exécutez la commande suivante : 

    gcloud init

  8. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  9. Verify that billing is enabled for your Google Cloud project.

  10. Enable the Cloud Bigtable API, Cloud Bigtable Admin API APIs.

    Enable the APIs

  11. Install the Google Cloud CLI.

  12. Si vous utilisez un fournisseur d'identité (IdP) externe, vous devez d'abord vous connecter à gcloud CLI avec votre identité fédérée.

  13. Pour initialiser gcloudCLI, exécutez la commande suivante : 

    gcloud init
  14. Exécutez la commande suivante pour installer la CLI cbt : 
    gcloud components install cbt

    15. Planifiez la configuration :

    1. Facultatif : Si vous envisagez d'activer la réplication, procédez comme suit :

    2. Facultatif : Si vous souhaitez utiliser des clés de chiffrement gérées par le client (CMEK) au lieu du chiffrement géré par Google, effectuez les tâches décrites dans Créer une instance utilisant des CMEK et préparez votre ID de clé CMEK avant de créer l'instance. Vous ne pouvez pas ajouter la protection CMEK après la création d'une instance, et vous ne pouvez pas modifier ni remplacer la clé CMEK après sa création.

    Créer une instance

    Pour créer une instance Bigtable :

    Console

    1. Dans la console Google Cloud , accédez à la page Créer une instance.

      Accéder à la page Créer une instance

    2. Entrez un nom pour l'instance.

      La console Google Cloud affiche ce nom pour identifier votre instance.

    3. Entrez un ID d'instance.

      L'ID d'instance est un identifiant permanent pour l'instance.

    4. Cliquez sur Continuer.

    5. Choisissez d'utiliser un disque SSD ou HDD pour vos clusters. Dans la plupart des cas, il est préférable de choisir un disque SSD. Ce choix est définitif. En savoir plus

    6. Cliquez sur Continuer.

    7. Entrez un ID de cluster pour le premier cluster.

      L'ID de cluster est un identifiant permanent pour le cluster.

    8. Choisissez la région et la zone dans lesquelles le premier cluster sera exécuté.

    9. Facultatif : Pour configurer le cluster afin qu'il effectue toujours un scaling par incréments de deux nœuds, sélectionnez Activer le scaling de nœuds X2. Le scaling de nœuds x2 n'est pas disponible dans toutes les zones. Pour en savoir plus, consultez Facteur de scaling des nœuds.

    10. Choisissez un mode de scaling des nœuds pour le cluster. Dans la plupart des cas, vous devez choisir l'autoscaling. Pour obtenir des conseils de scaling, consultez la section Autoscaling.

      1. Dans le champ Allocation de nœuds manuel, saisissez le nombre de nœuds Bigtable pour le premier cluster. Si vous ne savez pas de combien de nœuds vous avez besoin, utilisez la valeur par défaut. Vous pourrez ajouter des nœuds ultérieurement.
      2. Pour Autoscaling, saisissez les valeurs suivantes :
        • Nombre minimal de nœuds
        • Nombre maximal de nœuds
        • Objectif d'utilisation du CPU
        • Objectif d'utilisation du stockage

    11. Facultatif : Pour protéger votre instance avec des clés CMEK plutôt que d'utiliser le chiffrement géré par Google, procédez comme suit :

      1. Cliquez sur Afficher les options de chiffrement.
      2. Cochez la case d'option Clé de chiffrement gérée par le client (CMEK).
      3. Sélectionnez ou saisissez le nom de ressource de la clé CMEK que vous souhaitez utiliser pour le cluster. Vous ne pourrez pas l'ajouter ultérieurement.
      4. Si vous êtes invité à accorder l'autorisation au compte de service de la clé CMEK, cliquez sur Accorder. Pour effectuer cette tâche, votre compte utilisateur doit disposer du rôle d'administrateur Cloud KMS.
      5. Cliquez sur Enregistrer.

    12. (Facultatif) Pour activer la réplication maintenant, procédez comme suit :

      1. Cliquez sur Afficher les options avancées.
      2. Cliquez sur Ajouter un cluster, saisissez les paramètres du cluster, puis cliquez sur Ajouter. Répétez cette étape pour créer des clusters supplémentaires dans l'instance. Vous pouvez également activer la réplication ultérieurement en ajoutant un cluster.

      Chaque zone d'une région ne peut contenir qu'un seul cluster. Si le bouton Ajouter un cluster est désactivé, modifiez la zone de votre premier cluster.

      Pour créer une instance comportant plus de six clusters, commencez par créer une instance comportant six clusters, puis ajoutez-y d'autres clusters.

    13. Cliquez sur Créer pour créer l'instance.

    14. Vérifiez les paramètres de réplication dans le profil d'application par défaut pour vérifier qu'ils sont adaptés à votre cas d'utilisation de la réplication. Vous devrez peut-être mettre à jour le profil d'application par défaut ou créer des profils d'application personnalisés.

    gcloud

    1. Utilisez la commande bigtable instances create pour créer une instance :

      gcloud bigtable instances create INSTANCE_ID \
    --display-name=DISPLAY_NAME \
    [--cluster-storage-type=CLUSTER_STORAGE_TYPE] \
    [--cluster-config=id=CLUSTER_ID,zone=CLUSTER_ZONE, \
    nodes=NODES] \
    [--cluster-config=id=CLUSTER_ID,zone=CLUSTER_ZONE, \
    autoscaling-min-nodes=AUTOSCALING_MIN_NODES, \
    autoscaling-max-nodes=AUTOSCALING_MAX_NODES, \
    autoscaling-cpu-target=AUTOSCALING_CPU_TARGET, \
    autoscaling-storage-target=AUTOSCALING_STORAGE_TARGET, \
    kms-key=KMS_KEY], \
    [node-scaling-factor=NODE_SCALING_FACTOR]

      Remplacez les éléments suivants :

      • INSTANCE_ID : identifiant permanent de l'instance.
      • DISPLAY_NAME : nom lisible permettant d'identifier l'instance dans la console Google Cloud .
      • CLUSTER_ID : identifiant permanent du cluster.
      • CLUSTER_ZONE : zone dans laquelle le cluster est exécuté.

      Vous devez configurer au moins un cluster pour l'instance à l'aide de l'option --cluster-config. Pour créer une instance comportant plusieurs clusters, répétez l'option --cluster-config pour chaque cluster.

      Pour l'allocation manuelle des nœuds, il est facultatif de définir nodes dans l'option --cluster-config. Si aucune valeur n'est définie, Bigtable alloue automatiquement des nœuds au cluster en fonction de l'empreinte de vos données et optimise l'utilisation du stockage à 50 %. Cette allocation automatique de nœuds a un impact sur les tarifs. Si vous souhaitez contrôler le nombre de nœuds dans un cluster, remplacez NODES par le nombre de nœuds souhaité dans le cluster. En savoir plus sur les nœuds

      Dans la plupart des cas, choisissez l'autoscaling plutôt que l'allocation manuelle des nœuds. Pour l'autoscaling, fournissez les options autoscaling- dans l'indicateur --cluster-config (autoscaling-storage-target est facultatif) et n'utilisez pas nodes. Consultez la section Autoscaling pour savoir comment choisir les valeurs de vos paramètres d'autoscaling. Remplacez les éléments suivants pour les clés d'options cluster-config :

      • AUTOSCALING_MIN_NODES : nombre minimal de nœuds pour le cluster.
      • AUTOSCALING_MAX_NODES : nombre maximal de nœuds pour le cluster.
      • AUTOSCALING_CPU_TARGET : pourcentage cible d'utilisation du processeur pour le cluster Cette valeur doit être comprise entre 10 et 80.
      • AUTOSCALING_STORAGE_TARGET : (facultatif) cible d'utilisation du stockage en Gio, gérée par Bigtable, en ajoutant ou en supprimant des nœuds

      • KMS_KEY : clé CMEK du cluster.

        La valeur KMS_KEY doit être définie au format suivant :

        projects/PROJECT/locations/LOCATION/keyRings/KEYRING/cryptoKeys/KEY

        Remplacez les éléments suivants :

        • PROJECT : identifiant permanent du projet.
        • LOCATION : emplacement de votre cluster
        • KEYRING : nom du trousseau de clés contenant la clé
        • KEY : nom de la clé

        En voici un exemple :

        projects/examplestore.com:dev/locations/us-east1/keyRings/devt-cmek-2/cryptoKeys/key2

        Si l'instance est protégée par une clé CMEK, chaque cluster doit se trouver dans la même région que sa clé CMEK. Vous pouvez uniquement ajouter des clusters utilisant des clés CMEK aux instances déjà protégées de la sorte. En savoir plus

      La commande accepte les options facultatives suivantes :

      • --cluster-storage-type=CLUSTER_STORAGE_TYPE : type de stockage à utiliser pour l'instance. La valeur par défaut est SSD. Dans la plupart des cas, la valeur par défaut est la plus appropriée. Ce choix est définitif. En savoir plus

      • --project=PROJECT : projet de création du cluster s'il diffère du projet actuel.

      • node-scaling-factor=NODE_SCALING_FACTOR : indicateur qui active la mise à l'échelle des nœuds par deux. Vous pouvez activer cette fonctionnalité avec le scaling manuel et l'autoscaling. Les valeurs acceptables sont node-scaling-factor-2x ou node-scaling-factor-1x.

      Pour afficher la liste des zones Bigtable qui ne sont pas disponibles pour le scaling de nœuds par deux, consultez Limites du facteur de scaling des nœuds.

    2. Vérifiez les paramètres de réplication dans le profil d'application par défaut pour vérifier qu'ils sont adaptés à votre cas d'utilisation de la réplication. Vous devrez peut-être mettre à jour le profil d'application par défaut ou créer des profils d'application personnalisés.

    cbt

    1. Commencez par créer une instance à cluster unique. Utilisez la commande createinstance pour créer une instance :

      cbt createinstance INSTANCE_ID \
    DISPLAY_NAME \
    CLUSTER_ID \
    CLUSTER_ZONE \
    CLUSTER_NUM_NODES \
    CLUSTER_STORAGE_TYPE

      Indiquez les éléments suivants :

      • INSTANCE_ID : identifiant permanent de l'instance.
      • DISPLAY_NAME : nom lisible permettant d'identifier l'instance dans la console Google Cloud .
      • CLUSTER_ID : identifiant permanent du cluster.
      • CLUSTER_ZONE : zone dans laquelle le cluster est exécuté.
      • CLUSTER_NUM_NODES : ce champ est facultatif. Si aucune valeur n'est définie, Bigtable alloue automatiquement des nœuds en fonction de l'empreinte de vos données et optimise l'utilisation du stockage à 50 %. Si vous souhaitez contrôler le nombre de nœuds dans un cluster, mettez à jour la valeur CLUSTER_NUM_NODES. Assurez-vous que le nombre de nœuds est défini sur une valeur non nulle. En savoir plus sur les nœuds
      • CLUSTER_STORAGE_TYPE : type de stockage à utiliser pour le cluster. Chaque cluster d'une instance doit utiliser le même type de stockage. Accepte les valeurs SSD et HDD. Dans la plupart des cas, il est préférable de choisir SSD. Ce choix est définitif. En savoir plus

    2. Pour activer la réplication, utilisez la commande createcluster afin d'ajouter un cluster :

      
cbt -instance=INSTANCE_ID \
createcluster CLUSTER_ID \
ZONE \
NUM_NODES \
STORAGE_TYPE

      Indiquez les éléments suivants :

      • INSTANCE_ID : identifiant permanent de l'instance que vous venez de créer.
      • CLUSTER_ID : identifiant permanent du cluster.

      • ZONE : zone dans laquelle le cluster est exécuté.

        Chaque zone d'une région ne peut contenir qu'un seul cluster. Par exemple, si une instance dispose d'un cluster dans la région us-east1-b, vous pouvez ajouter un cluster dans une autre zone de la même région, telle que us-east1-c, ou dans une zone située dans une région distincte, telle que europe-west2-a.

      • NUM_NODES : ce champ est facultatif. Si aucune valeur n'est définie, Bigtable alloue automatiquement des nœuds en fonction de l'empreinte de vos données et optimise l'utilisation du stockage à 50 %. Si vous souhaitez contrôler le nombre de nœuds dans un cluster, mettez à jour la valeur NUM_NODES. Assurez-vous que le nombre de nœuds est défini sur une valeur non nulle.

        Dans de nombreux cas, chaque cluster d'une instance doit avoir le même nombre de nœuds, mais il existe des exceptions. En savoir plus sur les nœuds et la réplication

      • STORAGE_TYPE : type de stockage à utiliser pour le cluster. Chaque cluster d'une instance doit utiliser le même type de stockage. Accepte les valeurs SSD et HDD.

    3. (Facultatif) Vérifiez les paramètres de réplication dans le profil d'application par défaut pour vérifier qu'ils sont bien adaptés à votre cas d'utilisation de la réplication. Vous devrez peut-être mettre à jour le profil d'application par défaut ou créer des profils d'application personnalisés.

    C++

    Pour savoir comment installer et utiliser la bibliothèque cliente pour Bigtable, consultez la section Bibliothèques clientes Bigtable.

    Pour vous authentifier auprès de Bigtable, configurez les Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local. 

    namespace cbta = ::google::cloud::bigtable_admin;
using ::google::cloud::future;
using ::google::cloud::Location;
using ::google::cloud::Project;
using ::google::cloud::StatusOr;
[](cbta::BigtableInstanceAdminClient instance_admin,
   std::string const& project_id, std::string const& instance_id,
   std::string const& zone) {
  auto const project = Project(project_id);
  std::string project_name = project.FullName();
  std::string cluster_id = instance_id + "-c1";

  google::bigtable::admin::v2::Instance in;
  in.set_type(google::bigtable::admin::v2::Instance::PRODUCTION);
  in.set_display_name("Put description here");

  google::bigtable::admin::v2::Cluster cluster;
  cluster.set_location(Location(project, zone).FullName());
  cluster.set_serve_nodes(3);
  cluster.set_default_storage_type(google::bigtable::admin::v2::HDD);

  std::map<std::string, google::bigtable::admin::v2::Cluster> cluster_map = {
      {cluster_id, std::move(cluster)}};

  future<StatusOr<google::bigtable::admin::v2::Instance>> instance_future =
      instance_admin.CreateInstance(project_name, instance_id, std::move(in),
                                    std::move(cluster_map));
  // Show how to perform additional work while the long running operation
  // completes. The application could use future.then() instead.
  std::cout << "Waiting for instance creation to complete " << std::flush;
  instance_future.wait_for(std::chrono::seconds(1));
  std::cout << '.' << std::flush;
  auto instance = instance_future.get();
  if (!instance) throw std::move(instance).status();
  std::cout << "DONE, details=" << instance->DebugString() << "\n";
}

    C#

    Pour savoir comment installer et utiliser la bibliothèque cliente pour Bigtable, consultez la section Bibliothèques clientes Bigtable.

    Pour vous authentifier auprès de Bigtable, configurez les Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local. 

    // Creates a production instance with "<intanceId>-prod" instance ID,
// with cluster ID "ssd-cluster1", 3 nodes and location us-east1-b.
displayName += " Prod"; // Display name is for display purposes only. It doesn't have to equal instanceId and can be amended after instance is created.
string instanceId = Regex.Replace(displayName, @"[^A-Za-z0-9_\.~]+", "-").ToLower();

// Please refer to the link below for the full list of available locations:
// https://cloud.google.com/bigtable/docs/locations
string zone1 = "us-east1-b";

// The instance to create.
Instance myInstance = new Instance
{
    DisplayName = displayName,
    // You can choose DEVELOPMENT or PRODUCTION type here.
    // If not set, will default to PRODUCTION type.
    // Instance type can be upgraded from DEVELOPMENT to PRODUCTION but cannot be dowgraded after the instance is created.
    Type = Instance.Types.Type.Production,
    Labels = { { "prod-label", "prod-label" } }
};

// The first cluster to be created within the instance.
Cluster myCluster1 = new Cluster
{
    // You can choose SSD or HDD storage type here: StorageType.Ssd or StorageType.Hdd.
    // Cluster storage type can not be changed after the instance is created.
    // If not set will default to SSD type.
    DefaultStorageType = StorageType.Ssd,
    LocationAsLocationName = new LocationName(projectId, zone1),
    // Serve Nodes count can only be set if PRODUCTION type instance is being created.
    // Minimum count of 3 serve nodes must be specified.
    // Serve Nodes count can be increased and decreased after an instance is created.
    ServeNodes = 3
};

// Initialize request argument(s).
CreateInstanceRequest request = new CreateInstanceRequest
{
    ParentAsProjectName = new ProjectName(projectId),
    Instance = myInstance,
    InstanceId = instanceId,
    // Must specify at lease one cluster.
    // Only PRODUCTION type instance can be created with more than one cluster.
    // Currently all clusters must have the same storage type.
    // Clusters must be set to different locations.
    Clusters = { { "ssd-cluster1", myCluster1 } }
};

try
{
    // Make a request.
    Operation<Instance, CreateInstanceMetadata> createInstanceResponse =
        bigtableInstanceAdminClient.CreateInstance(request);
    Console.WriteLine("Waiting for operation to complete...");

    // Poll until the returned long-running operation is complete
    Operation<Instance, CreateInstanceMetadata> completedResponse =
        createInstanceResponse.PollUntilCompleted();
}
catch (Exception ex)
{
    Console.WriteLine($"Exception while creating {displayName} instance");
    Console.WriteLine(ex.Message);
}

    Java

    Pour savoir comment installer et utiliser la bibliothèque cliente pour Bigtable, consultez la section Bibliothèques clientes Bigtable.

    Pour vous authentifier auprès de Bigtable, configurez les Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local. 

    // Creates a Production Instance with the ID "ssd-instance",
// cluster id "ssd-cluster", 3 nodes and location "us-central1-f".
CreateInstanceRequest createInstanceRequest =
    CreateInstanceRequest.of(instanceId)
        .addCluster(clusterId, "us-central1-f", 3, StorageType.SSD)
        .setType(Instance.Type.PRODUCTION)
        .addLabel("department", "accounting");
// Creates a production instance with the given request.
try {
  Instance instance = adminClient.createInstance(createInstanceRequest);
  System.out.printf("PRODUCTION type instance %s created successfully%n", instance.getId());
} catch (Exception e) {
  System.err.println("Failed to create instance: " + e.getMessage());
  throw e;
}

    Node.js

    Pour savoir comment installer et utiliser la bibliothèque cliente pour Bigtable, consultez la section Bibliothèques clientes Bigtable.

    Pour vous authentifier auprès de Bigtable, configurez les Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local. 

    // Creates a Production Instance with the ID "ssd-instance"
// with cluster id "ssd-cluster", 3 nodes and location us-central1-f

const instanceOptions = {
  clusters: [
    {
      id: clusterID,
      nodes: 3,
      location: 'us-central1-f',
      storage: 'ssd',
    },
  ],
  type: 'PRODUCTION', // Optional as default type is PRODUCTION
  labels: {'prod-label': 'prod-label'},
};

// Create production instance with given options
const [prodInstance, operation] = await instance.create(instanceOptions);
await operation.promise();
console.log(`Created Instance: ${prodInstance.id}`);

    PHP

    Pour savoir comment installer et utiliser la bibliothèque cliente pour Bigtable, consultez la section Bibliothèques clientes Bigtable.

    Pour vous authentifier auprès de Bigtable, configurez les Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local. 

    use Exception;
use Google\ApiCore\ApiException;
use Google\Cloud\Bigtable\Admin\V2\Client\BigtableInstanceAdminClient;
use Google\Cloud\Bigtable\Admin\V2\Cluster;
use Google\Cloud\Bigtable\Admin\V2\CreateInstanceRequest;
use Google\Cloud\Bigtable\Admin\V2\GetInstanceRequest;
use Google\Cloud\Bigtable\Admin\V2\Instance;
use Google\Cloud\Bigtable\Admin\V2\Instance\Type as InstanceType;
use Google\Cloud\Bigtable\Admin\V2\StorageType;

/**
 * Create a production Bigtable instance
 *
 * @param string $projectId The Google Cloud project ID
 * @param string $instanceId The ID of the Bigtable instance to be generated
 * @param string $clusterId The ID of the cluster to be generated
 * @param string $locationId The Bigtable region ID where you want your instance to reside
 */
function create_production_instance(
    string $projectId,
    string $instanceId,
    string $clusterId,
    string $locationId = 'us-east1-b'
): void {
    $instanceAdminClient = new BigtableInstanceAdminClient();

    $projectName = $instanceAdminClient->projectName($projectId);
    $instanceName = $instanceAdminClient->instanceName($projectId, $instanceId);

    $serveNodes = 3;
    $storageType = StorageType::SSD;
    $production = InstanceType::PRODUCTION;
    $labels = ['prod-label' => 'prod-label'];

    $instance = new Instance();
    $instance->setDisplayName($instanceId);

    $instance->setLabels($labels);
    $instance->setType($production);

    $cluster = new Cluster();
    $cluster->setDefaultStorageType($storageType);
    $locationName = $instanceAdminClient->locationName($projectId, $locationId);
    $cluster->setLocation($locationName);
    $cluster->setServeNodes($serveNodes);
    $clusters = [
        $clusterId => $cluster
    ];
    try {
        $getInstanceRequest = (new GetInstanceRequest())
            ->setName($instanceName);
        $instanceAdminClient->getInstance($getInstanceRequest);
        printf('Instance %s already exists.' . PHP_EOL, $instanceId);
        throw new Exception(sprintf('Instance %s already exists.' . PHP_EOL, $instanceId));
    } catch (ApiException $e) {
        if ($e->getStatus() === 'NOT_FOUND') {
            printf('Creating an Instance: %s' . PHP_EOL, $instanceId);
            $createInstanceRequest = (new CreateInstanceRequest())
                ->setParent($projectName)
                ->setInstanceId($instanceId)
                ->setInstance($instance)
                ->setClusters($clusters);
            $operationResponse = $instanceAdminClient->createInstance($createInstanceRequest);
            $operationResponse->pollUntilComplete();
            if (!$operationResponse->operationSucceeded()) {
                print('Error: ' . $operationResponse->getError()->getMessage());
            } else {
                printf('Instance %s created.', $instanceId);
            }
        } else {
            throw $e;
        }
    }
}

    Python

    Pour savoir comment installer et utiliser la bibliothèque cliente pour Bigtable, consultez la section Bibliothèques clientes Bigtable.

    Pour vous authentifier auprès de Bigtable, configurez les Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local. 

    cluster = instance.cluster(
    cluster_id,
    location_id=location_id,
    serve_nodes=serve_nodes,
    default_storage_type=storage_type,
)
if not instance.exists():
    print("\nCreating an instance")
    # Create instance with given options
    operation = instance.create(clusters=[cluster])
    # Ensure the operation completes.
    operation.result(timeout=480)
    print("\nCreated instance: {}".format(instance_id))

    Ruby

    Pour savoir comment installer et utiliser la bibliothèque cliente pour Bigtable, consultez la section Bibliothèques clientes Bigtable.

    Pour vous authentifier auprès de Bigtable, configurez les Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local. 

    # instance_id      = "my-instance"
# cluster_id       = "my-cluster"
# cluster_location = "us-east1-b"
puts "Creating a PRODUCTION Instance"
job = bigtable.create_instance(
  instance_id,
  display_name: "Sample production instance",
  labels:       { "env": "production" },
  type:         :PRODUCTION # Optional as default type is :PRODUCTION
) do |clusters|
  clusters.add cluster_id, cluster_location, nodes: 3, storage_type: :SSD
end

job.wait_until_done!
instance = job.instance
puts "Created Instance: #{instance.instance_id}"

    Étapes suivantes