Hello World Ruby

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

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

Configura l'autenticazione

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

  1. Installa Google Cloud CLI.

  2. Per initialize gcloud CLI, esegui questo comando: 

    gcloud init

  3. Crea credenziali di autenticazione locali per il tuo Account Google: 

    gcloud auth application-default login

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

Esecuzione dell'esempio

Questo esempio di codice utilizza il pacchetto 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 dimostra 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 nell'applicazione, sostituendo "YOUR_PROJECT_ID" con l'ID di un progetto Google Cloud valido. Quindi crea un nuovo oggetto Bigtable che utilizzerai per connetterti a Bigtable.

# instance_id      = "my-instance"
# table_id         = "my-table"
# column_family    = "cf"
# column_qualifier = "greeting"

bigtable = Google::Cloud::Bigtable.new

Creazione di una tabella

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

if bigtable.table(instance_id, table_id).exists?
  puts "#{table_id} is already exists."
  exit 0
else
  table = bigtable.create_table instance_id, table_id do |column_families|
    column_families.add(
      column_family,
      Google::Cloud::Bigtable::GcRule.max_versions(1)
    )
  end

  puts "Table #{table_id} created."
end

Scrittura di righe in una tabella

Quindi, 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 metodo set_cell() 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.

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

# 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 tramite la relativa chiave di riga

Crea un oggetto riga, quindi chiama il metodo read_row(), 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}"

Analisi di tutte le righe della tabella

Richiama il metodo read_rows(), passando il filtro, per visualizzare tutte le righe della tabella. Poiché hai passato il filtro, Bigtable restituisce solo una versione per ciascun 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}"
table.delete

Riepilogo

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"

  # instance_id      = "my-instance"
  # table_id         = "my-table"
  # column_family    = "cf"
  # column_qualifier = "greeting"

  bigtable = Google::Cloud::Bigtable.new

  if bigtable.table(instance_id, table_id).exists?
    puts "#{table_id} is already exists."
    exit 0
  else
    table = bigtable.create_table instance_id, table_id do |column_families|
      column_families.add(
        column_family,
        Google::Cloud::Bigtable::GcRule.max_versions(1)
      )
    end

    puts "Table #{table_id} created."
  end

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

  # 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}"
  table.delete
end