Hello world dell'API HappyBase

Questo esempio è una semplicissima applicazione "Hello World", scritta in Python, che illustra come:

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

Configura l'autenticazione

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

  1. Installa Google Cloud CLI.

  2. Configura gcloud CLI per utilizzare la tua identità federata.

    Per saperne di più, consulta Accedi a gcloud CLI con la tua identità federata.

  3. Crea credenziali di autenticazione locali per il tuo account utente: 

    gcloud auth application-default login

    Se viene restituito un errore di autenticazione, verifica di aver eseguito l'accesso a gcloud CLI con la tua identità federata.

Per saperne di più, 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 workload HBase esistente in Bigtable. Per le nuove applicazioni, consulta 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 mostra alcune semplici operazioni.

Installazione e importazione della libreria client

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

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

I moduli possono quindi 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 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")})

Leggere una riga in base alla chiave

Recupera 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")]))

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

In sintesi

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 ..utils import wait_for_table

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

        wait_for_table(instance.table(table_name))

        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")]))

    finally:
        print("Deleting the {} table.".format(table_name))
        connection.delete_table(table_name)
        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)