Hello World Ruby

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

• Configura l'autenticazione
• Connettiti a un'istanza Bigtable.
• Crea una nuova tabella.
• Scrivi i dati nella tabella.
• Leggi di nuovo 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 ulteriori informazioni, vedi Accedi a gcloud CLI con la tua identità federata.

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

   gcloud auth application-default login

   Se viene restituito un errore di autenticazione e utilizzi un provider di identità (IdP) esterno, verifica di aver acceduto a gcloud CLI con la tua identità federata.

Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

Nota: per eseguire gli esempi seguenti, assicurati che l'account autenticato disponga del ruolo IAM Amministratore Bigtable. Per informazioni sulla concessione dei ruoli a un account, consulta Gestisci l'accesso a progetti, cartelle e organizzazioni.

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 Google Cloud console, 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 di sviluppo Ruby e build-essential, che sono 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 google-cloud-bigtable.gemspec file:

   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 file Gemfile e installalo:

   bundle add google-cloud-bigtable
   

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

Esecuzione dell'esempio

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

Per eseguire questo programma di esempio, segui le istruzioni riportate nell'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 Bigtable modulo.

require "google/cloud/bigtable"

Connessione a Bigtable

Imposta le variabili che utilizzerai nella tua applicazione, sostituendo "YOUR_PROJECT_ID" con l'ID di un progetto valido Google Cloud Quindi crea un nuovo Bigtable oggetto 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

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

Nota: le colonne correlate tra loro vengono in genere raggruppate in una famiglia di colonne. Per saperne di più sulle famiglie di colonne, consulta il Bigtable modello di archiviazione.

# 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. Quindi, utilizza il set_cell() metodo della voce per assegnare alla voce la famiglia di colonne, il qualificatore di colonna, il saluto e un timestamp. Infine, scrivi la voce nella tabella utilizzando il metodo mutate_row() della tabella.

Nota: in questa applicazione di esempio, set_Cell() viene chiamato una sola volta per mutazione, ma puoi chiamarlo fino a 10.000 volte per singola mutazione.

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

Creazione di 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

Lettura di una riga in base alla chiave di riga

Crea un oggetto riga, quindi chiama il read_row() metodo, passando il filtro, per ottenere una versione di ogni valore nella 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

Ecco 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