Questa pagina è stata tradotta dall'API Cloud Translation.

Controlla l'accesso alle risorse con IAM
bookmark_border Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Questo documento descrive come visualizzare il criterio di accesso corrente di una risorsa, come concedere l'accesso a una risorsa e come revocare l'accesso a una risorsa.

Questo documento presuppone la conoscenza del sistema Identity and Access Management (IAM) in Google Cloud.

Ruoli obbligatori

Per ottenere le autorizzazioni necessarie per modificare i criteri IAM per le risorse, chiedi all'amministratore di concederti il ruolo IAM Proprietario dati BigQuery (roles/bigquery.dataOwner) nel progetto. Per ulteriori informazioni sulla concessione dei ruoli, consulta Gestire l'accesso a progetti, cartelle e organizzazioni.

Questo ruolo predefinito contiene le autorizzazioni necessarie per modificare i criteri IAM per le risorse. Per visualizzare le autorizzazioni esatte richieste, espandi la sezione Autorizzazioni richieste:

Autorizzazioni obbligatorie

Per modificare i criteri IAM per le risorse sono necessarie le seguenti autorizzazioni:

Per ottenere i criteri di accesso di un set di dati: bigquery.datasets.get
Per impostare i criteri di accesso di un set di dati: bigquery.datasets.update
Per ottenere il criterio di accesso di un set di dati (solo console Google Cloud): bigquery.datasets.getIamPolicy
Per impostare i criteri di accesso di un set di dati (solo console): bigquery.datasets.setIamPolicy
Per ottenere il criterio di una tabella o di una vista: bigquery.tables.getIamPolicy
Per impostare il criterio di una tabella o di una vista: bigquery.tables.setIamPolicy
Per creare lo strumento bq o i job BigQuery SQL (facoltativo): bigquery.jobs.create

Potresti anche ottenere queste autorizzazioni con ruoli personalizzati o altri ruoli predefiniti.

Visualizzare il criterio di accesso di una risorsa

Le seguenti sezioni descrivono come visualizzare i criteri di accesso di diverse risorse.

Visualizzare il criterio di accesso di un set di dati

Seleziona una delle seguenti opzioni:

Console bq API Vai Java Node.js Python

Vai alla pagina BigQuery.

Vai a BigQuery
Nel riquadro Spazio di esplorazione, espandi il progetto e seleziona un set di dati.
Fai clic su Condivisione > Autorizzazioni.

I criteri di accesso ai set di dati vengono visualizzati nel riquadro Autorizzazioni set di dati.

In the Google Cloud console, activate Cloud Shell.

Activate Cloud Shell

At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.
Per recuperare un criterio esistente e stamparlo in un file locale in JSON, utilizza il comando bq show in Cloud Shell:
```
bq show \
   --format=prettyjson \
   PROJECT_ID:DATASET > PATH_TO_FILE
```
Sostituisci quanto segue:
- PROJECT_ID: il tuo ID progetto
- DATASET: il nome del set di dati
- PATH_TO_FILE: il percorso del file JSON sul computer locale

Per visualizzare il criterio di accesso di un set di dati, chiama il metodo datasets.get con una risorsa dataset definita.

Il criterio è disponibile nella proprietà access della risorsa dataset rimessa.

Prima di provare questo esempio, segui le istruzioni di configurazione Go riportate nella guida rapida all'utilizzo di BigQuery con le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API BigQuery Go.

Per autenticarti in BigQuery, configura le credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per le librerie client.

Chiama la funzione client.Dataset().Metadata(). Il criterio di accesso è disponibile nella proprietà Access.

import (
	"context"
	"fmt"
	"io"

	"cloud.google.com/go/bigquery"
)

// viewDatasetAccessPolicies retrieves the ACL for the given dataset
// For more information on the types of ACLs available see:
// https://cloud.google.com/storage/docs/access-control/lists
func viewDatasetAccessPolicies(w io.Writer, projectID, datasetID string) error {
	// TODO(developer): uncomment and update the following lines:
	// projectID := "my-project-id"
	// datasetID := "mydataset"

	ctx := context.Background()

	// Create new client.
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %w", err)
	}
	defer client.Close()

	// Get dataset's metadata.
	meta, err := client.Dataset(datasetID).Metadata(ctx)
	if err != nil {
		return fmt.Errorf("bigquery.Client.Dataset.Metadata: %w", err)
	}

	fmt.Fprintf(w, "Details for Access entries in dataset %v.\n", datasetID)

	// Iterate over access permissions.
	for _, access := range meta.Access {
		fmt.Fprintln(w)
		fmt.Fprintf(w, "Role: %s\n", access.Role)
		fmt.Fprintf(w, "Entity: %v\n", access.Entity)
	}

	return nil
}

Prima di provare questo esempio, segui le istruzioni di configurazione Java riportate nella guida rapida all'utilizzo di BigQuery con le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API BigQuery Java.

Per autenticarti in BigQuery, configura le credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per le librerie client.


import com.google.cloud.bigquery.Acl;
import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.Dataset;
import com.google.cloud.bigquery.DatasetId;
import java.util.List;

public class GetDatasetAccessPolicy {

  public static void main(String[] args) {
    // TODO(developer): Replace these variables before running the sample.
    // Project and dataset from which to get the access policy.
    String projectId = "MY_PROJECT_ID";
    String datasetName = "MY_DATASET_NAME";
    getDatasetAccessPolicy(projectId, datasetName);
  }

  public static void getDatasetAccessPolicy(String projectId, String datasetName) {
    try {
      // Initialize client that will be used to send requests. This client only needs to be created
      // once, and can be reused for multiple requests.
      BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();

      // Create datasetId with the projectId and the datasetName.
      DatasetId datasetId = DatasetId.of(projectId, datasetName);
      Dataset dataset = bigquery.getDataset(datasetId);

      // Show ACL details.
      // Find more information about ACL and the Acl Class here:
      // https://cloud.google.com/storage/docs/access-control/lists
      // https://cloud.google.com/java/docs/reference/google-cloud-bigquery/latest/com.google.cloud.bigquery.Acl
      List<Acl> acls = dataset.getAcl();
      System.out.println("ACLs in dataset \"" + dataset.getDatasetId().getDataset() + "\":");
      System.out.println(acls.toString());
      for (Acl acl : acls) {
        System.out.println();
        System.out.println("Role: " + acl.getRole());
        System.out.println("Entity: " + acl.getEntity());
      }
    } catch (BigQueryException e) {
      System.out.println("ACLs info not retrieved. \n" + e.toString());
    }
  }
}

Prima di provare questo esempio, segui le istruzioni di configurazione Node.js riportate nella guida rapida all'utilizzo di BigQuery con le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API BigQuery Node.js.

Per autenticarti in BigQuery, configura le credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per le librerie client.

Recupero i metadati del set di dati utilizzando la funzione Dataset#getMetadata(). Il criterio di accesso è disponibile nella proprietà access dell'oggetto dei metadati risultante.


/**
 * TODO(developer): Update and un-comment below lines
 */
// const datasetId = "my_project_id.my_dataset";

const {BigQuery} = require('@google-cloud/bigquery');

// Instantiate a client.
const bigquery = new BigQuery();

async function viewDatasetAccessPolicy() {
  const dataset = bigquery.dataset(datasetId);

  const [metadata] = await dataset.getMetadata();
  const accessEntries = metadata.access || [];

  // Show the list of AccessEntry objects.
  // More details about the AccessEntry object in the BigQuery documentation:
  // https://cloud.google.com/nodejs/docs/reference/bigquery/latest
  console.log(
    `${accessEntries.length} Access entries in dataset '${datasetId}':`
  );
  for (const accessEntry of accessEntries) {
    console.log(`Role: ${accessEntry.role || 'null'}`);
    console.log(`Special group: ${accessEntry.specialGroup || 'null'}`);
    console.log(`User by Email: ${accessEntry.userByEmail || 'null'}`);
  }
}

Prima di provare questo esempio, segui le istruzioni di configurazione Python riportate nella guida rapida all'utilizzo di BigQuery con le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API BigQuery Python.

Per autenticarti in BigQuery, configura le credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per le librerie client.

Chiama la funzione client.get_dataset(). Il criterio di accesso è disponibile nella proprietà dataset.access_entries.

from google.cloud import bigquery

# Instantiate a client.
client = bigquery.Client()

# TODO(developer): Update and uncomment the lines below.

# Dataset from which to get the access policy.
# dataset_id = "my_dataset"

# Get a reference to the dataset.
dataset = client.get_dataset(dataset_id)

# Show the list of AccessEntry objects.
# More details about the AccessEntry object here:
# https://cloud.google.com/python/docs/reference/bigquery/latest/google.cloud.bigquery.dataset.AccessEntry
print(
    f"{len(dataset.access_entries)} Access entries found "
    f"in dataset '{dataset_id}':"
)

for access_entry in dataset.access_entries:
    print()
    print(f"Role: {access_entry.role}")
    print(f"Special group: {access_entry.special_group}")
    print(f"User by Email: {access_entry.user_by_email}")

Visualizzare il criterio di accesso di una tabella o una visualizzazione

Seleziona una delle seguenti opzioni:

Console bq API Vai Java Node.js Python

Vai alla pagina BigQuery.

Vai a BigQuery
Nel riquadro Explorer, espandi il progetto e seleziona una tabella o una vista.
Fai clic su Condividi.

I criteri di accesso alla tabella o alla visualizzazione vengono visualizzati nel riquadro Condividi.

In the Google Cloud console, activate Cloud Shell.

Activate Cloud Shell

At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.
Per recuperare un criterio di accesso esistente e stamparlo in un file locale in JSON, utilizza il comando bq get-iam-policy in Cloud Shell:
```
bq get-iam-policy \
   --table=true \
   PROJECT_ID:DATASET.RESOURCE > PATH_TO_FILE
```
Sostituisci quanto segue:
- PROJECT_ID: il tuo ID progetto
- DATASET: il nome del set di dati
- RESOURCE: il nome della tabella o della vista di cui vuoi visualizzare il criterio
- PATH_TO_FILE: il percorso del file JSON sul computer locale

Per recuperare il criterio corrente, chiama il metodo tables.getIamPolicy.

Per autenticarti in BigQuery, configura le credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per le librerie client.

