Ejemplo: aplicación “Hello World” de Node.js

Esta muestra de código es una aplicación “hello world” que se ejecuta en Node.js. En este ejemplo, se muestra cómo completar las siguientes tareas:

  • Conectarse a una instancia de Cloud Bigtable.
  • Crear una tabla nueva
  • Escribir datos en la tabla
  • Volver a leer datos
  • Borrar la tabla

Ejecutar la muestra

En esta muestra de código se usa el paquete de Cloud Bigtable de la biblioteca cliente de Google Cloud para Node.js a fin de comunicarse con Cloud Bigtable.

A fin de ejecutar este programa de muestra, sigue las instrucciones que se indican en GitHub.

Usa la biblioteca cliente de Cloud con Cloud Bigtable

La aplicación de muestra se conecta con Cloud Bigtable y demuestra algunas operaciones simples.

Requisitos de la biblioteca cliente

La muestra requiere el módulo @google-cloud/bigtable, que proporciona la clase Bigtable.

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

Conectarse con Cloud Bigtable

Para conectarte a Cloud Bigtable, crea un nuevo objeto Bigtable. Luego, llama a su método instance() para obtener un objeto Instance que represente tu instancia de Cloud Bigtable.

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

Crea una tabla

Llama al método table() de la instancia para obtener un objeto Table que represente la tabla de saludos de "hello world". Si la tabla no existe, llama al método create() de la tabla a fin de crear una tabla con una sola familia de columnas que conserve una versión de cada valor.

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

Escribe filas en una tabla

Usa un arreglo de strings de saludos para crear algunas filas nuevas para la tabla: llama al método map() del arreglo para crear un nuevo arreglo de objetos que represente filas y, luego, llama al método insert() de la tabla para agregar las filas a la tabla.

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

Crear un filtro

Antes de leer los datos que escribiste, crea un filtro para limitar los datos que muestre Cloud Bigtable. El filtro le indica a Cloud Bigtable que muestre solo la versión más reciente de cada valor, incluso si la tabla contiene versiones anteriores que no pasaron por el proceso de recolección de elementos no utilizados.

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

Lee una fila por su clave de fila

Llama al método row() de la tabla para obtener una referencia de la fila con una clave de fila específica. Luego, llama al método get() de la fila, y aplica el filtro para obtener una versión de cada valor en esa fila.

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

Analiza todas las filas de una tabla

Llama al método getRows() de la tabla, y aplica el filtro para obtener todas las filas de la tabla. Dado que aplicaste el filtro, Cloud Bigtable solo mostrará una versión de cada valor.

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

Borra una tabla

Borra la tabla con el método delete().

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

Revisión general

El código de muestra completo sin comentarios.



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