Questa pagina è stata tradotta dall'API Cloud Translation.

Utilizzare Trino con Dataproc

Trino (in precedenza Presto) è un motore di query SQL distribuito progettato per eseguire query su set di dati di grandi dimensioni distribuiti su una o più origini dati eterogenee. Trino può eseguire query su Hive, MySQL, Kafka e altre origini dati tramite connettori. Questo tutorial mostra come:

Installa il servizio Trino su un cluster Dataproc
Esegui query sui dati pubblici da un client Trino installato sulla tua macchina locale che comunica con un servizio Trino sul tuo cluster
Esegui query da un'applicazione Java che comunica con il servizio Trino sul tuo cluster tramite il driver JDBC Java di Trino.

Crea un cluster Dataproc

Crea un cluster Dataproc utilizzando il flag optional-components (disponibile nella versione immagine 2.1 e successive) per installare il componente facoltativo Trino sul cluster e il flag enable-component-gateway per attivare il gateway dei componenti per consentirti di accedere all'interfaccia utente web di Trino dalla Google Cloud console.

Imposta le variabili di ambiente:
- PROJECT: il tuo ID progetto
- BUCKET_NAME::il nome del bucket Cloud Storage che hai creato in Prima di iniziare
- REGION: region dove verrà creato il cluster utilizzato in questo tutorial, ad esempio "us-west1"
- WORKER: per questo tutorial sono consigliati 3-5 worker
```
export PROJECT=project-id
export WORKERS=number
export REGION=region
export BUCKET_NAME=bucket-name
```
Esegui Google Cloud CLI sulla tua macchina locale per creare il cluster.
```
gcloud beta dataproc clusters create trino-cluster \
    --project=${PROJECT} \
    --region=${REGION} \
    --num-workers=${WORKERS} \
    --scopes=cloud-platform \
    --optional-components=TRINO \
    --image-version=2.1  \
    --enable-component-gateway
```
La creazione di un cluster ad alta disponibilità, ovvero un cluster con più nodi master, non è consigliata perché il coordinatore viene avviato sul nodo master 0 e tutti gli altri nodi master rimarranno inattivi.

Preparazione dei dati

Esporta il set di dati bigquery-public-data chicago_taxi_trips in Cloud Storage come file CSV, poi crea una tabella esterna Hive per fare riferimento ai dati.

Sulla tua macchina locale, esegui il seguente comando per importare i dati dei taxi da BigQuery come file CSV senza intestazioni nel bucket Cloud Storage che hai creato in Prima di iniziare.

bq --location=us extract --destination_format=CSV \
     --field_delimiter=',' --print_header=false \
       "bigquery-public-data:chicago_taxi_trips.taxi_trips" \
       gs://${BUCKET_NAME}/chicago_taxi_trips/csv/shard-*.csv

Crea tabelle esterne Hive supportate dai file CSV e Parquet nel tuo bucket Cloud Storage.

Crea la tabella esterna Hive chicago_taxi_trips_csv.

gcloud dataproc jobs submit hive \
    --cluster trino-cluster \
    --region=${REGION} \
    --execute "
        CREATE EXTERNAL TABLE chicago_taxi_trips_csv(
          unique_key   STRING,
          taxi_id  STRING,
          trip_start_timestamp  TIMESTAMP,
          trip_end_timestamp  TIMESTAMP,
          trip_seconds  INT,
          trip_miles   FLOAT,
          pickup_census_tract  INT,
          dropoff_census_tract  INT,
          pickup_community_area  INT,
          dropoff_community_area  INT,
          fare  FLOAT,
          tips  FLOAT,
          tolls  FLOAT,
          extras  FLOAT,
          trip_total  FLOAT,
          payment_type  STRING,
          company  STRING,
          pickup_latitude  FLOAT,
          pickup_longitude  FLOAT,
          pickup_location  STRING,
          dropoff_latitude  FLOAT,
          dropoff_longitude  FLOAT,
          dropoff_location  STRING)
        ROW FORMAT DELIMITED
        FIELDS TERMINATED BY ','
        STORED AS TEXTFILE
        location 'gs://${BUCKET_NAME}/chicago_taxi_trips/csv/';"

Verifica la creazione della tabella esterna Hive.
Ignora questo passaggio per risparmiare tempo e utilizzo delle risorse. Se il cluster ha 3 o meno nodi, questa query può richiedere diversi minuti. Puoi saltare questo passaggio della query e verificare solo la creazione del file Hive Parquet finale, di seguito, poiché questo passaggio della query è molto più veloce.
```
gcloud dataproc jobs submit hive \
    --cluster trino-cluster \
    --region=${REGION} \
    --execute "SELECT COUNT(*) FROM chicago_taxi_trips_csv;"
```

Crea un'altra tabella esterna Hive chicago_taxi_trips_parquet con le stesse colonne, ma con i dati archiviati in formato Parquet per migliorare le prestazioni delle query.