Chiama la funzione IAM().Policy() della risorsa. Quindi, chiama la funzione Roles() per ottenere il criterio di accesso per una tabella o una vista.

import (
	"context"
	"fmt"
	"io"

	"cloud.google.com/go/bigquery"
)

// viewTableOrViewAccessPolicies retrieves the ACL for the given resource
// For more information on the types of ACLs available see:
// https://cloud.google.com/storage/docs/access-control/lists
func viewTableOrViewAccessPolicies(w io.Writer, projectID, datasetID, resourceID string) error {
	// Resource can be a table or a view
	//
	// TODO(developer): uncomment and update the following lines:
	// projectID := "my-project-id"
	// datasetID := "my-dataset-id"
	// resourceID := "my-resource-id"

	ctx := context.Background()

	// Create new client.
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %w", err)
	}
	defer client.Close()

	// Get resource's policy access.
	policy, err := client.Dataset(datasetID).Table(resourceID).IAM().Policy(ctx)
	if err != nil {
		return fmt.Errorf("bigquery.Dataset.Table.IAM.Policy: %w", err)
	}

	fmt.Fprintf(w, "Details for Access entries in table or view %v.\n", resourceID)

	for _, role := range policy.Roles() {
		fmt.Fprintln(w)
		fmt.Fprintf(w, "Role: %s\n", role)
		fmt.Fprintf(w, "Entities: %v\n", policy.Members(role))
	}

	return nil
}

Per autenticarti in BigQuery, configura le credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per le librerie client.


import com.google.cloud.Policy;
import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.TableId;

public class GetTableOrViewAccessPolicy {

  public static void main(String[] args) {
    // TODO(developer): Replace these variables before running the sample.
    // Project, dataset and resource (table or view) from which to get the access policy.
    String projectId = "MY_PROJECT_ID";
    String datasetName = "MY_DATASET_NAME";
    String resourceName = "MY_RESOURCE_NAME";
    getTableOrViewAccessPolicy(projectId, datasetName, resourceName);
  }

  public static void getTableOrViewAccessPolicy(
      String projectId, String datasetName, String resourceName) {
    try {
      // Initialize client that will be used to send requests. This client only needs
      // to be created once, and can be reused for multiple requests.
      BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();

      // Create table identity given the projectId, the datasetName and the resourceName.
      TableId tableId = TableId.of(projectId, datasetName, resourceName);

      // Get the table IAM policy.
      Policy policy = bigquery.getIamPolicy(tableId);

      // Show policy details.
      // Find more information about the Policy Class here:
      // https://cloud.google.com/java/docs/reference/google-cloud-core/latest/com.google.cloud.Policy
      System.out.println(
          "IAM policy info of resource \"" + resourceName + "\" retrieved succesfully");
      System.out.println();
      System.out.println("IAM policy info: " + policy.toString());
    } catch (BigQueryException e) {
      System.out.println("IAM policy info not retrieved. \n" + e.toString());
    }
  }
}

Per autenticarti in BigQuery, configura le credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per le librerie client.

Recupero il criterio IAM per una tabella o una vista utilizzando la funzione Table#getIamPolicy(). I dettagli dei criteri di accesso sono disponibili nell'oggetto criterio restituito.


/**
 * TODO(developer): Update and un-comment below lines
 */
// const projectId = "YOUR_PROJECT_ID"
// const datasetId = "YOUR_DATASET_ID"
// const resourceName = "YOUR_RESOURCE_NAME";

const {BigQuery} = require('@google-cloud/bigquery');

// Instantiate a client.
const client = new BigQuery();

async function viewTableOrViewAccessPolicy() {
  const dataset = client.dataset(datasetId);
  const table = dataset.table(resourceName);

  // Get the IAM access policy for the table or view.
  const [policy] = await table.getIamPolicy();

  // Initialize bindings if they don't exist
  if (!policy.bindings) {
    policy.bindings = [];
  }

  // Show policy details.
  // Find more details for the Policy object here:
  // https://cloud.google.com/bigquery/docs/reference/rest/v2/Policy
  console.log(`Access Policy details for table or view '${resourceName}'.`);
  console.log(`Bindings: ${JSON.stringify(policy.bindings, null, 2)}`);
  console.log(`etag: ${policy.etag}`);
  console.log(`Version: ${policy.version}`);
}

Per autenticarti in BigQuery, configura le credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per le librerie client.

Chiama la funzione client.get_iam_policy() per ottenere il criterio di accesso per una tabella o una vista.

L'argomento full_resource_id deve essere una stringa nel formato project_id.dataset_id.table_id.

from google.cloud import bigquery

# TODO(developer): Update and uncomment the lines below.

# Google Cloud Platform project.
# project_id = "my_project_id"

# Dataset where the table or view is.
# dataset_id = "my_dataset_id"

# Table or view from which to get the access policy.
# resource_id = "my_table_id"

# Instantiate a client.
client = bigquery.Client()

# Get the full table or view id.
full_resource_id = f"{project_id}.{dataset_id}.{resource_id}"

# Get the IAM access policy for the table or view.
policy = client.get_iam_policy(full_resource_id)

# Show policy details.
# Find more details for the Policy object here:
# https://cloud.google.com/bigquery/docs/reference/rest/v2/Policy
print(f"Access Policy details for table or view '{resource_id}'.")
print(f"Bindings: {policy.bindings}")
print(f"etag: {policy.etag}")
print(f"Version: {policy.version}")

Concedere l'accesso a una risorsa

Le seguenti sezioni descrivono come concedere l'accesso a risorse diverse.

Concedere l'accesso a un set di dati

Puoi fornire l'accesso a un set di dati concedendo a un ruolo IAM l'autorizzazione di accesso al set di dati o concedendo l'accesso condizionale utilizzando una condizione IAM. Per ulteriori informazioni sulla concessione dell'accesso condizionale, consulta Controllare l'accesso con le condizioni IAM.

Per concedere a un ruolo IAM l'accesso a un set di dati senza condizioni, seleziona una delle seguenti opzioni:

Console SQL bq Terraform API Vai Java Node.js Python

Vai alla pagina BigQuery.

Vai a BigQuery
Nel riquadro Explorer, espandi il progetto e seleziona un set di dati da condividere.
Fai clic su Condivisione > Autorizzazioni.
Fai clic su Aggiungi entità.
Nel campo Nuovi principali, inserisci un principale.
Nell'elenco Seleziona un ruolo, seleziona un ruolo predefinito o un ruolo personalizzato.
Fai clic su Salva.
Per tornare alle informazioni del set di dati, fai clic su Chiudi.

Per concedere ai principali l'accesso ai set di dati, utilizza l'istruzione DCL GRANT:

Nella console Google Cloud, vai alla pagina BigQuery Studio.

Vai a BigQuery Studio
Nell'editor di query, inserisci la seguente istruzione:
```
GRANT `ROLE_LIST`
ON SCHEMA RESOURCE_NAME
TO "USER_LIST"
```
Sostituisci quanto segue:
- ROLE_LIST: un ruolo o un elenco di ruoli separati da virgole che vuoi concedere
- RESOURCE_NAME: il nome della risorsa su cui vuoi concedere l'autorizzazione
- USER_LIST: un elenco separato da virgole di utenti a cui viene concesso il ruolo
  
  Per un elenco dei formati validi, consulta user_list.
Fai clic su Esegui.

Per ulteriori informazioni su come eseguire query, consulta Eseguire una query interattiva.

Nell'esempio seguente viene concesso il ruolo Visualizzatore dati al set di datimyDataset:

GRANT `roles/bigquery.dataViewer`
ON SCHEMA `myProject`.myDataset
TO "user:raha@example-pet-store.com", "user:sasha@example-pet-store.com"

In the Google Cloud console, activate Cloud Shell.

Activate Cloud Shell

At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.
Per scrivere le informazioni esistenti del set di dati (inclusi i controlli di accesso) in un file JSON, utilizza il comando bq show:
```
bq show \
   --format=prettyjson \
   PROJECT_ID:DATASET > PATH_TO_FILE
```
Sostituisci quanto segue:
- PROJECT_ID: il tuo ID progetto
- DATASET: il nome del set di dati
- PATH_TO_FILE: il percorso del file JSON sul computer locale

Apporta modifiche alla sezione access del file JSON. Puoi aggiungere a una delle voci specialGroup: projectOwners, projectWriters, projectReaders e allAuthenticatedUsers. Puoi anche aggiungere uno dei seguenti valori: userByEmail, groupByEmail e domain.

Ad esempio, la sezione access del file JSON di un set di dati sarà simile alla seguente:

{
 "access": [
  {
   "role": "READER",
   "specialGroup": "projectReaders"
  },
  {
   "role": "WRITER",
   "specialGroup": "projectWriters"
  },
  {
   "role": "OWNER",
   "specialGroup": "projectOwners"
  },
  {
   "role": "READER",
   "specialGroup": "allAuthenticatedUsers"
  },
  {
   "role": "READER",
   "domain": "domain_name"
  },
  {
   "role": "WRITER",
   "userByEmail": "user_email"
  },
  {
   "role": "READER",
   "groupByEmail": "group_email"
  }
 ],
 ...
}

Al termine delle modifiche, utilizza il comando bq update e includi il file JSON utilizzando il flag --source. Se il set di dati si trova in un progetto diverso da quello predefinito, aggiungi l'ID progetto al nome del set di dati nel seguente formato: PROJECT_ID:DATASET.

Attenzione: quando applichi il file JSON che contiene i controlli di accesso, quelli esistenti vengono sovrascritti.
```
bq update \
--source PATH_TO_FILE \
PROJECT_ID:DATASET
```
Per verificare le modifiche al controllo dell'accesso, utilizza di nuovo il comando bq show senza scrivere le informazioni in un file:
```
bq show --format=prettyjson PROJECT_ID:DATASET
```

Utilizza le risorse google_bigquery_dataset_iam per aggiornare l'accesso a un set di dati.

Impostare i criteri di accesso per un set di dati

L'esempio seguente mostra come utilizzare la risorsa google_bigquery_dataset_iam_policy per impostare il criterio IAM per il mydataset set di dati. Questo sostituisce qualsiasi criterio esistente già associato al set di dati:

# This file sets the IAM policy for the dataset created by
# https://github.com/terraform-google-modules/terraform-docs-samples/blob/main/bigquery/bigquery_create_dataset/main.tf.
# You must place it in the same local directory as that main.tf file,
# and you must have already applied that main.tf file to create
# the "default" dataset resource with a dataset_id of "mydataset".

