Replica dati da PostgreSQL a Snowflake

Impara a replicare i dati da PostgreSQL a Snowflake utilizzando OCI GoldenGate.

Prima di iniziare

Per completare correttamente questo avvio rapido, è necessario disporre dei seguenti elementi:

Installazione PostgreSQL da utilizzare come database di origine (vedere l'impostazione dell'ambiente)
Aprire la porta 5432 nella lista di sicurezza della VCN
Un database Snowflake da utilizzare come database di destinazione.

Impostazione dell'ambiente: PostgreSQL

Per impostare l'ambiente per questo Quickstart:

Eseguire i comandi seguenti per installare PostgreSQL.
1. Installa server PostgreSQL:
```
sudo yum install postgresql-server
```
2. Installare il modulo postgresql-contrib per evitare questa eccezione SQL:
```
sudo yum install postgresql-contrib
```
3. Creare un nuovo cluster di database PostgreSQL:
```
sudo postgresql-setup --initdb
```
4. Abilita postgresql.service:
```
sudo systemctl enable postgresql.service
```
5. Avviare postgresql.service:
```
sudo systemctl start postgresql.service
```
Per impostazione predefinita, PostgreSQL consente solo connessioni locali. Consenti connettività remota a PostgreSQL.
1. In /var/lib/pgsql/data/postgresql.conf, preparare il database per la replica.
2. Individuare e rimuovere il punto listen_addresses = 'localhost' e modificare localhost in un asterisco (`):
```
listen_addresses = '*'
```
3. Impostare i parametri seguenti come indicato di seguito.
  - wal_level = logical
  - max_replication_slots = 1
  - max_wal_senders = 1
  - track_commit_timestamp = on
  Nota:
  
  Configurare /var/lib/pgsql/data/pg_hba.conf per assicurarsi che l'autenticazione client sia impostata in modo da consentire le connessioni da un host Oracle GoldenGate. Ad esempio, aggiungere quanto segue:
```
#Allow connections from remote hosts

host all all 0.0.0.0/0 md5
```
  Per ulteriori informazioni, vedere File pg_hba.conf.
  1. Riavviare il server PostgreSQL:
```
sudo systemctl restart postgresql.service
```
  1. Se si utilizza Oracle Cloud Compute per ospitare PostgreSQL, aprire la porta 5432:
```
sudo firewall-cmd --permanent --add-port=5432/tcp
sudo firewall-cmd --reload
sudo firewall-cmd --list-all
```
4. Aprire la porta 5432 nella lista di sicurezza della VCN.
5. Connetti a PostgreSQL.
```
> sudo su - postgres
> psql
```
  Nota: in alternativa, è possibile immettere sudo su - postgres psql se l'esempio precedente non funziona.
6. Impostare PostgreSQL.
  1. Scaricare ed eseguire seedSRCOCIGGLL_PostgreSQL.sql per impostare il database e caricare i dati di esempio.
  2. Eseguire i comandi indicati di seguito per configurare l'utente. Assicurarsi di sostituire <password> con una password effettiva.
```
create user ggadmin with password '<password>';
alter user ggadmin with SUPERUSER;
GRANT ALL PRIVILEGES ON DATABASE ociggll TO ggadmin;
```

Ambiente allestito: Snowflake

Creare un utente GoldenGate in Snowflake con privilegi appropriati.
Creare tabelle di destinazione utilizzando lo schema di esempio.

Assicurarsi che le tabelle e l'utente siano stati creati correttamente.

Task 1: creare le risorse OCI GoldenGate

Questo esempio di avvio rapido richiede distribuzioni e connessioni sia per l'origine che per la destinazione.

Creare una distribuzione per il database PostgreSQL di origine.
Creare una distribuzione Big Data per il database Snowflake di destinazione.
Creare una connessione PostgreSQL con i valori seguenti:
1. Per Tipo, selezionare Server PostgreSQL dall'elenco a discesa.
2. Per Nome database, immettere ociggll.
3. Per Host, immettere l'IP pubblico dell'istanza di computazione su cui viene eseguito PostgreSQL.
4. Per Porta, immettere 5432.
5. Per Nome utente, immettere ggadmin.
6. In Password, immettere la password.
7. Per Protocollo di sicurezza, selezionare Plain dall'elenco a discesa.
Creare una connessione con fiocco di neve con i valori seguenti:
1. Per URL di connessione, immettere jdbc:snowflake://<account_identifier>.snowflakecomputing.com/?warehouse=<warehouse name>&db=OCIGGLL.
  
  Nota: assicurarsi di sostituire <account_identifier> e <warehouse name> con i valori appropriati.
2. Per Tipo di autenticazione, selezionare Autenticazione di base dall'elenco a discesa.
3. Per Nome utente, immettere un nome.
4. Per Password, immettere una password.
(Facoltativo) Se la distribuzione Big Data non dispone di un endpoint pubblico, creare una connessione a GoldenGate e quindi assegnare questa connessione alla distribuzione PostgreSQL di origine.
Assegnare la connessione PostgreSQL di origine alla distribuzione PostgreSQL.
Assegnare la connessione Snowflake alla distribuzione Big Data di destinazione.

Task 2: Abilita log supplementare

Per abilitare il log supplementare, procedere come segue.

Avviare la console di distribuzione PostgreSQL GoldenGate:
1. Nella pagina Distribuzioni selezionare la distribuzione PostgreSQL per visualizzarne i dettagli.
2. Nella pagina dei dettagli della distribuzione PostgreSQL selezionare Avvia console.
3. Nella pagina di connessione della console di distribuzione, immettere le credenziali di amministratore GoldenGate fornite nel task 1, passo 1.
  
  Nota: l'accesso è obbligatorio se IAM non è stato selezionato come area di memorizzazione delle credenziali durante la creazione di una distribuzione.
Nella console di distribuzione, selezionare Connessioni DB nella navigazione a sinistra, quindi nel database PostgreSQL di origine, quindi in Trandata.
Nella pagina TRANDATA, accanto a Informazioni TRANDATA, selezionare Aggiungi TRANDATA (icona più).
Nel pannello Trandata, per Nome schema, immettere src_ociggll, quindi selezionare Sottometti.

Nota: utilizzare il campo di ricerca per cercare src_ociggll e verificare che le tabelle siano state aggiunte.

Task 3: Creazione delle estrazioni

Aggiungere l'estrazione di Change Data Capture:
1. Nella navigazione a sinistra selezionare Extracts,
2. Nella pagina Estrazioni, selezionare Aggiungi estrazione (icona più), quindi completare i campi come indicato di seguito.
  - Nella pagina Informazioni estrazione:
    1. Per Tipo estrazione, selezionare Modifica estrazione acquisizione dati.
    2. In Nome processo immettere un nome per l'estrazione, ad esempio ECDC.
    3. Selezionare Next.
  - Nella pagina Opzioni estrazione:
    1. Per le credenziali di origine, selezionare Oracle GoldenGate dall'elenco a discesa Dominio
    2. Selezionare il database PostgreSQL di origine dall'elenco a discesa Alias.
    3. Per Nome trail estrazione, immettere un nome trail di due caratteri, ad esempio C1.
    4. Selezionare Next.
  - Nella pagina Parametri estrazione, sostituire MAP *.*, TARGET *.*; con quanto segue:
```
TABLE SRC_OCIGGLL.*;
```
3. Selezionare Crea ed esegui.
Aggiungi estrazione caricamento iniziale:
1. Nella pagina Estrazioni selezionare Aggiungi estrazione, quindi completare il form Aggiungi estrazione come indicato di seguito.
  - Nella pagina Informazioni estrazione:
    1. Per il tipo di estrazione, selezionare Estrazione caricamento iniziale.
    2. In Nome processo, immettere un nome, ad esempio EIL.
    3. Selezionare Next.
  - Nella pagina Opzioni estrazione:
    1. Per le credenziali di origine, selezionare Oracle GoldenGate dall'elenco a discesa Dominio.
    2. Selezionare il database PostgreSQL dall'elenco a discesa Alias.
    3. Per Nome trail estrazione, immettere un nome trail di due caratteri, ad esempio I1.
    4. Selezionare Next.
  - Nella pagina Parametri estrazione, sostituire il contenuto dell'area di testo con quanto segue:
```
EXTRACT EIL
USERIDALIAS PostgreSQL_Compute, DOMAIN OracleGoldenGate
EXTFILE I1, PURGE
TABLE src_ociggll.*;
```
    Nota: prima di passare al parametro SOURCEDB, assicurarsi di rimuovere il parametro USERIDALIAS.
2. Selezionare Crea ed esegui.

Si torna alla pagina Estrazioni, in cui è possibile osservare l'inizio dell'estrazione.

Task 4: Crea percorso di distribuzione per estrazione caricamento iniziale

Per creare un percorso di distribuzione per l'estrazione del caricamento iniziale:

Nella console di Oracle Cloud, nella pagina Distribuzioni, selezionare la distribuzione Big Data di destinazione.
Nella pagina dei dettagli della distribuzione, selezionare Avvia console, quindi eseguire il login come utente amministratore.
Se si utilizza l'area di memorizzazione delle credenziali IAM, passare al passo Crea percorso di distribuzione. Se si utilizza l'area di memorizzazione delle credenziali GoldenGate, creare un utente con il quale GoldenGate di origine utilizza per connettersi a GoldenGate di destinazione.
1. Nel menu di navigazione selezionare Amministrazione utente.
2. Selezionare Aggiungi nuovo utente (icona più), completare i campi come indicato di seguito, quindi selezionare Sottometti.
  - Per Nome utente, immettere ggsnet.
  - Per Ruolo, selezionare Operatore.
  - Immettere due volte la password per la verifica.
Nella console di distribuzione PostgreSQL origine creare una connessione percorso per l'utente creato nel passo precedente.
1. Nel menu di navigazione selezionare Connessioni percorso.
2. Selezionare Aggiungi connessione percorso (icona più), completare i campi come indicato di seguito, quindi selezionare Sottometti.
  - Per l'alias credenziali, immettere dpuser.
  - Per ID utente, immettere ggsnet
  - Per Password, immettere la stessa password utilizzata nel passo precedente.
Creare un percorso di distribuzione.
1. Nella barra dei menu del servizio, selezionare Percorsi, quindi selezionare Aggiungi percorso di distribuzione (icona più).
2. Completare il modulo Aggiungi percorso come indicato di seguito.
  - Nella pagina Informazioni percorso:
    1. In Nome percorso, immettere un nome per questo percorso.
    2. Selezionare Next.
  - Nella pagina Opzioni origine, effettuare le operazioni riportate di seguito.
    1. Per Estrazione origine, lasciare vuoto.
    2. In Nome percorso, immettere il nome trail estrazione caricamento iniziale (I1).
    3. Selezionare Next.
  - Nella pagina Opzioni destinazione, effettuare le operazioni riportate di seguito.
    1. Per Destinazione, selezionare wss.
    2. Per Host di destinazione, immettere l'URL di distribuzione di destinazione senza le barre https:// o le barre finali.
    3. In Numero porta, immettere 443.
    4. Per Nome percorso, immettere I1.
    5. Per Metodo di autenticazione destinazione, selezionare Alias ID utente.
    6. Per Dominio, immettere il nome di dominio creato nel passo precedente.
    7. Per Alias, immettere l'alias creato nel passo precedente (dpuser).
    8. Selezionare Next.
3. Selezionare Crea ed esegui.
Si torna alla pagina Servizio di distribuzione in cui è possibile rivedere il percorso creato.
Nella console di distribuzione destinazione, esaminare il percorso del destinatario creato come risultato del percorso di distribuzione:
1. Selezionare Percorsi.
2. Esaminare i dettagli del percorso.

Task 5: Aggiungi Replicat per caricamento iniziale

Nella console di distribuzione Big Data destinazione, aggiungere Replicat caricamento iniziale.
1. Nel menu di navigazione, selezionare Replicat, quindi selezionare Aggiungi Replicat (icona più).
2. Nella pagina Replicat, completare i campi Aggiungi Replicat come indicato di seguito.
  1. Nella pagina Informazioni sulla replica:
    1. Per Tipo Replicat, selezionare Classic o Coordinated.
    2. In Nome processo, immettere un nome, ad esempio RIL.
    3. Selezionare Next.
  2. Nella pagina Opzioni Replicat:
    1. In Nome trail replica, immettere il nome del trail dal task 2 (I1).
    2. Per Credenziali di destinazione, selezionare il dominio e l'opzione Alias per la connessione Snowflake.
    3. Per Alias disponibili, selezionare un alias dall'elenco a discesa, ad esempio Snowflake.
    4. (Facoltativo) Abilita storage esterno per selezionare una posizione area intermedia disponibile dall'elenco a discesa.
    5. Selezionare Next.
  3. Nella pagina File dei parametri, aggiungere il mapping seguente:
```
INSERTALLRECORDS
MAP src_ociggll.src_city, TARGET SRCMIRROR_OCIGGLL.SRC_CITY;
MAP src_ociggll.src_region, TARGET SRCMIRROR_OCIGGLL.SRC_REGION;
MAP src_ociggll.src_customer, TARGET SRCMIRROR_OCIGGLL.SRC_CUSTOMER;
MAP src_ociggll.src_orders, TARGET SRCMIRROR_OCIGGLL.SRC_ORDERS;
MAP src_ociggll.src_order_lines, TARGET SRCMIRROR_OCIGGLL.SRC_ORDER_LINES;
MAP src_ociggll.src_product, TARGET SRCMIRROR_OCIGGLL.SRC_PRODUCT;
```
  4. Nella pagina Proprietà rivedere le proprietà, quindi selezionare Crea ed esegui.
    
    Si torna alla pagina Replicat, in cui è possibile rivedere i dettagli di Replicat.
Per verificare il caricamento iniziale, connettersi al database Snowflake ed eseguire le query riportate di seguito.
```
select * from SRCMIRROR_OCIGGLL.SRC_CITY;
select * from SRCMIRROR_OCIGGLL.SRC_CUSTOMER;
```

L'output deve restituire i dati caricati nelle tabelle del database di destinazione in seguito al caricamento iniziale.

Task 6: Creare il percorso di distribuzione per l'acquisizione dei dati di modifica

Nella console di distribuzione PostgreSQL origine, selezionare Servizio di distribuzione.
Selezionare Aggiungi percorso di distribuzione.
Completare il modulo Aggiungi percorso come indicato di seguito.
1. Nella pagina Informazioni percorso:
  1. In Nome percorso, immettere un nome.
  2. Selezionare Next.
2. Nella pagina Opzioni origine, effettuare le operazioni riportate di seguito.
  1. Per Estrazione origine, selezionare Estrazione acquisizione dati modifica (ECDC).
  2. In Nome percorso, selezionare il file trail di Change Data Capture (C1).
  3. Selezionare Next.
3. Nella pagina Opzioni destinazione, effettuare le operazioni riportate di seguito.
  1. Per Destinazione, selezionare wss.
  2. Per Host di destinazione, immettere l'URL della console di distribuzione di destinazione, disponibile nella pagina dei dettagli della distribuzione, senza le barre https:// o le barre finali.
  3. In Numero porta, immettere 443.
  4. Per Nome percorso, immettere C1.
  5. Per Metodo di autenticazione destinazione, selezionare Alias ID utente.
  6. Per Dominio, immettere il nome del dominio.
  7. Per Alias, immettere l'alias.
4. Selezionare Crea percorso ed esegui.
Nella console di distribuzione Big Data di destinazione, selezionare Servizio ricevente, quindi rivedere il percorso del ricevente creato.

Task 7: aggiungere un Replicat per Change Data Capture

Eseguire gli aggiornamenti al database PostgreSQL di origine per verificare la replica in Snowflake.

Aggiungere Replicat.
1. Nella console di distribuzione Big Data di destinazione selezionare Servizio di amministrazione, quindi nel menu di navigazione selezionare Replicat.
2. Nella pagina Replicat, selezionare Aggiungi Replicat (icona più), quindi completare il form Aggiungi Replicat come indicato di seguito.
  - Nella pagina Informazioni Replicat:
    1. Per Tipo Replicat, selezionare Classic o Coordinated.
    2. In Nome processo, immettere un nome, ad esempio RCDC.
    3. Selezionare Next.
  - Nella pagina Opzioni Replicat:
    1. In Nome trail replica, immettere il nome del trail dal task 3 (C1).
    2. Per Credenziali di destinazione, selezionare il dominio e l'alias per la connessione Snowflake.
    3. (Facoltativo) Abilita storage esterno per selezionare una posizione area intermedia disponibile dall'elenco a discesa.
  - Nella pagina File dei parametri aggiungere il mapping riportato di seguito, quindi selezionare Successivo.
```
MAP src_ociggll.src_city, TARGET SRCMIRROR_OCIGGLL.SRC_CITY;
MAP src_ociggll.src_region, TARGET SRCMIRROR_OCIGGLL.SRC_REGION;
MAP src_ociggll.src_customer, TARGET SRCMIRROR_OCIGGLL.SRC_CUSTOMER;
MAP src_ociggll.src_orders, TARGET SRCMIRROR_OCIGGLL.SRC_ORDERS;
MAP src_ociggll.src_order_lines, TARGET SRCMIRROR_OCIGGLL.SRC_ORDER_LINES;
MAP src_ociggll.src_product, TARGET SRCMIRROR_OCIGGLL.SRC_PRODUCT;
```
  - Nella pagina Proprietà rivedere le proprietà, quindi selezionare Crea ed esegui.
    
    Si torna alla pagina Replicat, in cui è possibile rivedere i dettagli di Replicat.

Verifica Change Data Acquisizione:

Eseguire gli aggiornamenti al database PostgreSQL di origine per verificare la replica in Snowflake. Eseguire lo script seguente per eseguire gli inserimenti nel database PostgreSQL:

Insert into src_ociggll.src_city (CITY_ID,CITY,REGION_ID,POPULATION) values (1000,'Houston',20,743113);
Insert into src_ociggll.src_city (CITY_ID,CITY,REGION_ID,POPULATION) values (1001,'Dallas',20,822416);
Insert into src_ociggll.src_city (CITY_ID,CITY,REGION_ID,POPULATION) values (1002,'San Francisco',21,157574);
Insert into src_ociggll.src_city (CITY_ID,CITY,REGION_ID,POPULATION) values (1003,'Los Angeles',21,743878);
Insert into src_ociggll.src_city (CITY_ID,CITY,REGION_ID,POPULATION) values (1004,'San Diego',21,840689);
Insert into src_ociggll.src_city (CITY_ID,CITY,REGION_ID,POPULATION) values (1005,'Chicago',23,616472);
Insert into src_ociggll.src_city (CITY_ID,CITY,REGION_ID,POPULATION) values (1006,'Memphis',23,580075);
Insert into src_ociggll.src_city (CITY_ID,CITY,REGION_ID,POPULATION) values (1007,'New York City',22,124434);
Insert into src_ociggll.src_city (CITY_ID,CITY,REGION_ID,POPULATION) values (1008,'Boston',22,275581);
Insert into src_ociggll.src_city (CITY_ID,CITY,REGION_ID,POPULATION) values (1009,'Washington D.C.',22,688002);

Nella console di distribuzione PostgreSQL di origine selezionare RCDC, quindi selezionare Statistiche. Verificare che in src_ociggll.src_city siano presenti 10 inserimenti.

Nota: se Extract non ha acquisito alcun inserimento, riavviare l'estrazione ECDC.
Nella console di distribuzione Big Data di destinazione selezionare RCDC, esaminare i relativi Dettagli e Statistiche per verificare il numero di inserimenti.