Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

Proteggi e controlla l'accesso ai dati dell'applicazione utilizzando viste sicure parametrizzate

Le viste sicure parametrizzate forniscono sicurezza dei dati e controllo dell'accesso a livello di riga filtrando i risultati delle query in base all'identità dell'utente dell'applicazione.

Questo tutorial descrive come configurare viste sicure con parametri in AlloyDB per PostgreSQL, configurare ruoli e privilegi del database per limitare l'accesso alle tabelle di base e verificare la sicurezza dei dati. Gli esempi forniti in questo documento hanno scopi puramente dimostrativi.

Che cosa sono le viste sicure con parametri?

Come best practice generale, l'applicazione deve essere eseguita utilizzando un account di servizio con l'accesso minimo richiesto al database. Ad esempio, se la tua applicazione non deve scrivere nel tuo database, deve utilizzare un ruolo con accesso di sola lettura. Devi configurare questi controlli dell'accesso a livello di database.

Quando la tua applicazione richiede una sicurezza più granulare rispetto a quella consentita dall'accesso standard a livello di database, puoi utilizzare viste sicure parametrizzate per assicurarti che gli utenti visualizzino solo i dati autorizzati.

L'utilizzo di viste sicure con parametri offre due vantaggi principali:

Sicurezza dinamica a livello di riga: filtra le query utilizzando gli identificatori degli utenti finali in modo che gli utenti accedano solo ai dati autorizzati, indipendentemente dalla formulazione della query.
Gestione semplificata dei ruoli: utilizza un unico ruolo di database condiviso per tutti gli utenti dell'applicazione anziché gestire ruoli di database separati per ogni singolo utente.

Obiettivi

Crea viste sicure parametrizzate con parametri di visualizzazione denominati.
Crea il ruolo del database utilizzato dall'applicazione per connettersi al database e accedere a viste sicure parametrizzate.
Concedi al nuovo ruolo le autorizzazioni per le viste sicure parametrizzate e revoca l'accesso alle tabelle di base.
Connettiti utilizzando il nuovo ruolo e verifica che non sia possibile accedere alle tabelle con limitazioni.
Esegui query sulle viste sicure con parametri utilizzando la funzione execute_parameterized_query() o l'API QueryData.

Costi

In questo documento vengono utilizzati i seguenti componenti fatturabili di Google Cloud:

AlloyDB per PostgreSQL

Per generare una stima dei costi in base all'utilizzo previsto, utilizza il calcolatore prezzi.

I nuovi utenti di Google Cloud potrebbero avere diritto a una prova senza costi.

Per evitare l'addebito di ulteriori costi, elimina le risorse che hai creato al termine delle attività descritte in questo documento. Per ulteriori informazioni, consulta Esegui la pulizia.

Prima di iniziare

Prima di creare viste sicure con parametri, completa i seguenti prerequisiti.

Abilita la fatturazione e le API richieste

Nella console Google Cloud , seleziona un progetto.

Vai al selettore di progetti
Verifica che la fatturazione sia attivata per il tuo progetto Google Cloud .
Abilita le API Cloud necessarie per creare e connetterti ad AlloyDB per PostgreSQL.
1. Abilita l'API
2. Nel passaggio Conferma progetto, fai clic su Avanti per confermare il nome del progetto a cui apporterai le modifiche.
3. Nel passaggio Abilita API, fai clic su Abilita per abilitare quanto segue:
  - API AlloyDB per PostgreSQL
  - API Knowledge Catalog

Creare e connettersi a un database

prepara l'ambiente

Per prepararti a eseguire query su una vista sicura con parametri, configura il database, i ruoli del database, l'estensione parameterized_views e lo schema dell'applicazione.

Attiva il flag del database

Attiva il flag di database parameterized_views.enabled, che carica le librerie di estensioni richieste. Per saperne di più, consulta Configurare i flag di database di un'istanza.

Configurare il database

Crea un database denominato database per i dati dell'applicazione e viste sicure parametrizzate. Per saperne di più, vedi Creare un database.