data "google_iam_policy" "iam_policy" {
  binding {
    role = "roles/bigquery.admin"
    members = [
      "user:hao@altostrat.com",
    ]
  }
  binding {
    role = "roles/bigquery.dataOwner"
    members = [
      "group:dba@altostrat.com",
    ]
  }
  binding {
    role = "roles/bigquery.dataEditor"
    members = [
      "serviceAccount:bqcx-1234567891011-12a3@gcp-sa-bigquery-condel.iam.gserviceaccount.com",
    ]
  }
}

resource "google_bigquery_dataset_iam_policy" "dataset_iam_policy" {
  dataset_id  = google_bigquery_dataset.default.dataset_id
  policy_data = data.google_iam_policy.iam_policy.policy_data
}

Impostare l'appartenenza a un ruolo per un set di dati

L'esempio seguente mostra come utilizzare la risorsa google_bigquery_dataset_iam_binding per impostare l'appartenenza a un determinato ruolo per il mydataset set di dati. Verrà sostituito qualsiasi appartenenza esistente a quel ruolo. Gli altri ruoli all'interno del criterio IAM per il set di dati vengono conservati:

# This file sets membership in an IAM role for the dataset created by
# https://github.com/terraform-google-modules/terraform-docs-samples/blob/main/bigquery/bigquery_create_dataset/main.tf.
# You must place it in the same local directory as that main.tf file,
# and you must have already applied that main.tf file to create
# the "default" dataset resource with a dataset_id of "mydataset".

resource "google_bigquery_dataset_iam_binding" "dataset_iam_binding" {
  dataset_id = google_bigquery_dataset.default.dataset_id
  role       = "roles/bigquery.jobUser"

  members = [
    "user:raha@altostrat.com",
    "group:analysts@altostrat.com"
  ]
}

Impostare l'appartenenza a un ruolo per un'entità

L'esempio seguente mostra come utilizzare la risorsa google_bigquery_dataset_iam_member per aggiornare il criterio IAM per il set di dati mydataset in modo da concedere un ruolo a un'entità. L'aggiornamento di questo criterio IAM non influisce sull'accesso di altre entità a cui è stato concesso questo ruolo per il set di dati.

# This file adds a member to an IAM role for the dataset created by
# https://github.com/terraform-google-modules/terraform-docs-samples/blob/main/bigquery/bigquery_create_dataset/main.tf.
# You must place it in the same local directory as that main.tf file,
# and you must have already applied that main.tf file to create
# the "default" dataset resource with a dataset_id of "mydataset".

resource "google_bigquery_dataset_iam_member" "dataset_iam_member" {
  dataset_id = google_bigquery_dataset.default.dataset_id
  role       = "roles/bigquery.user"
  member     = "user:yuri@altostrat.com"
}

Per applicare la configurazione Terraform in un progetto Google Cloud, completa i passaggi nelle seguenti sezioni.

Prepara Cloud Shell

Avvia Cloud Shell.
Imposta il progetto Google Cloud predefinito in cui vuoi applicare le configurazioni Terraform.

Devi eseguire questo comando una sola volta per progetto e puoi farlo in qualsiasi directory.
```
export GOOGLE_CLOUD_PROJECT=PROJECT_ID
```
Le variabili di ambiente vengono sostituite se imposti valori espliciti nel file di configurazione Terraform.

Prepara la directory

Ogni file di configurazione di Terraform deve avere una propria directory (chiamata anche modulo principale).

In Cloud Shell, crea una directory e un nuovo file al suo interno. Il nome file deve avere l'estensione .tf, ad esempio main.tf. In questo tutorial, il file è denominato main.tf.
```
mkdir DIRECTORY && cd DIRECTORY && touch main.tf
```
Se stai seguendo un tutorial, puoi copiare il codice di esempio in ogni sezione o passaggio.

Copia il codice di esempio nel main.tf appena creato.

Se vuoi, copia il codice da GitHub. Questa opzione è consigliata quando lo snippet Terraform fa parte di una soluzione end-to-end.
Rivedi e modifica i parametri di esempio da applicare al tuo ambiente.
Salva le modifiche.
Inizializza Terraform. Devi eseguire questa operazione una sola volta per directory.
```
terraform init
```
Se vuoi, per utilizzare la versione più recente del provider Google, includi l'opzione -upgrade:
```
terraform init -upgrade
```

Applica le modifiche

Rivedi la configurazione e verifica che le risorse che Terraform sta per creare o aggiornare corrispondano alle tue aspettative:
```
terraform plan
```
Apporta le correzioni necessarie alla configurazione.
Applica la configurazione di Terraform eseguendo il seguente comando e inserendo yes al prompt:
```
terraform apply
```
Attendi che Terraform mostri il messaggio "Applicazione completata".
Apri il tuo progetto Google Cloud per visualizzare i risultati. Nella console Google Cloud, vai alle risorse nell'interfaccia utente per assicurarti che Terraform le abbia create o aggiornate.

Per applicare i controlli di accesso al momento della creazione del set di dati, chiama il metodo datasets.insert con una risorsa set di dati definita. Per aggiornare i controlli di accesso, chiama il metodo datasets.patch e utilizza la proprietà access nella risorsa Dataset.

Poiché il metodo datasets.update sostituisce l'intera risorsa del set di dati, datasets.patch è il metodo preferito per aggiornare i controlli di accesso.

Per autenticarti in BigQuery, configura le credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per le librerie client.

Imposta il nuovo elenco di accesso aggiungendo la nuova voce all'elenco esistente con tipo DatasetMetadataToUpdate. Quindi, chiama la funzione dataset.Update() per aggiornare la proprietà.

import (
	"context"
	"fmt"
	"io"

	"cloud.google.com/go/bigquery"
)

// grantAccessToDataset creates a new ACL conceding the READER role to the group "example-analyst-group@google.com"
// For more information on the types of ACLs available see:
// https://cloud.google.com/storage/docs/access-control/lists
func grantAccessToDataset(w io.Writer, projectID, datasetID string) error {
	// TODO(developer): uncomment and update the following lines:
	// projectID := "my-project-id"
	// datasetID := "mydataset"

	ctx := context.Background()

	// Create BigQuery handler.
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %w", err)
	}
	defer client.Close()

	// Create dataset handler
	dataset := client.Dataset(datasetID)

	// Get metadata
	meta, err := dataset.Metadata(ctx)
	if err != nil {
		return fmt.Errorf("bigquery.Dataset.Metadata: %w", err)
	}

	// Find more details about BigQuery Entity Types here:
	// https://pkg.go.dev/cloud.google.com/go/bigquery#EntityType
	//
	// Find more details about BigQuery Access Roles here:
	// https://pkg.go.dev/cloud.google.com/go/bigquery#AccessRole

	entityType := bigquery.GroupEmailEntity
	entityID := "example-analyst-group@google.com"
	roleType := bigquery.ReaderRole

	// Append a new access control entry to the existing access list.
	update := bigquery.DatasetMetadataToUpdate{
		Access: append(meta.Access, &bigquery.AccessEntry{
			Role:       roleType,
			EntityType: entityType,
			Entity:     entityID,
		}),
	}

	// Leverage the ETag for the update to assert there's been no modifications to the
	// dataset since the metadata was originally read.
	meta, err = dataset.Update(ctx, update, meta.ETag)
	if err != nil {
		return err
	}

	fmt.Fprintf(w, "Details for Access entries in dataset %v.\n", datasetID)
	for _, access := range meta.Access {
		fmt.Fprintln(w)
		fmt.Fprintf(w, "Role: %s\n", access.Role)
		fmt.Fprintf(w, "Entities: %v\n", access.Entity)
	}

	return nil
}

Per autenticarti in BigQuery, configura le credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per le librerie client.

import com.google.cloud.bigquery.Acl;
import com.google.cloud.bigquery.Acl.Entity;
import com.google.cloud.bigquery.Acl.Group;
import com.google.cloud.bigquery.Acl.Role;
import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.Dataset;
import com.google.cloud.bigquery.DatasetId;
import java.util.ArrayList;
import java.util.List;

public class GrantAccessToDataset {

  public static void main(String[] args) {
    // TODO(developer): Replace these variables before running the sample.
    // Project and dataset from which to get the access policy
    String projectId = "MY_PROJECT_ID";
    String datasetName = "MY_DATASET_NAME";
    // Group to add to the ACL
    String entityEmail = "group-to-add@example.com";

    grantAccessToDataset(projectId, datasetName, entityEmail);
  }

  public static void grantAccessToDataset(
      String projectId, String datasetName, String entityEmail) {
    try {
      // Initialize client that will be used to send requests. This client only needs to be created
      // once, and can be reused for multiple requests.
      BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();

      // Create datasetId with the projectId and the datasetName.
      DatasetId datasetId = DatasetId.of(projectId, datasetName);
      Dataset dataset = bigquery.getDataset(datasetId);

      // Create a new Entity with the corresponding type and email
      // "user-or-group-to-add@example.com"
      // For more information on the types of Entities available see:
      // https://cloud.google.com/java/docs/reference/google-cloud-bigquery/latest/com.google.cloud.bigquery.Acl.Entity
      // and
      // https://cloud.google.com/java/docs/reference/google-cloud-bigquery/latest/com.google.cloud.bigquery.Acl.Entity.Type
      Entity entity = new Group(entityEmail);

      // Create a new ACL granting the READER role to the group with the entity email
      // "user-or-group-to-add@example.com"
      // For more information on the types of ACLs available see:
      // https://cloud.google.com/storage/docs/access-control/lists
      Acl newEntry = Acl.of(entity, Role.READER);

      // Get a copy of the ACLs list from the dataset and append the new entry.
      List<Acl> acls = new ArrayList<>(dataset.getAcl());
      acls.add(newEntry);

      // Update the ACLs by setting the new list.
      Dataset updatedDataset = bigquery.update(dataset.toBuilder().setAcl(acls).build());
      System.out.println(
          "ACLs of dataset \""
              + updatedDataset.getDatasetId().getDataset()
              + "\" updated successfully");
    } catch (BigQueryException e) {
      System.out.println("ACLs were not updated \n" + e.toString());
    }
  }
}

