Hello World dell'API HappyBase

Alpha

Questo prodotto è soggetto ai "Termini delle offerte pre-GA" nella sezione Termini di servizio generali dei Termini specifici dei servizi. I prodotti pre-GA sono disponibili "così come sono" e potrebbero avere un supporto limitato. Per saperne di più, consulta le descrizioni della fase di lancio.

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

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

Configura l'autenticazione

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

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.

Per ulteriori informazioni, consulta Set up authentication for a local development environment.

Eseguire il sample

Questo esempio utilizza il pacchetto HappyBase della libreria client 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 su 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.

Utilizzare le API HappyBase con Bigtable

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

Installazione e importazione della libreria client

I pacchetti Python richiesti possono essere installati utilizzando PIP in un ambiente virtualenv. Il sample include un file requirements 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

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.

Nota: le colonne correlate una all'altra sono generalmente raggruppate insieme in una famiglia di colonne. Per saperne di più sulle famiglie di colonne, consulta il modello di archiviazione di Bigtable.

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

Ricevi 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")})

Lettura di una riga tramite la relativa 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)