Replica dei dati da PostgreSQL a MySQL

Prima di iniziare

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

Installazione PostgreSQL da utilizzare come database di origine (le istruzioni di installazione sono riportate nell'impostazione dell'ambiente).
Aprire la porta 5432 nell'elenco di sicurezza della VCN per poter accedere a PostgreSQL sulla porta predefinita.
Un database HeatWave da utilizzare come database di destinazione.

Ambiente impostato: PostgreSQL

Per impostare l'ambiente per questo Quickstart:

Eseguire i comandi seguenti per installare PostgreSQL.
1. Installare il 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. Abilitare 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 decommentare listen_addresses = 'localhost' e modificare localhost in un asterisco (*):
```
listen_addresses = '*'
```
3. Impostare i parametri indicati 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 per consentire le connessioni da un host Oracle GoldenGate. Ad esempio:
```
#Allow connections from remote hosts
host    all    all    0.0.0.0/0    md5
```
  Per ulteriori informazioni, vedere Il file pg_hba.conf.
4. Riavviare il server PostgreSQL:
```
sudo systemctl restart postgresql.service
```

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

Aprire la porta 5432 nella lista di sicurezza della VCN.
Connetti a PostgreSQL.
```
> sudo su - postgres
> psql
```
Nota
In alternativa, è possibile immettere sudo su - postgres psql se l'esempio precedente non funziona.
Impostare PostgreSQL.
1. Scaricare ed eseguire seedSRCOCIGGLL_PostgreSQL.sql per impostare il database e caricare i dati di esempio.
2. Eseguire i seguenti comandi per impostare 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 impostato: MySQL

Aprire la porta 3306, tramite la quale OCI GoldenGate può connettersi.
1. Nella console di Oracle Cloud, individuare la subnet utilizzata dal database HeatWave.
2. Nella lista di sicurezza della subnet creare una regola di entrata per la porta TCP/3306.

Creare un utente ggadmin utilizzando lo script seguente. Ricordarsi di sostituire <ggadmin-password> con una password valida:

CREATE USER 'ggadmin' IDENTIFIED BY '<ggadmin-password>';
GRANT SELECT, REPLICATION SLAVE, REPLICATION CLIENT, CREATE,CREATE VIEW, EVENT, INSERT, UPDATE, DROP,EXECUTE, DELETE ON *.* TO 'ggadmin';

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 MySQL per il database di destinazione HeatWave.
Creare una connessione PostgreSQL.
1. Per Tipo, selezionare PostgreSQL Server dall'elenco a discesa.
2. Per Nome database, immettere ociggll.
3. Per l'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 HeatWave.
(Facoltativo) Se il database HeatWave non dispone di un endpoint pubblico, creare una connessione a GoldenGate, quindi assegnare questa connessione alla distribuzione PostgreSQL di origine.
Assegnare la connessione di origine alla distribuzione PostgreSQL di origine.
Assegnare la connessione di destinazione alla distribuzione MySQL di destinazione.

Task 2: Abilita il log supplementare

Per abilitare il log supplementare:

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 fare clic su Avvia console.
3. Nella pagina di collegamento della console di distribuzione, immettere le credenziali di amministrazione GoldenGate fornite nel task 1, passo 1.
In GoldenGate 23ai, fare clic su Connessioni al database nella navigazione a sinistra, quindi sul database PostgreSQL di origine e infine su Trandata.
Nella pagina TRANDATA, accanto alle informazioni TRANDATA, fare clic su Aggiungi TRANDATA (icona più).
Nel pannello Trandata, in Nome schema, immettere src_ociggll.*, quindi fare clic su Sottometti.

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

Task 3: creare le estrazioni

Aggiungere il file Change Data Capture Extract:
1. Nella navigazione a sinistra, fare clic su Estrazioni,
2. Nella pagina Estrazioni, fare clic su Aggiungi Estrazione (icona più), quindi completare i campi come indicato di seguito.
  - Nella pagina Informazioni estrazione:
    1. Per Tipo di estrazione, selezionare Modifica acquisizione dati Estrazione.
    2. In Nome processo, immettere un nome per Estrai, ad esempio ECDC.
    3. Fare clic su Successivo.
  - 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. In Estrai nome trail, immettere un nome di trail di due caratteri, ad esempio C1.
    4. Fare clic su Successivo.
  - Nella pagina Parametri di estrazione sostituire MAP *.*, TARGET *.*; con gli elementi riportati di seguito.
