Esta página se ha traducido con Cloud Translation API.

Hola, mundo en Python

Este ejemplo es una aplicación "Hola, mundo" escrita en Python que muestra cómo hacer lo siguiente:

Configura la autenticación.
Conéctate a una instancia de Bigtable.
Crea una tabla.
Escribe datos en la tabla.
Lee los datos.
Elimina la tabla.

La biblioteca de cliente de Python para Bigtable ofrece dos APIs: asyncio y una API síncrona. Si tu aplicación es asíncrona, usa asyncio.

Configurar la autenticación

Para usar las Python muestras de esta página en un entorno de desarrollo local, instala e inicializa la CLI de gcloud y, a continuación, configura las credenciales predeterminadas de la aplicación con tus credenciales de usuario.

Instala Google Cloud CLI.

Si utilizas un proveedor de identidades (IdP) externo, primero debes iniciar sesión en la CLI de gcloud con tu identidad federada.

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.

If an authentication error is returned, and you are using an external identity provider (IdP), confirm that you have signed in to the gcloud CLI with your federated identity.

Para obtener más información, consulta Set up authentication for a local development environment.

Ejecutar la muestra

En este ejemplo se usa el paquete Bigtable de las bibliotecas de cliente de Cloud para Python para comunicarse con Bigtable. El paquete Bigtable es la mejor opción para las aplicaciones nuevas. Si necesitas migrar una carga de trabajo de HBase a Bigtable, consulta el ejemplo"hello world" que usa el paquete HappyBase.

Para ejecutar este programa de ejemplo, sigue las instrucciones del ejemplo en GitHub.

Usar las bibliotecas de cliente de Cloud con Bigtable

La aplicación de ejemplo se conecta a Bigtable y muestra algunas operaciones.

Instalar e importar la biblioteca de cliente

Usa PIP para instalar los paquetes de Python necesarios en un entorno virtualenv. El ejemplo incluye un archivo de requisitos que define los paquetes necesarios.

google-cloud-bigtable==2.30.1
google-cloud-core==2.4.3

Importa los módulos.

Asyncio

Para saber cómo instalar y usar la biblioteca de cliente de Bigtable, consulta el artículo Bibliotecas de cliente de Bigtable.

Para autenticarte en Bigtable, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local.

from google.cloud import bigtable
from google.cloud.bigtable.data import row_filters

Sincronizar

Para saber cómo instalar y usar la biblioteca de cliente de Bigtable, consulta el artículo Bibliotecas de cliente de Bigtable.

import datetime

from google.cloud import bigtable
from google.cloud.bigtable import column_family
from google.cloud.bigtable import row_filters

Conectarse a Bigtable

Conéctate a Bigtable mediante un bigtable.Client.

Asyncio

Para saber cómo instalar y usar la biblioteca de cliente de Bigtable, consulta el artículo Bibliotecas de cliente de Bigtable.

client = bigtable.data.BigtableDataClientAsync(project=project_id)
table = client.get_table(instance_id, table_id)

Sincronizar

Para saber cómo instalar y usar la biblioteca de cliente de Bigtable, consulta el artículo Bibliotecas de cliente de Bigtable.

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

Crear una tabla

Crea una instancia de un objeto de tabla con Instance.table(). Crea una familia de columnas y define su política de recolección de elementos no utilizados. A continuación, pasa la familia de columnas a Table.create() para crear la tabla.

print("Creating the {} table.".format(table_id))
table = instance.table(table_id)

print("Creating column family cf1 with Max Version GC rule...")
# Create a column family with GC policy : most recent N versions
# Define the GC policy to retain only the most recent 2 versions
max_versions_rule = bigtable.column_family.MaxVersionsGCRule(2)
column_family_id = "cf1"
column_families = {column_family_id: max_versions_rule}
if not table.exists():
    table.create(column_families=column_families)
else:
    print("Table {} already exists.".format(table_id))

Escribir filas en una tabla

Recorre una lista de cadenas de saludo para crear algunas filas en la tabla. En cada iteración, usa Table.row() para definir una fila y asignarle una clave de fila, llama a Row.set_cell() para definir un valor para la celda actual y añade la nueva fila a una matriz de filas. Por último, llama a Table.mutate_rows() para añadir las filas a la tabla.

Asyncio

