Crea un'istanza

Un'istanza Bigtable funge da container di primo livello per i cluster e le tabelle, consentendoti di configurare lo spazio di archiviazione e la replica in un massimo di 8 regioni per un'alta affidabilità. Puoi creare e configurare un'istanza utilizzando la console Google Cloud , Google Cloud CLI, l'interfaccia a riga di comandocbto le librerie client di Cloud Bigtable.

Prima di iniziare

Assicurati di avere familiarità con la panoramica di Bigtable e con Istanze, cluster e nodi.

Prepara l'ambiente:

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

    Roles required to select or create a project

    • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
    • Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

    Go to project selector

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

  3. Enable the Cloud Bigtable API, Cloud Bigtable Admin API APIs, if any are not already enabled.

    Roles required to enable APIs

    To enable APIs, you need the serviceusage.services.enable permission. If you created the project, then you likely already have this permission through the Owner role (roles/owner). Otherwise, you can get this permission through the Service Usage Admin role (roles/serviceusage.serviceUsageAdmin). Learn how to grant roles.

    Enable the APIs

  4. Install the Google Cloud CLI.

  5. Configure the gcloud CLI to use your federated identity.

    For more information, see Sign in to the gcloud CLI with your federated identity.

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

    gcloud init
  7. Esegui questo comando per installare l'interfaccia a riga di comando cbt: 
    gcloud components install cbt

Pianifica la configurazione:

  1. (Facoltativo) Se prevedi di abilitare la replica, segui questi passaggi:

  2. (Facoltativo) Se vuoi utilizzare le chiavi di crittografia gestite dal cliente (CMEK) anziché la crittografia predefinita gestita da Google, tieni pronto l'ID chiave CMEK prima di creare la nuova istanza. Non puoi aggiungere la protezione CMEK a un'istanza dopo la sua creazione e non puoi modificare o sostituire la chiave CMEK dopo la creazione dell'istanza. Per saperne di più, consulta Utilizza le chiavi di crittografia gestite dal cliente (CMEK).

Crea un'istanza

Per creare un'istanza Bigtable:

