1. Omówienie
BigQuery to ekonomiczna, w pełni zarządzana analityczna hurtownia danych Google o skali petabajtowej. BigQuery to rozwiązanie bezobsługowe – nie wymaga zarządzania infrastrukturą ani administratora baz danych. Możesz więc skupić się na analizowaniu danych, aby uzyskać przydatne statystyki, używać dobrze znanego języka SQL i korzystać z naszego modelu płatności według wykorzystania.
W tym ćwiczeniu w programowaniu użyjesz biblioteki klienta Google Cloud BigQuery, aby tworzyć zapytania do publicznych zbiorów danych BigQuery za pomocą Node.js.
Czego się nauczysz
- Jak używać Cloud Shell
- Jak włączyć interfejs BigQuery API
- Jak uwierzytelniać żądania do interfejsu API
- Jak zainstalować bibliotekę klienta BigQuery dla środowiska Node.js
- Jak wysyłać zapytania dotyczące dzieł Szekspira
- Jak tworzyć zapytania do zbioru danych GitHub
- Jak dostosować pamięć podręczną i wyświetlić statystyki
Czego potrzebujesz
Ankieta
Jak wykorzystasz ten samouczek?
Jak oceniasz korzystanie z Node.js?
Jak oceniasz swoje wrażenia z korzystania z usług Google Cloud Platform?
2. Konfiguracja i wymagania
Samodzielne konfigurowanie środowiska
- Zaloguj się w konsoli Google Cloud i utwórz nowy projekt lub wykorzystaj już istniejący. Jeśli nie masz jeszcze konta Gmail lub G Suite, musisz je utworzyć.
Zapamiętaj identyfikator projektu, unikalną nazwę we wszystkich projektach Google Cloud (powyższa nazwa jest już zajęta i nie będzie Ci odpowiadać). W dalszej części tego ćwiczenia w Codelabs będzie ona określana jako PROJECT_ID.
- Następnie musisz włączyć płatności w Cloud Console, aby korzystać z zasobów Google Cloud.
Ukończenie tego ćwiczenia z programowania nie powinno kosztować zbyt wiele. Postępuj zgodnie z instrukcjami podanymi w sekcji „Czyszczenie” W tym samouczku znajdziesz wskazówki, jak wyłączyć zasoby, aby uniknąć naliczania opłat. Nowi użytkownicy Google Cloud mogą skorzystać z programu bezpłatnego okresu próbnego o wartości 300 USD.
Uruchamianie Cloud Shell
Narzędzia wiersza poleceń Cloud SDK można obsługiwać zdalnie z laptopa, ale w tym ćwiczeniu z programowania wykorzystasz Google Cloud Shell – środowisko wiersza poleceń działające w chmurze.
Aktywowanie Cloud Shell
- W konsoli Cloud kliknij Aktywuj Cloud Shell
.
Jeśli dopiero zaczynasz korzystać z Cloud Shell, wyświetli się ekran pośredni (w części strony widocznej po przewinięciu) z opisem tej funkcji. W takim przypadku kliknij Dalej (nie zobaczysz go więcej). Tak wygląda ten jednorazowy ekran:
Uzyskanie dostępu do Cloud Shell i połączenie się z nim powinno zająć tylko kilka chwil.
Ta maszyna wirtualna ma wszystkie potrzebne narzędzia dla programistów. Zawiera stały katalog domowy o pojemności 5 GB i działa w Google Cloud, co znacznie zwiększa wydajność sieci i uwierzytelnianie. Większość czynności z tego ćwiczenia z programowania można wykonać w przeglądarce lub na Chromebooku.
Po nawiązaniu połączenia z Cloud Shell powinno pojawić się informacja, że użytkownik jest już uwierzytelniony i że projekt jest już ustawiony na identyfikator Twojego projektu.
- Uruchom to polecenie w Cloud Shell, aby potwierdzić, że jesteś uwierzytelniony:
gcloud auth list
Dane wyjściowe polecenia
Credentialed Accounts
ACTIVE ACCOUNT
* <my_account>@<my_domain.com>
To set the active account, run:
$ gcloud config set account `ACCOUNT`
gcloud config list project
Dane wyjściowe polecenia
[core] project = <PROJECT_ID>
Jeśli tak nie jest, możesz go ustawić za pomocą tego polecenia:
gcloud config set project <PROJECT_ID>
Dane wyjściowe polecenia
Updated property [core/project].
3. Włączanie interfejsu BigQuery API
Interfejs BigQuery API powinien być domyślnie włączony we wszystkich projektach Google Cloud. Aby to sprawdzić, użyj tego polecenia w Cloud Shell:
gcloud services list
Powinna Ci się wyświetlić lista BigQuery:
NAME TITLE
bigquery-json.googleapis.com BigQuery API
...
Jeśli interfejs BigQuery API nie jest włączony, możesz go włączyć za pomocą tego polecenia w Cloud Shell:
gcloud services enable bigquery-json.googleapis.com
4. Uwierzytelnianie żądań do interfejsu API
Aby wysyłać żądania do interfejsu BigQuery API, musisz używać konta usługi. Konto usługi należy do Twojego projektu i jest używane przez bibliotekę klienta Google BigQuery w Node.js do wykonywania żądań do interfejsu BigQuery API. Tak jak każde inne konto użytkownika, konto usługi jest reprezentowane przez adres e-mail. W tej sekcji utworzysz konto usługi za pomocą pakietu Cloud SDK, a następnie utworzysz dane logowania, które będziesz potrzebować do uwierzytelnienia jako konto usługi.
Najpierw ustaw zmienną środowiskową wykorzystującą Twój PROJECT_ID (IDENTYFIKATOR_PROJEKTU), której będziesz używać podczas tego ćwiczenia w Codelabs:
export GOOGLE_CLOUD_PROJECT=$(gcloud config get-value core/project)
Następnie utwórz nowe konto usługi z dostępem do interfejsu BigQuery API, wpisując w tym celu:
gcloud iam service-accounts create my-bigquery-sa --display-name "my bigquery codelab service account"
Następnie utwórz dane logowania, których Twój kod w Node.js będzie używać do logowania się jako Twoje nowe konto usługi. Utwórz te dane i zapisz je w pliku JSON „~/key.json”. za pomocą tego polecenia:
gcloud iam service-accounts keys create ~/key.json --iam-account my-bigquery-sa@${GOOGLE_CLOUD_PROJECT}.iam.gserviceaccount.com
Na koniec skonfiguruj zmienną środowiskową GOOGLE_APPLICATION_CREDENTIALS, która będzie używana przez bibliotekę C# interfejsu BigQuery API w języku C# (opisaną w następnym kroku), aby znaleźć swoje dane logowania. Zmienna środowiskowa powinna zawierać pełną ścieżkę do utworzonego przez Ciebie pliku JSON z danymi logowania. Ustaw zmienną środowiskową za pomocą tego polecenia:
export GOOGLE_APPLICATION_CREDENTIALS="/home/${USER}/key.json"
Dowiedz się więcej o uwierzytelnianiem interfejsu BigQuery API.
5. Skonfiguruj kontrolę dostępu
BigQuery używa Identity and Access Management (IAM) do zarządzania dostępem do zasobów. BigQuery ma szereg wstępnie zdefiniowanych ról (użytkownik, dataOwner, dataViewer itp.), które możesz przypisać do konta usługi utworzonego w poprzednim kroku. Więcej informacji o kontroli dostępu znajdziesz w dokumentacji BigQuery.
Aby móc wysyłać zapytania do publicznych zbiorów danych, musisz upewnić się, że konto usługi ma co najmniej rolę bigquery.user. W Cloud Shell uruchom to polecenie, aby przypisać rolę bigquery.user do konta usługi:
gcloud projects add-iam-policy-binding ${GOOGLE_CLOUD_PROJECT} --member "serviceAccount:my-bigquery-sa@${GOOGLE_CLOUD_PROJECT}.iam.gserviceaccount.com" --role "roles/bigquery.user"
Aby sprawdzić, czy do konta usługi jest przypisana rola użytkownika, możesz uruchomić to polecenie:
gcloud projects get-iam-policy $GOOGLE_CLOUD_PROJECT
6. Instalowanie biblioteki klienta BigQuery dla środowiska Node.js
Najpierw utwórz folder BigQueryDemo i przejdź do niego:
mkdir BigQueryDemo
cd BigQueryDemo
Następnie utwórz projekt Node.js, w którym będziesz uruchamiać przykładowe biblioteki klienta BigQuery:
npm init -y
Powinien wyświetlić się utworzony projekt Node.js:
{
"name": "BigQueryDemo",
"version": "1.0.0",
"description": "",
"main": "index.js",
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1"
},
"keywords": [],
"author": "",
"license": "ISC"
}
Zainstaluj bibliotekę klienta 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
Teraz możesz już korzystać z biblioteki klienta BigQuery w Node.js.
7. Przeglądaj dzieła Szekspira
Publiczny zbiór danych to dowolny zbiór danych przechowywany w BigQuery i udostępniony publicznie. Istnieje wiele innych publicznych zbiorów danych, z których można wysyłać zapytania. Niektóre z nich są hostowane przez Google, ale wiele z nich jest hostowanych przez firmy zewnętrzne. Więcej informacji znajdziesz na stronie Publiczne zbiory danych.
Oprócz publicznych zbiorów danych BigQuery udostępnia ograniczoną liczbę przykładowych tabel, do których można wysyłać zapytania. Te tabele są zawarte w tabeli bigquery-public-data:samples dataset. Jedna z nich nosi nazwę shakespeare.. Zawiera indeks słów dzieł Szekspira, który podaje, ile razy poszczególne słowa występują w każdym korpusie.
W tym kroku wyślesz zapytanie do tabeli Szekspira.
Najpierw otwórz edytor kodu w prawym górnym rogu Cloud Shell:
Utwórz plik queryShakespeare.js w folderze BigQueryDemo :
touch queryShakespeare.js
Przejdź do pliku queryShakespeare.js i wstaw ten kod:
'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();
Poświęć chwilę na zapoznanie się z kodem i zobacz, jak są wysyłane zapytania do tabeli.
Uruchom aplikację w Cloud Shell:
node queryShakespeare.js
Powinna pojawić się lista słów i ich wystąpień:
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. Tworzenie zapytania do zbioru danych GitHub
Aby lepiej poznać BigQuery, wyślesz zapytanie do publicznego zbioru danych GitHub. Najpopularniejsze komunikaty o zatwierdzeniach znajdziesz na GitHubie. Będziesz też używać interfejsu internetowego BigQuery do wyświetlania podglądu i uruchamiania doraźnych zapytań.
Aby wyświetlić dane, otwórz zbiór danych GitHub w interfejsie internetowym BigQuery:
Aby zobaczyć szybki podgląd danych, kliknij kartę Podgląd:
Utwórz plik queryGitHub.js w folderze BigQueryDemo:
touch queryGitHub.js
Przejdź do pliku queryGitHub.js i wstaw ten kod:
'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();
Poświęć chwilę na zapoznanie się z kodem i sprawdź, jak są wyszukiwane w tabeli najczęściej spotykane komunikaty zatwierdzenia.
Uruchom aplikację w Cloud Shell:
node queryGitHub.js
Powinna wyświetlić się lista komunikatów zatwierdzenia wraz z ich wystąpieniami:
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. Pamięć podręczna i statystyki
Gdy uruchomisz zapytanie, BigQuery zapisze wyniki w pamięci podręcznej. W rezultacie kolejne identyczne zapytania zajmują znacznie mniej czasu. Za pomocą opcji zapytań można wyłączyć buforowanie. BigQuery śledzi również niektóre statystyki dotyczące zapytań, takie jak czas utworzenia, czas zakończenia i łączna liczba przetworzonych bajtów.
W tym kroku wyłączysz zapisywanie w pamięci podręcznej i wyświetlisz statystyki dotyczące zapytań.
Przejdź do pliku queryShakespeare.js znajdującego się w folderze BigQueryDemo i zastąp kod poniższym kodem:
'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();
Kilka uwag na temat kodu. Po pierwsze, buforowanie jest wyłączone przez ustawienie opcji UseQueryCache na false w obiekcie options. Zdobyliśmy też dostęp do statystyk zapytania z obiektu zadania.
Uruchom aplikację w Cloud Shell:
node queryShakespeare.js
Powinna wyświetlić się lista komunikatów zatwierdzenia wraz z ich wystąpieniami. Zobaczysz też statystyki dotyczące zapytania:
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. Wczytywanie danych do BigQuery
Jeśli chcesz tworzyć zapytania dotyczące własnych danych, musisz najpierw wczytać dane do BigQuery. BigQuery obsługuje wczytywanie danych z wielu źródeł, takich jak Google Cloud Storage lub inne usługi Google, a także lokalne, możliwe do odczytania źródło. Możesz nawet przesyłać strumieniowo swoje dane. Więcej informacji znajdziesz na stronie Wczytywanie danych do BigQuery.
W tym kroku wczytasz do tabeli BigQuery plik JSON zapisany w Google Cloud Storage. Lokalizacja pliku JSON: gs://cloud-samples-data/bigquery/us-states/us-states.json
Jeśli chcesz poznać zawartość pliku JSON, możesz użyć narzędzia wiersza poleceń gsutil, aby pobrać go do 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.
Widać, że zawiera listę stanów USA, a każdy z nich to obiekt JSON w osobnym wierszu:
less us-states.json
{"name": "Alabama", "post_abbr": "AL"}
{"name": "Alaska", "post_abbr": "AK"}
...
Aby wczytać ten plik JSON do BigQuery, utwórz pliki createDataset.js i loadBigQueryJSON.js w folderze BigQueryDemo:
touch createDataset.js
touch loadBigQueryJSON.js
Zainstaluj bibliotekę klienta Google Cloud Storage Node.js:
npm install --save @google-cloud/storage
Przejdź do pliku createDataset.js i wstaw ten kod:
'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();
Następnie przejdź do pliku loadBigQueryJSON.js i wstaw ten kod:
'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();
Poświęć kilka minut na zapoznanie się z tym, jak kod wczytuje plik JSON i tworzy tabelę (ze schematem) w zbiorze danych.
Uruchom aplikację w Cloud Shell:
node createDataset.js
node loadBigQueryJSON.js
Zbiór danych i tabela są tworzone w BigQuery:
Table my_states_table created.
Job [JOB ID] completed.
Aby sprawdzić, czy zbiór danych został utworzony, możesz otworzyć interfejs internetowy BigQuery. Powinno wyświetlić się nowy zbiór danych i tabela. Jeśli przejdziesz na kartę Podgląd tabeli, zobaczysz rzeczywiste dane:
11. Gratulacje!
Wiesz już, jak korzystać z BigQuery dzięki środowisku Node.js.
Czyszczenie danych
Oto kroki, które musisz wykonać, aby uniknąć obciążenia konta Google Cloud Platform opłatami za zasoby zużyte podczas krótkiego wprowadzenia:
- Otwórz konsolę Cloud Platform.
- Wybierz projekt, który chcesz wyłączyć, i kliknij „Usuń”. u góry: spowoduje to zaplanowanie usunięcia projektu.
Więcej informacji
- Google BigQuery: https://cloud.google.com/bigquery/docs/,
- Node.js w Google Cloud Platform: https://cloud.google.com/nodejs/
- Biblioteka klienta Google BigQuery w Node.js: https://github.com/googleapis/nodejs-bigquery
Licencja
To zadanie jest licencjonowane na podstawie ogólnej licencji Creative Commons Attribution 2.0.