Para saber cómo instalar y usar la biblioteca de cliente de Bigtable, consulta el artículo Bibliotecas de cliente de Bigtable.

print("Writing some greetings to the table.")
greetings = ["Hello World!", "Hello Cloud Bigtable!", "Hello Python!"]
mutations = []
column = "greeting"
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).encode()
    row_mutation = bigtable.data.RowMutationEntry(
        row_key, bigtable.data.SetCell(column_family_id, column, value)
    )
    mutations.append(row_mutation)
await table.bulk_mutate_rows(mutations)

Sincronizar

Para saber cómo instalar y usar la biblioteca de cliente de Bigtable, consulta el artículo Bibliotecas de cliente de Bigtable.

print("Writing some greetings to the table.")
greetings = ["Hello World!", "Hello Cloud Bigtable!", "Hello Python!"]
rows = []
column = "greeting".encode()
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).encode()
    row = table.direct_row(row_key)
    row.set_cell(
        column_family_id, column, value, timestamp=datetime.datetime.utcnow()
    )
    rows.append(row)
table.mutate_rows(rows)

Crear un filtro

Antes de leer los datos que ha escrito, cree un filtro con row_filters.CellsColumnLimitFilter() para limitar los datos que devuelve Bigtable. Este filtro indica a Bigtable que devuelva solo la celda más reciente de cada columna, aunque la tabla contenga celdas más antiguas que aún no se hayan eliminado durante la recogida de elementos obsoletos.

Asyncio

Para saber cómo instalar y usar la biblioteca de cliente de Bigtable, consulta el artículo Bibliotecas de cliente de Bigtable.

# Create a filter to only retrieve the most recent version of the cell
# for each column across entire row.
row_filter = bigtable.data.row_filters.CellsColumnLimitFilter(1)

Sincronizar

Para saber cómo instalar y usar la biblioteca de cliente de Bigtable, consulta el artículo Bibliotecas de cliente de Bigtable.

row_filter = bigtable.row_filters.CellsColumnLimitFilter(1)

Leer una fila por su clave de fila

Llama al método Table.read_row() de la tabla para obtener una referencia a la fila con una clave de fila específica. Para ello, pasa la clave y el filtro para obtener una versión de cada valor de esa fila.

Asyncio

Para saber cómo instalar y usar la biblioteca de cliente de Bigtable, consulta el artículo Bibliotecas de cliente de Bigtable.

print("Getting a single greeting by row key.")
key = "greeting0".encode()

row = await table.read_row(key, row_filter=row_filter)
cell = row.cells[0]
print(cell.value.decode("utf-8"))

Sincronizar

Para saber cómo instalar y usar la biblioteca de cliente de Bigtable, consulta el artículo Bibliotecas de cliente de Bigtable.

print("Getting a single greeting by row key.")
key = "greeting0".encode()

row = table.read_row(key, row_filter)
cell = row.cells[column_family_id][column][0]
print(cell.value.decode("utf-8"))

Analizar todas las filas de la tabla

Usa Table.read_rows() para leer un intervalo de filas de una tabla.

Asyncio

Para saber cómo instalar y usar la biblioteca de cliente de Bigtable, consulta el artículo Bibliotecas de cliente de Bigtable.

print("Scanning for all greetings:")
query = bigtable.data.ReadRowsQuery(row_filter=row_filter)
async for row in await table.read_rows_stream(query):
    cell = row.cells[0]
    print(cell.value.decode("utf-8"))

Sincronizar

Para saber cómo instalar y usar la biblioteca de cliente de Bigtable, consulta el artículo Bibliotecas de cliente de Bigtable.

print("Scanning for all greetings:")
partial_rows = table.read_rows(filter_=row_filter)

for row in partial_rows:
    cell = row.cells[column_family_id][column][0]
    print(cell.value.decode("utf-8"))

Eliminar una tabla

Elimina una tabla con Table.delete().

print("Deleting the {} table.".format(table_id))
table.delete()

Analizar todos los datos en conjunto

Aquí tienes el ejemplo completo sin comentarios.

Asyncio

Para saber cómo instalar y usar la biblioteca de cliente de Bigtable, consulta el artículo Bibliotecas de cliente de Bigtable.