Console

  1. Nella console Google Cloud , vai alla pagina Crea istanza.

    Vai a Crea istanza

  2. Inserisci un nome per l'istanza.

    La console Google Cloud visualizza questo nome per identificare l'istanza.

  3. Inserisci un ID istanza.

    L'ID istanza è un identificatore permanente dell'istanza.

  4. Fai clic su Continua.

  5. Nella sezione Seleziona la versione, seleziona una versione di Bigtable.

    Se vuoi confrontare le specifiche tra le versioni, fai clic su Confronta le versioni. Per saperne di più, consulta la panoramica delle versioni.

  6. Fai clic su Continua.

  7. Scegli se utilizzare un disco SSD o HDD per i tuoi cluster. Nella maggior parte dei casi, l'SSD è la scelta migliore. Se vuoi abilitare il livello in memoria, seleziona SSD. Questa scelta è definitiva.

  8. Fai clic su Continua.

  9. Inserisci un ID cluster per il primo cluster.

    L'ID cluster è un identificatore permanente del cluster.

  10. Scegli la regione e la zona in cui verrà eseguito il primo cluster.

  11. (Facoltativo) Per configurare il cluster in modo che venga sempre fare lo scale in incrementi di due nodi, seleziona Abilita la scalabilità dei nodi in incrementi di 2. La scalabilità dei nodi in incrementi di 2 non è disponibile in tutte le zone. Per la versione Enterprise Plus, la scalabilità dei nodi 2x è l'opzione predefinita. Per saperne di più, consulta Fattore di scalabilità dei nodi.

  12. (Facoltativo) Per utilizzare il livello in memoria a livello di cluster, seleziona Abilita in memoria.

  13. Scegli una modalità di scalabilità dei nodi per il cluster. Nella maggior parte dei casi, dovresti scegliere la scalabilità automatica. Per indicazioni sulla scalabilità, consulta Scalabilità automatica.

    1. In Allocazione manuale dei nodi, inserisci il numero di nodi Bigtable per il primo cluster. Se non sai con certezza quanti nodi ti servono, utilizza il valore predefinito. Puoi aggiungere altri nodi in un secondo momento.
    2. In Scalabilità automatica, inserisci i valori per i seguenti campi:
      • Numero minimo di nodi
      • Numero massimo di nodi
      • Target di utilizzo della CPU
      • Target di utilizzo dello spazio di archiviazione

  14. (Facoltativo) Per proteggere l'istanza con CMEK anziché con la crittografia predefinita gestita da Google, completa i seguenti passaggi:

    1. Fai clic su Mostra opzioni di crittografia.
    2. Seleziona Chiave Cloud KMS.
    3. Nel campo Tipo di gestione delle chiavi, seleziona una delle seguenti opzioni:
      • Se vuoi automatizzare la creazione di chiavi Cloud KMS, seleziona Cloud KMS con Autokey, quindi fai clic su Richiedi una chiave. Un messaggio indica quando la chiave è stata creata correttamente ed è pronta per l'uso.
      • Se vuoi aggiungere una chiave manualmente, seleziona Cloud KMS. Seleziona o inserisci il nome della risorsa per la chiave CMEK che vuoi utilizzare per il cluster. Non puoi aggiungerlo in un secondo momento. Se ti viene chiesto di concedere l'autorizzazione al account di servizio della chiave CMEK, fai clic su Concedi. Per completare questa attività, al tuo account utente deve essere concesso il ruolo Amministratore Cloud KMS. Fai clic su Salva.

  15. (Facoltativo) Per attivare la replica ora, completa i seguenti passaggi aggiuntivi:

    1. Fai clic su Mostra opzioni avanzate.
    2. Fai clic su Aggiungi cluster, inserisci le impostazioni per il cluster e poi fai clic su Aggiungi. Ripeti questo passaggio per creare altri cluster nell'istanza. Puoi anche attivare la replica in un secondo momento aggiungendo un cluster.

    Ogni zona di una regione può contenere un solo cluster. Se il pulsante Aggiungi cluster è disattivato, cambia la zona del primo cluster.

    Per creare un'istanza con più di sei cluster, crea prima un'istanza con sei cluster, quindi aggiungi altri cluster all'istanza.

  16. Fai clic sul pulsante Crea per creare l'istanza.

  17. Esamina le impostazioni di replica nel profilo dell'app predefinito per verificare se sono adatte al tuo caso d'uso di replica. Potresti dover aggiornare il profilo dell'app predefinito o creare profili dell'app personalizzati.

