Connettiti a Blob Storage

Una connessione Azure in BigQuery consente agli utenti di eseguire query sui dati archiviati in Azure Blob Storage ed esportare i risultati delle query in Blob Storage. Puoi creare una connessione in modo che BigQuery Omni possa accedere in modo sicuro ai tuoi dati di Blob Storage.

BigQuery Omni supporta la federazione delle identità dei workload di Azure, che ti consente di concedere l'accesso a un'applicazione Azure nel tuo tenant a un account di servizio Google senza gestire i secret client dell'applicazione.

Prima di iniziare

Ruoli obbligatori

Quote

Per saperne di più sulle quote, consulta API BigQuery Connection.

Crea una connessione Azure

Per creare una connessione Azure, segui questi passaggi:

  1. Crea un'applicazione nel tenant di Azure.
  2. Crea la connessione BigQuery Azure.
  3. Aggiungi una credenziale federata.
  4. Assegna un ruolo alle applicazioni Azure AD di BigQuery.

Per saperne di più sull'utilizzo delle credenziali dell'identità federata per accedere ai dati in Azure, consulta Federazione delle identità dei workload.

Crea un'applicazione nel tenant di Azure

Per creare un'applicazione nel tenant di Azure, segui questi passaggi:

Portale Azure

  1. Nel portale di Azure, vai ad App registrations (Registrazioni app), quindi fai clic su New registration (Nuova registrazione).

  2. In Nome, inserisci un nome per l'applicazione.

  3. In Tipi di account supportati, seleziona Solo account in questa directory dell'organizzazione.

  4. Per registrare la nuova applicazione, fai clic su Register (Registra).

  5. Prendi nota dell'ID applicazione (client). Devi fornire questo ID quando crei la connessione.

    Portale Azure per la creazione di applicazioni

Terraform

Aggiungi quanto segue al file di configurazione Terraform:

  data "azuread_client_config" "current" {}

  resource "azuread_application" "example" {
    display_name = "bigquery-omni-connector"
    owners       = [data.azuread_client_config.current.object_id]
  }

  resource "azuread_service_principal" "example" {
    client_id                    = azuread_application.example.client_id
    app_role_assignment_required = false
    owners                       = [data.azuread_client_config.current.object_id]
  }

Per saperne di più, scopri come registrare un'applicazione in Azure.

Crea una connessione

Console

  1. Nella console Google Cloud , vai alla pagina BigQuery.

    Vai a BigQuery

  2. Nel riquadro Dati, fai clic su Aggiungi dati.

    Si apre la finestra di dialogo Aggiungi dati.

  3. Nel riquadro Filtra per, nella sezione Tipo di origine dati, seleziona Database.

    In alternativa, nel campo Cerca origini dati, puoi inserire Azure.

  4. Nella sezione Origini dati in primo piano, fai clic su Azure Blob Storage.

  5. Fai clic sulla scheda della soluzione Azure Blob Storage Omni: BigQuery Federation.

  6. Nella finestra di dialogo Crea tabella, nel campo ID connessione, seleziona Crea una nuova connessione ABS.

  7. Nel riquadro Origine dati esterna, inserisci le seguenti informazioni:

    • In Tipo di connessione, seleziona BigLake su Azure (tramite BigQuery Omni).
    • In ID connessione, inserisci un identificatore per la risorsa di connessione. Puoi utilizzare lettere, numeri, trattini e trattini bassi.
    • Seleziona la località in cui vuoi creare la connessione.
    • (Facoltativo) In Nome descrittivo, inserisci un nome facile da usare per la connessione, ad esempio My connection resource. Il nome descrittivo può essere qualsiasi valore che ti aiuti a identificare la risorsa di connessione se devi modificarla in un secondo momento.
    • (Facoltativo) In Descrizione, inserisci una descrizione della risorsa di connessione.
    • In ID tenant Azure, inserisci l'ID tenant Azure, noto anche come ID directory (tenant).

    • Seleziona la casella di controllo Utilizza identità federata e inserisci l'ID applicazione federata Azure (client).

      Per scoprire come ottenere gli ID Azure, consulta Crea un'applicazione nel tenant di Azure.

  8. Fai clic su Crea connessione.

  9. Fai clic su Vai alla connessione.

  10. Nella sezione Informazioni sulla connessione, prendi nota del valore di Identità Google BigQuery, che è l'ID del account di servizio. Questo ID è per il service accountGoogle Cloud che autorizzi ad accedere alla tua applicazione.

