Creazione di un data lake da una JDBC fonte in Lake Formation

1. Apri la console IAM all'indirizzo https://console.aws.amazon.com/iam. Accedi come utente amministratore che hai creato Crea un utente con accesso amministrativo o come utente con la policy AdministratorAccess AWS gestita.

2. Crea un utente denominato datalake_user con le seguenti impostazioni:

   • Abilita AWS Management Console l'accesso.

   • Imposta una password e non richiedi la reimpostazione della password.

   • Allega la politica AmazonAthenaFullAccess AWS gestita.

   • Allega la seguente politica in linea. Assegnare un nome alla policy DatalakeUserBasic.

     {
         "Version": "2012-10-17",
         "Statement": [
             {
                 "Effect": "Allow",
                 "Action": [
                     "lakeformation:GetDataAccess",
                     "glue:GetTable",
                     "glue:GetTables",
                     "glue:SearchTables",
                     "glue:GetDatabase",
                     "glue:GetDatabases",
                     "glue:GetPartitions",
                     "lakeformation:GetResourceLFTags",
                     "lakeformation:ListLFTags",
                     "lakeformation:GetLFTag",
                     "lakeformation:SearchTablesByLFTags",
                     "lakeformation:SearchDatabasesByLFTags"                
                ],
                 "Resource": "*"
             }
         ]
     }

Per creare una connessione

1. Apri AWS Glue la console all'indirizzo https://console.aws.amazon.com/glue/ e accedi come utente amministratore con cui hai creato il fileCrea un utente con accesso amministrativo.

2. Nel riquadro di navigazione, in Data catalog (Catalogo dati), seleziona Connections (Connessioni).

3. Nella pagina Connectors (Connettori), seleziona Create custom connector (Crea connettore personalizzato).

4. Nella pagina delle proprietà del connettore, immettete datalake-tutorial come nome della connessione e scegliete JDBCcome tipo di connessione. Quindi scegli Successivo.

5. Continuate con la procedura guidata di connessione e salvate la connessione.

   Per informazioni sulla creazione di una connessione, consulta le proprietà della AWS Glue JDBC connessione nella Guida per gli AWS Glue sviluppatori.

1. Apri la console Amazon S3 all'indirizzo https://console.aws.amazon.com/s3/e accedi come utente amministratore con cui hai creato. Crea un utente con accesso amministrativo

2. Scegli Crea bucket e segui la procedura guidata per creare un bucket denominato, dove <yourName>-datalake-tutorial <yourName> è la tua prima iniziale e il tuo cognome. Ad esempio: jdoe-datalake-tutorial.

   Per istruzioni dettagliate sulla creazione di un bucket Amazon S3, vedi Come si crea un bucket S3? nella Guida per l'utente di Amazon Simple Storage Service.

1. Apri la console Lake Formation all'indirizzo https://console.aws.amazon.com/lakeformation/. Accedi come amministratore del data lake.

2. Nel riquadro di navigazione, in Amministrazione, scegli Posizioni dei data lake.

3. Scegli Registra posizione, quindi scegli Sfoglia.

4. Seleziona il <yourName>-datalake-tutorial bucket che hai creato in precedenza, accetta il IAM ruolo predefinitoAWSServiceRoleForLakeFormationDataAccess, quindi scegli Registra posizione.

   Per ulteriori informazioni sulla registrazione delle sedi, consulta. Aggiungere una posizione Amazon S3 al tuo data lake

1. Sulla console Lake Formation, nel riquadro di navigazione, in Autorizzazioni, scegli Posizioni dati.

2. Scegliete Concedi e, nella finestra di dialogo Concedi autorizzazioni, effettuate le seguenti operazioni:

   1. Per IAMutenti e ruoli, sceglieteLakeFormationWorkflowRole.

   2. Per le posizioni di archiviazione, scegli il tuo <yourName>-datalake-tutorial bucket.

3. Scegli Concessione.

1. Nella console Lake Formation, nel riquadro di navigazione, in Catalogo dati, scegli Databases.

2. Scegli Crea database e, in Dettagli del database, inserisci il nomelakeformation_tutorial.

3. Lascia vuoti gli altri campi e scegli Crea database.

