Example: Java App Engine Application

This example is an App Engine application, written in Java, that writes some "hello world" greetings to a table and reads them back. The application uses the App Engine runtime and has full access to App Engine APIs. It runs in the cloud in the App Engine flexible environment. The code for this version is in the GitHub repository GoogleCloudPlatform/cloud-bigtable-examples, in the directory java/gae-flexible-helloworld.

Overview of the code sample

The code sample includes the following classes:


BigtableHelper provides a method to create a connection to Cloud Bigtable. It also caches the connection and provides a method that will retrieve the cached connection if it exists. This is because creating the connection is a relatively expensive operation.

public static void connect() throws IOException {

  if (PROJECT_ID == null || INSTANCE_ID == null ) {
    sc.log("environment variables BIGTABLE_PROJECT, and BIGTABLE_INSTANCE need to be defined.");

  connection = BigtableConfiguration.connect(PROJECT_ID, INSTANCE_ID);

public static Connection getConnection() {
  if (connection == null) {
    try {
    } catch (IOException e) {
      sc.log("connect ", e);
  if (connection == null) {
    sc.log("BigtableHelper-No Connection");
  return connection;


BigtableHelloWorld is used to write a series of greetings to Cloud Bigtable, then read them back and display them. The class gets a Cloud Bigtable connection from BigtableHelper; uses the connection to get a Table object, which enables you to read and write values; and uses the Table object to write to and read from the table:

 * A minimal application that connects to Cloud Bigtable using the native HBase API
 * and performs some basic operations.
public class BigtableHelloWorld {

  // Refer to table metadata names by byte array in the HBase API
  private static final byte[] TABLE_NAME = Bytes.toBytes("Hello-Bigtable");
  private static final byte[] COLUMN_FAMILY_NAME = Bytes.toBytes("cf1");
  private static final byte[] COLUMN_NAME = Bytes.toBytes("greeting");

  // Write some friendly greetings to Cloud Bigtable
  private static final String[] GREETINGS =
      { "Hello World!", "Hello Cloud Bigtable!", "Hello HBase!" };

  public static String create(Connection connection) {
    try {
        // The admin API lets us create, manage and delete tables
      Admin admin = connection.getAdmin();

      // Create a table with a single column family
      HTableDescriptor descriptor = new HTableDescriptor(TableName.valueOf(TABLE_NAME));
      descriptor.addFamily(new HColumnDescriptor(COLUMN_FAMILY_NAME));

    } catch (IOException e) {
      return "Table exists.";
    return "Create table " + TABLE_NAME.toString();


   * Connects to Cloud Bigtable, runs some basic operations and prints the results.
  public static String doHelloWorld() {

    StringBuilder result = new StringBuilder();

    // Create the Bigtable connection, use try-with-resources to make sure it gets closed
    Connection connection = BigtableHelper.getConnection();
    try (Table table = connection.getTable(TableName.valueOf(TABLE_NAME))) {

      // Retrieve the table we just created so we can do some reads and writes

      // Write some rows to the table
      result.append("Write some greetings to the table<br>");
      for (int i = 0; i < GREETINGS.length; i++) {
        // Each row has a unique row key.
        // Note: This example uses sequential numeric IDs for simplicity, but
        // this can result in poor performance in a production application.
        // Since rows are stored in sorted order by key, sequential keys can
        // result in poor distribution of operations across nodes.
        // For more information about how to design a Bigtable schema for the
        // best performance, see the documentation:
        //     https://cloud.google.com/bigtable/docs/schema-design
        String rowKey = "greeting" + i;

        // Put a single row into the table. We could also pass a list of Puts to write a batch.
        Put put = new Put(Bytes.toBytes(rowKey));
        put.addColumn(COLUMN_FAMILY_NAME, COLUMN_NAME, Bytes.toBytes(GREETINGS[i]));

      // Get the first greeting by row key
      String rowKey = "greeting0";
      Result getResult = table.get(new Get(Bytes.toBytes(rowKey)));
      String greeting = Bytes.toString(getResult.getValue(COLUMN_FAMILY_NAME, COLUMN_NAME));
      result.append("Get a single greeting by row key<br>");
      result.append("     ");
      result.append("= ");

      // Now scan across all rows.
      Scan scan = new Scan();

      result.append("Scan for all greetings:");
      ResultScanner scanner = table.getScanner(scan);
      for (Result row : scanner) {
        byte[] valueBytes = row.getValue(COLUMN_FAMILY_NAME, COLUMN_NAME);
        result.append("    ");

    } catch (IOException e) {
      result.append("Exception while running HelloWorld: " + e.getMessage() + "<br>");
      return result.toString();

    return result.toString();


Send feedback about...

Cloud Bigtable Documentation