Per autenticarti in BigQuery, configura le credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per le librerie client.

Imposta il nuovo elenco di accesso aggiungendo la nuova voce all'elenco esistente utilizzando il metodo Dataset#metadata. Quindi, chiama la funzione Dataset#setMetadata() per aggiornare la proprietà.


/**
 * TODO(developer): Update and un-comment below lines.
 */

// const datasetId = "my_project_id.my_dataset_name";

// ID of the user or group from whom you are adding access.
// const entityId = "user-or-group-to-add@example.com";

// One of the "Basic roles for datasets" described here:
// https://cloud.google.com/bigquery/docs/access-control-basic-roles#dataset-basic-roles
// const role = "READER";

const {BigQuery} = require('@google-cloud/bigquery');

// Instantiate a client.
const client = new BigQuery();

// Type of entity you are granting access to.
// Find allowed allowed entity type names here:
// https://cloud.google.com/bigquery/docs/reference/rest/v2/datasets#resource:-dataset
const entityType = 'groupByEmail';

async function grantAccessToDataset() {
  const [dataset] = await client.dataset(datasetId).get();

  // The 'access entries' array is immutable. Create a copy for modifications.
  const entries = [...dataset.metadata.access];

  // Append an AccessEntry to grant the role to a dataset.
  // Find more details about the AccessEntry object in the BigQuery documentation:
  // https://cloud.google.com/python/docs/reference/bigquery/latest/google.cloud.bigquery.dataset.AccessEntry
  entries.push({
    role,
    [entityType]: entityId,
  });

  // Assign the array of AccessEntries back to the dataset.
  const metadata = {
    access: entries,
  };

  // Update will only succeed if the dataset
  // has not been modified externally since retrieval.
  //
  // See the BigQuery client library documentation for more details on metadata updates:
  // https://cloud.google.com/nodejs/docs/reference/bigquery/latest

  // Update just the 'access entries' property of the dataset.
  await client.dataset(datasetId).setMetadata(metadata);

  console.log(
    `Role '${role}' granted for entity '${entityId}' in '${datasetId}'.`
  );
}

Per autenticarti in BigQuery, configura le credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per le librerie client.

Imposta la proprietà dataset.access_entries con i controlli di accesso per un set di dati. Quindi, chiama la funzione client.update_dataset() per aggiornare la proprietà.

from google.api_core.exceptions import PreconditionFailed
from google.cloud import bigquery
from google.cloud.bigquery.enums import EntityTypes

# TODO(developer): Update and uncomment the lines below.

# ID of the dataset to grant access to.
# dataset_id = "my_project_id.my_dataset"

# ID of the user or group receiving access to the dataset.
# Alternatively, the JSON REST API representation of the entity,
# such as the view's table reference.
# entity_id = "user-or-group-to-add@example.com"

# One of the "Basic roles for datasets" described here:
# https://cloud.google.com/bigquery/docs/access-control-basic-roles#dataset-basic-roles
# role = "READER"

# Type of entity you are granting access to.
# Find allowed allowed entity type names here:
# https://cloud.google.com/python/docs/reference/bigquery/latest/enums#class-googlecloudbigqueryenumsentitytypesvalue
entity_type = EntityTypes.GROUP_BY_EMAIL

# Instantiate a client.
client = bigquery.Client()

# Get a reference to the dataset.
dataset = client.get_dataset(dataset_id)

# The `access_entries` list is immutable. Create a copy for modifications.
entries = list(dataset.access_entries)

# Append an AccessEntry to grant the role to a dataset.
# Find more details about the AccessEntry object here:
# https://cloud.google.com/python/docs/reference/bigquery/latest/google.cloud.bigquery.dataset.AccessEntry
entries.append(
    bigquery.AccessEntry(
        role=role,
        entity_type=entity_type,
        entity_id=entity_id,
    )
)

# Assign the list of AccessEntries back to the dataset.
dataset.access_entries = entries

# Update will only succeed if the dataset
# has not been modified externally since retrieval.
#
# See the BigQuery client library documentation for more details on `update_dataset`:
# https://cloud.google.com/python/docs/reference/bigquery/latest/google.cloud.bigquery.client.Client#google_cloud_bigquery_client_Client_update_dataset
try:
    # Update just the `access_entries` property of the dataset.
    dataset = client.update_dataset(
        dataset,
        ["access_entries"],
    )

    # Show a success message.
    full_dataset_id = f"{dataset.project}.{dataset.dataset_id}"
    print(
        f"Role '{role}' granted for entity '{entity_id}'"
        f" in dataset '{full_dataset_id}'."
    )
except PreconditionFailed:  # A read-modify-write error
    print(
        f"Dataset '{dataset.dataset_id}' was modified remotely before this update. "
        "Fetch the latest version and retry."
    )

Concedere l'accesso a una tabella o una vista

Seleziona una delle seguenti opzioni:

Console SQL bq Terraform API Vai Java Node.js Python

Vai alla pagina BigQuery.

Vai a BigQuery
Nel riquadro Explorer, espandi il progetto e seleziona una tabella o una vista da condividere.
Fai clic su Condividi.
Fai clic su Aggiungi entità.
Nel campo Nuovi principali, inserisci un principale.
Nell'elenco Seleziona un ruolo, seleziona un ruolo predefinito o un ruolo personalizzato.
Fai clic su Salva.
Per tornare alla tabella o visualizzare i dettagli, fai clic su Chiudi.

Per concedere ai principali l'accesso a tabelle o viste, utilizza GRANT l'istruzione DCL:

Nella console Google Cloud, vai alla pagina BigQuery Studio.

Vai a BigQuery Studio
Nell'editor di query, inserisci la seguente istruzione:
```
GRANT `ROLE_LIST`
ON RESOURCE_TYPE RESOURCE_NAME
TO "USER_LIST"
```
Sostituisci quanto segue:
- ROLE_LIST: un ruolo o un elenco di ruoli separati da virgole che vuoi concedere
- RESOURCE_TYPE: il tipo di risorsa a cui viene applicato il ruolo
  
  I valori supportati includono TABLE, VIEW, MATERIALIZED VIEW e EXTERNAL TABLE.
- RESOURCE_NAME: il nome della risorsa su cui vuoi concedere l'autorizzazione
- USER_LIST: un elenco separato da virgole di utenti a cui viene concesso il ruolo
  
  Per un elenco dei formati validi, consulta user_list.
Fai clic su Esegui.

Per ulteriori informazioni su come eseguire query, consulta Eseguire una query interattiva.

L'esempio seguente concede il ruolo Visualizzatore dati alla tabellamyTable:

GRANT `roles/bigquery.dataViewer`
ON TABLE `myProject`.myDataset.myTable
TO "user:raha@example-pet-store.com", "user:sasha@example-pet-store.com"

In the Google Cloud console, activate Cloud Shell.

Activate Cloud Shell

At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.
Per concedere l'accesso a una tabella o una vista, utilizza il comando bq add-iam-policy-binding:
```
bq add-iam-policy-binding --member=MEMBER_TYPE:MEMBER --role=ROLE
 --table=true RESOURCE
```
Sostituisci quanto segue:
- MEMBER_TYPE: il tipo di membro, ad esempio user, group, serviceAccount o domain.
- MEMBER: l'indirizzo email o il nome di dominio del membro.
- ROLE: il ruolo che vuoi assegnare al membro.
- RESOURCE: il nome della tabella o della vista di cui vuoi aggiornare il criterio.

Utilizza le risorse google_bigquery_table_iam per aggiornare l'accesso a una tabella.

Impostare il criterio di accesso per una tabella

L'esempio seguente mostra come utilizzare la risorsa google_bigquery_table_iam_policy per impostare il criterio IAM per la tabellamytable. Questo sostituisce qualsiasi criterio esistente già associato alla tabella:

# This file sets the IAM policy for the table created by
# https://github.com/terraform-google-modules/terraform-docs-samples/blob/main/bigquery/bigquery_create_table/main.tf.
# You must place it in the same local directory as that main.tf file,
# and you must have already applied that main.tf file to create
# the "default" table resource with a table_id of "mytable".

data "google_iam_policy" "iam_policy" {
  binding {
    role = "roles/bigquery.dataOwner"
    members = [
      "user:raha@altostrat.com",
    ]
  }
}

resource "google_bigquery_table_iam_policy" "table_iam_policy" {
  dataset_id  = google_bigquery_table.default.dataset_id
  table_id    = google_bigquery_table.default.table_id
  policy_data = data.google_iam_policy.iam_policy.policy_data
}

Impostare l'appartenenza ai ruoli per una tabella

L'esempio seguente mostra come utilizzare la risorsa google_bigquery_table_iam_binding per impostare l'appartenenza a un determinato ruolo per la tabella mytable. Verrà sostituito qualsiasi appartenenza esistente a quel ruolo. Gli altri ruoli all'interno del criterio IAM per la tabella vengono conservati.

# This file sets membership in an IAM role for the table created by
# https://github.com/terraform-google-modules/terraform-docs-samples/blob/main/bigquery/bigquery_create_table/main.tf.
# You must place it in the same local directory as that main.tf file,
# and you must have already applied that main.tf file to create
# the "default" table resource with a table_id of "mytable".

resource "google_bigquery_table_iam_binding" "table_iam_binding" {
  dataset_id = google_bigquery_table.default.dataset_id
  table_id   = google_bigquery_table.default.table_id
  role       = "roles/bigquery.dataOwner"

  members = [
    "group:analysts@altostrat.com",
  ]
}

Impostare l'appartenenza a un ruolo per un'entità

L'esempio seguente mostra come utilizzare la risorsa google_bigquery_table_iam_member per aggiornare il criterio IAM per la tabella mytable in modo da concedere un ruolo a un'entità. L'aggiornamento di questo criterio IAM non influisce sull'accesso di altre entità a cui è stato concesso questo ruolo per il set di dati.

# This file adds a member to an IAM role for the table created by
# https://github.com/terraform-google-modules/terraform-docs-samples/blob/main/bigquery/bigquery_create_table/main.tf.
# You must place it in the same local directory as that main.tf file,
# and you must have already applied that main.tf file to create
# the "default" table resource with a table_id of "mytable".

