Questa pagina è stata tradotta dall'API Cloud Translation.

Connettiti ad Apache Spark

In qualità di amministratore BigQuery, puoi creare una connessione per consentire ai data analyst di eseguire stored procedure per Apache Spark.

Prima di iniziare

Abilita l'API BigQuery Connection.

Abilitare l'API
Per ottenere le autorizzazioni necessarie per creare una connessione Spark, chiedi all'amministratore di concederti il ruolo IAM Amministratore connessione BigQuery (roles/bigquery.connectionAdmin) per il progetto. Per saperne di più sulla concessione dei ruoli, consulta Gestire l'accesso.

Potresti anche essere in grado di ottenere le autorizzazioni richieste tramite i ruoli personalizzati o altri ruoli predefiniti.
(Facoltativo) Per gestire i metadati utilizzando Dataproc Metastore, assicurati di aver creato un servizio Dataproc Metastore.
(Facoltativo) Per visualizzare la cronologia dei job utilizzando le interfacce web del server di cronologia Spark, assicurati di aver creato un server di cronologia permanente Dataproc (PHS).

Considerazioni sulla località

Quando scegli una località per i tuoi dati, considera quanto segue:

Più regioni

Devi specificare le risorse Google Cloud che si trovano nella stessa vasta area geografica:

Una connessione nella località multiregionale degli Stati Uniti di BigQuery può fare riferimento a un server di cronologia Spark o a un metastore Dataproc in qualsiasi singola regione dell'area geografica degli Stati Uniti, ad esempio us-central1, us-east4 o us-west2.
Una connessione nella località multiregionale dell'UE di BigQuery può fare riferimento a un server di cronologia Spark o a un Metastore Dataproc negli stati membri dell'Unione Europea, ad esempio europe-north1 o europe-west3.

Regioni singole

Una connessione in una singola regione può fare riferimento alle risorse Google Cloud nella stessa regione. Ad esempio, una connessione nella singola regione us-east4 può fare riferimento solo a un server di cronologia Spark o a un metastore Dataproc in us-east4.

Creare connessioni

Seleziona una delle seguenti opzioni:

Console

Vai alla pagina BigQuery.

Vai a BigQuery
Per creare una connessione, fai clic su Aggiungi Aggiungi dati, poi fai clic su Connessioni a origini dati esterne.
Nell'elenco Tipo di connessione, seleziona Apache Spark.
Nel campo ID connessione, inserisci un nome per la connessione, ad esempio spark_connection.
Nell'elenco Località dei dati, seleziona una regione.

Puoi creare una connessione in regioni e multiregionali che supportano BigQuery. Per ulteriori informazioni, consulta la sezione Considerazioni sulla località.
(Facoltativo) Dall'elenco Servizio Metastore, seleziona un Metastore Dataproc.
(Facoltativo) Nel campo Cluster di server di cronologia, inserisci un server di cronologia permanente di Dataproc.
Fai clic su Crea connessione.
Fai clic su Vai alla connessione.
Nel riquadro Informazioni sulla connessione, copia l'ID account di servizio da utilizzare nei passaggi successivi.

bq

In un ambiente a riga di comando, utilizza il comando bq mk per creare una connessione:
```
bq mk --connection --connection_type='SPARK' \
 --properties=PROPERTIES \
 --project_id=PROJECT_ID \
 --location=LOCATION
 CONNECTION_ID
```
Sostituisci quanto segue:
- PROPERTIES: una coppia chiave-valore per fornire parametri specifici per la connessione
  
  Ad esempio:
```
--properties='{
"metastoreServiceConfig": {"metastoreService": "METASTORE_SERVICE_NAME"},
"sparkHistoryServerConfig": {"dataprocCluster": "DATAPROC_CLUSTER_NAME"}
}'
```
  Sostituisci quanto segue:
  - METASTORE_SERVICE_NAME: Dataproc Metastore con una configurazione di rete gRPC, ad esempio projects/my-project-id/locations/us-central1/services/my-service
    
    Per ulteriori informazioni, consulta l'articolo su come accedere ai metadati del metastore Hive archiviati utilizzando un protocollo degli endpoint.
  - DATAPROC_CLUSTER_NAME: la configurazione del server di cronologia Spark, ad esempio projects/my-project-id/regions/us-central1/clusters/my-cluster
    
    Per ulteriori informazioni, consulta Creare un cluster del server di cronologia permanente.
- PROJECT_ID: l'ID del tuo progetto Google Cloud
- LOCATION: la località in cui vuoi archiviare la connessione, ad esempio US
- CONNECTION_ID: l'ID connessione, ad esempio myconnection
  
  Quando visualizza i dettagli della connessione in Google Cloud Console, l'ID connessione è il valore nell'ultima sezione dell'ID connessione completo mostrato in ID connessione, ad esempio projects/.../locations/.../connections/myconnection

Recupera e copia l'ID account di servizio perché ti servirà in un altro passaggio:

bq show --location=LOCATION --connection PROJECT_ID.LOCATION.CONNECTION_ID

L'output è simile al seguente:

Connection myproject.us.myconnection

       name           type                    properties
---------------------- ------- ---------------------------------------------------
myproject.us.myconnection  SPARK   {"serviceAccountId": "[email protected]"}

Per informazioni su come gestire le connessioni, vedi Gestire le connessioni.

Concedi l'accesso all'account di servizio

Per consentire a una stored procedure per Apache Spark di accedere alle risorse Google Cloud, devi concedere all'account di servizio associato alla connessione della stored procedure le autorizzazioni IAM necessarie. In alternativa, puoi utilizzare il tuo account di servizio personalizzato per l'accesso ai dati.