gcloud

  1. Utilizza il comando bigtable instances create per creare un'istanza:

    gcloud bigtable instances create INSTANCE_ID \
    --display-name=DISPLAY_NAME \
    [--edition=EDITION] \
    [--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]

    Sostituisci quanto segue:

    • INSTANCE_ID: l'identificatore permanente dell'istanza
    • DISPLAY_NAME: un nome leggibile che identifica l'istanza nella console Google Cloud .
    • CLUSTER_ID: l'identificatore permanente del cluster
    • CLUSTER_ZONE: la zona in cui viene eseguito il cluster.

    Devi configurare almeno un cluster per l'istanza utilizzando il flag --cluster-config. Per creare un'istanza con più cluster, ripeti il flag --cluster-config per ogni cluster.

    Per l'allocazione manuale dei nodi, l'impostazione di nodes nel flag --cluster-config è facoltativa. Se non viene impostato alcun valore, Bigtable alloca automaticamente i nodi al cluster in base al footprint dei dati e ottimizza l'utilizzo dello spazio di archiviazione al 50%. Questa allocazione automatica dei nodi ha un impatto sui prezzi. Se vuoi controllare il numero di nodi in un cluster, sostituisci NODES con il numero di nodi che vuoi nel cluster. Scopri di più sui nodi.

    Nella maggior parte dei casi, scegli la scalabilità automatica anziché l'allocazione manuale dei nodi. Per_autoscaling, fornisci le opzioni autoscaling- nel flag --cluster-config (autoscaling-storage-target è facoltativo) e non utilizzare nodes. Consulta Scalabilità automatica per indicazioni sulla scelta dei valori per le impostazioni di scalabilità automatica. Sostituisci quanto segue per le chiavi di opzione cluster-config:

    • AUTOSCALING_MIN_NODES: il numero minimo di nodi per il cluster.
    • AUTOSCALING_MAX_NODES: il numero massimo di nodi per il cluster.
    • AUTOSCALING_CPU_TARGET: la percentuale di utilizzo della CPU target per il cluster. Questo valore deve essere compreso tra 10 e 80.
    • AUTOSCALING_STORAGE_TARGET: (facoltativo) il target di utilizzo dello spazio di archiviazione in GiB che Bigtable mantiene aggiungendo o rimuovendo nodi.

    • KMS_KEY: la chiave CMEK del cluster.

      Il valore KMS_KEY deve essere impostato nel seguente formato:

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

      Sostituisci quanto segue:

      • PROJECT: l'identificatore permanente del progetto
      • LOCATION: la località del cluster
      • KEYRING: il nome della chiave automatizzata che contiene la chiave
      • KEY: il nome della chiave

      Ecco un esempio:

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

      Se l'istanza è protetta da CMEK, ogni cluster deve trovarsi nella stessa regione della chiave CMEK. Puoi aggiungere cluster CMEK solo alle istanze già protette da CMEK.

    Il comando accetta i seguenti flag facoltativi:

    • --edition=EDITION: la versione dell'istanza che crei. I valori accettati sono ENTERPRISE e ENTERPRISE_PLUS. Il valore predefinito è ENTERPRISE.

    • --cluster-storage-type=CLUSTER_STORAGE_TYPE: il tipo di spazio di archiviazione da utilizzare per l'istanza. Il valore predefinito è SSD. Nella maggior parte dei casi, il valore predefinito è quello migliore. Questa scelta è definitiva. Scopri di più.

    • --project=PROJECT: il progetto in cui creare il cluster, se diverso dal progetto corrente.

    • node-scaling-factor=NODE_SCALING_FACTOR: un flag che attiva la scalabilità dei nodi 2x. Puoi attivare questa funzionalità sia con la scalabilità manuale che con la scalabilità automatica. I valori accettabili sono node-scaling-factor-2x o node-scaling-factor-1x.

      Per visualizzare un elenco delle zone Bigtable non disponibili per la scalabilità dei nodi 2x, consulta Limitazioni del fattore di scalabilità dei nodi.

    • --tags=TAGKEY_NAME=TAGVALUE_NAME: un flag che aggiunge tag a una nuova istanza. Puoi specificare sia la chiave tag sia il valore tag in base al relativo ID permanente o al nome con spazio dei nomi. Puoi fornire più tag come elenco separato da virgole, ad esempio:

      • Utilizzo di ID permanenti:
        --tags=tagKeys/984321798431=tagValues/567890123456,
        tagKeys/123456789012=tagValues/098765432109
      • Utilizzo di nomi con spazio dei nomi:
        --tags=123456789012/environment=123456789012/environment/prod,
        123456789012/costcenter=123456789012/costcenter/marketing

  2. Esamina le impostazioni di replica nel profilo dell'app predefinito per verificare se sono adatte al tuo caso d'uso di replica. Potresti dover aggiornare il profilo dell'app predefinito o creare profili dell'app personalizzati.