"""Demonstrates how to connect to Cloud Bigtable and run some basic operations with the async APIs

Prerequisites:

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

import argparse
import asyncio
from ..utils import wait_for_table

from google.cloud import bigtable
from google.cloud.bigtable.data import row_filters

row_filters


async def main(project_id, instance_id, table_id):
    client = bigtable.data.BigtableDataClientAsync(project=project_id)
    table = client.get_table(instance_id, table_id)

    from google.cloud.bigtable import column_family

    print("Creating the {} table.".format(table_id))
    admin_client = bigtable.Client(project=project_id, admin=True)
    admin_instance = admin_client.instance(instance_id)
    admin_table = admin_instance.table(table_id)

    print("Creating column family cf1 with Max Version GC rule...")
    max_versions_rule = column_family.MaxVersionsGCRule(2)
    column_family_id = "cf1"
    column_families = {column_family_id: max_versions_rule}
    if not admin_table.exists():
        admin_table.create(column_families=column_families)
    else:
        print("Table {} already exists.".format(table_id))

    try:
        wait_for_table(admin_table)
        print("Writing some greetings to the table.")
        greetings = ["Hello World!", "Hello Cloud Bigtable!", "Hello Python!"]
        mutations = []
        column = "greeting"
        for i, value in enumerate(greetings):
            row_key = "greeting{}".format(i).encode()
            row_mutation = bigtable.data.RowMutationEntry(
                row_key, bigtable.data.SetCell(column_family_id, column, value)
            )
            mutations.append(row_mutation)
        await table.bulk_mutate_rows(mutations)

        row_filter = bigtable.data.row_filters.CellsColumnLimitFilter(1)

        print("Getting a single greeting by row key.")
        key = "greeting0".encode()

        row = await table.read_row(key, row_filter=row_filter)
        cell = row.cells[0]
        print(cell.value.decode("utf-8"))

        print("Scanning for all greetings:")
        query = bigtable.data.ReadRowsQuery(row_filter=row_filter)
        async for row in await table.read_rows_stream(query):
            cell = row.cells[0]
            print(cell.value.decode("utf-8"))
    finally:
        print("Deleting the {} table.".format(table_id))
        admin_table.delete()


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()
    asyncio.run(main(args.project_id, args.instance_id, args.table))

Sincronizar

Para saber cómo instalar y usar la biblioteca de cliente de Bigtable, consulta el artículo Bibliotecas de cliente de Bigtable.



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

Prerequisites:

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

import argparse
from ..utils import wait_for_table

import datetime

from google.cloud import bigtable
from google.cloud.bigtable import column_family
from google.cloud.bigtable import row_filters


row_filters
column_family


def main(project_id, instance_id, table_id):
    client = bigtable.Client(project=project_id, admin=True)
    instance = client.instance(instance_id)

    print("Creating the {} table.".format(table_id))
    table = instance.table(table_id)

    print("Creating column family cf1 with Max Version GC rule...")
    max_versions_rule = bigtable.column_family.MaxVersionsGCRule(2)
    column_family_id = "cf1"
    column_families = {column_family_id: max_versions_rule}
    if not table.exists():
        table.create(column_families=column_families)
    else:
        print("Table {} already exists.".format(table_id))

    try:
        wait_for_table(table)

        print("Writing some greetings to the table.")
        greetings = ["Hello World!", "Hello Cloud Bigtable!", "Hello Python!"]
        rows = []
        column = "greeting".encode()
        for i, value in enumerate(greetings):
            row_key = "greeting{}".format(i).encode()
            row = table.direct_row(row_key)
            row.set_cell(
                column_family_id, column, value, timestamp=datetime.datetime.utcnow()
            )
            rows.append(row)
        table.mutate_rows(rows)

        row_filter = bigtable.row_filters.CellsColumnLimitFilter(1)

        print("Getting a single greeting by row key.")
        key = "greeting0".encode()

        row = table.read_row(key, row_filter)
        cell = row.cells[column_family_id][column][0]
        print(cell.value.decode("utf-8"))

        print("Scanning for all greetings:")
        partial_rows = table.read_rows(filter_=row_filter)

        for row in partial_rows:
            cell = row.cells[column_family_id][column][0]
            print(cell.value.decode("utf-8"))

    finally:
        print("Deleting the {} table.".format(table_id))
        table.delete()


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)