1. Nella console Lake Formation, nel riquadro di navigazione, in Autorizzazioni, scegli Autorizzazioni Data lake.

2. Scegli Concedi e nella finestra di dialogo Concedi le autorizzazioni per i dati, procedi come segue:

   1. In Principali, per IAMutenti e ruoli, scegliete. LakeFormationWorkflowRole

   2. In LF-Tags o Catalog resources, scegli Named data catalog resources.

   3. Per Database, scegliete il database che avete creato in precedenza,. lakeformation_tutorial

   4. In Autorizzazioni del database, seleziona Crea tabella, Alter e Drop e deseleziona Super se è selezionato.

3. Scegli Concessione.

1. Nella console Lake Formation, nel pannello di navigazione, scegli Blueprints, quindi scegli Usa blueprint.

2. Nella pagina Usa un blueprint, in Tipo di blueprint, scegli Database snapshot.

3. In Origine di importazione, per Connessione al database, scegli la connessione che hai appena creato o scegli una connessione esistente per la tua origine dati. datalake-tutorial

4. Per Percorso dei dati di origine, inserisci nel modulo <database>/<schema>/<table> il percorso da cui importare i dati.

   È possibile sostituire lo schema o la tabella con il carattere jolly percentuale (%). Per i database che supportano gli schemi, immettere <database>/<schema>/% per abbinare tutte le tabelle in <schema> entro <database>. Oracle Database e My SQL non supportano lo schema nel percorso; invece, inserisci <database>/%. Per Oracle Database, <database> è l'identificatore di sistema (SID).

   Ad esempio, se un database Oracle dispone orcl di un database OracleSID, orcl/% immettilo in modo che corrisponda a tutte le tabelle a cui ha accesso l'utente specificato nella JDCB connessione.

   Importante

   Questo campo fa distinzione tra minuscole e maiuscole.

5. In Import target, specifica questi parametri:

   Database di destinazione	lakeformation_tutorial
   Ubicazione di archiviazione di destinazione	s3://<yourName>-datalake-tutorial
   Formato dei dati	(Scegli Parquet oCSV)

6. Per la frequenza di importazione, scegliete Esegui su richiesta.

7. In Opzioni di importazione, specificate questi parametri:

   Nome del flusso di lavoro	lakeformationjdbctest
   IAMruolo	LakeFormationWorkflowRole
   prefisso della tabella	jdbctest Nota Deve essere in lettere minuscole.

8. Scegli Crea e attendi che la console segnali che il flusso di lavoro è stato creato correttamente.

   Suggerimento

   Hai ricevuto il seguente messaggio di errore?

   User: arn:aws:iam::<account-id>:user/<datalake_administrator_user> is not authorized to perform: iam:PassRole on resource:arn:aws:iam::<account-id>:role/LakeFormationWorkflowRole...

   In tal caso, verifica di averlo sostituito <account-id> nella politica in linea per l'utente amministratore del data lake con un numero di AWS account valido.

1. Nella console Lake Formation, nella pagina Blueprints, seleziona il flusso di lavorolakeformationjdbctest.

2. Scegli Azioni, quindi scegli Avvia.

3. Durante l'esecuzione del flusso di lavoro, visualizzane l'avanzamento nella colonna Stato dell'ultima esecuzione. Scegli il pulsante di aggiornamento di tanto in tanto.

   Lo stato va da RUNNING, a In scoperta, a Importazione, a. COMPLETED

   Quando il flusso di lavoro è completo:

   • Il Data Catalog ha nuove tabelle di metadati.

   • I tuoi dati vengono inseriti nel data lake.

   Se il flusso di lavoro fallisce, procedi come segue:

   1. Seleziona un flusso di lavoro. Scegliete Azioni, quindi scegliete Visualizza grafico.

      Il flusso di lavoro si apre nella AWS Glue console.

   2. Seleziona il flusso di lavoro e scegli la scheda Cronologia.

   3. Seleziona l'esecuzione più recente e scegli Visualizza i dettagli della corsa.

   4. Seleziona un processo o un crawler non riuscito nel grafico dinamico (runtime) ed esamina il messaggio di errore. I nodi con errori sono rossi o gialli.

1. Nella console Lake Formation, nel riquadro di navigazione, in Autorizzazioni, scegli Autorizzazioni Data lake.