cbt

  1. Inizia creando un'istanza con un singolo cluster. Utilizza il comando createinstance per creare un'istanza:

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

    Fornisci quanto segue:

    • INSTANCE_ID: l'identificatore permanente dell'istanza
    • DISPLAY_NAME: un nome leggibile che identifica l'istanza nella console Google Cloud .
    • CLUSTER_ID: l'identificatore permanente del cluster
    • CLUSTER_ZONE: la zona in cui viene eseguito il cluster.
    • CLUSTER_NUM_NODES: questo campo è facoltativo. Se non viene impostato alcun valore, Bigtable alloca automaticamente i nodi in base all'impatto dei dati e ottimizza l'utilizzo dello spazio di archiviazione al 50%. Se vuoi controllare il numero di nodi in un cluster, aggiorna il valore CLUSTER_NUM_NODES. Assicurati che il numero di nodi sia impostato su un valore diverso da zero. Scopri di più sui nodi.
    • CLUSTER_STORAGE_TYPE: il tipo di archiviazione da utilizzare per il cluster. Ogni cluster di un'istanza deve utilizzare lo stesso tipo di archiviazione. Accetta i valori SSD e HDD. Nella maggior parte dei casi, SSD è la soluzione migliore. Questa scelta è definitiva. Scopri di più.

  2. Per abilitare la replica, utilizza il comando createcluster per aggiungere un cluster:

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

    Fornisci quanto segue:

    • INSTANCE_ID: l'identificatore permanente dell'istanza appena creata
    • CLUSTER_ID: l'identificatore permanente del cluster

    • ZONE: la zona in cui viene eseguito il cluster.

      Ogni zona di una regione può contenere un solo cluster. Ad esempio, se un'istanza ha un cluster in us-east1-b, puoi aggiungere un cluster in una zona diversa della stessa regione, ad esempio us-east1-c, o in una zona di una regione separata, ad esempio europe-west2-a.

    • NUM_NODES: Questo campo è facoltativo. Se non viene impostato alcun valore, Bigtable alloca automaticamente i nodi in base all'impatto dei dati e ottimizza l'utilizzo dello spazio di archiviazione al 50%. Se vuoi controllare il numero di nodi in un cluster, aggiorna il valore NUM_NODES. Assicurati che il numero di nodi sia impostato su un valore diverso da zero.

      In molti casi, ogni cluster di un'istanza deve avere lo stesso numero di nodi, ma esistono delle eccezioni. Scopri di più sui nodi e sulla replica.

    • STORAGE_TYPE: il tipo di archiviazione da utilizzare per il cluster. Ogni cluster di un'istanza deve utilizzare lo stesso tipo di archiviazione. Accetta i valori SSD e HDD.

  3. (Facoltativo) Esamina le impostazioni di replica nel profilo dell'app predefinito per verificare se sono adatte al tuo caso d'uso di replica. Potresti dover aggiornare il profilo dell'app predefinito o creare profili dell'app personalizzati.

C++

Per scoprire come installare e utilizzare la libreria client per Bigtable, consulta Librerie client di Bigtable.

Per eseguire l'autenticazione in Bigtable, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale. 

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#

Per scoprire come installare e utilizzare la libreria client per Bigtable, consulta Librerie client di Bigtable.

Per eseguire l'autenticazione in Bigtable, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale. 

// 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);
}

Vai

Per scoprire come installare e utilizzare la libreria client per Bigtable, consulta Librerie client di Bigtable.

Per eseguire l'autenticazione in Bigtable, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale. 

// Copyright 2026 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

// Instance admin is a sample program demonstrating use of the Cloud Bigtable client
// library to perform basic instance admin operations.
package main

import (
	"context"
	"flag"
	"fmt"
	"io"
	"os"

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

func main() {
	projectID := "my-project-id" // The Google Cloud Platform project ID
	instanceID := "my-bigtable-instance"
	clusterID := "my-cluster"
	zone := "us-central1-b"

	// Allow overriding with flags
	flag.StringVar(&projectID, "project", projectID, "The Google Cloud Platform project ID.")
	flag.StringVar(&instanceID, "instance", instanceID, "The Google Cloud Bigtable instance ID to create.")
	flag.StringVar(&zone, "zone", zone, "The zone for the initial cluster.")
	flag.Parse()

	if err := createInstance(os.Stdout, projectID, instanceID, clusterID, zone); err != nil {
		fmt.Fprintf(os.Stderr, "Error creating instance: %v", err)
	}
}

func createInstance(w io.Writer, projectID, instanceID, clusterID, zone string) error {
	ctx := context.Background()

	instanceAdminClient, err := bigtable.NewInstanceAdminClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigtable.NewInstanceAdminClient: %w", err)
	}
	defer instanceAdminClient.Close()

	// These are placeholders. You must create these in your GCP Organization/Project first.
	// See [Creating and managing tags](https://docs.cloud.google.com/bigtable/docs/tags) for
	// more information on creating a tag.
	// tagKey := "tagKeys/12345"
	// tagValue := "tagValues/56789"

	instanceConf := &bigtable.InstanceConf{
		InstanceId:   instanceID,
		DisplayName:  instanceID,
		ClusterId:    clusterID,
		NumNodes:     1,
		InstanceType: bigtable.PRODUCTION,
		StorageType:  bigtable.SSD,
		Zone:         zone,
		// The 'Tags' field is optional. Uncomment the lines below (and the tagKey, tagValue lines above)
		// only if you want to create an instance with tags.
		// Ensure the tagKey and tagValue exist in your GCP project.
		// Tags: map[string]string{tagKey: tagValue},
	}

	fmt.Fprintf(w, "Creating instance %s with cluster %s in %s...\n", instanceID, clusterID, zone)

	if err := instanceAdminClient.CreateInstance(ctx, instanceConf); err != nil {
		return fmt.Errorf("CreateInstance: %w", err)
	}

	fmt.Fprintf(w, "Instance %s created successfully.\n", instanceID)
	return nil
}