Terraform 

  resource "google_bigquery_connection" "connection" {
    connection_id = "omni-azure-connection"
    location      = "azure-eastus2"
    description   = "created by terraform"

    azure {
      customer_tenant_id              = "TENANT_ID"
      federated_application_client_id = azuread_application.example.client_id
    }
  }

Sostituisci TENANT_ID con l'ID tenant della directory Azure che contiene l'account Blob Storage.

bq

Utilizza il comando bq mk. Per ottenere l'output in formato JSON, utilizza il parametro --format=json. 

bq mk --connection --connection_type='Azure' \
  --tenant_id=TENANT_ID \
  --location=AZURE_LOCATION \
  --federated_azure=true \
  --federated_app_client_id=APP_ID \
  CONNECTION_ID

Sostituisci quanto segue:

  • TENANT_ID: l'ID tenant della directory Azure che contiene l'account Azure Storage.
  • AZURE_LOCATION: la regione Azure in cui si trovano i dati di Azure Storage. BigQuery Omni supporta la regione azure-eastus2.
  • APP_ID: l'ID applicazione Azure (client). Per scoprire come ottenere questo ID, consulta Crea un'applicazione nel tenant Azure.
  • CONNECTION_ID: il nome della connessione.

L'output è simile al seguente:

Connection CONNECTION_ID successfully created
Please add the following identity to your Azure application APP_ID
Identity: SUBJECT_ID

Questo output include i seguenti valori:

  • APP_ID: l'ID dell'applicazione che hai creato.

  • SUBJECT_ID: l'ID del account di servizio account Google Cloudche l'utente autorizza ad accedere alla propria applicazione. Questo valore è obbligatorio quando crei una credenziale federata in Azure.

Prendi nota dei valori APP_ID e SUBJECT_ID da utilizzare nei passaggi successivi.

Successivamente, aggiungi una credenziale federata per la tua applicazione.

Aggiungi una credenziale federata

Per creare una credenziale federata, segui questi passaggi:

Portale Azure

  1. Nel portale di Azure, vai ad App registrations (Registrazioni app), quindi fai clic sulla tua applicazione.

  2. Seleziona Certificates & secrets (Certificati e secret) > Federated credentials (Credenziali federate) > Add credentials (Aggiungi credenziali). Quindi:

    1. Nell'elenco Federated credential scenario (Scenario delle credenziali federate), seleziona Other issuer (Altro emittente).

    2. In Issuer (Emittente), inserisci https://accounts.google.com.

    3. In Identificatore soggetto, inserisci l'identità Google BigQuery del service account Google Cloud che hai ottenuto quando hai creato la connessione.

    4. In Nome, inserisci un nome per la credenziale.

    5. Fai clic su Aggiungi.

Terraform

Aggiungi quanto segue al file di configurazione Terraform:

  resource "azuread_application_federated_identity_credential" "example" {
    application_id = azuread_application.example.id
    display_name   = "omni-federated-credential"
    description    = "BigQuery Omni federated credential"
    audiences      = ["api://AzureADTokenExchange"]
    issuer         = "https://accounts.google.com"
    subject        = google_bigquery_connection.connection.azure[0].identity
  }

Per saperne di più, consulta Configura un'app per considerare attendibile un provider di identità esterno.

Assegna un ruolo alle applicazioni Azure di BigQuery

Per assegnare un ruolo all'applicazione Azure di BigQuery, utilizza il portale Azure, Azure PowerShell o l'API REST di gestione di Microsoft:

Portale Azure

Puoi eseguire le assegnazioni dei ruoli nel portale Azure accedendo come utente con l'autorizzazione Microsoft.Authorization/roleAssignments/write. L'assegnazione del ruolo consente alla connessione Azure di BigQuery di accedere ai dati di Azure Storage come specificato nella policy dei ruoli.