Crea ruoli di database, l'estensione e lo schema dell'applicazione

Nella console Google Cloud , vai alla pagina AlloyDB.

Vai ad AlloyDB
Seleziona un cluster dall'elenco.
Nel menu di navigazione, fai clic su AlloyDB Studio.
Accedi a Studio utilizzando l'autenticazione Postgres.
Fai clic su Authenticate (Autentica). Il riquadro Explorer mostra un elenco degli oggetti nel database.
Fai clic su Nuova scheda dell'editor SQL o Nuova scheda per aprire una nuova scheda.
Per utilizzare le visualizzazioni con parametri, crea l'estensione parameterized_views nel database:
```
-- Requires parameterized_views.enabled set to true
CREATE EXTENSION parameterized_views;
```
Quando viene creata l'estensione, il database crea anche uno schema denominato parameterized_views in modo che le API siano contenute nello spazio dei nomi dello schema e non entrino in conflitto con le API esistenti.

Nota :devi creare un'estensione in ogni database in cui vengono create viste parametrizzate.
Accedi come utente con privilegi di superutente, ad esempio l'utente postgres integrato. Se vuoi creare un nuovo superutente, ad esempio admin_user, esegui questi comandi:
```
CREATE ROLE admin_user WITH LOGIN PASSWORD '...';
GRANT ALL PRIVILEGES ON DATABASE database TO admin_user;
```
Per saperne di più, vedi CREATE USER.
Crea un nuovo ruolo del database per l'esecuzione di query sulle viste sicure con parametri. Si tratta di un ruolo AlloyDB che l'applicazione utilizza per connettersi e accedere al database per eseguire query con accesso limitato a funzioni o oggetti pubblici al set minimo richiesto.
```
CREATE ROLE psv_user WITH LOGIN PASSWORD '...';
```
Per saperne di più, vedi CREATE USER.
Connettiti come utente amministrativo.
```
SET role TO admin_user;
```
Crea lo schema che contiene le tabelle.
```
CREATE SCHEMA store;
```

Crea le tabelle e inserisci i dati.

CREATE TABLE store.checked_items(bag_id INT,timestamp TIMESTAMP, loc_code CHAR(3), scan_type CHAR(1), location TEXT, customer_id INT);

INSERT INTO store.checked_items (bag_id, timestamp, loc_code, scan_type, location, customer_id) VALUES
(101, '2023-10-26 10:00:00', 'ABC', 'I', 'Warehouse A', 123),
(102, '2023-10-26 10:15:30', 'DEF', 'O', 'Loading Dock B', 456),
(103, '2023-10-26 10:30:45', 'GHI', 'I', 'Conveyor Belt 1', 789),
(104, '2023-10-26 11:00:00', 'JKL', 'O', 'Shipping Area C', 101),
(105, '2023-10-26 11:45:15', 'MNO', 'I', 'Sorting Station D', 202),
(106, '2023-10-26 12:00:00', 'PQR', 'O', 'Truck Bay E', 303);

Crea viste sicure con parametri e configura i privilegi di accesso

Per creare viste sicure parametrizzate e configurare privilegi di accesso appropriati per la tabella di base e le viste:

Nella console Google Cloud , vai alla pagina AlloyDB.

Vai ad AlloyDB
Seleziona un cluster dall'elenco.
Nel menu di navigazione, fai clic su AlloyDB Studio.
Accedi a Studio e connettiti a database come admin_user.
Fai clic su Authenticate (Autentica). Il riquadro Explorer mostra un elenco degli oggetti nel database.
Fai clic su Nuova scheda dell'editor SQL o Nuova scheda per aprire una nuova scheda.
Per fornire un accesso limitato alla visualizzazione, crea una visualizzazione parametrizzata:
```
CREATE VIEW store.secure_checked_items WITH (security_barrier) AS
SELECT bag_id, timestamp, location
FROM store.checked_items t
WHERE customer_id = $@app_end_userid;
```
Nota :assicurati di utilizzare nomi di parametri unici, ad esempio $@app_end_userid, quando crei viste sicure con parametri.