resource "google_bigquery_table_iam_member" "table_iam_member" {
  dataset_id = google_bigquery_table.default.dataset_id
  table_id   = google_bigquery_table.default.table_id
  role       = "roles/bigquery.dataEditor"
  member     = "serviceAccount:bqcx-1234567891011-12a3@gcp-sa-bigquery-condel.iam.gserviceaccount.com"
}

Per applicare la configurazione Terraform in un progetto Google Cloud, completa i passaggi nelle seguenti sezioni.

Prepara Cloud Shell

Avvia Cloud Shell.
Imposta il progetto Google Cloud predefinito in cui vuoi applicare le configurazioni Terraform.

Devi eseguire questo comando una sola volta per progetto e puoi farlo in qualsiasi directory.
```
export GOOGLE_CLOUD_PROJECT=PROJECT_ID
```
Le variabili di ambiente vengono sostituite se imposti valori espliciti nel file di configurazione Terraform.

Prepara la directory

Ogni file di configurazione di Terraform deve avere una propria directory (chiamata anche modulo principale).

In Cloud Shell, crea una directory e un nuovo file al suo interno. Il nome file deve avere l'estensione .tf, ad esempio main.tf. In questo tutorial, il file è denominato main.tf.
```
mkdir DIRECTORY && cd DIRECTORY && touch main.tf
```
Se stai seguendo un tutorial, puoi copiare il codice di esempio in ogni sezione o passaggio.

Copia il codice di esempio nel main.tf appena creato.

Se vuoi, copia il codice da GitHub. Questa opzione è consigliata quando lo snippet Terraform fa parte di una soluzione end-to-end.
Rivedi e modifica i parametri di esempio da applicare al tuo ambiente.
Salva le modifiche.
Inizializza Terraform. Devi eseguire questa operazione una sola volta per directory.
```
terraform init
```
Se vuoi, per utilizzare la versione più recente del provider Google, includi l'opzione -upgrade:
```
terraform init -upgrade
```

Applica le modifiche

Rivedi la configurazione e verifica che le risorse che Terraform sta per creare o aggiornare corrispondano alle tue aspettative:
```
terraform plan
```
Apporta le correzioni necessarie alla configurazione.
Applica la configurazione di Terraform eseguendo il seguente comando e inserendo yes al prompt:
```
terraform apply
```
Attendi che Terraform mostri il messaggio "Applicazione completata".
Apri il tuo progetto Google Cloud per visualizzare i risultati. Nella console Google Cloud, vai alle risorse nell'interfaccia utente per assicurarti che Terraform le abbia create o aggiornate.

Per recuperare il criterio corrente, chiama il metodo tables.getIamPolicy.
Modifica il criterio per aggiungere membri o associazioni o entrambi. Per il formato richiesto per le norme, consulta l'argomento di riferimento Norme.

Attenzione: quando imposti il criterio, recupera sempre il criterio corrente come primo passaggio per ottenere il valore corrente di etag. Il file del criterio aggiornato deve includere lo stesso valore per etag del criterio corrente che stai sostituendo, altrimenti l'aggiornamento non andrà a buon fine. Questa funzionalità impedisce gli aggiornamenti contemporaneamente.

Nel file delle norme, il valore di version rimane 1. Questo numero di versione si riferisce alla versione dello schema del criterio IAM, non alla versione del criterio. Il valore di etag è il numero di versione del criterio.
Chiama tables.setIamPolicy per scrivere il criterio aggiornato. Nota: le associazioni vuote senza membri non sono consentite e generano un errore.

Per autenticarti in BigQuery, configura le credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per le librerie client.

Chiama la funzioneIAM().SetPolicy() della risorsa per salvare le modifiche al criterio di accesso per una tabella o una vista.

import (
	"context"
	"fmt"
	"io"

	"cloud.google.com/go/bigquery"
	"cloud.google.com/go/iam"
)

// grantAccessToResource creates a new ACL conceding the VIEWER role to the group "example-analyst-group@google.com"
// For more information on the types of ACLs available see:
// https://cloud.google.com/storage/docs/access-control/lists
func grantAccessToResource(w io.Writer, projectID, datasetID, resourceID string) error {
	// Resource can be a table or a view
	//
	// TODO(developer): uncomment and update the following lines:
	// projectID := "my-project-id"
	// datasetID := "mydataset"
	// resourceID := "myresource"

	ctx := context.Background()

	// Create new client
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %w", err)
	}
	defer client.Close()

	// Get resource policy.
	policy, err := client.Dataset(datasetID).Table(resourceID).IAM().Policy(ctx)
	if err != nil {
		return fmt.Errorf("bigquery.Dataset.Table.IAM.Policy: %w", err)
	}

	// Find more details about IAM Roles here:
	// https://pkg.go.dev/cloud.google.com/go/iam#RoleName
	entityID := "example-analyst-group@google.com"
	roleType := iam.Viewer

	// Add new policy.
	policy.Add(fmt.Sprintf("group:%s", entityID), roleType)

	// Update resource's policy.
	err = client.Dataset(datasetID).Table(resourceID).IAM().SetPolicy(ctx, policy)
	if err != nil {
		return fmt.Errorf("bigquery.Dataset.Table.IAM.Policy: %w", err)
	}

	// Get resource policy again expecting the update.
	policy, err = client.Dataset(datasetID).Table(resourceID).IAM().Policy(ctx)
	if err != nil {
		return fmt.Errorf("bigquery.Dataset.Table.IAM.Policy: %w", err)
	}

	fmt.Fprintf(w, "Details for Access entries in table or view %v.\n", resourceID)

	for _, role := range policy.Roles() {
		fmt.Fprintln(w)
		fmt.Fprintf(w, "Role: %s\n", role)
		fmt.Fprintf(w, "Entities: %v\n", policy.Members(role))
	}

	return nil
}

Per autenticarti in BigQuery, configura le credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per le librerie client.

import com.google.cloud.Identity;
import com.google.cloud.Policy;
import com.google.cloud.Role;
import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.TableId;

public class GrantAccessToTableOrView {

  public static void main(String[] args) {
    // TODO(developer): Replace these variables before running the sample.
    // Project, dataset and resource (table or view) from which to get the access policy.
    String projectId = "MY_PROJECT_ID";
    String datasetName = "MY_DATASET_NAME";
    String resourceName = "MY_TABLE_NAME";
    // Role to add to the policy access
    Role role = Role.of("roles/bigquery.dataViewer");
    // Identity to add to the policy access
    Identity identity = Identity.user("user-add@example.com");
    grantAccessToTableOrView(projectId, datasetName, resourceName, role, identity);
  }

  public static void grantAccessToTableOrView(
      String projectId, String datasetName, String resourceName, Role role, Identity identity) {
    try {
      // Initialize client that will be used to send requests. This client only needs
      // to be created once, and can be reused for multiple requests.
      BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();

      // Create table identity given the projectId, the datasetName and the resourceName.
      TableId tableId = TableId.of(projectId, datasetName, resourceName);

      // Add new user identity to current IAM policy.
      Policy policy = bigquery.getIamPolicy(tableId);
      policy = policy.toBuilder().addIdentity(role, identity).build();

      // Update the IAM policy by setting the new one.
      bigquery.setIamPolicy(tableId, policy);

      System.out.println("IAM policy of resource \"" + resourceName + "\" updated successfully");
    } catch (BigQueryException e) {
      System.out.println("IAM policy was not updated. \n" + e.toString());
    }
  }
}

Per autenticarti in BigQuery, configura le credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per le librerie client.

Chiama la funzione Table#getIamPolicy() per recuperare il criterio IAM corrente per una tabella o una vista, modifica il criterio aggiungendo nuove associazioni e poi utilizza la funzione Table#setIamPolicy() per salvare le modifiche al criterio di accesso.


/**
 * TODO(developer): Update and un-comment below lines
 */
// const projectId = "YOUR_PROJECT_ID";
// const datasetId = "YOUR_DATASET_ID";
// const tableId = "YOUR_TABLE_ID";
// const principalId = "YOUR_PRINCIPAL_ID";
// const role = "YOUR_ROLE";

const {BigQuery} = require('@google-cloud/bigquery');

// Instantiate a client.
const client = new BigQuery();

async function grantAccessToTableOrView() {
  const dataset = client.dataset(datasetId);
  const table = dataset.table(tableId);

  // Get the IAM access policy for the table or view.
  const [policy] = await table.getIamPolicy();

  // Initialize bindings array.
  if (!policy.bindings) {
    policy.bindings = [];
  }

  // To grant access to a table or view
  // add bindings to the Table or View policy.
  //
  // Find more details about Policy and Binding objects here:
  // https://cloud.google.com/security-command-center/docs/reference/rest/Shared.Types/Policy
  // https://cloud.google.com/security-command-center/docs/reference/rest/Shared.Types/Binding
  const binding = {
    role,
    members: [principalId],
  };
  policy.bindings.push(binding);

  // Set the IAM access policy with updated bindings.
  await table.setIamPolicy(policy);

  // Show a success message.
  console.log(
    `Role '${role}' granted for principal '${principalId}' on resource '${datasetId}.${tableId}'.`
  );
}

await grantAccessToTableOrView();

Per autenticarti in BigQuery, configura le credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per le librerie client.

Chiama la funzione client.set_iam_policy() per salvare le modifiche al criterio di accesso per una tabella o una vista.

from google.cloud import bigquery

# TODO(developer): Update and uncomment the lines below.

# Google Cloud Platform project.
# project_id = "my_project_id"

# Dataset where the table or view is.
# dataset_id = "my_dataset"

# Table or view name to get the access policy.
# resource_name = "my_table"

# Principal to grant access to a table or view.
# For more information about principal identifiers see:
# https://cloud.google.com/iam/docs/principal-identifiers
# principal_id = "user:bob@example.com"

# Role to grant to the principal.
# For more information about BigQuery roles see:
# https://cloud.google.com/bigquery/docs/access-control
# role = "roles/bigquery.dataViewer"

# Instantiate a client.
client = bigquery.Client()

# Get the full table or view name.
full_resource_name = f"{project_id}.{dataset_id}.{resource_name}"

# Get the IAM access policy for the table or view.
policy = client.get_iam_policy(full_resource_name)

# To grant access to a table or view, add bindings to the IAM policy.
#
# Find more details about Policy and Binding objects here:
# https://cloud.google.com/security-command-center/docs/reference/rest/Shared.Types/Policy
# https://cloud.google.com/security-command-center/docs/reference/rest/Shared.Types/Binding
binding = {
    "role": role,
    "members": [principal_id, ],
}
policy.bindings.append(binding)

