Hello World dell'API HappyBase

Questo esempio è un'applicazione "hello world" molto semplice, scritta in Python, che illustra come:

  • Configura l'autenticazione
  • Connettiti a un'istanza Bigtable.
  • Crea una nuova tabella.
  • Scrivi i dati nella tabella.
  • Leggere i dati.
  • Elimina la tabella.

Configura l'autenticazione

Per utilizzare gli esempi Python in questa pagina da un ambiente di sviluppo locale, installa e inizializza gcloud CLI, quindi configura le Credenziali predefinite dell'applicazione con le tue credenziali utente.

  1. Installa Google Cloud CLI.
  2. Per initialize gcloud CLI, esegui questo comando:

    gcloud init
  3. Crea credenziali di autenticazione locali per il tuo Account Google:

    gcloud auth application-default login

Per ulteriori informazioni, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

Esecuzione dell'esempio

Questo esempio utilizza il pacchetto HappyBase della libreria client di Google Cloud per Python, un'implementazione delle API HappyBase, per comunicare con Bigtable. Utilizza il pacchetto HappyBase se devi spostare un carico di lavoro HBase esistente in Bigtable. Per le nuove applicazioni, vedi l'esempio "Hello World" che utilizza il pacchetto Bigtable.

Per eseguire questo programma di esempio, segui le istruzioni per l'esempio su GitHub.

Utilizzo delle API HappyBase con Bigtable

L'applicazione di esempio si connette a Bigtable e dimostra alcune operazioni semplici.

Installazione e importazione della libreria client

I pacchetti Python richiesti possono essere installati utilizzando PIP in un ambiente virtualenv. L'esempio include un file dei requisiti che definisce i pacchetti necessari.

google-cloud-happybase==0.33.0
six==1.16.0 # See https://github.com/googleapis/google-cloud-python-happybase/issues/128

A questo punto i moduli possono essere importati.

from google.cloud import bigtable
from google.cloud import happybase

Connessione a Bigtable

Connettiti a Bigtable passando un bigtable.Client a un happybase.Connection.

# The client must be created with admin=True because it will create a
# table.
client = bigtable.Client(project=project_id, admin=True)
instance = client.instance(instance_id)
connection = happybase.Connection(instance=instance)

Creazione di una tabella

Utilizza Connection.create_table() per creare una tabella e le relative famiglie di colonne.

print("Creating the {} table.".format(table_name))
column_family_name = "cf1"
connection.create_table(
    table_name, {column_family_name: dict()}  # Use default options.
)

Scrittura di righe in una tabella

Ottieni un elemento Table esistente con Connection.table(). Utilizza Table.put() per scrivere una riga nella tabella.

print("Writing some greetings to the table.")
table = connection.table(table_name)
column_name = "{fam}:greeting".format(fam=column_family_name)
greetings = [
    "Hello World!",
    "Hello Cloud Bigtable!",
    "Hello HappyBase!",
]

for i, value in enumerate(greetings):
    # 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
    row_key = "greeting{}".format(i)
    table.put(row_key, {column_name.encode("utf-8"): value.encode("utf-8")})

Lettura di una riga tramite la relativa chiave

Ricevi una riga direttamente utilizzando la relativa chiave con Table.row().

print("Getting a single greeting by row key.")
key = "greeting0".encode("utf-8")
row = table.row(key)
print("\t{}: {}".format(key, row[column_name.encode("utf-8")]))

Analisi di tutte le righe della tabella

Utilizza Table.scan() per ottenere un intervallo di righe.

print("Scanning for all greetings:")

for key, row in table.scan():
    print("\t{}: {}".format(key, row[column_name.encode("utf-8")]))

Eliminazione di una tabella

Elimina una tabella con Connection.delete_table().

print("Deleting the {} table.".format(table_name))
connection.delete_table(table_name)

Riepilogo

Ecco l'esempio completo senza commenti.



"""Demonstrates how to connect to Cloud Bigtable and run some basic operations.

Prerequisites:

- Create a Cloud Bigtable cluster.
  https://cloud.google.com/bigtable/docs/creating-cluster
- Set your Google Application Default Credentials.
  https://developers.google.com/identity/protocols/application-default-credentials
"""

import argparse

from google.cloud import bigtable
from google.cloud import happybase

def main(project_id, instance_id, table_name):
    client = bigtable.Client(project=project_id, admin=True)
    instance = client.instance(instance_id)
    connection = happybase.Connection(instance=instance)

    try:
        print("Creating the {} table.".format(table_name))
        column_family_name = "cf1"
        connection.create_table(
            table_name, {column_family_name: dict()}  # Use default options.
        )

        print("Writing some greetings to the table.")
        table = connection.table(table_name)
        column_name = "{fam}:greeting".format(fam=column_family_name)
        greetings = [
            "Hello World!",
            "Hello Cloud Bigtable!",
            "Hello HappyBase!",
        ]

        for i, value in enumerate(greetings):
            row_key = "greeting{}".format(i)
            table.put(row_key, {column_name.encode("utf-8"): value.encode("utf-8")})

        print("Getting a single greeting by row key.")
        key = "greeting0".encode("utf-8")
        row = table.row(key)
        print("\t{}: {}".format(key, row[column_name.encode("utf-8")]))

        print("Scanning for all greetings:")

        for key, row in table.scan():
            print("\t{}: {}".format(key, row[column_name.encode("utf-8")]))

        print("Deleting the {} table.".format(table_name))
        connection.delete_table(table_name)

    finally:
        connection.close()

if __name__ == "__main__":
    parser = argparse.ArgumentParser(
        description=__doc__, formatter_class=argparse.ArgumentDefaultsHelpFormatter
    )
    parser.add_argument("project_id", help="Your Cloud Platform project ID.")
    parser.add_argument(
        "instance_id", help="ID of the Cloud Bigtable instance to connect to."
    )
    parser.add_argument(
        "--table", help="Table to create and destroy.", default="Hello-Bigtable"
    )

    args = parser.parse_args()
    main(args.project_id, args.instance_id, args.table)