Hello World Ruby

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

• 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 Ruby 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 di codice utilizza il pacchetto 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 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.

Richiedere la libreria client

Il sample richiede google/cloud/bigtable, che fornisce il modulo Bigtable.

require "google/cloud/bigtable"

Connessione a Bigtable

Stabilisci le variabili da utilizzare nell'applicazione, sostituendo "YOUR_PROJECT_ID" con l'ID di un progetto Google Cloud valido. Quindi, crea un nuovo oggetto Bigtable che utilizzerai per collegarti 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

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 ciascun valore.

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.

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

A questo punto, 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() della voce per assegnare la famiglia di colonne, il qualificatore di colonna, il saluto e un timestamp alla voce. 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!"]

# 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 che Bigtable restituisce. Questo filtro indica a Bigtable di restituire solo la versione più recente di ogni valore, anche se la tabella contiene versioni precedenti per le quali non è stata eseguita la raccolta dei rifiuti.

# 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 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}"

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

In sintesi

Ecco il 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