# Set the IAM access policy with updated bindings.
updated_policy = client.set_iam_policy(full_resource_name, policy)

# Show a success message.
print(
    f"Role '{role}' granted for principal '{principal_id}'"
    f" on resource '{full_resource_name}'."
)

Revocare l'accesso a una risorsa

Le seguenti sezioni descrivono come revocare l'accesso a diverse risorse.

Revocare l'accesso a un set di dati

Seleziona una delle seguenti opzioni:

Console SQL bq API Vai Java Node.js Python

Vai alla pagina BigQuery.

Vai a BigQuery
Nel riquadro Spazio di esplorazione, espandi il progetto e seleziona un set di dati.
Nel riquadro dei dettagli, fai clic su Condivisione > Autorizzazioni.
Nella finestra di dialogo Autorizzazioni set di dati, espandi l'entità di cui vuoi revocare l'accesso.
Fai clic su Rimuovi proprietario.
Nella finestra di dialogo Vuoi rimuovere il ruolo dall'entità?, fai clic su Rimuovi.
Per tornare ai dettagli del set di dati, fai clic su Chiudi.

Per rimuovere l'accesso ai set di dati dai principali, utilizza l'istruzione DCL REVOKE:

Nella console Google Cloud, vai alla pagina BigQuery Studio.

Vai a BigQuery Studio
Nell'editor di query, inserisci la seguente istruzione:
```
REVOKE `ROLE_LIST`
ON SCHEMA RESOURCE_NAME
FROM "USER_LIST"
```
Sostituisci quanto segue:
- ROLE_LIST: un ruolo o un elenco di ruoli separati da virgole che vuoi revocare
- RESOURCE_NAME: il nome della risorsa per la quale vuoi revocare l'autorizzazione
- USER_LIST: un elenco separato da virgole di utenti a cui verranno revocati i ruoli
  
  Per un elenco dei formati validi, consulta user_list.
Fai clic su Esegui.

Per ulteriori informazioni su come eseguire query, consulta Eseguire una query interattiva.

L'esempio seguente revoca il ruolo Amministratore nel set di dati myDataset:

REVOKE `roles/bigquery.admin`
ON SCHEMA `myProject`.myDataset
FROM "group:example-team@example-pet-store.com", "serviceAccount:user@test-project.iam.gserviceaccount.com"

In the Google Cloud console, activate Cloud Shell.

Activate Cloud Shell

At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.
Per scrivere le informazioni esistenti del set di dati (inclusi i controlli di accesso) in un file JSON, utilizza il comando bq show:
```
bq show \
  --format=prettyjson \
  PROJECT_ID:DATASET > PATH_TO_FILE
```
Sostituisci quanto segue:
- PROJECT_ID: il tuo ID progetto
- DATASET: il nome del set di dati
- PATH_TO_FILE: il percorso del file JSON sul computer locale

Apporta modifiche alla sezione access del file JSON. Puoi rimuovere una delle voci specialGroup: projectOwners, projectWriters, projectReaders e allAuthenticatedUsers. Puoi anche rimuovere uno dei seguenti elementi: userByEmail,groupByEmail e domain.

Ad esempio, la sezione access del file JSON di un set di dati sarà simile alla seguente:

{
 "access": [
  {
   "role": "READER",
   "specialGroup": "projectReaders"
  },
  {
   "role": "WRITER",
   "specialGroup": "projectWriters"
  },
  {
   "role": "OWNER",
   "specialGroup": "projectOwners"
  },
  {
   "role": "READER",
   "specialGroup": "allAuthenticatedUsers"
  },
  {
   "role": "READER",
   "domain": "domain_name"
  },
  {
   "role": "WRITER",
   "userByEmail": "user_email"
  },
  {
   "role": "READER",
   "groupByEmail": "group_email"
  }
 ],
 ...
}

Al termine delle modifiche, utilizza il comando bq update e includi il file JSON utilizzando il flag --source. Se il set di dati si trova in un progetto diverso da quello predefinito, aggiungi l'ID progetto al nome del set di dati nel seguente formato: PROJECT_ID:DATASET.

Attenzione: quando applichi il file JSON che contiene i controlli di accesso, quelli esistenti vengono sovrascritti.
```
bq update \
    --source PATH_TO_FILE \
    PROJECT_ID:DATASET
```
Per verificare le modifiche al controllo dell'accesso, utilizza di nuovo il comando show senza scrivere le informazioni in un file:
```
bq show --format=prettyjson PROJECT_ID:DATASET
```

Chiama datasets.patch e utilizza la proprietà access nella risorsa Dataset per aggiornare i controlli dell'accesso.

Poiché il metodo datasets.update sostituisce l'intera risorsa del set di dati, datasets.patch è il metodo preferito per aggiornare i controlli di accesso.

Per autenticarti in BigQuery, configura le credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per le librerie client.

Imposta il nuovo elenco di accesso rimuovendo la voce dall'elenco esistente con tipo DatasetMetadataToUpdate. Quindi, chiama la funzione dataset.Update() per aggiornare la proprietà.

import (
	"context"
	"fmt"
	"io"

	"cloud.google.com/go/bigquery"
)

// revokeAccessToDataset creates a new ACL removing the dataset access to "example-analyst-group@google.com" entity
// For more information on the types of ACLs available see:
// https://cloud.google.com/storage/docs/access-control/lists
func revokeAccessToDataset(w io.Writer, projectID, datasetID, entity string) error {
	// TODO(developer): uncomment and update the following lines:
	// projectID := "my-project-id"
	// datasetID := "mydataset"
	// entity := "user@mydomain.com"

	ctx := context.Background()

	// Create BigQuery client.
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %w", err)
	}
	defer client.Close()

	// Get dataset handler
	dataset := client.Dataset(datasetID)

	// Get dataset metadata
	meta, err := dataset.Metadata(ctx)
	if err != nil {
		return err
	}

	// Create new access entry list by copying the existing and omiting the access entry entity value
	var newAccessList []*bigquery.AccessEntry
	for _, entry := range meta.Access {
		if entry.Entity != entity {
			newAccessList = append(newAccessList, entry)
		}
	}

	// Only proceed with update if something in the access list was removed.
	// Additionally, we use the ETag from the initial metadata to ensure no
	// other changes were made to the access list in the interim.
	if len(newAccessList) < len(meta.Access) {
		update := bigquery.DatasetMetadataToUpdate{
			Access: newAccessList,
		}
		meta, err = dataset.Update(ctx, update, meta.ETag)
		if err != nil {
			return err
		}
	} else {
		return fmt.Errorf("any access entry was revoked")
	}

	fmt.Fprintf(w, "Details for Access entries in dataset %v.\n", datasetID)

	for _, access := range meta.Access {
		fmt.Fprintln(w)
		fmt.Fprintf(w, "Role: %s\n", access.Role)
		fmt.Fprintf(w, "Entity: %v\n", access.Entity)
	}

	return nil
}

Per autenticarti in BigQuery, configura le credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per le librerie client.


import com.google.cloud.bigquery.Acl;
import com.google.cloud.bigquery.Acl.Entity;
import com.google.cloud.bigquery.Acl.Group;
import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.Dataset;
import com.google.cloud.bigquery.DatasetId;
import java.util.List;

public class RevokeDatasetAccess {

  public static void main(String[] args) {
    // TODO(developer): Replace these variables before running the sample.
    // Project and dataset from which to get the access policy.
    String projectId = "MY_PROJECT_ID";
    String datasetName = "MY_DATASET_NAME";
    // Group to remove from the ACL
    String entityEmail = "group-to-remove@example.com";

    revokeDatasetAccess(projectId, datasetName, entityEmail);
  }

  public static void revokeDatasetAccess(String projectId, String datasetName, String entityEmail) {
    try {
      // Initialize client that will be used to send requests. This client only needs
      // to be created once, and can be reused for multiple requests.
      BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();

      // Create datasetId with the projectId and the datasetName.
      DatasetId datasetId = DatasetId.of(projectId, datasetName);
      Dataset dataset = bigquery.getDataset(datasetId);

      // Create a new Entity with the corresponding type and email
      // "user-or-group-to-remove@example.com"
      // For more information on the types of Entities available see:
      // https://cloud.google.com/java/docs/reference/google-cloud-bigquery/latest/com.google.cloud.bigquery.Acl.Entity
      // and
      // https://cloud.google.com/java/docs/reference/google-cloud-bigquery/latest/com.google.cloud.bigquery.Acl.Entity.Type
      Entity entity = new Group(entityEmail);

      // To revoke access to a dataset, remove elements from the Acl list.
      // Find more information about ACL and the Acl Class here:
      // https://cloud.google.com/storage/docs/access-control/lists
      // https://cloud.google.com/java/docs/reference/google-cloud-bigquery/latest/com.google.cloud.bigquery.Acl
      // Remove the entity from the ACLs list.
      List<Acl> acls =
          dataset.getAcl().stream().filter(acl -> !acl.getEntity().equals(entity)).toList();

      // Update the ACLs by setting the new list.
      bigquery.update(dataset.toBuilder().setAcl(acls).build());
      System.out.println("ACLs of \"" + datasetName + "\" updated successfully");
    } catch (BigQueryException e) {
      System.out.println("ACLs were not updated \n" + e.toString());
    }
  }
}

Per autenticarti in BigQuery, configura le credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per le librerie client.

Aggiorna l'elenco di accesso al set di dati rimuovendo la voce specificata dall'elenco esistente utilizzando il metodo Dataset#get() per recuperare i metadati correnti. Modifica la proprietà di accesso per escludere l'entità desiderata, quindi chiama la funzione Dataset#setMetadata() per applicare l'elenco di accesso aggiornato.


/**
 * TODO(developer): Update and un-comment below lines
 */

// const datasetId = "my_project_id.my_dataset"

// ID of the user or group from whom you are revoking access.
// const entityId = "user-or-group-to-remove@example.com"

const {BigQuery} = require('@google-cloud/bigquery');

// Instantiate a client.
const bigquery = new BigQuery();

