Cette page a été traduite par l'API Cloud Translation.

Utiliser Trino avec Dataproc

Trino (anciennement Presto) est un moteur de requêtes SQL distribué conçu pour interroger des ensembles de données volumineux répartis entre une ou plusieurs sources de données hétérogènes. Trino peut interroger Hive, Kafka, MySQL et d'autres sources de données par le biais de connecteurs. Ce tutoriel vous explique comment :

installer le service Trino sur un cluster Dataproc ;
interroger les données publiques d'un client Trino installé sur votre machine locale qui communique avec un service Trino sur votre cluster ;
exécuter des requêtes à partir d'une application Java qui communique avec le service Trino sur votre cluster par le biais du pilote Java JDBC de Trino.

Créer un cluster Dataproc

Créez un cluster Dataproc en utilisant l'option optional-components (disponible sur les versions d'image 2.1 et ultérieures) pour installer le composant facultatif Trino sur le cluster, et en utilisant l'option enable-component-gateway pour activer la passerelle des composants et ainsi vous permettre d'accéder à l'interface utilisateur Web de Trino depuis la console Google Cloud .

Définissez les variables d'environnement :
- PROJECT : ID du projet
- BUCKET_NAME : nom du bucket Cloud Storage créé à la section Avant de commencer
- REGION : région dans laquelle le cluster utilisé dans ce tutoriel sera créé (par exemple, "us-west1")
- WORKERS : trois à cinq nœuds de calcul sont recommandés pour ce tutoriel
```
export PROJECT=project-id
export WORKERS=number
export REGION=region
export BUCKET_NAME=bucket-name
```
Exécutez la Google Cloud CLI sur votre ordinateur local pour créer le 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 création d'un cluster à haute disponibilité (cluster avec plusieurs nœuds maîtres) n'est pas recommandée, car le coordinateur est démarré sur le nœud maître 0, et tous les autres nœuds maîtres resteront inactifs.

Préparer les données

Exportez l'ensemble de données bigquery-public-data chicago_taxi_trips vers Cloud Storage sous forme de fichiers CSV, puis créez une table externe Hive pour référencer les données.

Sur votre ordinateur local, exécutez la commande suivante pour importer les données relatives aux taxis issues de BigQuery sous forme de fichiers CSV sans en-têtes dans le bucket Cloud Storage créé à la section Avant de commencer.

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

Créez des tables externes Hive sauvegardées sous forme de fichiers CSV et Parquet dans le bucket Cloud Storage.

Créez la table externe 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/';"

Vérifiez que la table externe Hive a été créée.
Passez cette étape pour gagner du temps et réduire l'utilisation des ressources. Si votre cluster possède jusqu'à trois nœuds, cette requête peut prendre plusieurs minutes. Vous pouvez ne vérifier que la création du dernier fichier Parquet Hive (ci-dessous), car cette étape de la requête est considérablement plus rapide.
```
gcloud dataproc jobs submit hive \
    --cluster trino-cluster \
    --region=${REGION} \
    --execute "SELECT COUNT(*) FROM chicago_taxi_trips_csv;"
```

Créez une autre table externe Hive chicago_taxi_trips_parquet comportant les mêmes colonnes, mais avec des données stockées au format Parquet pour de meilleures performances d'interrogation.

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/';"

Chargez les données issues de la table CSV Hive dans la table Parquet 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;"

Vérifiez que les données ont été chargées correctement.

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

Exécuter des requêtes

Vous pouvez exécuter des requêtes localement à partir de la CLI Trino ou d'une application.

Requêtes depuis la CLI Trino

Cette section explique comment interroger l'ensemble de données Parquet Hive sur les taxis à l'aide de la CLI Trino.

Exécutez la commande suivante sur votre ordinateur local pour vous connecter en SSH au nœud maître de votre cluster. Le terminal local cessera de répondre pendant l'exécution de la commande.
```
gcloud compute ssh trino-cluster-m
```
Dans la fenêtre de terminal SSH du nœud maître de votre cluster, exécutez la CLI Trino, qui se connecte au serveur Trino s'exécutant sur le nœud maître.
```
trino --catalog hive --schema default
```

À l'invite trino:default, vérifiez que Trino a accès aux tables Hive.

show tables;

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

Exécutez les requêtes depuis l'invite trino:default, et comparez les performances d'interrogation des données Parquet par rapport aux données CSV.

Requête de données 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]

Requête de données 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]

Requêtes depuis une application Java

Pour exécuter des requêtes depuis une application Java par le biais du pilote Java JDBC de Trino : 1. Téléchargez le pilote Java JDBC de Trino. 1. Ajoutez une dépendance trino-jdbc dans le fichier Maven pom.xml.

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

Exemple de code Java

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();
    }
  }
}

Journalisation et surveillance

Journalisation

Les journaux Trino se trouvent sous /var/log/trino/ sur les nœuds maîtres et les nœuds de calcul du cluster.

UI Web

Consultez la section Afficher les URL de la passerelle des composants et y accéder pour ouvrir l'interface utilisateur Web de Trino s'exécutant sur le nœud maître du cluster dans votre navigateur local.

Surveillance

Trino présente les informations d'exécution du cluster dans des tables d'exécution. Dans une invite de session Trino (depuis trino:default), exécutez la requête suivante pour afficher les données des tables d'exécution :

select * FROM system.runtime.nodes;