Per aggiungere assegnazioni di ruoli utilizzando il portale Azure, segui questi passaggi:

  1. Dal tuo account Azure Storage, inserisci IAM nella barra di ricerca.

  2. Fai clic su Controllo degli accessi (IAM).

  3. Fai clic su Aggiungi e seleziona Aggiungi assegnazioni di ruoli.

  4. Per fornire l'accesso di sola lettura, seleziona il ruolo Storage Blob Data Reader. Per fornire l'accesso in lettura e scrittura, seleziona il ruolo Storage Blob Data Contributor.

  5. Imposta Assegna accesso a su Utente, gruppo o entità servizio.

  6. Fai clic su Seleziona membri.

  7. Nel campo Seleziona, inserisci il nome dell'applicazione Azure che hai assegnato quando hai creato l'applicazione nel tenant Azure.

  8. Fai clic su Salva.

Per saperne di più, consulta Assegna ruoli di Azure utilizzando il portale di Azure.

Terraform

Aggiungi quanto segue al file di configurazione Terraform:

  resource "azurerm_role_assignment" "data_role" {
    scope                = data.azurerm_storage_account.example.id
    # Read permission for Omni on the storage account
    role_definition_name = "Storage Blob Data Reader"
    principal_id         = azuread_service_principal.example.id
  }

Azure PowerShell

Per aggiungere un'assegnazione di ruolo per un service principal nell'ambito di una risorsa, puoi utilizzare il comando New-AzRoleAssignment:

  New-AzRoleAssignment`
   -SignInName APP_NAME`
   -RoleDefinitionName ROLE_NAME`
   -ResourceName RESOURCE_NAME`
   -ResourceType RESOURCE_TYPE`
   -ParentResource PARENT_RESOURCE`
   -ResourceGroupName RESOURCE_GROUP_NAME

Sostituisci quanto segue:

  • APP_NAME: il nome dell'applicazione.
  • ROLE_NAME: il nome del ruolo che vuoi assegnare.
  • RESOURCE_NAME: il nome della risorsa.
  • RESOURCE_TYPE: il tipo di risorsa.
  • PARENT_RESOURCE: la risorsa padre.
  • RESOURCE_GROUP_NAME: il nome del gruppo di risorse.

Per saperne di più sull'utilizzo di Azure PowerShell per aggiungere un nuovo service principal, consulta Assegna ruoli di Azure utilizzando Azure PowerShell.

Interfaccia a riga di comando di Azure

Per aggiungere un'assegnazione di ruolo per un service principal nell'ambito di una risorsa, puoi utilizzare lo strumento a riga di comando di Azure. Devi disporre dell'autorizzazione Microsoft.Authorization/roleAssignments/write per l'account di archiviazione per concedere i ruoli.

Per assegnare un ruolo, ad esempio il ruolo Storage Blob Data Reader, all'entità servizio, esegui il comando az role assignment create:

  az role assignment create --role "Storage Blob Data Reader" \
    --assignee-object-id ${SP_ID} \
    --assignee-principal-type ServicePrincipal \
    --scope   subscriptions/SUBSCRIPTION_ID/resourcegroups/RESOURCE_GROUP_NAME/providers/Microsoft.Storage/storageAccounts/STORAGE_ACCOUNT_NAME

Sostituisci quanto segue:

  • SP_ID: l'ID dell'entità di servizio. Questa entità servizio è per l'applicazione che hai creato. Per ottenere l'entità servizio per una connessione federata, consulta Oggetto entità servizio.
  • STORAGE_ACCOUNT_NAME: il nome dell'account di archiviazione.
  • RESOURCE_GROUP_NAME: il nome del gruppo di risorse.
  • SUBSCRIPTION_ID: l'ID della sottoscrizione.

Per saperne di più, consulta Assegna ruoli di Azure utilizzando l'interfaccia a riga di comando di Azure.

API REST Microsoft

Per aggiungere assegnazioni di ruoli per un service principal, puoi inviare una richiesta HTTP a Microsoft Management.

