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.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

3. Make sure 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.

   Note: If you installed the gcloud CLI previously, make sure you have the latest version by running gcloud components update.

6. If you're using an external identity provider (IdP), you must first sign in to the gcloud CLI with your federated identity.

7. To initialize the gcloud CLI, run the following command:

   gcloud init

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

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

9. Make sure 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.

    Note: If you installed the gcloud CLI previously, make sure you have the latest version by running gcloud components update.

12. If you're using an external identity provider (IdP), you must first sign in to the gcloud CLI with your federated identity.

13. To initialize the gcloud CLI, run the following command:

    gcloud init

14. Exécutez la commande suivante pour installer la CLI cbt :

    gcloud components install cbt

Planifiez la configuration :

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

   • Prenez quelques minutes pour lire la présentation de la réplication.
   • Identifiez votre cas d'utilisation de la réplication.
   • Déterminez la ou les région(s) devant héberger votre instance en fonction de votre cas d'utilisation, ainsi que de l'emplacement de votre application et du trafic.
   • Décidez comment vous comptez utiliser les profils d'application pour acheminer les requêtes entrantes.

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 Google Cloud console, 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 pour 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 la section Facteur de scaling de nœud.

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. Sélectionnez le bouton radio à côté de 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, le paramètre nodes dans l'option --cluster-config est facultatif. Si aucune valeur n'est définie, Bigtable alloue automatiquement des nœuds au cluster en fonction de votre empreinte de 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és 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 ne pouvez ajouter des clusters utilisant des clés CMEK qu'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: option permettant d'activer la mise à l'échelle de deux fois le nombre de nœuds. Vous pouvez activer cette fonctionnalité avec le scaling manuel et l'autoscaling. Les valeurs acceptées sont node-scaling-factor-2x ou node-scaling-factor-1x.

   Pour obtenir la liste des zones Bigtable qui ne sont pas disponibles pour le doublement du nombre de nœuds, consultez la section Limites du facteur de scaling de nœud.

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

Remarque :Vous ne pouvez pas créer de ressources protégées par des clés CMEK ni configurer l'autoscaling à l'aide de la CLI cbt. Vous ne pouvez pas non plus activer le doublement de l'échelle des nœuds avec la CLI 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 votre empreinte de données et optimise l'utilisation du stockage à 50 %. Si vous souhaitez contrôler le nombre de nœuds d'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. Par exemple, 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 votre empreinte de données et optimise l'utilisation du stockage à 50 %. Si vous souhaitez contrôler le nombre de nœuds d'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 le service 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 le service 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 le service 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 le service 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 le service 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 le service 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 le service 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}"

Étape suivante

• Découvrez comment Bigtable utilise les instances, les clusters et les nœuds.
• Apprenez-en plus sur la réplication Bigtable.
• Examinez et mettez à jour le profil d'application par défaut pour la réplication, et créez des profils d'application personnalisés selon vos besoins.
• Découvrez comment modifier une instance existante.