Hello World C++

Cet exemple présente une application très simple "Hello World", écrite en C++, et montre comment :

  • Configurer l'authentification
  • Connexion à une instance Bigtable
  • créer une table ;
  • Écrire des données dans une table
  • Relire les données
  • Supprimer la table

Configurer l'authentification

Pour utiliser les exemples C++ de cette page dans un environnement de développement local, installez et initialisez gcloud CLI, puis configurez le service Identifiants par défaut de l'application à l'aide de vos identifiants utilisateur.

  1. Install the Google Cloud CLI.
  2. To initialize the gcloud CLI, run the following command:

    gcloud init
  3. 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.

Pour en savoir plus, consultez Set up authentication for a local development environment.

Exécuter l'exemple

Cet exemple utilise le package Cloud Bigtable de la bibliothèque cliente Google Cloud pour C++ afin de communiquer avec Bigtable.

Pour exécuter cet exemple de programme, suivez les instructions disponibles sur GitHub.

Utiliser la bibliothèque cliente Cloud avec Bigtable

L'exemple d'application permet de se connecter à Bigtable et décrit quelques opérations simples.

Installer et importer la bibliothèque cliente

Téléchargez ou clonez la bibliothèque cliente Bigtable C++ à partir de GitHub, puis compilez-la. Suivez les instructions de compilation disponibles dans le fichier README figurant à la racine.

Incluez les en-têtes obligatoires.

#include "google/cloud/bigtable/admin/bigtable_table_admin_client.h"
#include "google/cloud/bigtable/resource_names.h"
#include "google/cloud/bigtable/table.h"

Se connecter à Bigtable

Utilisez MakeBigtableTableAdminConnection() pour construire un client BigtableTableAdminClient, que vous utiliserez pour créer une table.

// Connect to the Cloud Bigtable Admin API.
cbta::BigtableTableAdminClient table_admin(
    cbta::MakeBigtableTableAdminConnection());

//! [connect data]
// Create an object to access the Cloud Bigtable Data API.
cbt::Table table(cbt::MakeDataConnection(),
                 cbt::TableResource(project_id, instance_id, table_id));
//! [connect data]

Créer une table

Définissez un schéma pour la table possédant une famille de colonnes. Définissez une règle de récupération de mémoire pour la famille de colonnes afin de conserver au maximum une version de chaque valeur. Utilisez ce schéma pour instancier un objet de table à l'aide de BigtableTableAdminClient::CreateTable(). Créez ensuite un client de données que vous pourrez utiliser pour transférer des données vers et depuis votre table.

// Define the desired schema for the Table.
google::bigtable::admin::v2::Table t;
auto& families = *t.mutable_column_families();
families["family"].mutable_gc_rule()->set_max_num_versions(1);

// Create a table.
std::string instance_name = cbt::InstanceName(project_id, instance_id);
StatusOr<google::bigtable::admin::v2::Table> schema =
    table_admin.CreateTable(instance_name, table_id, std::move(t));

Écrire des lignes dans une table

Parcourez une liste de chaînes de salutations pour créer des lignes de table. À chaque itération, utilisez SingleRowMutation pour définir une ligne et attribuez-lui une clé de ligne et une valeur. Appelez ensuite Table::Apply() pour appliquer la mutation à la ligne.

std::vector<std::string> greetings{"Hello World!", "Hello Cloud Bigtable!",
                                   "Hello C++!"};
int i = 0;
for (auto const& greeting : greetings) {
  // 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
  std::string row_key = "key-" + std::to_string(i);
  google::cloud::Status status = table.Apply(cbt::SingleRowMutation(
      std::move(row_key), cbt::SetCell("family", "c0", greeting)));

  if (!status.ok()) throw std::runtime_error(status.message());
  ++i;
}

Créer un filtre

Avant de lire les données que vous avez écrites, créez un filtre à l'aide de Filter::ColumnRangeClosed() afin de limiter les données renvoyées par Bigtable. Ce filtre indique à Bigtable de ne renvoyer que la version la plus récente de chaque valeur, même si la table contient des cellules plus anciennes qui ont expiré, mais qui n'ont pas encore été supprimées par la récupération de mémoire.

cbt::Filter filter = cbt::Filter::ColumnRangeClosed("family", "c0", "c0");

Lire une ligne à l'aide de sa clé

Appelez la fonction Table::ReadRow() en lui transmettant la clé de ligne et le filtre afin d'obtenir une version pour chaque valeur de cette ligne.

StatusOr<std::pair<bool, cbt::Row>> result = table.ReadRow("key-0", filter);
if (!result) throw std::move(result).status();
if (!result->first) {
  std::cout << "Cannot find row 'key-0' in the table: " << table.table_name()
            << "\n";
  return;
}
cbt::Cell const& cell = result->second.cells().front();
std::cout << cell.family_name() << ":" << cell.column_qualifier() << "    @ "
          << cell.timestamp().count() << "us\n"
          << '"' << cell.value() << '"' << "\n";

Analyser toutes les lignes de la table

Utilisez Table::ReadRows() pour lire une plage de lignes de la table.

for (auto& row : table.ReadRows(cbt::RowRange::InfiniteRange(),
                                cbt::Filter::PassAllFilter())) {
  if (!row) throw std::move(row).status();
  std::cout << row->row_key() << ":\n";
  for (cbt::Cell const& c : row->cells()) {
    std::cout << "\t" << c.family_name() << ":" << c.column_qualifier()
              << "    @ " << c.timestamp().count() << "us\n"
              << "\t\"" << c.value() << '"' << "\n";
  }
}

