Node.js hello world

This code sample is a "hello world" application that runs on Node.js. The sample illustrates how to complete the following tasks:

Set up authentication
Connect to a Bigtable instance.
Create a new table.
Write data to the table.
Read the data back.
Delete the table.

Set up authentication

To use the Node.js samples on this page in a local development environment, install and initialize the gcloud CLI, and then set up Application Default Credentials with your user credentials.

Install the Google Cloud CLI.

If you're using an external identity provider (IdP), you must first sign in to the gcloud CLI with your federated identity .

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.

If an authentication error is returned, and you are using an external identity provider (IdP), confirm that you have signed in to the gcloud CLI with your federated identity .

For more information, see Set up authentication for a local development environment .

Running the sample

This code sample uses the Bigtable package of the Google Cloud Client Library for Node.js to communicate with Bigtable.

To run this sample program, follow the instructions for the sample on GitHub .

Using the Cloud Client Library with Bigtable

The sample application connects to Bigtable and demonstrates some simple operations.

Requiring the client library

The sample requires the @google-cloud/bigtable module, which provides the Bigtable class.

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

Connecting to Bigtable

To connect to Bigtable, create a new Bigtable object. Then call its instance() method to get an Instance object that represents your Bigtable instance.

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

Creating a table

Call the instance's table() method to get a Table object that represents the table for "hello world" greetings. If the table doesn't exist, call the table's create() method to create a table with a single column family that retains one version of each value.

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

Writing rows to a table

Use an array of greeting strings to create some new rows for the table: call the array's map() method to create a new array of objects that represent rows, then call the table's insert() method to add the rows to the table.

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

Creating a filter

Before you read the data that you wrote, create a filter to limit the data that Bigtable returns. This filter tells Bigtable to return only the most recent cell for each column, even if the column contains older cells.

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

Reading a row by its row key

Call the table's row() method to get a reference to the row with a specific row key. Then call the row's get() method, passing in the filter, to get one version of each value in that row.

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

Scanning all table rows

Call the table's getRows() method, passing in the filter, to get all of the rows in the table. Because you passed in the filter, Bigtable returns only one version of each value.

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

Deleting a table

Delete the table with the table's delete() method.

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

Putting it all together

Here is the full code sample without comments.

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