Per leggere e scrivere dati da e in BigQuery, devi concedere all'account di servizio le seguenti autorizzazioni IAM:
- bigquery.tables.* nelle tabelle BigQuery
- bigquery.readsessions.* sul tuo progetto
Il ruolo IAM roles/bigquery.admin include le autorizzazioni necessarie all'account di servizio per leggere e scrivere dati da e verso BigQuery.

Nota: se la stored procedure scrive dati in un bucket Cloud Storage temporaneo e carica i dati di Cloud Storage in BigQuery, devi concedere all'account di servizio l'autorizzazione bigquery.jobs.create sul progetto. Per ulteriori informazioni sui ruoli e sulle autorizzazioni IAM in BigQuery, consulta Controllo dell'accesso con IAM.
Per leggere e scrivere dati da e verso Cloud Storage, devi concedere all'account di servizio l'autorizzazione storage.objects.* per gli oggetti Cloud Storage.

Il ruolo IAM roles/storage.objectAdmin include le autorizzazioni necessarie all'account di servizio per leggere e scrivere dati da e verso Cloud Storage.
Se specifichi Dataproc Metastore quando crei una connessione, affinché BigQuery possa recuperare i dettagli sulla configurazione del metastore, devi concedere all'account di servizio l'autorizzazione metastore.services.get su Dataproc Metastore.

Il ruolo roles/metastore.metadataViewer predefinito include l'autorizzazione necessaria all'account di servizio per recuperare i dettagli sulla configurazione del metastore.

Devi inoltre concedere all'account di servizio il ruolo roles/storage.objectAdmin nel bucket Cloud Storage in modo che la procedura archiviata possa accedere alla directory del warehouse Hive del tuo Metastore Dataproc (hive.metastore.warehouse.dir). Se la tua stored procedure esegue operazioni sul metastore, potresti dover concedere ulteriori autorizzazioni. Per ulteriori informazioni sui ruoli e sulle autorizzazioni IAM in Dataproc Metastore, consulta Ruoli e autorizzazioni predefiniti di Dataproc Metastore.
Se specifichi un server di cronologia permanente Dataproc quando crei una connessione, devi concedere all'account di servizio i ruoli seguenti:
- Il ruolo roles/dataproc.viewer sul server di cronologia permanente Dataproc che contiene l'autorizzazione dataproc.clusters.get.
- Il ruolo roles/storage.objectAdmin nel bucket Cloud Storage specificato per la proprietà spark:spark.history.fs.logDirectory durante la creazione del server di cronologia permanente Dataproc.
Per ulteriori informazioni, consulta Server di cronologia permanente di Dataproc e Ruoli e autorizzazioni di Dataproc.

Condividere i contatti con gli utenti

Puoi concedere i ruoli seguenti per consentire agli utenti di eseguire query sui dati e gestire le connessioni:

roles/bigquery.connectionUser: consente agli utenti di utilizzare le connessioni per connettersi a origini dati esterne ed eseguire query su di esse.
roles/bigquery.connectionAdmin: consente agli utenti di gestire le connessioni.

Per ulteriori informazioni sui ruoli e sulle autorizzazioni IAM in BigQuery, consulta Autorizzazioni e ruoli predefiniti.

Seleziona una delle seguenti opzioni:

Console

Vai alla pagina BigQuery.

Vai a BigQuery

Le connessioni sono elencate nel progetto in un gruppo chiamato Connessioni esterne.
Nel riquadro Explorer, fai clic sul nome del progetto > Connessioni esterne > connessione.
Nel riquadro Dettagli, fai clic su Condividi per condividere una connessione. Quindi:
1. Nella finestra di dialogo Autorizzazioni di connessione, condividi la connessione con altre entità aggiungendo o modificando entità.
2. Fai clic su Salva.

bq

Non puoi condividere una connessione con lo strumento a riga di comando bq. Per condividere una connessione, utilizza la console Google Cloud o il metodo dell'API BigQuery Connections per condividere una connessione.

API

Utilizza il metodo projects.locations.connections.setIAM nella sezione di riferimento dell'API REST BigQuery Connections e fornisci un'istanza della risorsa policy.

Java

Prima di provare questo esempio, segui le istruzioni di configurazione di Java disponibili nella guida rapida di BigQuery sull'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API BigQuery Java.

Per eseguire l'autenticazione in BigQuery, configura Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per le librerie client.

import com.google.api.resourcenames.ResourceName;
import com.google.cloud.bigquery.connection.v1.ConnectionName;
import com.google.cloud.bigqueryconnection.v1.ConnectionServiceClient;
import com.google.iam.v1.Binding;
import com.google.iam.v1.Policy;
import com.google.iam.v1.SetIamPolicyRequest;
import java.io.IOException;

// Sample to share connections
public class ShareConnection {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "MY_PROJECT_ID";
    String location = "MY_LOCATION";
    String connectionId = "MY_CONNECTION_ID";
    shareConnection(projectId, location, connectionId);
  }

  static void shareConnection(String projectId, String location, String connectionId)
      throws IOException {
    try (ConnectionServiceClient client = ConnectionServiceClient.create()) {
      ResourceName resource = ConnectionName.of(projectId, location, connectionId);
      Binding binding =
          Binding.newBuilder()
              .addMembers("group:[email protected]")
              .setRole("roles/bigquery.connectionUser")
              .build();
      Policy policy = Policy.newBuilder().addBindings(binding).build();
      SetIamPolicyRequest request =
          SetIamPolicyRequest.newBuilder()
              .setResource(resource.toString())
              .setPolicy(policy)
              .build();
      client.setIamPolicy(request);
      System.out.println("Connection shared successfully");
    }
  }
}

Passaggi successivi

Scopri di più sui diversi tipi di connessione.
Scopri di più sulla gestione delle connessioni.
Scopri come creare una stored procedure per Apache Spark.
Scopri come gestire le stored procedure.