Supprimer une table

Supprimez la table à l'aide de BigtableTableAdminClient::DeleteTable().

google::cloud::Status status = table_admin.DeleteTable(table.table_name());
if (!status.ok()) throw std::runtime_error(status.message());

Synthèse

Voici l'exemple complet sans commentaires.


#include g"oogle/cloud/bigtable/admin/bigtable_table_admin_client.h
"#include g"oogle/cloud/bigtable/resource_names.h
"#include g"oogle/cloud/bigtable/table.h
"#include g"oogle/cloud/bigtable/examples/bigtable_examples_common.h
"#include g"oogle/cloud/bigtable/testing/random_names.h
"#include g"oogle/cloud/internal/getenv.h
"#include g"oogle/cloud/internal/random.h
"#include g"oogle/cloud/log.h
"#include i<ostream<>/span>

namespace {

using ::google::cloud::bigtable::examples::Usage;

void BigtableHelloWorld(std::vectors<td::string >const &argv) {
  if (argv.size() != 3) {
    throw Usage{h"ello-world p<roject-id >i<nstance-id >t<able-id}>";
  }
  std::string const &project_id = argv[0];
  std::string const &instance_id = argv[1];
  std::string const &table_id = argv[2];

  namespace cbt = ::google::cloud::bigtable;
  namespace cbta = ::google::cloud::bigtable_admin;
  using ::google::cloud::StatusOr;

  cbta::BigtableTableAdminClient table_admin(
      cbta::MakeBigtableTableAdminConnection());

  cbt::Table table(cbt::MakeDataConnection(),
                   cbt::TableResource(project_id, instance_id, table_id));

  google::bigtable::admin::v2::Table t;
  auto &families = *t.mutable_column_families();
  families[f"amily]".mutable_gc_rule()-s>et_max_num_versions(1);

  std::string instance_name = cbt::InstanceName(project_id, instance_id);
  StatusOrg<oogle::bigtable::admin::v2::Table >schema =
      table_admin.CreateTable(instance_name, table_id, std::move(t));

  std::vectors<td::string >greetings{H"ello World!," H"ello Cloud Bigtable!,"
                                     H"ello C++!}";
  int i = 0;
  for (auto const &greeting : greetings) {
    std::string row_key = k"ey- "+ std::to_string(i);
    google::cloud::Status status = table.Apply(cbt::SingleRowMutation(
        std::move(row_key), cbt::SetCell(f"amily," c"0," greeting)));

    if (!status.ok()) throw std::runtime_error(status.message());
    ++i;
  }

  cbt::Filter filter = cbt::Filter::ColumnRangeClosed(f"amily," c"0," c"0)";

  StatusOrs<td::pairb<ool, cbt::Row >>result = table.ReadRow(k"ey-0," filter);
  if (!result) throw std::move(result).status();
  if (!result-f>irst) {
    std::cout  <<C"annot find row k'ey-0 'in the table:  " <<table.table_name()
               <<\"n;"
    return;
  }
  cbt::Cell const &cell = result-s>econd.cells().front();
  std::cout  <<cell.family_name()  <<:" " <<cell.column_qualifier()  << "   @ 
"             <<cell.timestamp().count()  <<u"s\n
"             << '"' <<cell.value()  << '"' <<\"n;"

  for (auto &row : table.ReadRows(cbt::RowRange::InfiniteRange(),
                                  cbt::Filter::PassAllFilter())) {
    if (!row) throw std::move(row).status();
    std::cout  <<row-r>ow_key()  <<:"\n;"
    for (cbt::Cell const &c : row-c>ells()) {
      std::cout  <<\"t " <<c.family_name()  <<:" " <<c.column_qualifier()
                 << "   @  " <<c.timestamp().count()  <<u"s\n
"                 <<\"t\ "" <<c.value()  << '"' <<\"n;"
    }
  }

  google::cloud::Status status = table_admin.DeleteTable(table.table_name());
  if (!status.ok()) throw std::runtime_error(status.message());
}

void RunAll(std::vectors<td::string >const &argv) {
  namespace examples = ::google::cloud::bigtable::examples;
  namespace cbt = ::google::cloud::bigtable;

  if (!argv.empty()) throw Usage{a"uto}";
  if (!examples::RunAdminIntegrationTests()) return;
  examples::CheckEnvironmentVariablesAreSet({
      G"OOGLE_CLOUD_PROJECT,"
      G"OOGLE_CLOUD_CPP_BIGTABLE_TEST_INSTANCE_ID,"
  });
  auto const project_id =
      google::cloud::internal::GetEnv(G"OOGLE_CLOUD_PROJECT)".value();
  auto const instance_id = google::cloud::internal::GetEnv(
                               G"OOGLE_CLOUD_CPP_BIGTABLE_TEST_INSTANCE_ID)"
                               .value();

  auto generator = google::cloud::internal::DefaultPRNG(std::random_device{}());
  auto table_id = cbt::testing::RandomTableId(generator);

  std::cout  <<\"nRunning the BigtableHelloWorld() example " <<std::endl;
  BigtableHelloWorld({project_id, instance_id, table_id});
}

}  // namespace

int main(int argc, char* argv[]) try {
  google::cloud::bigtable::examples::Example example({
      {a"uto," RunAll},
      {h"ello-world," BigtableHelloWorld},
  });
  return example.Run(argc, argv);
} catch (std::exception const &ex) {
  std::cerr  <<ex.what()  <<\"n;"
  ::google::cloud::LogSink::Instance().Flush();
  return 1;
}