async function revokeDatasetAccess() {
  const [dataset] = await bigquery.dataset(datasetId).get();

  // To revoke access to a dataset, remove elements from the access list.
  //
  // See the BigQuery client library documentation for more details on access entries:
  // https://cloud.google.com/nodejs/docs/reference/bigquery/latest

  // Filter access entries to exclude entries matching the specified entity_id
  // and assign a new list back to the access list.
  dataset.metadata.access = dataset.metadata.access.filter(entry => {
    return !(
      entry.entity_id === entityId ||
      entry.userByEmail === entityId ||
      entry.groupByEmail === entityId
    );
  });

  // Update will only succeed if the dataset
  // has not been modified externally since retrieval.
  //
  // See the BigQuery client library documentation for more details on metadata updates:
  // https://cloud.google.com/bigquery/docs/updating-datasets

  // Update just the 'access entries' property of the dataset.
  await dataset.setMetadata(dataset.metadata);

  console.log(`Revoked access to '${entityId}' from '${datasetId}'.`);
}

Per autenticarti in BigQuery, configura le credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per le librerie client.

Imposta la proprietà dataset.access_entries con i controlli di accesso per un set di dati. Quindi, chiama la funzione client.update_dataset() per aggiornare la proprietà.

from google.cloud import bigquery
from google.api_core.exceptions import PreconditionFailed

# TODO(developer): Update and uncomment the lines below.

# ID of the dataset to revoke access to.
# dataset_id = "my-project.my_dataset"

# ID of the user or group from whom you are revoking access.
# Alternatively, the JSON REST API representation of the entity,
# such as a view's table reference.
# entity_id = "user-or-group-to-remove@example.com"

# Instantiate a client.
client = bigquery.Client()

# Get a reference to the dataset.
dataset = client.get_dataset(dataset_id)

# To revoke access to a dataset, remove elements from the AccessEntry list.
#
# See the BigQuery client library documentation for more details on `access_entries`:
# https://cloud.google.com/python/docs/reference/bigquery/latest/google.cloud.bigquery.dataset.Dataset#google_cloud_bigquery_dataset_Dataset_access_entries

# Filter `access_entries` to exclude entries matching the specified entity_id
# and assign a new list back to the AccessEntry list.
dataset.access_entries = [
    entry for entry in dataset.access_entries
    if entry.entity_id != entity_id
]

# Update will only succeed if the dataset
# has not been modified externally since retrieval.
#
# See the BigQuery client library documentation for more details on `update_dataset`:
# https://cloud.google.com/python/docs/reference/bigquery/latest/google.cloud.bigquery.client.Client#google_cloud_bigquery_client_Client_update_dataset
try:
    # Update just the `access_entries` property of the dataset.
    dataset = client.update_dataset(
        dataset,
        ["access_entries"],
    )

    # Notify user that the API call was successful.
    full_dataset_id = f"{dataset.project}.{dataset.dataset_id}"
    print(f"Revoked dataset access for '{entity_id}' to ' dataset '{full_dataset_id}.'")
except PreconditionFailed:  # A read-modify-write error.
    print(
        f"Dataset '{dataset.dataset_id}' was modified remotely before this update. "
        "Fetch the latest version and retry."
    )

Revocare l'accesso a una tabella o una visualizzazione

Seleziona una delle seguenti opzioni:

Console SQL bq API Vai Java Node.js Python

Vai alla pagina BigQuery.

Vai a BigQuery
Nel riquadro Explorer, espandi il progetto e seleziona una tabella o una vista.
Nel riquadro dei dettagli, fai clic su Condividi.
Nella finestra di dialogo Condividi, espandi l'entità di cui vuoi revocare l'accesso.
Fai clic su Elimina.
Nella finestra di dialogo Vuoi rimuovere il ruolo dall'entità?, fai clic su Rimuovi.
Per tornare alla tabella o visualizzare i dettagli, fai clic su Chiudi.

Per rimuovere l'accesso a tabelle o viste dai principali, utilizza l'istruzione DCL REVOKE:

Nella console Google Cloud, vai alla pagina BigQuery Studio.

Vai a BigQuery Studio
Nell'editor di query, inserisci la seguente istruzione:
```
REVOKE `ROLE_LIST`
ON RESOURCE_TYPE RESOURCE_NAME
FROM "USER_LIST"
```
Sostituisci quanto segue:
- ROLE_LIST: un ruolo o un elenco di ruoli separati da virgole che vuoi revocare
- RESOURCE_TYPE: il tipo di risorsa da cui viene revocato il ruolo
  
  I valori supportati includono TABLE, VIEW, MATERIALIZED VIEW e EXTERNAL TABLE.
- RESOURCE_NAME: il nome della risorsa per la quale vuoi revocare l'autorizzazione
- USER_LIST: un elenco separato da virgole di utenti a cui verranno revocati i ruoli
  
  Per un elenco dei formati validi, consulta user_list.
Fai clic su Esegui.

Per ulteriori informazioni su come eseguire query, consulta Eseguire una query interattiva.

L'esempio seguente revoca il ruolo Amministratore per la tabella myTable:

REVOKE `roles/bigquery.admin`
ON TABLE `myProject`.myDataset.myTable
FROM "group:example-team@example-pet-store.com", "serviceAccount:user@test-project.iam.gserviceaccount.com"

In the Google Cloud console, activate Cloud Shell.

Activate Cloud Shell

At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.
Per revocare l'accesso a una tabella o una vista, utilizza il comando bq remove-iam-policy-binding:
```
bq remove-iam-policy-binding --member=MEMBER_TYPE:MEMBER --role=ROLE
 --table=true RESOURCE
```
Sostituisci quanto segue:
- MEMBER_TYPE: il tipo di membro, ad esempio user, group, serviceAccount o domain.
- MEMBER: l'indirizzo email o il nome di dominio del membro.
- ROLE: il ruolo che vuoi revocare al membro.
- RESOURCE: il nome della tabella o della vista di cui vuoi aggiornare il criterio.

Per recuperare il criterio corrente, chiama il metodo tables.getIamPolicy.
Modifica il criterio per rimuovere membri o associazioni o entrambi. Per il formato richiesto per le norme, consulta l'argomento di riferimento Norme.

Attenzione: quando imposti il criterio, recupera sempre il criterio corrente come primo passaggio per ottenere il valore corrente di etag. Il file del criterio aggiornato deve includere lo stesso valore per etag del criterio corrente che stai sostituendo, altrimenti l'aggiornamento non andrà a buon fine. Questa funzionalità impedisce gli aggiornamenti contemporaneamente.

Nel file delle norme, il valore di version rimane 1. Questo numero di versione si riferisce alla versione dello schema del criterio IAM, non alla versione del criterio. Il valore di etag è il numero di versione del criterio.
Chiama tables.setIamPolicy per scrivere il criterio aggiornato. Nota: le associazioni vuote senza membri non sono consentite e generano un errore.

Per autenticarti in BigQuery, configura le credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per le librerie client.

Chiama la funzione policy.Remove() per rimuovere l'accesso. Quindi, chiama la funzione IAM().SetPolicy() per salvare le modifiche al criterio di accesso per una tabella o una vista.

import (
	"context"
	"fmt"
	"io"

	"cloud.google.com/go/bigquery"
	"cloud.google.com/go/iam"
)

// revokeTableOrViewAccessPolicies creates a new ACL removing the VIEWER role to group "example-analyst-group@google.com"
// For more information on the types of ACLs available see:
// https://cloud.google.com/storage/docs/access-control/lists
func revokeTableOrViewAccessPolicies(w io.Writer, projectID, datasetID, resourceID string) error {
	// Resource can be a table or a view
	//
	// TODO(developer): uncomment and update the following lines:
	// projectID := "my-project-id"
	// datasetID := "mydataset"
	// resourceID := "myresource"

	ctx := context.Background()

	// Create new client
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %w", err)
	}
	defer client.Close()

	// Get resource policy.
	policy, err := client.Dataset(datasetID).Table(resourceID).IAM().Policy(ctx)
	if err != nil {
		return fmt.Errorf("bigquery.Dataset.Table.IAM.Policy: %w", err)
	}

	// Find more details about IAM Roles here:
	// https://pkg.go.dev/cloud.google.com/go/iam#RoleName
	entityID := "example-analyst-group@google.com"
	roleType := iam.Viewer

	// Revoke policy access.
	policy.Remove(fmt.Sprintf("group:%s", entityID), roleType)

	// Update resource's policy.
	err = client.Dataset(datasetID).Table(resourceID).IAM().SetPolicy(ctx, policy)
	if err != nil {
		return fmt.Errorf("bigquery.Dataset.Table.IAM.Policy: %w", err)
	}

	// Get resource policy again expecting the update.
	policy, err = client.Dataset(datasetID).Table(resourceID).IAM().Policy(ctx)
	if err != nil {
		return fmt.Errorf("bigquery.Dataset.Table.IAM.Policy: %w", err)
	}

	fmt.Fprintf(w, "Details for Access entries in table or view %v.\n", resourceID)

	for _, role := range policy.Roles() {
		fmt.Fprintln(w)
		fmt.Fprintf(w, "Role: %s\n", role)
		fmt.Fprintf(w, "Entities: %v\n", policy.Members(role))
	}

	return nil
}

Per autenticarti in BigQuery, configura le credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per le librerie client.

import com.google.cloud.Identity;
import com.google.cloud.Policy;
import com.google.cloud.Role;
import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.TableId;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

public class RevokeAccessToTableOrView {

  public static void main(String[] args) {
    // TODO(developer): Replace these variables before running the sample.
    // Project, dataset and resource (table or view) from which to get the access policy
    String projectId = "MY_PROJECT_ID";
    String datasetName = "MY_DATASET_NAME";
    String resourceName = "MY_RESOURCE_NAME";
    // Role to remove from the access policy
    Role role = Role.of("roles/bigquery.dataViewer");
    // Identity to remove from the access policy
    Identity user = Identity.user("user-add@example.com");
    revokeAccessToTableOrView(projectId, datasetName, resourceName, role, user);
  }

