No final de 2022 a Oracle passou a suportar a simulação de cargas de trabalho com Oracle RAT (Real Application Testing) no Autonomous Database através da package DBMS_CLOUD_ADMIN, o que trouxe uma boa automação para copiar arquivos de captura a partir de um Bucket no Object Storage e executá-los em um dos nodes de Exadata que suportam o Autonomous Database. Ao final do processo, os arquivos resultantes do RAT Replay são carregados de volta no mesmo Bucket dos arquivos de captura.

Este post apresenta um passo a passo de como testar um workload no Autonomous Database usando Oracle RAT, demonstrando as particularidades específicas para usar o RAT neste serviço da OCI.

Resumo das etapas:

1. (Apenas para LAB): Criando um schema de exemplo no banco de dados de origem
2. Captura da carga de trabalho na origem
3. Gerando DUMP do schema na origem para carga inicial no Autonomous
4. Upload dos arquivos para o Bucket OCI
5. Carga Inicial no Autonomous
6. Executando o RAT Database Replay no Autonomous

1) (Apenas para LAB): Crie um schema de exemplo no banco de dados da origem

Neste post usarei um schema de exemplo chamado “user_replay” apenas para fins didáticos.

[oracle@lab01 ~]$ sqlplus system/dibiei@pdbsoe

drop user user_replay cascade;

CREATE USER user_replay IDENTIFIED BY user_replay;
GRANT CONNECT, resource, unlimited tablespace TO user_replay;

Conecte-se com o usuário de teste do RAT:

[oracle@lab01 ~]$ sqlplus user_replay/user_replay@pdbsoe

Crie uma carga inicial com 10 mil registros:

CREATE TABLE user_replay.db_replay_test_tab (
  id           NUMBER,
  description  VARCHAR2(50),
  CONSTRAINT db_replay_test_tab_pk PRIMARY KEY (id)
);  


BEGIN
  FOR i IN 1 .. 10000 LOOP
    INSERT INTO db_replay_test_tab (id, description)
    VALUES (i, 'Description for ' || i);
  END LOOP;
  COMMIT;
END;
/ 

2) Captura do RAT na Origem

2.1) Crie diretório no sistema operacional:

[oracle@lab01 ~]$ rm -rf /u01/capture/
[oracle@lab01 ~]$ mkdir -p /u01/capture/

2.2) Crie um Oracle Directory para o RAT (Esse Directory será usado pelo RAT para gerar os arquivos de captura):

SQL> CREATE OR REPLACE DIRECTORY CAPTURE_DIR AS '/u01/capture/';

:

2.3) Inicie a captura do RAT no banco de origem:

BEGIN
  DBMS_WORKLOAD_CAPTURE.start_capture (
  name => 'captura_adb', 
  dir  => 'CAPTURE_DIR',
  duration => NULL
  );
END;
/

2.4) Simulando carga de trabalho na origem (apenas para LAB)

Em um cenário real, você apenas precisaria aguardar um determinado tempo enquanto os usuários trabalham normalmente na aplicação.

Como estou realizando teste em LAB, vou simular uma carga de trabalho com INSERTs na tabela user_replay.db_replay_test_tab.

2.4.1) Conecte-se com o usuário da “aplicação”:

[oracle@lab01 ~]$ sqlplus user_replay/user_replay@pdbsoe

2.4.2) Execute os inserts de 10.001 a 5.000.000:

BEGIN
  FOR i IN 10001 .. 5000000 LOOP
    INSERT INTO db_replay_test_tab (id, description)
    VALUES (i, 'Description for ' || i);
  END LOOP;
  COMMIT;
END;
/

2.5) Pare a captura quando a carga de trabalho desejada for concluída

2.5.1) Conecte como SYS/SYSTEM novamente:

[oracle@lab01 ~]$ sqlplus system/dibiei@pdbsoe

2.5.2) Pare a captura em andamento:

BEGIN
  DBMS_WORKLOAD_CAPTURE.finish_capture;
END;
/  

3) Gere um DUMP para Carga Inicial no Autonomous

3.1) Obtenha o ID da última captura:

SQL> SELECT DBMS_WORKLOAD_CAPTURE.GET_CAPTURE_INFO('CAPTURE_DIR') AS ID FROM DUAL;

        ID
----------
        21

3.2) Obtenha o SCN do início da captura:

SQL> SELECT START_SCN FROM DBA_WORKLOAD_CAPTURES WHERE ID = 21;

 START_SCN
----------
   5489941

3.3) Crie o diretório para o export no sistema operacional:

[oracle@lab01 ~]$ mkdir -p /u01/export_adb

3.4) Crie o Oracle Directory para o DataPump export:

CREATE OR REPLACE DIRECTORY EXPORT_ADB AS '/u01/export_adb/';

3.5) Crie um arquivo de parâmetros para o DataPump export (expdp):

[oracle@lab01 ~]$ vi exp_adb.par

Exemplo com os parâmetros básicos recomendados para Autonomous Database:

exclude=cluster,indextype,db_link
directory=EXPORT_ADB
parallel=4
schemas=replay_user
dumpfile=adbrat%u.dmp
encryption_pwd_prompt=yes
flashback_scn=548994

Em flashback_scn, informe o SCN referente ao início da captura do RAT.

3.6) Inicie o export usando a opção parfile e escolha uma senha para o DataPump encriptar o dumpfile (pode ser uma senha simples):

[oracle@lab01 ~]$ expdp system/dibiei@pdbsoe parfile=exp_adb.par

Copyright (c) 1982, 2019, Oracle and/or its affiliates.  All rights reserved.

Connected to: Oracle Database 19c Enterprise Edition Release 19.0.0.0.0 - Production