```
TABLE SRC_OCIGGLL.*;
```
3. Fare clic su Crea ed esegui.
Aggiungere l'estrazione del caricamento iniziale:
1. Nella pagina Estrazioni, fare clic su Aggiungi Estrai, quindi completare il form Aggiungi Estrai nel modo seguente:
  - Nella pagina Estrai informazioni:
    1. Per il tipo Estrai, selezionare Caricamento iniziale Estrai.
    2. Per Nome processo, immettere un nome, ad esempio EIL.
    3. Fare clic su Successivo.
  - 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. In Estrai nome trail, immettere un nome trail di due caratteri, ad esempio I1.
    4. Fare clic su Successivo.
  - Nella pagina Parametri Estrai, sostituire il contenuto dell'area di testo con i seguenti elementi:
```
EXTRACT EIL
USERIDALIAS PostgreSQL_Compute, DOMAIN OracleGoldenGate
EXTFILE I1, PURGE
TABLE src_ociggll.*;
```
    Nota
    Assicurarsi di rimuovere il parametro SOURCEDB davanti a USERIDALIAS prima di procedere.
2. Fare clic su Crea ed esegui.

Si torna alla pagina Estrazioni, in cui è possibile osservare l'avvio di Estrazione.

Task 4: creare il file Distribution Path per Initial Load Extract

Per creare un file Distribution Path per Initial Load Extract, effettuare le operazioni riportate di seguito.

Nella console di Oracle Cloud, nella pagina Distribuzioni, selezionare la distribuzione MySQL di destinazione.
Nella pagina dei dettagli della distribuzione, fare clic su Avvia console ed eseguire il login utilizzando l'amministratore dettagliato creato nel task 1, passo 2.
Se si utilizza l'area di memorizzazione delle credenziali IAM, passare al passo Crea Distribution Path. Se si utilizza l'area di memorizzazione delle credenziali GoldenGate, creare un utente con cui utilizzare l'origine GoldenGate per connettersi alla destinazione GoldenGate.
1. Nel menu di navigazione fare clic su Amministrazione utenti.
2. Fare clic su Aggiungi nuovo utente (icona più), completare i campi come indicato di seguito, quindi fare clic su Sottometti:
  - In Nome utente immettere ggsnet.
  - In Ruolo, selezionare Operatore.
  - Immettere due volte la password per verifica.
Nella console di distribuzione di origine PostgreSQL creare una connessione percorso per l'utente creata nel passo precedente.
1. Nel menu di navigazione fare clic su Connessioni percorso.
2. Fare clic su Aggiungi connessione percorso (icona più), completare i campi come indicato di seguito, quindi fare clic su Sottometti:
  - Per Alias credenziale, immettere dpuser.
  - Per l'ID utente, immettere ggsnet
  - Per Password, immettere la stessa password utilizzata nel passo precedente.
Creare un Distribution Path.
1. Nella barra dei menu del servizio, fare clic su Distribution Service, quindi su Aggiungi Distribution Path (icona più).
2. Completare il form Aggiungi percorso come riportato di seguito.
  - Nella pagina Informazioni percorso:
    1. Per Nome percorso, immettere un nome per questo percorso.
    2. Fare clic su Successivo.
  - Nella pagina Opzioni di origine:
    1. Per Origine Extract, lasciare vuoto.
    2. In Nome traccia, immettere il nome del trail Initial Load Extract (I1).
    3. Fare clic su Successivo.
  - Nella pagina Opzioni target:
    1. Per Target, selezionare wss.
    2. Per Host di destinazione, immettere l'URL di distribuzione di destinazione, senza l'https:// o le barre finali.
    3. In Numero porta, immettere 443.
    4. Per Nome percorso, immettere I1.
    5. Per Metodo di autenticazione target, selezionare Alias UserID.
    6. In Dominio, immettere il nome di dominio creato nel passo precedente.
    7. In Alias, immettere l'alias creato nel passo precedente (dpuser).
    8. Fare clic su Successivo.
3. Fare clic su Crea ed esegui.
Si torna alla pagina Distribution Service in cui è possibile rivedere il percorso creato.
Nella console di distribuzione MySQL di destinazione, esaminare il file Receiver path creato come risultato del file Distribution Path:
1. Fare clic su Receiver Service.
2. Esaminare i dettagli di Distribution Path.

Task 5: aggiungere Replicat per Initial Load

Nella console di distribuzione target MySQL aggiungere una tabella Checkpoint.
1. Nel menu di navigazione, selezionare Connessioni al database, Database HeatWave di destinazione, quindi Checkpoints.
2. Fare clic su Aggiungi Checkpoint (icona con il segno più).
3. Nel riquadro Checkpoint, in Tabella schema, immettere SRCMIRROR_OCIGGLL.CHECKTABLE.
4. Fare clic su Sottometti.
Aggiungere il file Initial Load Replicat.
1. Nel menu di navigazione, fare clic su Replicats, quindi su Aggiungi Replicat (icona più).
2. Nella pagina Replicats, completare i campi Aggiungi Replicat come indicato di seguito.
  1. Nella pagina Replicat Informazioni:
    1. Per tipo Replicat, selezionare Parallelo o Coordinato.
    2. Per Nome processo, immettere un nome, ad esempio RIL.
    3. Fare clic su Successivo.
  2. Nella pagina Opzioni Replicat:
    1. In Nome trail replicato, immettere il nome del trail dal task 2 (I1).
    2. Per Credenziali di destinazione, selezionare Dominio e Alias per la connessione al database HeatWave.
    3. Per Checkpoint Tabella, selezionare la tabella Checkpoint creata nel passo 1.
    4. Fare clic su Successivo.
  3. Nella pagina File parametri aggiungere il mapping seguente:
```
MAP src_ociggll.*, TARGET SRCMIRROR_OCIGGLL.*;
```
3. Fare clic su Crea ed esegui.
Si torna alla pagina Replicats, dove è possibile rivedere i dettagli di Replicat.
Verifica il file Initial Load:
1. In Cloud Shell, connettersi alla VCN e alla subnet utilizzate dall'istanza HeatWave.
2. Una volta connesso, eseguire il comando seguente:
```
mysqlsh <user>@<MySQL DB Private IP>:3306 --sql
```
3. Eseguire lo script riportato di seguito per verificare i dati.
```
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 come risultato del comando Initial Load.

Task 6: creare il file Distribution Path per Change Data Capture

Per creare un file Distribution Path per Change Data Capture, effettuare le operazioni riportate di seguito.

Nella console di distribuzione origine PostgreSQL, fare clic su Servizio di distribuzione.
Fare clic su Aggiungi Distribution Path.
Completare il form Aggiungi percorso come riportato di seguito.
1. Nella pagina Informazioni percorso:
  1. Per Nome percorso, immettere un nome.
  2. Fare clic su Successivo.
2. Nella pagina Opzioni di origine:
  1. Per Origine Extract, selezionare Change Data Capture Extract (ECDC)).
  2. In Nome percorso, selezionare il file trail Change Data Capture (C1).
  3. Fare clic su Successivo.
3. Nella pagina Opzioni target:
  1. Per Target, selezionare wss.
  2. Per Host di destinazione, immettere l'URL della console di distribuzione di destinazione (è possibile trovarlo nella pagina dei dettagli della distribuzione, senza l'https:// o le barre finali.
  3. In Numero porta, immettere 443.
  4. Per Nome percorso, immettere C1.
  5. Per Metodo di autenticazione target, selezionare Alias UserID.
  6. Per Dominio, immettere il nome del dominio.
  7. Per Alias, immettere l'alias.
4. Fare clic su Crea percorso ed esegui.
Nella console di distribuzione destinazione MySQL, fare clic su Servizio ricevente, quindi esaminare il Receiver Path creato.

Task 7: aggiungere un Replicat per Change Data Capture

Eseguire gli aggiornamenti al database PostgreSQL di origine per verificare la replica nel database HeatWave di destinazione.

Aggiungi Replicat:
1. Nella console di distribuzione destinazione, fare clic su Administration Service, quindi nel menu di navigazione fare clic su Replicats.
2. Nella pagina Replicats, fare clic su Aggiungi Replicat (icona più), quindi completare il form Aggiungi Replicat come indicato di seguito.
  - Nella pagina Replicat Informazioni:
    1. Per tipo Replicat, selezionare Nonintegrated Replicat.
    2. Per Nome processo, immettere un nome, ad esempio RCDC.
    3. Fare clic su Successivo.
  - Nella pagina Opzioni Replicat:
    1. In Replicat Nome trail, immettere il nome del trail dal task 3 (C1).
    2. Per Credenziali di destinazione, selezionare il dominio e l'alias per la connessione HeatWave.
    3. In Tabella checkpoint, selezionare la tabella Checkpoint.
3. Nella pagina Parametri Replicat, sostituire MAP *.*, TARGET *.*; con il mapping seguente:
```
MAP src_ociggll.*, TARGET SRCMIRROR_OCIGGLL.*;
```
4. Fare clic su Crea ed esegui.
  
  Si torna alla pagina Replicats, dove è possibile rivedere i dettagli di Replicat.

Verifica Change Data Capture:

Eseguire gli aggiornamenti al database PostgreSQL di origine per verificare la replica nel database di destinazione HeatWave. 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 origine PostgreSQL selezionare il nome Change Data Capture Extract (ECDC), fare clic su Dettagli, quindi fare clic su Statistiche. Verificare che src_ociggll.src_city contenga 10 inserimenti.

Nota
Se Extract non ha acquisito alcun inserimento, riavviare ECDC Extract.
Nella distribuzione destinazione MySQL, selezionare RCDC Replicat, rivedere i relativi dettagli e statistiche per verificare il numero di inserimenti.