Java

Per scoprire come installare e utilizzare la libreria client per Bigtable, consulta Librerie client di Bigtable.

Per eseguire l'autenticazione in Bigtable, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale. 

// Creates a Production Instance with the ID "ssd-instance",
// cluster id "ssd-cluster", 3 nodes and location "us-central1-f".
String parent = "projects/" + projectId;
Instance.Builder instanceObjBuilder =
    Instance.newBuilder()
        .setDisplayName(instanceId)
        .setType(Instance.Type.PRODUCTION)
        .putLabels("department", "accounting");

if (createWithTags) {
  System.out.println("Enabling tags for instance creation.");
  // These are placeholders. You must create these in your GCP Organization/Project first.
  String tagKey = "tagKeys/12345";
  String tagValue = "tagValues/6789";
  instanceObjBuilder.putTags(tagKey, tagValue);
}
Instance instanceObj = instanceObjBuilder.build();

Cluster clusterObj =
    Cluster.newBuilder()
        .setLocation("projects/" + projectId + "/locations/us-central1-f")
        .setServeNodes(3)
        .setDefaultStorageType(StorageType.SSD)
        .build();
CreateInstanceRequest request =
    CreateInstanceRequest.newBuilder()
        .setParent(parent)
        .setInstanceId(instanceId)
        .setInstance(instanceObj)
        .putClusters(clusterId, clusterObj)
        .build();
// Creates a production instance with the given request.
try {
  Instance instance = adminClient.createInstanceAsync(request).get();
  System.out.printf("PRODUCTION type instance %s created successfully%n", instance.getName());
} catch (Exception e) {
  System.err.println("Failed to create instance: " + e.getMessage());
  throw new RuntimeException(e);
}

Node.js

Per scoprire come installare e utilizzare la libreria client per Bigtable, consulta Librerie client di Bigtable.

Per eseguire l'autenticazione in Bigtable, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale. 

// Creates a Production Instance with the ID "ssd-instance"
// with cluster id "ssd-cluster", 3 nodes and location us-central1-f
const {BigtableInstanceAdminClient} = require('@google-cloud/bigtable').v2;
const instanceAdminClient = new BigtableInstanceAdminClient();
const projectId = await instanceAdminClient.getProjectId();

const instanceOptions = {
  parent: `projects/${projectId}`,
  instanceId: instanceID,
  instance: {
    displayName: instanceID,
    labels: {'prod-label': 'prod-label'},
    type: 'PRODUCTION',
  },
  clusters: {
    [clusterID]: {
      location: `projects/${projectId}/locations/us-central1-f`,
      serveNodes: 3,
      defaultStorageType: 'SSD',
    },
  },
};

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

PHP

Per scoprire come installare e utilizzare la libreria client per Bigtable, consulta Librerie client di Bigtable.

Per eseguire l'autenticazione in Bigtable, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale. 

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

Per scoprire come installare e utilizzare la libreria client per Bigtable, consulta Librerie client di Bigtable.

Per eseguire l'autenticazione in Bigtable, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale. 

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

Per scoprire come installare e utilizzare la libreria client per Bigtable, consulta Librerie client di Bigtable.

Per eseguire l'autenticazione in Bigtable, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale. 

# 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}"

Passaggi successivi