Diese Seite wurde von der Cloud Translation API übersetzt.

Node.js Hello World

Dieses Codebeispiel ist eine "Hello World"-Anwendung, die auf Node.js ausgeführt wird. Das Beispiel veranschaulicht die folgenden Aufgaben:

Authentifizierung einrichten
Verbindung zu einer Bigtable-Instanz herstellen
Erstellen einer neuen Tabelle
Schreiben von Daten in die Tabelle
Lesen von Daten aus der Tabelle
Löschen einer Tabelle

Authentifizierung einrichten

Wenn Sie die Node.js Beispiele auf dieser Seite in einer lokalen Entwicklungsumgebung verwenden möchten, installieren und initialisieren Sie die gcloud CLI und richten dann die Standardanmeldedaten für Anwendungen mit Ihren Nutzeranmeldedaten ein.

Install the Google Cloud CLI.
To initialize the gcloud CLI, run the following command:
```
gcloud init
```
If you're using a local shell, then create local authentication credentials for your user account:
```
gcloud auth application-default login
```
You don't need to do this if you're using Cloud Shell.

Weitere Informationen unter Set up authentication for a local development environment.

Beispiel ausführen

In diesem Codebeispiel wird die Methode Bigtable-Paket des Google Cloud-Clientbibliothek für Node.js zur Kommunikation mit Bigtable.

Folgen Sie der Anleitung zum Beispiel auf GitHub, um das Beispielprogramm auszuführen.

Cloud-Clientbibliothek mit Bigtable verwenden

Die Beispielanwendung stellt eine Verbindung zu Bigtable her und zeigt einige einfache Vorgänge.

Clientbibliothek anfordern

Für das Beispiel ist das Modul @google-cloud/bigtable erforderlich, das die Klasse Bigtable bereitstellt.

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

Verbindung zu Bigtable herstellen

Erstellen Sie ein neues Bigtable-Objekt, um eine Verbindung zu Bigtable herzustellen. Rufen Sie dann die Methode instance() auf, um das Objekt Instance abzurufen, das die Bigtable-Instanz darstellt.

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

Tabelle erstellen

Sie rufen die Methode table() der Instanz auf, um ein Table-Objekt abzurufen, das die Tabelle mit den Begrüßungen für "Hello World" darstellt. Wenn die Tabelle nicht vorhanden ist, rufen Sie die Methode create() der Tabelle auf. Damit erstellen Sie eine Tabelle mit einer einzigen Spaltenfamilie, die nur eine Version von jedem Wert enthält.

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

Zeilen in eine Tabelle schreiben

Mit einem Array aus Begrüßungsstrings erstellen Sie neue Zeilen für die Tabelle. Dazu rufen Sie die Methode map() des Arrays auf, um aus Objekten für Zeilen ein neues Array zu erstellen. Danach rufen Sie die Methode insert() der Tabelle auf, um der Tabelle die Zeilen hinzuzufügen.

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

Filter erstellen

Erstellen Sie vor dem Lesen der von Ihnen geschriebenen Daten einen Filter, um die von Bigtable zurückgegebenen Daten zu beschränken. Mit diesem Filter wird Bigtable angewiesen, nur die neueste Zelle für jede Spalte zurückzugeben, auch wenn die Spalte ältere Zellen enthält.

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

Zeile über ihren Zeilenschlüssel lesen

Mit der Methode row() der Tabelle rufen Sie einen Verweis auf die Zeile mit einem bestimmten Zeilenschlüssel ab. Rufen Sie dann die Methode get() der Zeile auf und übergeben den Filter, um nur eine Version von jedem Wert in dieser Zeile abzurufen.

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

Alle Tabellenzeilen scannen

Rufen Sie die Methode getRows() der Tabelle auf und übergeben Sie den Filter, um alle Zeilen in der Tabelle abzurufen. Durch Übergabe des Filters gibt Bigtable nur eine Version jedes Werts zurück.

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

Tabelle löschen

Mit der Methode delete() der Tabelle löschen Sie die Tabelle.

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

Zusammenfassung

Im Folgenden ist das vollständige Codebeispiel ohne Kommentare aufgeführt.




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