Hello World en 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:

  • Configura la autenticación
  • Conectarse a una instancia de Bigtable
  • Crear una tabla nueva
  • Escribir datos en la tabla
  • Volver a leer datos
  • Borrar la tabla

Configura la autenticación

Para usar las muestras de Node.js de esta página desde un entorno de desarrollo local, instala e inicializa la CLI de gcloud y, luego, configura las credenciales predeterminadas de la aplicación con tus credenciales de usuario.

  1. Instala Google Cloud CLI.
  2. Para inicializar la CLI de gcloud, ejecuta el siguiente comando:

    gcloud init
  3. Crea credenciales de autenticación locales para tu Cuenta de Google:

    gcloud auth application-default login

Para obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

Ejecuta la muestra

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

Para ejecutar este programa de muestra, sigue las instrucciones de la muestra en GitHub.

Usa la biblioteca cliente de Cloud con Bigtable

La aplicación de muestra se conecta con 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');

Conéctate a Bigtable

Para conectarte a Bigtable, crea un objeto Bigtable nuevo. Luego, llama a su método instance() para obtener un objeto Instance que represente tu instancia de 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);

Crea un filtro

Antes de leer los datos que escribiste, crea un filtro para limitar los datos que muestre Bigtable. El filtro le indica a Bigtable que muestre solo la celda más reciente de cada columna, incluso si contiene celdas más antiguas.

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