gcloud dataproc jobs submit hive \
    --cluster trino-cluster \
    --region=${REGION} \
    --execute "
        CREATE EXTERNAL TABLE chicago_taxi_trips_parquet(
          unique_key   STRING,
          taxi_id  STRING,
          trip_start_timestamp  TIMESTAMP,
          trip_end_timestamp  TIMESTAMP,
          trip_seconds  INT,
          trip_miles   FLOAT,
          pickup_census_tract  INT,
          dropoff_census_tract  INT,
          pickup_community_area  INT,
          dropoff_community_area  INT,
          fare  FLOAT,
          tips  FLOAT,
          tolls  FLOAT,
          extras  FLOAT,
          trip_total  FLOAT,
          payment_type  STRING,
          company  STRING,
          pickup_latitude  FLOAT,
          pickup_longitude  FLOAT,
          pickup_location  STRING,
          dropoff_latitude  FLOAT,
          dropoff_longitude  FLOAT,
          dropoff_location  STRING)
        STORED AS PARQUET
        location 'gs://${BUCKET_NAME}/chicago_taxi_trips/parquet/';"

Carica i dati dalla tabella CSV di Hive nella tabella Parquet di Hive.

gcloud dataproc jobs submit hive \
    --cluster trino-cluster \
    --region=${REGION} \
    --execute "
        INSERT OVERWRITE TABLE chicago_taxi_trips_parquet
        SELECT * FROM chicago_taxi_trips_csv;"

Verifica che i dati siano stati caricati correttamente.

gcloud dataproc jobs submit hive \
    --cluster trino-cluster \
    --region=${REGION} \
    --execute "SELECT COUNT(*) FROM chicago_taxi_trips_parquet;"

esegui delle query

Puoi eseguire query localmente dalla CLI Trino o da un'applicazione.

Query dell'interfaccia a riga di comando di Trino

Questa sezione mostra come eseguire query sul set di dati sui taxi Hive Parquet utilizzando la CLI Trino.

Esegui il seguente comando sulla tua macchina locale per accedere tramite SSH al nodo master del cluster. Il terminale locale smetterà di rispondere durante l'esecuzione del comando.
```
gcloud compute ssh trino-cluster-m
```
Nella finestra del terminale SSH sul nodo master del cluster, esegui l'interfaccia a riga di comando Trino, che si connette al server Trino in esecuzione sul nodo master.
```
trino --catalog hive --schema default
```

Al prompt trino:default, verifica che Trino possa trovare le tabelle Hive.

show tables;

Table
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
 chicago_taxi_trips_csv
 chicago_taxi_trips_parquet
(2 rows)

Esegui query dal prompt trino:default e confronta le prestazioni delle query sui dati Parquet e CSV.

Query sui dati Parquet

select count(*) from chicago_taxi_trips_parquet where trip_miles > 50;

 _col0
‐‐‐‐‐‐‐‐
 117957
(1 row)

Query 20180928_171735_00006_2sz8c, FINISHED, 3 nodes
Splits: 308 total, 308 done (100.00%)
0:16 [113M rows, 297MB] [6.91M rows/s, 18.2MB/s]

Query sui dati CSV

select count(*) from chicago_taxi_trips_csv where trip_miles > 50;

_col0
‐‐‐‐‐‐‐‐
 117957
(1 row)

Query 20180928_171936_00009_2sz8c, FINISHED, 3 nodes
Splits: 881 total, 881 done (100.00%)
0:47 [113M rows, 41.5GB] [2.42M rows/s, 911MB/s]

Query delle applicazioni Java

Per eseguire query da un'applicazione Java tramite il driver JDBC Java di Trino: 1. Scarica il driver JDBC Java di Trino. 1. Aggiungi una dipendenza trino-jdbc in Maven pom.xml.

<dependency>
  <groupId>io.trino</groupId>
  <artifactId>trino-jdbc</artifactId>
  <version>376</version>
</dependency>

Codice Java di esempio

package dataproc.codelab.trino;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;
public class TrinoQuery {
  private static final String URL = "jdbc:trino://trino-cluster-m:8080/hive/default";
  private static final String SOCKS_PROXY = "localhost:1080";
  private static final String USER = "user";
  private static final String QUERY =
      "select count(*) as count from chicago_taxi_trips_parquet where trip_miles > 50";
  public static void main(String[] args) {
    try {
      Properties properties = new Properties();
      properties.setProperty("user", USER);
      properties.setProperty("socksProxy", SOCKS_PROXY);
      Connection connection = DriverManager.getConnection(URL, properties);
      try (Statement stmt = connection.createStatement()) {
        ResultSet rs = stmt.executeQuery(QUERY);
        while (rs.next()) {
          int count = rs.getInt("count");
          System.out.println("The number of long trips: " + count);
        }
      }
    } catch (SQLException e) {
      e.printStackTrace();
    }
  }
}

Logging e monitoraggio

Logging

I log di Trino si trovano in /var/log/trino/ sui nodi master e worker del cluster.

UI web

Consulta Visualizzazione e accesso agli URL del gateway dei componenti per aprire la UI web di Trino in esecuzione sul nodo master del cluster nel browser locale.

Monitoraggio

Trino espone le informazioni sul runtime del cluster tramite le tabelle di runtime. In una sessione Trino (dal prompt trino:default), esegui la seguente query per visualizzare i dati della tabella di runtime:

select * FROM system.runtime.nodes;