Encryption Password:
Starting "SYSTEM"."SYS_EXPORT_SCHEMA_01":  system/********@pdbsoe parfile=exp_adb.par
Processing object type SCHEMA_EXPORT/TABLE/STATISTICS/TABLE_STATISTICS
Processing object type SCHEMA_EXPORT/TABLE/INDEX/STATISTICS/INDEX_STATISTICS
........

4) Upload dos arquivos para o Bucket OCI

4.1) Crie um Bucket na OCI para armazenar os arquivos do DataPump (carga inicial) e do RAT (captura + resultado do replay):

4.2 Crie uma Auth Token na OCI para o seu usuário conseguir acessar o Object Storage via API / HTTPs.

Além de ser usado pelo DataPump import durante a carga inicial, esse token também será usado como uma “senha” do seu usuário da OCI pela API do RAT no Autonomous Database para acessar os arquivos de captura que serão hospedados no Object Storage.

Na página do usuário, siga esses passos:

1. Clique em “Auth Tokens”
2. Clique em “Generate Token”
3. Informe uma descrição que ajude a identificar o uso desse Token
4. Clique em “Generate Token”
5. Copie o Token gerado e salve em um local seguro
6. Clique em close

IMPORTANTE: Você precisa copiar o token e salvar em algum lugar antes de clicar em “Close”, não é possível consultar o token depois de fechar esta janela. Se você esquecer de anotar, será necessário deletar este Token e criar um novo.

4.3) Anote o OCI Object Storage Namespace do seu Tenancy.

a) Clique no ícone do seu usuário e depois em Tenancy:

b) Anote o texto apresentado em Object storage namespace

4.4) Crie e ajuste o script upload_to_oci.sh usando as informações da sua conta OCI coletadas nas etapas anteriores.

4.5) Upload dos arquivos de export do DataPump para serem importados no Autonomous:

[oracle@lab01 ~]$ ./upload_to_oci.sh /u01/export_adb/

4.6) Upload dos arquivos de captura do RAT para serem reproduzidos no Autonomous:

[oracle@lab01 ~]$ ./upload_to_oci.sh /u01/capture/

Exemplo de como os arquivos devem aparecer no Bucket após o upload ser concluído:

5) Carga Inicial no Autonomous

5.1) Faça o download da wallet de conexão do Autonomous pela console OCI:

5.2) Copie o arquivo zip para a máquina onde executará o impdp. No meu caso, utilizo o próprio servidor de banco de dados de origem.

O diretório escolhido neste exemplo para armazenar os arquivos de tns do Autonomous é “/home/oracle/tns_adb”.

[oracle@lab01 ~]$ mkdir -P ~/tns_adb
[oracle@lab01 ~]$ unzip Wallet_test.zip -d ~/tns_adb/
[oracle@lab01 ~]$ export TNS_ADMIN=/home/oracle/tns_adb/

5.3) Edite o arquivo sqlnet.ora e altere o parâmetro WALLET_LOCATION para usar o diretório correto do TNS_ADMIN:

[oracle@lab01 ~]$ cat ~/tns_adb/sqlnet.ora
WALLET_LOCATION = (SOURCE = (METHOD = file) (METHOD_DATA = (DIRECTORY="$TNS_ADMIN")))
SSL_SERVER_DN_MATCH=yes

5.4) Conecte-se no Autonomous com usuário ADMIN:

[oracle@lab01 ~]$ sqlplus admin/"ADB_Admin_Password"@test_high

5.5) Crie uma credencial no Autonomous Database usando o Token OCI como”password”.

Essa credencial será usada pelo DataPump impdp e também pelo RAT Database Replay. Isso é um requisito para o Autonomous acessar o conteúdo do Bucket no Object Storage.

BEGIN
  DBMS_CLOUD.CREATE_CREDENTIAL(
    credential_name => 'CRED_ADB_RAT',
    username => 'oracleidentitycloudservice/dibiei@example.com',
    password => 'XXXXYYYWWWW¨&#¨@&$@'
  );
END;
/ 

5.6) Crie um arquivo de parâmetros para usar no DataPump import (impdp):

[oracle@lab01 ~]$ vi imp_adb.par

Exemplo:

directory=DATA_PUMP_DIR
credential=CRED_ADB_RAT
dumpfile= https://objectstorage.sa-saopaulo-1.oraclecloud.com/n/grupbuuadgbc/b/adb-rat/o/export_adb/adbrat%u.dmp
parallel=4
encryption_pwd_prompt=yes
exclude=cluster,indextype,db_link

Para o import, sempre usamos o Directory padrão DATA_PUMP_DIR.

Em dumpfile, use esse padrão para criar a URL correta:

https://objectstorage.<region>.oraclecloud.com/n/<namespace>/b/<bucket_name>/o/<export_folder>/<dumpfile_name>

Observe que “dumpfile_name” deve ser informado o mesmo padrão usado durante o Export.

“export_folder” é opcional, você pode carregar os arquivos direto na raiz do Bucket, mas eu sempre crio essa organização.

Execute o impdp para importar o dumpfile do Bucket OCI para o Autonomous Database (o client impdp utilizado neste exemplo é do próprio servidor de origem):

[oracle@lab01 ~]$ impdp admin/"ADB_Admin_Password"@adb1_high parfile=imp_adb.par

Connected to: Oracle Database 19c Enterprise Edition Release 19.0.0.0.0 - Production

Encryption Password:
Master table "ADMIN"."SYS_IMPORT_FULL_01" successfully loaded/unloaded
import done in AL32UTF8 character set and AL16UTF16 NCHAR character set
export done in US7ASCII character set and AL16UTF16 NCHAR character set
Starting "ADMIN"."SYS_IMPORT_FULL_01":  admin/********@adb1_high parfile=imp_rat.par
Processing object type SCHEMA_EXPORT/USER
Processing object type SCHEMA_EXPORT/SYSTEM_GRANT
Processing object type SCHEMA_EXPORT/ROLE_GRANT
Processing object type SCHEMA_EXPORT/DEFAULT_ROLE
Processing object type SCHEMA_EXPORT/PRE_SCHEMA/PROCACT_SCHEMA
Processing object type SCHEMA_EXPORT/TABLE/TABLE
Processing object type SCHEMA_EXPORT/TABLE/TABLE_DATA
. . imported "USER_REPLAY"."DB_REPLAY_TEST_TAB"          287.4 KB   10000 rows
Processing object type SCHEMA_EXPORT/TABLE/CONSTRAINT/CONSTRAINT
Processing object type SCHEMA_EXPORT/TABLE/INDEX/STATISTICS/INDEX_STATISTICS
Processing object type SCHEMA_EXPORT/TABLE/STATISTICS/TABLE_STATISTICS
Processing object type SCHEMA_EXPORT/STATISTICS/MARKER
Job "ADMIN"."SYS_IMPORT_FULL_01" successfully completed at Fri Feb 10 02:06:25 2023 elapsed 0 00:00:14

6) Executando o RAT Database Replay no Autonomous

6.1) Conecte-se no Autonomous com usuário ADMIN e execute o comando para iniciar o Replay:

BEGIN
 DBMS_CLOUD_ADMIN.replay_workload(
  location_uri => 'https://swiftobjectstorage.sa-saopaulo-1.oraclecloud.com/v1/grupbuuadgbc/adb-rat/capture',
  credential_name => 'CRED_ADB_RAT',
  synchronization => TRUE,
  process_capture => TRUE
  );
END;
/ 

A execução do RAT via DBMS_CLOUD_ADMIN automatiza todo o processo do RAT que normalmente precisamos executar sequencialmente de forma manual em um banco não-Autonomous, como:

• Processar a Captura (DBMS_WORKLOAD_REPLAY.process_capture)
• Inicializar o Replay (DBMS_WORKLOAD_REPLAY.initialize_replay)
• Preparar o Replay para Calibragem dos Clients (DBMS_WORKLOAD_REPLAY.prepare_replay)
• Calibrar os Clients (wrc mode=calibrate)
• Inicializar os Clients (wrc mode=replay)
• Iniciar o Replay no Banco de Dados (DBMS_WORKLOAD_REPLAY.start_replay)
• Gerar o relatório HTML com resultado do RAT (DBMS_WORKLOAD_REPLAY.report)

6.2) Monitore o progresso do Replay com a query abaixo:

SET LINESIZE 300
COL END_SCN FORMAT 999999999999999999
COL START_SCN FORMAT 9999999999999999999
COL NAME FORMAT A40
COL STATUS FORMAT A20
COL CAPTURE_SIZE_MB FORMAT 999,999,999.99
COL SIZE_ESTIMATED FORMAT 999,999,999.99
SELECT ID, 
       NAME, 
	   STATUS,  
	   TO_CHAR(START_TIME,'DD/MM/YYYY HH24:MI:SS') AS START_TIME,
	   TO_CHAR(END_TIME,'DD/MM/YYYY HH24:MI:SS') AS END_TIME
FROM DBA_WORKLOAD_REPLAYS
ORDER BY 1;

        ID NAME                                     STATUS               START_TIME          END_TIME
---------- ---------------------------------------- -------------------- ------------------- -------------------
         1 REPLAY_1676150124                        IN PROGRESS          11/02/2023 21:16:10

Nesse momento, podemos usar a interface da OCI para monitorar o comportamento do banco de dados durante a execução do RAT:

Algum tempo depois:

        ID NAME                                     STATUS               START_TIME          END_TIME
---------- ---------------------------------------- -------------------- ------------------- -------------------
         1 REPLAY_1676150124                        COMPLETED            11/02/2023 21:16:10 11/02/2023 21:23:52

Após alguns minutos com o Replay concluído, os arquivos com resultado do RAT serão carregados automaticamente no mesmo Bucket usado pelos arquivos de captura (nos testes que realizei, isso levou entre 5 a 15 minutos).

Podemos fazer download desses arquivos e analisá-los localmente. Inicialmente os mais interessantes são “adb_replay_report.html” que contém o resumo do RAT Database Replay, como o comparativo de tempo de execução e possíveis erros que ocorreram durante o processo.

O arquivo “awr_report.html” é um relatório AWR gerado a nível de PDB com Snapshots criados no início e no final da operação de Replay, que podemos usar para analisar o comportamento do banco de dados durante a execução do RAT.

É possível que a operação de REPLAY seja apresentada com status de COMPLETED na DBA_WORKLOAD_REPLAYS, mas a execuções dos comandos SQL falhem com algum erro ORA. Você pode identificar esses possíveis erros no arquivo adb_replay_report.html.