Connettersi a Blob Storage

Portale di Azure

1. Nel portale di Azure, vai a Registrazioni app e fai clic su Nuova registrazione.

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

3. Per i tipi di account supportati, seleziona Solo account in questa directory dell'organizzazione.

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

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

   

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]
  }

Console

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

   Vai a BigQuery

2. Nel riquadro Explorer, fai clic su add Aggiungi dati.

   Si apre la finestra di dialogo Aggiungi dati.

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

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

4. Nella sezione Origini dati in evidenza, 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:

   • Per Tipo di connessione, seleziona BigLake su Azure (tramite BigQuery Omni).
   • In Connection ID (ID connessione), inserisci un identificatore per la risorsa di connessione. Puoi utilizzare lettere, numeri, trattini e trattini bassi.
   • Seleziona la posizione in cui vuoi creare la connessione.
   • (Facoltativo) In Nome descrittivo, inserisci un nome intuitivo 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 per la risorsa di connessione.
   • Per ID tenant Azure, inserisci l'ID tenant Azure, chiamato anche ID directory (tenant).

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

     Per scoprire come ottenere gli ID Azure, consulta Creare 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, ovvero l'ID del account di servizio. Questo ID è per l'Google Cloud service account 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 (client) Azure. Per scoprire come ottenere questo ID, consulta Creare 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 Google Cloud che l'utente autorizza ad accedere alla sua 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.

Portale di Azure

1. Nel portale di Azure, vai a Registrazioni app e poi fai clic sulla tua applicazione.

2. Seleziona Certificati e secreti > Credenziali federate > Aggiungi credenziali. Poi, procedi nel seguente modo:

   1. Nell'elenco Scenario delle credenziali federate, seleziona Altro emittente.

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

   3. Per Identificatore soggetto, inserisci l'identità Google BigQuery dell' Google Cloud account di servizio 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
  }

Portale di Azure

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

Per aggiungere assegnazioni di ruolo utilizzando il portale Azure:

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

2. Fai clic su Controllo accesso (IAM).

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

4. Per fornire l'accesso in sola lettura, seleziona il ruolo Lettore dati BLOB di archiviazione. Per fornire l'accesso in lettura/scrittura, seleziona il ruolo Storage Blob Data Contributor.

5. Imposta Assegna accesso a su Utente, gruppo o service principal.

6. Fai clic su Seleziona membri.

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

8. Fai clic su Salva.

Per maggiori informazioni, consulta Assegnare ruoli Azure utilizzando il portale 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 in un ambito di 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 una nuova entità di servizio, consulta l'articolo Assegnare ruoli Azure utilizzando Azure PowerShell.

Interfaccia a riga di comando di Azure

Per aggiungere un'assegnazione di ruolo per un'entità di servizio in un ambito di risorsa, puoi utilizzare lo strumento a riga di comando di Azure. Per concedere i ruoli, devi disporre dell'autorizzazione Microsoft.Authorization/roleAssignments/write per l'account di archiviazione.

Per assegnare un ruolo, ad esempio il ruolo Lettore di dati BLOB di archiviazione, all'entità di 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 entità servizio. Questo service principal è per l'applicazione che hai creato. Per ottenere il service principal per una connessione federata, consulta Oggetto service principal.
• STORAGE_ACCOUNT_NAME: il nome dell'account di archiviazione.
• RESOURCE_GROUP_NAME: il nome del gruppo di risorse.
• SUBSCRIPTION_ID: l'ID abbonamento.

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

API REST Microsoft

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

Per chiamare l'API REST Microsoft Graph, recupera un token OAuth per un'applicazione. Per saperne di più, vedi Ottenere l'accesso senza un utente. L'applicazione che ha chiamato l'API REST Microsoft Graph deve disporre dell'autorizzazione 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 predefiniti di Azure che vuoi assegnare all'entità servizio.

Di seguito sono riportati alcuni ruoli comuni:

• Collaboratore ai dati del blob di archiviazione: ba92f5b4-2d11-453d-a403-e96b0029c9fe
• Lettore dei dati dei blob di archiviazione: 2a2b9908-6ea1-4ae2-8e65-a410df84e7d1

Per assegnare un ruolo all'entità 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 entità servizio. Questo service principal è per l'applicazione che hai creato. Per ottenere il service principal per una connessione federata, consulta Oggetto service principal.
• SUBSCRIPTION_ID: l'ID abbonamento.
• RESOURCE_GROUP_NAME: il nome del gruppo di risorse.
• STORAGE_ACCOUNT_NAME: il nome dell'account di archiviazione.
• SUBSCRIPTION_ID: l'ID abbonamento.

Console

1. Vai alla pagina BigQuery.

   Vai a BigQuery

   Le connessioni sono elencate nel tuo progetto, in un gruppo chiamato Connessioni esterne.

2. Nel riquadro Explorer, fai clic sul nome del progetto > Connessioni esterne > connessione.

3. 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 le 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

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