1. Panoramica
BigQuery è il data warehouse di analisi di Google completamente gestito, a basso costo e con capacità di petabyte. BigQuery è NoOps: non c'è alcuna infrastruttura da gestire e non hai bisogno di un amministratore di database, quindi puoi concentrarti sull'analisi dei dati per trovare insight significativi, utilizzare un ambiente SQL familiare e sfruttare il nostro modello di pagamento a consumo.
In questo codelab, utilizzerai la libreria client di BigQuery di Google Cloud per eseguire query su set di dati pubblici BigQuery con Node.js.
Cosa imparerai a fare
- Come utilizzare Cloud Shell
- Come abilitare l'API BigQuery
- Come autenticare le richieste API
- Come installare la libreria client BigQuery per Node.js
- Come interrogare le opere di Shakespeare
- Come eseguire query sul set di dati GitHub
- Come regolare la memorizzazione nella cache e la visualizzazione delle statistiche
Che cosa ti serve
- Un progetto Google Cloud
- Un browser, ad esempio Chrome o Firefox
- Dimestichezza nell'utilizzo di Node.js
Sondaggio
Come utilizzerai questo tutorial?
Come valuteresti la tua esperienza con Node.js?
Come giudichi la tua esperienza di utilizzo dei servizi della piattaforma Google Cloud?
2. Configurazione e requisiti
Configurazione dell'ambiente da seguire in modo autonomo
- Accedi alla console Cloud e crea un nuovo progetto o riutilizzane uno esistente. Se non hai ancora un account Gmail o G Suite, devi crearne uno.
Ricorda l'ID progetto, un nome univoco in tutti i progetti Google Cloud (il nome precedente è già stato utilizzato e non funzionerà correttamente). Verrà indicato più avanti in questo codelab come PROJECT_ID.
- Successivamente, dovrai abilitare la fatturazione in Cloud Console per utilizzare le risorse Google Cloud.
Eseguire questo codelab non dovrebbe costare molto. Assicurati di seguire le istruzioni nella sezione "Pulizia" in cui viene spiegato come arrestare le risorse in modo da non incorrere in fatturazione oltre questo tutorial. I nuovi utenti di Google Cloud sono idonei al programma prova senza costi di 300$.
Avvia Cloud Shell
Mentre lo strumento a riga di comando di Cloud SDK può essere utilizzato da remoto dal tuo laptop, in questo codelab utilizzerai Google Cloud Shell, un ambiente a riga di comando in esecuzione nel cloud.
Attiva Cloud Shell
- Dalla console Cloud, fai clic su Attiva Cloud Shell
.
Se non hai mai avviato Cloud Shell, ti viene mostrata una schermata intermedia (below the fold) che descrive di cosa si tratta. In tal caso, fai clic su Continua (e non la vedrai più). Ecco come appare quella singola schermata:
Il provisioning e la connessione a Cloud Shell dovrebbero richiedere solo qualche istante.
Questa macchina virtuale viene caricata con tutti gli strumenti di sviluppo di cui hai bisogno. Offre una home directory permanente da 5 GB e viene eseguita in Google Cloud, migliorando notevolmente le prestazioni di rete e l'autenticazione. Gran parte, se non tutto, del lavoro in questo codelab può essere svolto semplicemente con un browser o Chromebook.
Una volta eseguita la connessione a Cloud Shell, dovresti vedere che il tuo account è già autenticato e il progetto è già impostato sul tuo ID progetto.
- Esegui questo comando in Cloud Shell per verificare che l'account sia autenticato:
gcloud auth list
Output comando
Credentialed Accounts
ACTIVE ACCOUNT
* <my_account>@<my_domain.com>
To set the active account, run:
$ gcloud config set account `ACCOUNT`
gcloud config list project
Output comando
[core] project = <PROJECT_ID>
In caso contrario, puoi impostarlo con questo comando:
gcloud config set project <PROJECT_ID>
Output comando
Updated property [core/project].
3. Abilita l'API BigQuery
L'API BigQuery deve essere abilitata per impostazione predefinita in tutti i progetti Google Cloud. Per verificare se è vero, usa il comando seguente in Cloud Shell:
gcloud services list
BigQuery dovrebbe essere elencato:
NAME TITLE
bigquery-json.googleapis.com BigQuery API
...
Se l'API BigQuery non è abilitata, puoi utilizzare il comando seguente in Cloud Shell per abilitarla:
gcloud services enable bigquery-json.googleapis.com
4. Autentica le richieste API
Per effettuare richieste all'API BigQuery, devi utilizzare un account di servizio. Un account di servizio appartiene al progetto e viene utilizzato dalla libreria client Node.js di Google BigQuery per effettuare richieste API BigQuery. Come qualsiasi altro account utente, un account di servizio è rappresentato da un indirizzo email. In questa sezione utilizzerai Cloud SDK per creare un account di servizio e quindi creare le credenziali necessarie per l'autenticazione come account di servizio.
Per prima cosa, imposta una variabile di ambiente con il tuo PROJECT_ID che utilizzerai durante questo codelab:
export GOOGLE_CLOUD_PROJECT=$(gcloud config get-value core/project)
Successivamente, crea un nuovo account di servizio per accedere all'API BigQuery utilizzando:
gcloud iam service-accounts create my-bigquery-sa --display-name "my bigquery codelab service account"
Successivamente, crea le credenziali che il codice Node.js utilizzerà per accedere come nuovo account di servizio. Crea le credenziali e salvale come file JSON "~/key.json" utilizzando il seguente comando:
gcloud iam service-accounts keys create ~/key.json --iam-account my-bigquery-sa@${GOOGLE_CLOUD_PROJECT}.iam.gserviceaccount.com
Infine, imposta la variabile di ambiente GOOGLE_APPLICATION_CREDENTIALS, utilizzata dalla libreria C# dell'API BigQuery, descritta nel passaggio successivo, per trovare le tue credenziali. La variabile di ambiente deve essere impostata sul percorso completo del file JSON delle credenziali che hai creato. Imposta la variabile di ambiente utilizzando il comando seguente:
export GOOGLE_APPLICATION_CREDENTIALS="/home/${USER}/key.json"
Scopri di più sull'autenticazione dell'API BigQuery.
5. Configura il controllo degli accessi
BigQuery utilizza Identity and Access Management (IAM) per gestire l'accesso alle risorse. BigQuery offre una serie di ruoli predefiniti (utente, proprietario dati, visualizzatore dati e così via) che puoi assegnare all'account di servizio che hai creato nel passaggio precedente. Per saperne di più sul controllo dell'accesso, consulta la documentazione di BigQuery.
Prima di poter eseguire query sui set di dati pubblici, devi assicurarti che l'account di servizio abbia almeno il ruolo bigquery.user. In Cloud Shell, esegui questo comando per assegnare il ruolo bigquery.user all'account di servizio:
gcloud projects add-iam-policy-binding ${GOOGLE_CLOUD_PROJECT} --member "serviceAccount:my-bigquery-sa@${GOOGLE_CLOUD_PROJECT}.iam.gserviceaccount.com" --role "roles/bigquery.user"
Per verificare che all'account di servizio sia assegnato il ruolo utente, puoi eseguire questo comando:
gcloud projects get-iam-policy $GOOGLE_CLOUD_PROJECT
6. Installa la libreria client BigQuery per Node.js
Per prima cosa, crea una cartella BigQueryDemo e vai alla cartella:
mkdir BigQueryDemo
cd BigQueryDemo
Poi, crea un progetto Node.js che utilizzerai per eseguire esempi di librerie client BigQuery:
npm init -y
Dovresti vedere il progetto Node.js creato:
{
"name": "BigQueryDemo",
"version": "1.0.0",
"description": "",
"main": "index.js",
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1"
},
"keywords": [],
"author": "",
"license": "ISC"
}
Installa la libreria client di BigQuery:
npm install --save @google-cloud/bigquery
npm notice created a lockfile as package-lock.json. You should commit this file.
npm WARN BigQueryDemo@1.0.0 No description
npm WARN BigQueryDemo@1.0.0 No repository field.
+ @google-cloud/bigquery@2.1.0
added 69 packages from 105 contributors and audited 147 packages in 4.679s
found 0 vulnerabilities
Ora è tutto pronto per utilizzare la libreria client Node.js di BigQuery.
7. Interroga le opere di Shakespeare
Per set di dati pubblico si intende qualsiasi set di dati archiviato in BigQuery e reso disponibile al pubblico. Esistono molti altri set di dati pubblici su cui eseguire le query, alcuni dei quali sono anch'essi ospitati da Google, ma molti altri sono ospitati da terze parti. Per saperne di più, consulta la pagina Set di dati pubblici.
Oltre ai set di dati pubblici, BigQuery fornisce un numero limitato di tabelle di esempio su cui puoi eseguire query. Queste tabelle sono contenute in bigquery-public-data:samples dataset. Una di queste tabelle è chiamata shakespeare.. Contiene un indice di parole delle opere di Shakespeare, che indica il numero di volte in cui ogni parola compare in ciascun corpus.
In questo passaggio eseguirai una query sulla tabella shakespeare.
Innanzitutto, apri l'editor di codice dall'angolo in alto a destra di Cloud Shell:
Crea un file queryShakespeare.js all'interno della cartella BigQueryDemo :
touch queryShakespeare.js
Vai al file queryShakespeare.js e inserisci il seguente codice:
'use strict';
function main() {
// Import the Google Cloud client library
const {BigQuery} = require('@google-cloud/bigquery');
async function queryShakespeare() {
// Queries a public Shakespeare dataset.
// Create a client
const bigqueryClient = new BigQuery();
// The SQL query to run
const sqlQuery = `SELECT word, word_count
FROM \`bigquery-public-data.samples.shakespeare\`
WHERE corpus = @corpus
AND word_count >= @min_word_count
ORDER BY word_count DESC`;
const options = {
query: sqlQuery,
// Location must match that of the dataset(s) referenced in the query.
location: 'US',
params: {corpus: 'romeoandjuliet', min_word_count: 250},
};
// Run the query
const [rows] = await bigqueryClient.query(options);
console.log('Rows:');
rows.forEach(row => console.log(row));
}
queryShakespeare();
}
main();
Prenditi un minuto o due per studiare il codice e vedere come vengono eseguite le query nella tabella.
Torna in Cloud Shell ed esegui l'app:
node queryShakespeare.js
Viene visualizzato un elenco di parole con le relative occorrenze:
Rows:
{ word: 'the', word_count: 614 }
{ word: 'I', word_count: 577 }
{ word: 'and', word_count: 490 }
{ word: 'to', word_count: 486 }
{ word: 'a', word_count: 407 }
{ word: 'of', word_count: 367 }
{ word: 'my', word_count: 314 }
{ word: 'is', word_count: 307 }
...
8. esegui una query sul set di dati GitHub
Per acquisire familiarità con BigQuery, ora eseguirai una query sul set di dati pubblico GitHub. Troverai i messaggi di commit più comuni su GitHub. Utilizzerai anche l'interfaccia utente web di BigQuery per visualizzare in anteprima ed eseguire query ad hoc.
Per visualizzare i dati, apri il set di dati GitHub nella UI web di BigQuery:
Per visualizzare un'anteprima rapida dell'aspetto dei dati, fai clic sulla scheda Anteprima:
Crea il file queryGitHub.js all'interno della cartella BigQueryDemo:
touch queryGitHub.js
Vai al file queryGitHub.js e inserisci il seguente codice:
'use strict';
function main() {
// Import the Google Cloud client library
const {BigQuery} = require('@google-cloud/bigquery');
async function queryGitHub() {
// Queries a public GitHub dataset.
// Create a client
const bigqueryClient = new BigQuery();
// The SQL query to run
const sqlQuery = `SELECT subject AS subject, COUNT(*) AS num_duplicates
FROM \`bigquery-public-data.github_repos.commits\`
GROUP BY subject
ORDER BY num_duplicates
DESC LIMIT 10`;
const options = {
query: sqlQuery,
// Location must match that of the dataset(s) referenced in the query.
location: 'US',
};
// Run the query
const [rows] = await bigqueryClient.query(options);
console.log('Rows:');
rows.forEach(row => console.log(`${row.subject}: ${row.num_duplicates}`));
}
queryGitHub();
}
main();
Prenditi un minuto o due per studiare il codice e vedere come vengono eseguite le query nella tabella per i messaggi di commit più comuni.
Torna in Cloud Shell ed esegui l'app:
node queryGitHub.js
Dovresti vedere un elenco di messaggi di commit e le relative occorrenze:
Rows:
Update README.md: 2572220
: 1985733
Initial commit: 1940228
Mirroring from Micro.blog.: 646772
update: 592520
Update data.json: 548730
Update data.js: 548354
...
9. Memorizzazione nella cache e statistica
Quando esegui una query, BigQuery memorizza i risultati nella cache. Di conseguenza, le successive query identiche richiedono molto meno tempo. È possibile disabilitare la memorizzazione nella cache utilizzando le opzioni di query. BigQuery tiene anche traccia di alcune statistiche sulle query, come ora di creazione, ora di fine e byte totali elaborati.
In questo passaggio disattiverai la memorizzazione nella cache e verranno visualizzate alcune statistiche sulle query.
Vai al file queryShakespeare.js all'interno della cartella BigQueryDemo e sostituisci il codice con il seguente:
'use strict';
function main() {
// Import the Google Cloud client library
const {BigQuery} = require('@google-cloud/bigquery');
async function queryShakespeareDisableCache() {
// Queries the Shakespeare dataset with the cache disabled.
// Create a client
const bigqueryClient = new BigQuery();
const sqlQuery = `SELECT word, word_count
FROM \`bigquery-public-data.samples.shakespeare\`
WHERE corpus = @corpus
AND word_count >= @min_word_count
ORDER BY word_count DESC`;
const options = {
query: sqlQuery,
// Location must match that of the dataset(s) referenced in the query.
location: 'US',
params: {corpus: 'romeoandjuliet', min_word_count: 250},
useQueryCache: false,
};
// Run the query as a job
const [job] = await bigqueryClient.createQueryJob(options);
console.log(`Job ${job.id} started.`);
// Wait for the query to finish
const [rows] = await job.getQueryResults();
// Print the results
console.log('Rows:');
rows.forEach(row => console.log(row));
// Print job statistics
console.log('JOB STATISTICS:')
console.log(`Status: ${job.metadata.status.state}`);
console.log(`Creation time: ${job.metadata.statistics.creationTime}`);
console.log(`Start time: ${job.metadata.statistics.startTime}`);
console.log(`Statement type: ${job.metadata.statistics.query.statementType}`);
}
queryShakespeareDisableCache();
}
main();
Due aspetti da considerare riguardo al codice. Innanzitutto, la memorizzazione nella cache viene disattivata impostando UseQueryCache su false all'interno dell'oggetto options. In secondo luogo, hai eseguito l'accesso alle statistiche sulla query dall'oggetto job.
Torna in Cloud Shell ed esegui l'app:
node queryShakespeare.js
Dovresti vedere un elenco di messaggi di commit e le relative occorrenze. Inoltre, dovresti visualizzare anche alcune statistiche sulla query:
Rows:
{ word: 'the', word_count: 614 }
{ word: 'I', word_count: 577 }
{ word: 'and', word_count: 490 }
{ word: 'to', word_count: 486 }
{ word: 'a', word_count: 407 }
{ word: 'of', word_count: 367 }
{ word: 'my', word_count: 314 }
{ word: 'is', word_count: 307 }
{ word: 'in', word_count: 291 }
{ word: 'you', word_count: 271 }
{ word: 'that', word_count: 270 }
{ word: 'me', word_count: 263 }
JOB STATISTICS:
Status: RUNNING
Creation time: 1554309220660
Start time: 1554309220793
Statement type: SELECT
10. Caricamento di dati in BigQuery
Se vuoi eseguire query sui tuoi dati, devi prima caricarli in BigQuery. BigQuery supporta il caricamento di dati da molte origini, come Google Cloud Storage, altri servizi Google o un'origine locale leggibile. Puoi persino trasmettere i dati in modalità flusso. Per saperne di più, consulta la pagina Caricamento di dati in BigQuery.
In questo passaggio, caricherai un file JSON archiviato in Google Cloud Storage in una tabella BigQuery. Il file JSON si trova in: gs://cloud-samples-data/bigquery/us-states/us-states.json
Se ti interessano i contenuti del file JSON, puoi utilizzare lo strumento a riga di comando gsutil per scaricarlo in Cloud Shell:
gsutil cp gs://cloud-samples-data/bigquery/us-states/us-states.json .
Copying gs://cloud-samples-data/bigquery/us-states/us-states.json...
/ [1 files][ 2.0 KiB/ 2.0 KiB]
Operation completed over 1 objects/2.0 KiB.
Puoi vedere che contiene l'elenco degli stati USA e che ogni stato è un oggetto JSON su una riga separata:
less us-states.json
{"name": "Alabama", "post_abbr": "AL"}
{"name": "Alaska", "post_abbr": "AK"}
...
Per caricare questo file JSON in BigQuery, crea un file createDataset.js e un file loadBigQueryJSON.js all'interno della cartella BigQueryDemo:
touch createDataset.js
touch loadBigQueryJSON.js
Installa la libreria client Node.js di Google Cloud Storage:
npm install --save @google-cloud/storage
Vai al file createDataset.js e inserisci il seguente codice:
'use strict';
function main() {
// Import the Google Cloud client libraries
const {BigQuery} = require('@google-cloud/bigquery');
async function createDataset() {
const datasetId = "my_states_dataset3";
const bigqueryClient = new BigQuery();
// Specify the geographic location where the dataset should reside
const options = {
location: 'US',
};
// Create a new dataset
const [dataset] = await bigqueryClient.createDataset(datasetId, options);
console.log(`Dataset ${dataset.id} created.`);
}
createDataset();
}
main();
Quindi, passa al file loadBigQueryJSON.js e inserisci il seguente codice:
'use strict';
function main() {
// Import the Google Cloud client libraries
const {BigQuery} = require('@google-cloud/bigquery');
const {Storage} = require('@google-cloud/storage');
const datasetId = "my_states_dataset3";
const tableId = "my_states_table";
async function createTable(datasetId, tableId) {
// Creates a new table
// Create a client
const bigqueryClient = new BigQuery();
const options = {
location: 'US',
};
// Create a new table in the dataset
const [table] = await bigqueryClient
.dataset(datasetId)
.createTable(tableId, options);
console.log(`Table ${table.id} created.`);
}
async function loadJSONFromGCS(datasetId, tableId) {
// Import a GCS file into a table with manually defined schema.
// Instantiate clients
const bigqueryClient = new BigQuery();
const storageClient = new Storage();
const bucketName = 'cloud-samples-data';
const filename = 'bigquery/us-states/us-states.json';
// Configure the load job.
const metadata = {
sourceFormat: 'NEWLINE_DELIMITED_JSON',
schema: {
fields: [
{name: 'name', type: 'STRING'},
{name: 'post_abbr', type: 'STRING'},
],
},
location: 'US',
};
// Load data from a Google Cloud Storage file into the table
const [job] = await bigqueryClient
.dataset(datasetId)
.table(tableId)
.load(storageClient.bucket(bucketName).file(filename), metadata);
// load() waits for the job to finish
console.log(`Job ${job.id} completed.`);
// Check the job's status for errors
const errors = job.status.errors;
if (errors && errors.length > 0) {
throw errors;
}
}
// createDataset(datasetId);
createTable(datasetId, tableId);
loadJSONFromGCS(datasetId, tableId);
}
main();
Dedica qualche minuto a studiare come il codice carica il file JSON e crea una tabella (con uno schema) in un set di dati.
Torna in Cloud Shell ed esegui l'app:
node createDataset.js
node loadBigQueryJSON.js
In BigQuery vengono creati un set di dati e una tabella:
Table my_states_table created.
Job [JOB ID] completed.
Per verificare che il set di dati sia stato creato, puoi andare alla UI web di BigQuery. Dovresti vedere un nuovo set di dati e una tabella. Se passi alla scheda Anteprima della tabella, puoi visualizzare i dati effettivi:
11. Complimenti!
Hai imparato a usare BigQuery con Node.js.
Esegui la pulizia
Per evitare che al tuo account Google Cloud Platform vengano addebitate le risorse utilizzate in questa guida rapida, procedi come segue.
- Vai alla console di Cloud Platform.
- Seleziona il progetto che vuoi chiudere e fai clic su "Elimina". in alto: in questo modo viene pianificata l'eliminazione del progetto.
Scopri di più
- Google BigQuery: https://cloud.google.com/bigquery/docs/
- Node.js su Google Cloud: https://cloud.google.com/nodejs/
- Libreria client Node.js di Google BigQuery: https://github.com/googleapis/nodejs-bigquery
Licenza
Questo lavoro è concesso in licenza ai sensi di una licenza Creative Commons Attribution 2.0 Generic.