Hello World Ruby

Questo esempio di codice è un'applicazione "Hello World" eseguita su Ruby. L'esempio mostra come completare le seguenti attività:

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

Configura l'autenticazione

Per utilizzare gli esempi di Ruby 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 le credenziali di autenticazione locale 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.

Configurazione dell'ambiente

Per eseguire questo esempio, devi aver installato Ruby.

1. Installa Ruby

Per verificare la versione minima di Ruby richiesta per la libreria client, consulta required_ruby_version nel file google-cloud-bigtable.gemspec.

Configurazione di Ruby su una VM di Compute Engine Se vuoi eseguire l'esempio su una VM di Compute Engine, segui queste istruzioni per configurare Ruby su una VM Debian o Ubuntu.

  1. Nella console Cloud de Confiance , vai alla pagina Istanze VM.

    Vai a Istanze VM

  2. Se non hai una VM Linux che utilizza il sistema operativo Debian o Ubuntu, creane una e connettiti. Per maggiori informazioni, consulta la Guida rapida all'utilizzo di una VM Linux.

  3. Nella finestra del terminale della VM, aggiorna gli elenchi di pacchetti:

    sudo apt update

  4. Installa Ruby, gli strumenti per sviluppatori Ruby e build-essential, richiesti dalla libreria client:

    sudo apt install -y ruby ruby-dev build-essential

  5. Verifica che la versione di Ruby installata soddisfi il requisito minimo specificato nel file google-cloud-bigtable.gemspec:

    ruby --version

2. Installa la libreria client

Per installare la libreria client:

  1. Inizializza Bundler per creare un file Gemfile nella directory root del progetto:

    bundle init

  2. Aggiungi google-cloud-bigtable al tuo Gemfile e installalo:

    bundle add google-cloud-bigtable

Per saperne di più sulla libreria client, consulta il file README di google-cloud-bigtable.

Esecuzione dell'esempio

Questo esempio di codice utilizza il pacchetto della libreria client Ruby per Bigtable della libreria client di Google Cloud per Ruby per comunicare con Bigtable.

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

Utilizzo della libreria client di Cloud con Bigtable

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

Richiesta della libreria client

L'esempio richiede google/cloud/bigtable, che fornisce il modulo Bigtable.

require "google/cloud/bigtable"

Connessione a Bigtable

Stabilisci le variabili che utilizzerai nella tua applicazione, sostituendo "YOUR_PROJECT_ID" con l'ID di un progetto Cloud de Confiance valido. Quindi crea un nuovo oggetto Bigtable che utilizzerai per connetterti a Bigtable.

# These variables are used in the sample code below.
# instance_id      = "my-instance"
# table_id         = "my-table"
# column_family    = "cf"
# column_qualifier = "greeting"

bigtable = Google::Cloud::Bigtable.new
table_client = bigtable.table_admin_client

Creazione di una tabella

Controlla se la tabella esiste già. In caso contrario, chiama il metodo create_table() per creare un oggetto Table. La tabella ha una singola famiglia di colonne che conserva una versione di ogni valore.

# This is the full resource name for the table. Use this name to make admin
# calls for the table, such as reading or deleting the resource.
table_name = table_client.table_path project: bigtable.project_id,
                                     instance: instance_id,
                                     table: table_id
begin
  # Attempt to get the table to see if it already exists
  table_client.get_table name: table_name
  puts "#{table_id} is already exists."
  exit 0
rescue Google::Cloud::NotFoundError
  # The table doesn't exist, so let's create it.
  # The following is the resource name for the table's instance.
  instance_name = table_client.instance_path project: bigtable.project_id,
                                             instance: instance_id
  # This is the configuration of the table's column families.
  table_config = {
    column_families: {
      column_family => {
        gc_rule: Google::Cloud::Bigtable::Admin::V2::GcRule.max_num_versions(1)
      }
    }
  }
  # Now call the API to create the table.
  table_client.create_table parent: instance_name,
                            table_id: table_id,
                            table: table_config
  puts "Table #{table_id} created."
end

Scrittura di righe in una tabella

Poi, utilizza un array di stringhe di saluti per creare alcune nuove righe per la tabella. Per ogni saluto, crea una voce utilizzando il metodo new_mutation_entry() della tabella. Poi, utilizza il metodo set_cell() dell'entry per assegnare la famiglia di colonne, il qualificatore di colonna, il saluto e un timestamp all'entry. Infine, scrivi la voce nella tabella utilizzando il metodo mutate_row() della tabella.

puts "Write some greetings to the table #{table_id}"
greetings = ["Hello World!", "Hello Bigtable!", "Hello Ruby!"]