2. Scegli Concedi e nella finestra di dialogo Concedi le autorizzazioni per i dati, procedi come segue:

   1. In Principali, per IAMutenti e ruoli, scegliete. datalake_user

   2. In LF-Tags o Catalog resources, scegli Named data catalog resources.

   3. Per Database, scegliete. lakeformation_tutorial

      Viene compilato l'elenco Tabelle.

   4. Per Tabelle, scegli una o più tabelle dalla tua fonte di dati.

   5. In Autorizzazioni per tabelle e colonne, scegli Seleziona.

3. Scegli Concessione.

1. Apri la console Athena all'indirizzo e accedi come analista di dati https://console.aws.amazon.com/athena/, utente. datalake_user

2. Se necessario, scegli Inizia per passare all'editor di query Athena.

3. Per Origine dati scegliere AwsDataCatalog.

4. Per Database, scegliere lakeformation_tutorial.

   L'elenco delle tabelle viene compilato.

5. Nel menu pop-up accanto a una delle tabelle, scegli Anteprima tabella.

   La query viene eseguita e visualizza 10 righe di dati.

Per configurare le autorizzazioni per eseguire le query su Amazon Redshift

1. Apri la console all'IAMindirizzo. https://console.aws.amazon.com/iam/ Accedi come utente amministratore in cui hai creato Crea un utente con accesso amministrativo (nome utenteAdministrator) o come utente con la policy AdministratorAccess AWS gestita.

2. Nel pannello di navigazione, selezionare Policy.

   Se è la prima volta che selezioni Policy, verrà visualizzata la pagina Benvenuto nelle policy gestite. Seleziona Inizia.

3. Scegli Create Policy (Crea policy).

4. Scegli la JSONscheda.

5. Incolla il seguente documento JSON di policy.

   {
       "Version": "2012-10-17",
       "Statement": [
           {
               "Effect": "Allow",
               "Action": [
                   "lakeformation:GetDataAccess",
                   "glue:GetTable",
                   "glue:GetTables",
                   "glue:SearchTables",
                   "glue:GetDatabase",
                   "glue:GetDatabases",
                   "glue:GetPartitions",
                   "lakeformation:GetResourceLFTags",
                   "lakeformation:ListLFTags",
                   "lakeformation:GetLFTag",
                   "lakeformation:SearchTablesByLFTags",
                   "lakeformation:SearchDatabasesByLFTags"                
              ],
               "Resource": "*"
           }
       ]
   }

6. Una volta terminato, selezionare Review (Rivedi) per rivedere la policy. In Validatore di policy vengono segnalati eventuali errori di sintassi.

7. Nella pagina Rivedi la politica, inserisci RedshiftLakeFormationPolicy il nome della politica che stai creando. (Opzionale) Immettere una Description (descrizione). Consulta il Summary (Riepilogo) della policy per visualizzare le autorizzazioni concesse dalla policy. Seleziona Create policy (Crea policy) per salvare il proprio lavoro.

8. Nel riquadro di navigazione della IAM console, scegli Ruoli, quindi scegli Crea ruolo.

9. In Seleziona tipo di entità attendibile, scegli Servizio AWS .

10. Scegliere il servizio Amazon Redshift per assumere questo ruolo.

11. Selezionare il caso d'uso Redshift Customizable (Redshift personalizzabile) per il servizio. Quindi scegliere Next: Permissions (Successivo: Autorizzazioni).

12. Cerca la politica di autorizzazione che hai creato e seleziona la casella di controllo accanto al nome della politica nell'elenco. RedshiftLakeFormationPolicy

13. Scegliere Next: Tags (Successivo: Tag).

14. Scegliere Next:Review (Successivo: Rivedi).

15. In Role name (Nome ruolo), inserire il nome RedshiftLakeFormationRole.

16. (Facoltativo) In Descrizione ruolo, immettere una descrizione per il nuovo ruolo.

17. Verificare il ruolo e quindi scegliere Create role (Crea ruolo).

Per concedere Select le autorizzazioni sulla tabella da interrogare nel database Lake Formation

1. Apri la console Lake Formation all'indirizzo https://console.aws.amazon.com/lakeformation/. Accedi come amministratore del data lake.