  public static void revokeAccessToTableOrView(
      String projectId, String datasetName, String resourceName, Role role, Identity identity) {
    try {
      // Initialize client that will be used to send requests. This client only needs
      // to be created once, and can be reused for multiple requests.
      BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();

      // Create table identity given the projectId, the datasetName and the resourceName.
      TableId tableId = TableId.of(projectId, datasetName, resourceName);

      // Remove either identities or roles, or both from bindings and replace it in
      // the current IAM policy.
      Policy policy = bigquery.getIamPolicy(tableId);
      // Create a copy of an immutable map.
      Map<Role, Set<Identity>> bindings = new HashMap<>(policy.getBindings());

      // Remove all identities with a specific role.
      bindings.remove(role);
      // Update bindings.
      policy = policy.toBuilder().setBindings(bindings).build();

      // Remove one identity in all the existing roles.
      for (Role roleKey : bindings.keySet()) {
        if (bindings.get(roleKey).contains(identity)) {
          // Create a copy of an immutable set if the identity is present in the role.
          Set<Identity> identities = new HashSet<>(bindings.get(roleKey));
          // Remove identity.
          identities.remove(identity);
          bindings.put(roleKey, identities);
          if (bindings.get(roleKey).isEmpty()) {
            // Remove the role if it has no identities.
            bindings.remove(roleKey);
          }
        }
      }
      // Update bindings.
      policy = policy.toBuilder().setBindings(bindings).build();

      // Update the IAM policy by setting the new one.
      bigquery.setIamPolicy(tableId, policy);

      System.out.println("IAM policy of resource \"" + resourceName + "\" updated successfully");
    } catch (BigQueryException e) {
      System.out.println("IAM policy was not updated. \n" + e.toString());
    }
  }
}

Per autenticarti in BigQuery, configura le credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per le librerie client.

Recupero il criterio IAM corrente per una tabella o una vista utilizzando il metodo Table#getIamPolicy(). Modifica il criterio per rimuovere il ruolo o l'entità desiderati, quindi applica il criterio aggiornato utilizzando il metodo Table#setIamPolicy().


/**
 * TODO(developer): Update and un-comment below lines
 */
// const projectId = "YOUR_PROJECT_ID"
// const datasetId = "YOUR_DATASET_ID"
// const tableId = "YOUR_TABLE_ID"
// const roleToRemove = "YOUR_ROLE"
// const principalToRemove = "YOUR_PRINCIPAL_ID"

const {BigQuery} = require('@google-cloud/bigquery');

// Instantiate a client.
const client = new BigQuery();

async function revokeAccessToTableOrView() {
  const dataset = client.dataset(datasetId);
  const table = dataset.table(tableId);

  // Get the IAM access policy for the table or view.
  const [policy] = await table.getIamPolicy();

  // Initialize bindings array.
  if (!policy.bindings) {
    policy.bindings = [];
  }

  // To revoke access to a table or view,
  // remove bindings from the Table or View policy.
  //
  // Find more details about Policy objects here:
  // https://cloud.google.com/security-command-center/docs/reference/rest/Shared.Types/Policy

  if (principalToRemove) {
    // Create a copy of bindings for modifications.
    const bindings = [...policy.bindings];

    // Filter out the principal from each binding.
    for (const binding of bindings) {
      if (binding.members) {
        binding.members = binding.members.filter(
          m => m !== principalToRemove
        );
      }
    }

    // Filter out bindings with empty members.
    policy.bindings = bindings.filter(
      binding => binding.members && binding.members.length > 0
    );
  }

  if (roleToRemove) {
    // Filter out all bindings with the roleToRemove
    // and assign a new list back to the policy bindings.
    policy.bindings = policy.bindings.filter(b => b.role !== roleToRemove);
  }

  // Set the IAM access policy with updated bindings.
  await table.setIamPolicy(policy);

  // Both role and principal are removed
  if (roleToRemove !== null && principalToRemove !== null) {
    console.log(
      `Role '${roleToRemove}' revoked for principal '${principalToRemove}' on resource '${datasetId}.${tableId}'.`
    );
  }

  // Only role is removed
  if (roleToRemove !== null && principalToRemove === null) {
    console.log(
      `Role '${roleToRemove}' revoked for all principals on resource '${datasetId}.${tableId}'.`
    );
  }

  // Only principal is removed
  if (roleToRemove === null && principalToRemove !== null) {
    console.log(
      `Access revoked for principal '${principalToRemove}' on resource '${datasetId}.${tableId}'.`
    );
  }

  // No changes were made
  if (roleToRemove === null && principalToRemove === null) {
    console.log(
      `No changes made to access policy for '${datasetId}.${tableId}'.`
    );
  }
}

Per autenticarti in BigQuery, configura le credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per le librerie client.

Chiama la funzione client.set_iam_policy() per salvare le modifiche al criterio di accesso per una tabella o una vista.

from google.cloud import bigquery

# TODO(developer): Update and uncomment the lines below.

# Google Cloud Platform project.
# project_id = "my_project_id"

# Dataset where the table or view is.
# dataset_id = "my_dataset"

# Table or view name to get the access policy.
# resource_name = "my_table"

# (Optional) Role to remove from the table or view.
# role_to_remove = "roles/bigquery.dataViewer"

# (Optional) Principal to revoke access to the table or view.
# principal_to_remove = "user:alice@example.com"

# Find more information about roles and principals (referred to as members) here:
# https://cloud.google.com/security-command-center/docs/reference/rest/Shared.Types/Binding

# Instantiate a client.
client = bigquery.Client()

# Get the full table name.
full_resource_name = f"{project_id}.{dataset_id}.{resource_name}"

# Get the IAM access policy for the table or view.
policy = client.get_iam_policy(full_resource_name)

# To revoke access to a table or view,
# remove bindings from the Table or View IAM policy.
#
# Find more details about the Policy object here:
# https://cloud.google.com/security-command-center/docs/reference/rest/Shared.Types/Policy

if role_to_remove:
    # Filter out all bindings with the `role_to_remove`
    # and assign a new list back to the policy bindings.
    policy.bindings = [b for b in policy.bindings if b["role"] != role_to_remove]

if principal_to_remove:
    # The `bindings` list is immutable. Create a copy for modifications.
    bindings = list(policy.bindings)

    # Filter out the principal for each binding.
    for binding in bindings:
        binding["members"] = [m for m in binding["members"] if m != principal_to_remove]

    # Assign back the modified binding list.
    policy.bindings = bindings

new_policy = client.set_iam_policy(full_resource_name, policy)

Rifiutare l'accesso a una risorsa

I criteri di rifiuto IAM ti consentono di impostare sistemi di protezione per gli accessi alle risorse BigQuery. Puoi definire regole di negazione che impediscono a determinate entità di utilizzare determinate autorizzazioni, indipendentemente dai ruoli loro concessi.

Per informazioni su come creare, aggiornare ed eliminare i criteri di rifiuto, consulta Negare l'accesso alle risorse.

Casi speciali

Considera i seguenti scenari quando crei criteri di rifiuto IAM su alcune autorizzazioni BigQuery:

L'accesso alle risorse autorizzate (visualizzazioni, routine, set di dati o procedure archiviate) ti consente di creare, eliminare o manipolare una tabella, nonché di leggere e modificare i dati della tabella, anche se non disponi dell'autorizzazione diretta per eseguire queste operazioni. Inoltre, può recuperare i dati o i metadati del modello e richiamare altre procedure memorizzate sulla tabella sottostante. Questa funzionalità implica che le risorse autorizzate dispongano delle seguenti autorizzazioni:

bigquery.tables.get
bigquery.tables.list
bigquery.tables.getData
bigquery.tables.updateData
bigquery.tables.create
bigquery.tables.delete
bigquery.routines.get
bigquery.routines.list
bigquery.datasets.get
bigquery.models.getData
bigquery.models.getMetadata

Per negare l'accesso a queste risorse autorizzate, aggiungi uno dei seguenti valori al campo deniedPrincipal quando crei il criterio di rifiuto:

Valore	Caso d'uso
`principalSet://goog/public:all`	Blocca tutti i principali, incluse le risorse autorizzate.
`principalSet://bigquery.googleapis.com/projects/PROJECT_NUMBER/*`	Blocca tutte le risorse BigQuery autorizzate nel progetto specificato. `PROJECT_NUMBER` è un identificatore univoco generato automaticamente per il tuo progetto di tipo `INT64`.

Per esentare determinate entità dal criterio di rifiuto, specificale nel campo exceptionPrincipals del criterio di rifiuto. Ad esempio: exceptionPrincipals: "principalSet://bigquery.googleapis.com/projects/1234/*".
BigQuery memorizza nella cache i risultati delle query di un proprietario del job per 24 ore, a cui il proprietario può accedere senza dover disporre dell'autorizzazione bigquery.tables.getData per la tabella contenente i dati. Di conseguenza, l'aggiunta di un criterio di negazione IAM all'autorizzazione bigquery.tables.getData non blocca l'accesso ai risultati memorizzati nella cache per il proprietario del job fino alla scadenza della cache. Per bloccare l'accesso del proprietario del job ai risultati memorizzati nella cache, crea una policy di rifiuto separata per l'autorizzazione bigquery.jobs.create.
Per impedire l'accesso non intenzionale ai dati quando utilizzi i criteri di rifiuto per bloccare le operazioni di lettura dei dati, ti consigliamo di esaminare e revocare anche eventuali iscrizioni esistenti al set di dati.
Per creare un criterio di rifiuto IAM per la visualizzazione dei controlli di accesso ai set di dati, rifiuta le seguenti autorizzazioni:
- bigquery.datasets.get
- bigquery.datasets.getIamPolicy
Per creare un criterio di rifiuto IAM per aggiornare i controlli dell'accesso ai set di dati, nega le seguenti autorizzazioni:
- bigquery.datasets.update
- bigquery.datasets.setIamPolicy

Controlla l'accesso alle risorse con IAM bookmark_borderbookmark Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Ruoli obbligatori

Autorizzazioni obbligatorie

Visualizzare il criterio di accesso di una risorsa

Visualizzare il criterio di accesso di un set di dati

Visualizzare il criterio di accesso di una tabella o una visualizzazione

Concedere l'accesso a una risorsa

Concedere l'accesso a un set di dati

Prepara Cloud Shell

Prepara la directory

Applica le modifiche

Concedere l'accesso a una tabella o una vista

Prepara Cloud Shell

Prepara la directory

Applica le modifiche

Revocare l'accesso a una risorsa

Revocare l'accesso a un set di dati

Revocare l'accesso a una tabella o una visualizzazione

Rifiutare l'accesso a una risorsa

Casi speciali

Controlla l'accesso alle risorse con IAM
bookmark_border Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.