# Get a table data object for the new table we created.
table = bigtable.table instance_id, table_id

# Insert rows one by one
# Note: To perform multiple mutation on multiple rows use `mutate_rows`.
greetings.each_with_index do |value, i|
  puts " Writing,  Row key: greeting#{i}, Value: #{value}"

  entry = table.new_mutation_entry "greeting#{i}"
  entry.set_cell(
    column_family,
    column_qualifier,
    value,
    timestamp: (Time.now.to_f * 1_000_000).round(-3)
  )

  table.mutate_row entry
end

Creare un filtro

Prima di leggere i dati che hai scritto, crea un filtro per limitare i dati restituiti da Bigtable. Questo filtro indica a Bigtable di restituire solo la versione più recente di ogni valore, anche se la tabella contiene versioni precedenti che non sono state sottoposte a garbage collection.

# Only retrieve the most recent version of the cell.
filter = Google::Cloud::Bigtable::RowFilter.cells_per_column 1

Leggere una riga in base alla relativa chiave di riga

Crea un oggetto riga, quindi chiama il metodo read_row(), passando il filtro, per ottenere una versione di ogni valore in quella riga.

puts "Reading a single row by row key"
row = table.read_row "greeting0", filter: filter
puts "Row key: #{row.key}, Value: #{row.cells[column_family].first.value}"

Scansione di tutte le righe della tabella

Chiama il metodo read_rows(), passando il filtro, per ottenere tutte le righe della tabella. Poiché hai passato il filtro, Bigtable restituisce una sola versione di ogni valore.

puts "Reading the entire table"
table.read_rows.each do |row|
  puts "Row key: #{row.key}, Value: #{row.cells[column_family].first.value}"
end

Eliminazione di una tabella

Elimina la tabella con il metodo delete() della tabella.

puts "Deleting the table #{table_id}"
# Call the admin API to delete the table given its full resource path.
table_client.delete_table name: table_name

In sintesi

Di seguito è riportato l'esempio di codice completo senza commenti.

# Copyright 2021 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

def hello_world instance_id, table_id, column_family, column_qualifier
  require "google/cloud/bigtable"

  # These variables are used in the sample code below.
  # instance_id      = "my-instance"
  # table_id         = "my-table"
  # column_family    = "cf"
  # column_qualifier = "greeting"

  bigtable = Google::Cloud::Bigtable.new
  table_client = bigtable.table_admin_client

  # This is the full resource name for the table. Use this name to make admin
  # calls for the table, such as reading or deleting the resource.
  table_name = table_client.table_path project: bigtable.project_id,
                                       instance: instance_id,
                                       table: table_id
  begin
    # Attempt to get the table to see if it already exists
    table_client.get_table name: table_name
    puts "#{table_id} is already exists."
    exit 0
  rescue Google::Cloud::NotFoundError
    # The table doesn't exist, so let's create it.
    # The following is the resource name for the table's instance.
    instance_name = table_client.instance_path project: bigtable.project_id,
                                               instance: instance_id
    # This is the configuration of the table's column families.
    table_config = {
      column_families: {
        column_family => {
          gc_rule: Google::Cloud::Bigtable::Admin::V2::GcRule.max_num_versions(1)
        }
      }
    }
    # Now call the API to create the table.
    table_client.create_table parent: instance_name,
                              table_id: table_id,
                              table: table_config
    puts "Table #{table_id} created."
  end

  puts "Write some greetings to the table #{table_id}"
  greetings = ["Hello World!", "Hello Bigtable!", "Hello Ruby!"]

  # Get a table data object for the new table we created.
  table = bigtable.table instance_id, table_id

  # Insert rows one by one
  # Note: To perform multiple mutation on multiple rows use `mutate_rows`.
  greetings.each_with_index do |value, i|
    puts " Writing,  Row key: greeting#{i}, Value: #{value}"

    entry = table.new_mutation_entry "greeting#{i}"
    entry.set_cell(
      column_family,
      column_qualifier,
      value,
      timestamp: (Time.now.to_f * 1_000_000).round(-3)
    )

    table.mutate_row entry
  end

  # Only retrieve the most recent version of the cell.
  filter = Google::Cloud::Bigtable::RowFilter.cells_per_column 1

  puts "Reading a single row by row key"
  row = table.read_row "greeting0", filter: filter
  puts "Row key: #{row.key}, Value: #{row.cells[column_family].first.value}"

  puts "Reading the entire table"
  table.read_rows.each do |row|
    puts "Row key: #{row.key}, Value: #{row.cells[column_family].first.value}"
  end

  puts "Deleting the table #{table_id}"
  # Call the admin API to delete the table given its full resource path.
  table_client.delete_table name: table_name
end