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

Esta muestra de código 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.

Usar 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

Esta 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 objeto Bigtable nuevo. 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 nueva con una sola familia de columnas que contenga 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);
}

Escribir filas en una tabla

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

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 han pasado por el proceso de recolección de elementos no utilizados.

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

Leer una fila por su clave de fila

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

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

Analizar todas las filas de una tabla

Llama al método getRows() de la tabla y aplica el filtro a fin de 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)}`);
}

Borrar una tabla

Borra la tabla con su 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);
  }
})();
¿Te sirvió esta página? Envíanos tu opinión:

Enviar comentarios sobre…

Documentación de Cloud Bigtable