Concedi l'accesso alla visualizzazione.

GRANT SELECT ON store.secure_checked_items TO psv_user;

Per accedere alla visualizzazione, concedi l'accesso allo schema.
```
GRANT USAGE ON SCHEMA store TO psv_user;
```
Revoca l'accesso diretto alla tabella di base.
```
REVOKE ALL PRIVILEGES ON store.checked_items FROM psv_user;
```
Nota:il proprietario della vista parametrizzata deve disporre dei privilegi SELECT sulle tabelle di base. Inoltre, l'utente della vista parametrizzata deve disporre di USAGE sullo schema della vista e di SELECT sulla vista. Ad esempio, l'utente admin_user è proprietario della vista parametrizzata, quindi dispone dei privilegi SELECT sulle tabelle di base, mentre l'utente psv_user deve disporre dei privilegi USAGE sullo schema store e SELECT sulla vista.
Accedi come amministratore di admin_user e concedi il ruolo psv_user a un utente autenticato tramite IAM:
```
GRANT psv_user TO "IAM_USER_EMAIL";
```
Sostituisci IAM_USER_EMAIL con l'indirizzo email dell'utente IAM.

Verificare la sicurezza dei dati

Per verificare che le viste sicure parametrizzate limitino l'accesso alle viste designate, accedi al database come utente autenticato da IAM. In AlloyDB, gli utenti IAM ereditano le autorizzazioni dei ruoli del database assegnati.

Accedi al database come utente autenticato da IAM.

Verifica che non sia possibile accedere alla tabella di base.

SELECT * FROM store.checked_items;
ERROR:  permission denied for table checked_items

Accedi alle viste sicure parametrizzate utilizzando la funzione execute_parameterized_query:

SELECT * FROM parameterized_views.execute_parameterized_query(
  query => 'SELECT * from store.secure_checked_items',
  param_names => ARRAY ['app_end_userid'],
  param_values => ARRAY ['303']
);

Esegui query sulle viste sicure con parametri utilizzando la sintassi SQL e la richiesta QueryData con i parametri PSV.

  curl -X POST \
    "https://geminidataanalytics.googleapis.com/v1beta/projects/PROJECT_ID/locations/REGION:queryData" \
    -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    -H "Content-Type: application/json; charset=utf-8" \
    -d '{
      "prompt": "Show me the checked items.",
      "context": {
        "datasource_references": {
          "alloydb": {
            "database_reference": {
              "project_id": "PROJECT_ID",
              "region": "REGION",
              "cluster_id": "CLUSTER_ID",
              "instance_id": "INSTANCE_ID",
              "database_id": "DATABASE_ID"
            }
          }
        },
        "parameterized_secure_view_parameters": {
          "parameters": {
            "app_end_userid": "303"
          }
        }
      },
      "generation_options": {
        "generate_query_result": true,
        "generate_natural_language_answer": true,
        "generate_explanation": true
      }
    }'

Sostituisci i seguenti valori:

PROJECT_ID: l'ID progetto Google Cloud .
REGION: la regione in cui si trova l'istanza AlloyDB per PostgreSQL.
CLUSTER_ID: l'ID del cluster AlloyDB per PostgreSQL.
INSTANCE_ID: l'ID dell'istanza AlloyDB per PostgreSQL.
DATABASE_ID: l'ID del tuo database AlloyDB per PostgreSQL.

Esegui la pulizia

Elimina il cluster

Quando elimini il cluster che hai creato nella sezione Prima di iniziare, vengono eliminati anche tutti gli oggetti che hai creato.

Nella console Google Cloud , vai alla pagina AlloyDB.

Vai ad AlloyDB
Seleziona un cluster dall'elenco.
Fai clic su Elimina cluster.
In Elimina cluster, inserisci il nome del cluster per confermare che vuoi eliminarlo.

Passaggi successivi

Scopri di più sulle visualizzazioni sicure parametrizzate.
Scopri come gestire la sicurezza dei dati delle applicazioni utilizzando viste sicure parametrizzate.