Per chiamare l'API REST di Microsoft Graph, recupera un token OAuth per un'applicazione. Per saperne di più, consulta Ottieni l'accesso senza un utente. L'applicazione che ha chiamato l'API REST di Microsoft Graph deve disporre dell'autorizzazione dell'applicazione Application.ReadWrite.All.

Per generare un token OAuth, esegui questo comando:

  export TOKEN=$(curl -X POST \
    https://login.microsoftonline.com/TENANT_ID/oauth2/token \
    -H 'cache-control: no-cache' \
    -H 'content-type: application/x-www-form-urlencoded' \
    --data-urlencode "grant_type=client_credentials" \
    --data-urlencode "resource=https://graph.microsoft.com/" \
    --data-urlencode "client_id=CLIENT_ID" \
    --data-urlencode "client_secret=CLIENT_SECRET" \
  | jq --raw-output '.access_token')

Sostituisci quanto segue:

  • TENANT_ID: l'ID tenant corrispondente all'ID della directory Azure che contiene l'account Azure Storage.
  • CLIENT_ID: l'ID client Azure.
  • CLIENT_SECRET: il client secret di Azure.

Ottieni l'ID dei ruoli integrati di Azure che vuoi assegnare all'entità servizio.

Ecco alcuni ruoli comuni:

Per assegnare un ruolo all'entità di servizio, chiama l'API REST Microsoft Graph all'API REST Azure Resource Management:

  export ROLE_ASSIGNMENT_ID=$(uuidgen)
  curl -X PUT \
'https://management.azure.com/subscriptions/SUBSCRIPTION_ID/resourcegroups/RESOURCE_GROUP_NAME/providers/Microsoft.Storage/storageAccounts/STORAGE_ACCOUNT_NAME/providers/Microsoft.Authorization/roleAssignments/ROLE_ASSIGNMENT_ID?api-version=2018-01-01-preview' \
    -H "authorization: Bearer ${TOKEN?}" \
    -H 'cache-control: no-cache' \
    -H 'content-type: application/json' \
    -d '{
        "properties": {
            "roleDefinitionId": "subscriptions/SUBSCRIPTION_ID/resourcegroups/RESOURCE_GROUP_NAME/providers/Microsoft.Storage/storageAccounts/STORAGE_ACCOUNT_NAME/providers/Microsoft.Authorization/roleDefinitions/ROLE_ID",
            "principalId": "SP_ID"
        }
    }'

Sostituisci quanto segue:

  • ROLE_ASSIGNMENT_ID: l'ID ruolo.
  • SP_ID: l'ID dell'entità di servizio. Questa entità servizio è per l'applicazione che hai creato. Per ottenere l'entità di servizio per una connessione federata, consulta Oggetto entità di servizio.
  • SUBSCRIPTION_ID: l'ID della sottoscrizione.
  • RESOURCE_GROUP_NAME: il nome del gruppo di risorse.
  • STORAGE_ACCOUNT_NAME: il nome dell'account di archiviazione.
  • SUBSCRIPTION_ID: l'ID della sottoscrizione.

La connessione è ora pronta per l'uso. Tuttavia, potrebbe verificarsi un ritardo nella propagazione per l'assegnazione di un ruolo in Azure. Se non riesci a utilizzare la connessione a causa di problemi di autorizzazione, riprova dopo un po' di tempo.

Condividi le connessioni con gli utenti

Puoi concedere i seguenti ruoli 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 saperne di più sui ruoli e sulle autorizzazioni IAM in BigQuery, consulta Ruoli e autorizzazioni predefiniti.

Seleziona una delle seguenti opzioni:

Console

  1. Vai alla pagina BigQuery.

    Vai a BigQuery

    Le connessioni sono elencate nel progetto, in un gruppo denominato Connessioni.

  2. Nel riquadro a sinistra, fai clic su Spazio di esplorazione:

    Pulsante evidenziato per il riquadro Spazio di esplorazione.

    Se non vedi il riquadro a sinistra, fai clic su Espandi riquadro sinistro per aprirlo.

  3. Fai clic sul progetto, poi su Connessioni e seleziona una connessione.

  4. 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à aggiungendole o modificandole.

    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.

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 nella guida rapida di BigQuery per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API BigQuery Java.

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura 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:example-analyst-group@google.com")
              .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