Hello World Node.js

Cet exemple de code est une application "Hello World" qui s'exécute sur Node.js. Il montre comment effectuer les tâches suivantes :

Configurer l'authentification
Se connecter à une instance Bigtable
créer une table ;
Écrire des données dans une table
Relire les données
Supprimer la table

Configurer l'authentification

Pour utiliser les exemples Node.js de cette page dans un environnement de développement local, installez et initialisez gcloud CLI, puis configurez le service Identifiants par défaut de l'application à l'aide de vos identifiants utilisateur.

Installez Google Cloud CLI.
Pour initialiser gcloudCLI, exécutez la commande suivante :
```
gcloud init
```

Créez des identifiants d'authentification locaux pour votre compte Google :
```
gcloud auth application-default login
```

Pour en savoir plus, consultez les sections sur Configurer l'authentification pour un environnement de développement local.

Exécuter l'exemple

Cet exemple de code communique avec Bigtable à l'aide du package Bigtable de la bibliothèque cliente Google Cloud pour Node.js.

Pour exécuter ce programme, suivez les instructions de l'exemple sur GitHub.

Utiliser la bibliothèque cliente Cloud avec Bigtable

L'exemple d'application permet de se connecter à Bigtable et décrit quelques opérations simples.

Bibliothèque cliente requise

L'exemple nécessite le module @google-cloud/bigtable, qui fournit la classe Bigtable.

const {Bigtable} = require('@google-cloud/bigtable');

Se connecter à Bigtable

Pour vous connecter à Bigtable, créez un objet Bigtable. Appelez ensuite la méthode instance() pour obtenir un objet Instance qui représente votre instance Bigtable.

const bigtableClient = new Bigtable();
const instance = bigtableClient.instance(INSTANCE_ID);

Créer une table

Appelez la méthode table() de l'instance pour obtenir un objet Table qui représente la table pour les messages d'accueil de l'application "Hello World". Si la table n'existe pas, appelez sa méthode create() pour créer une table avec une seule famille de colonnes qui conserve une version de chaque valeur.

const table = instance.table(TABLE_ID);
const [tableExists] = await table.exists();
if (!tableExists) {
  console.log(`Creating table ${TABLE_ID}`);
  const options = {
    families: [
      {
        name: COLUMN_FAMILY_ID,
        rule: {
          versions: 1,
        },
      },
    ],
  };
  await table.create(options);
}

Écrire des lignes dans une table

Créez des lignes pour la table à l'aide d'un tableau de chaînes de salutations : appelez la méthode map() du tableau pour créer un tableau d'objets représentant les lignes, puis appelez la méthode insert() de la table pour ajouter les lignes à cette dernière.

console.log('Write some greetings to the table');
const greetings = ['Hello World!', 'Hello Bigtable!', 'Hello Node!'];
const rowsToInsert = greetings.map((greeting, index) => ({
  // Note: This example uses sequential numeric IDs for simplicity, but this
  // pattern can result in poor performance in a production application.
  // Rows are stored in sorted order by key, so sequential keys can result
  // in poor distribution of operations across nodes.
  //
  // For more information about how to design an effective schema for Cloud
  // Bigtable, see the documentation:
  // https://cloud.google.com/bigtable/docs/schema-design
  key: `greeting${index}`,
  data: {
    [COLUMN_FAMILY_ID]: {
      [COLUMN_QUALIFIER]: {
        // Setting the timestamp allows the client to perform retries. If
        // server-side time is used, retries may cause multiple cells to
        // be generated.
        timestamp: new Date(),
        value: greeting,
      },
    },
  },
}));
await table.insert(rowsToInsert);

Créer un filtre

Avant de lire les données que vous avez écrites, créez un filtre pour limiter les données renvoyées par Bigtable. Ce filtre indique à Bigtable de ne renvoyer que la cellule la plus récente pour chaque colonne, même si celle-ci contient des cellules plus anciennes.

const filter = [
  {
    column: {
      cellLimit: 1, // Only retrieve the most recent version of the cell.
    },
  },
];

Lire une ligne à l'aide de sa clé

Appelez la méthode row() de la table pour obtenir une référence à la ligne avec une clé de ligne spécifique. Appelez ensuite la méthode get() sur la ligne en appliquant le filtre pour obtenir une version de chaque valeur figurant dans cette ligne.

console.log('Reading a single row by row key');
const [singleRow] = await table.row('greeting0').get({filter});
console.log(`\tRead: ${getRowGreeting(singleRow)}`);

Analyser toutes les lignes de la table

Appelez la méthode getRows() de la table en appliquant le filtre pour obtenir toutes les lignes de la table. En raison du filtre, Bigtable ne renvoie qu'une version de chaque valeur.

console.log('Reading the entire table');
// Note: For improved performance in production applications, call
// `Table#readStream` to get a stream of rows. See the API documentation:
// https://cloud.google.com/nodejs/docs/reference/bigtable/latest/Table#createReadStream
const [allRows] = await table.getRows({filter});
for (const row of allRows) {
  console.log(`\tRead: ${getRowGreeting(row)}`);
}

Supprimer une table

Supprimez la table à l'aide de sa méthode delete().

console.log('Delete the table');
await table.delete();

Synthèse

Voici l'exemple de code complet sans commentaires.



const {Bigtable} = require('@google-cloud/bigtable');

const TABLE_ID = 'Hello-Bigtable';
const COLUMN_FAMILY_ID = 'cf1';
const COLUMN_QUALIFIER = 'greeting';
const INSTANCE_ID = process.env.INSTANCE_ID;

if (!INSTANCE_ID) {
  throw new Error('Environment variables for INSTANCE_ID must be set!');
}

const getRowGreeting = row => {
  return row.data[COLUMN_FAMILY_ID][COLUMN_QUALIFIER][0].value;
};

(async () => {
  try {
    const bigtableClient = new Bigtable();
    const instance = bigtableClient.instance(INSTANCE_ID);

    const table = instance.table(TABLE_ID);
    const [tableExists] = await table.exists();
    if (!tableExists) {
      console.log(`Creating table ${TABLE_ID}`);
      const options = {
        families: [
          {
            name: COLUMN_FAMILY_ID,
            rule: {
              versions: 1,
            },
          },
        ],
      };
      await table.create(options);
    }

    console.log('Write some greetings to the table');
    const greetings = ['Hello World!', 'Hello Bigtable!', 'Hello Node!'];
    const rowsToInsert = greetings.map((greeting, index) => ({
      key: `greeting${index}`,
      data: {
        [COLUMN_FAMILY_ID]: {
          [COLUMN_QUALIFIER]: {
            timestamp: new Date(),
            value: greeting,
          },
        },
      },
    }));
    await table.insert(rowsToInsert);

    const filter = [
      {
        column: {
          cellLimit: 1, // Only retrieve the most recent version of the cell.
        },
      },
    ];

    console.log('Reading a single row by row key');
    const [singleRow] = await table.row('greeting0').get({filter});
    console.log(`\tRead: ${getRowGreeting(singleRow)}`);

    console.log('Reading the entire table');
    const [allRows] = await table.getRows({filter});
    for (const row of allRows) {
      console.log(`\tRead: ${getRowGreeting(row)}`);
    }

    console.log('Delete the table');
    await table.delete();
  } catch (error) {
    console.error('Something went wrong:', error);
  }
})();