2. Nel riquadro di navigazione, in Autorizzazioni, scegli Autorizzazioni Data lake, quindi scegli Concedi.

3. Inserisci le informazioni che seguono:

   • Per IAMutenti e ruoli, scegli il IAM ruolo che hai creato,. RedshiftLakeFormationRole Quando esegui Amazon Redshift Query Editor, utilizza questo IAM ruolo per l'autorizzazione ai dati.

   • Per Database, scegliere lakeformation_tutorial.

     L'elenco delle tabelle viene compilato.

   • Per Tabella, scegli una tabella all'interno della fonte di dati da interrogare.

   • Scegli l'autorizzazione Seleziona tabella.

4. Scegli Concessione.

Per configurare Amazon Redshift Spectrum ed eseguire query

1. Apri la console Amazon Redshift all'indirizzo. https://console.aws.amazon.com/redshift Accedi come utenteAdministrator.

2. Scegli Create cluster (Crea cluster).

3. Nella pagina Crea cluster, inserisci redshift-lakeformation-demo l'identificatore del cluster.

4. Per il tipo di nodo, seleziona dc2.large.

5. Scorri verso il basso e, in Configurazioni del database, inserisci o accetta questi parametri:

   • Nome utente dell'amministratore: awsuser

   • Password utente amministratore: (Choose a password)

6. Espandi le autorizzazioni del cluster e, per IAMRuoli disponibili, scegli RedshiftLakeFormationRole. Quindi scegli Aggiungi IAM ruolo.

7. Se è necessario utilizzare una porta diversa dal valore predefinito di 5439, accanto a Configurazioni aggiuntive, disattiva l'opzione Usa valori predefiniti. Espandi la sezione relativa alle configurazioni del database e inserisci un nuovo numero di porta del database.

8. Scegli Create cluster (Crea cluster).

   Viene caricata la pagina Cluster.

9. Attendi che lo stato del cluster diventi Disponibile. Scegli periodicamente l'icona di aggiornamento.

10. Concedi all'analista dei dati l'autorizzazione a eseguire query sul cluster. Per fare ciò, completare questa procedura:

    1. Apri la IAM console all'indirizzo https://console.aws.amazon.com/iam/e accedi come utente. Administrator

    2. Nel riquadro di navigazione, scegli Utenti e allega all'utente le seguenti politiche gestitedatalake_user.

       • AmazonRedshiftQueryEditor

       • AmazonRedshiftReadOnlyAccess

11. Esci dalla console Amazon Redshift e accedi nuovamente come utente. datalake_user

12. Nella barra degli strumenti verticale a sinistra, scegli l'EDITORicona per aprire l'editor di query e connetterti al cluster. Se viene visualizzata la finestra di dialogo Connetti al database, scegliete il nome redshift-lakeformation-demo del cluster e immettete il nome dev del databaseawsuser, il nome utente e la password che avete creato. Quindi scegli Connect to database (Collegati al database).

    Nota

    Se non ti vengono richiesti i parametri di connessione e nell'editor di query è già selezionato un altro cluster, scegli Cambia connessione per aprire la finestra di dialogo Connetti al database.

13. Nella casella di testo New Query 1, inserisci ed esegui la seguente istruzione per mappare il database lakeformation_tutorial in Lake Formation al nome dello schema Amazon Redshift: redshift_jdbc

    Importante

    Replace (Sostituisci) <account-id> con un numero di AWS account valido e <region> con un nome di AWS regione valido (ad esempio,us-east-1).

    create external schema if not exists redshift_jdbc from DATA CATALOG database 'lakeformation_tutorial' iam_role 'arn:aws:iam::<account-id>:role/RedshiftLakeFormationRole' region '<region>';

14. Nell'elenco degli schemi in Seleziona schema, scegli redshift_jdbc.

    L'elenco delle tabelle viene compilato. L'editor di query mostra solo le tabelle per le quali ti sono state concesse le autorizzazioni per il data lake di Lake Formation.

15. Nel menu a comparsa accanto al nome di una tabella, scegli Anteprima dati.

    Amazon Redshift restituisce le prime 10 righe.

    Ora puoi eseguire query sulle tabelle e sulle colonne per le quali disponi delle autorizzazioni.