# Administração da sua instância de banco de dados Oracle
A seguir estão as tarefas de gerenciamento comuns que você realiza com uma instância de banco de dados do Amazon RDS. Algumas tarefas são as mesmas para todas as instâncias de banco de dados do RDS. Outras tarefas são específicas do RDS for Oracle.
As tarefas a seguir são comuns a todos os bancos de dados do RDS, mas o Oracle tem considerações especiais. Por exemplo, conecte-se a um banco de dados Oracle usando os clientes Oracle SQL\$1Plus e SQL Developer.
****
| Área de tarefa | Documentação relevante |
| --- | --- |
| **Classes de instância, armazenamento e PIOPS** Se você estiver criando uma instância de produção, saiba como funcionam as classes de instância, os tipos de armazenamento e as IOPS provisionadas no Amazon RDS. | [Classes de instância de banco de dados do RDS para Oracle](Oracle.Concepts.InstanceClasses.md) [Tipos de armazenamento do Amazon RDS](CHAP_Storage.md#Concepts.Storage) |
| **Implantações multi-AZ** Uma instância de banco de dados de produção deve usar implantações multi-AZ. As implantações multi-AZ oferecem maior disponibilidade, durabilidade de dados e tolerância a falhas para instâncias de banco de dados. | [Configurar e gerenciar uma implantação multi-AZ para o Amazon RDS](Concepts.MultiAZ.md) |
| **Amazon VPC** Se a sua conta AWS tiver uma nuvem privada virtual (VPC) padrão, a instância de banco de dados será criada automaticamente dentro da VPC padrão. Se a sua conta não tiver uma VPC padrão e você desejar a instância de banco de dados em uma VPC, crie os grupos de VPC e sub-redes antes de criar a instância. | [Trabalhar com uma instância de banco de dados em uma VPC](USER_VPC.WorkingWithRDSInstanceinaVPC.md) |
| **Grupos de segurança** Por padrão, as instâncias de banco de dados usam um firewall que impede o acesso. Crie um grupo de segurança com os endereços IP corretos e uma configuração de rede para acessar a instância de banco de dados. | [Controlar acesso com grupos de segurança](Overview.RDSSecurityGroups.md) |
| **Grupos de parâmetros** Se a sua instância de banco de dados exigir parâmetros de banco de dados específicos, crie um grupo de parâmetros antes de criar essa instância de banco de dados. | [Grupos de parâmetros para Amazon RDS](USER_WorkingWithParamGroups.md) |
| **Grupos de opções** Se a sua instância de banco de dados exigir opções de banco de dados específicas, crie um grupo de opções antes de criar a instância de banco de dados. | [Adição de opções a instâncias de banco de dados Oracle](Appendix.Oracle.Options.md) |
| **Conexão à instância de banco de dados** Após criar um grupo de segurança e associá-lo a uma instância de banco de dados, será possível se conectar à instância de banco de dados usando qualquer aplicativo de cliente SQL padrão, como o Oracle SQL\$1Plus. | [Conectar-se a uma instância de banco de dados Oracle](USER_ConnectToOracleInstance.md) |
| **Backup e restauração** Você pode configurar a instância de banco de dados para fazer backups automáticos ou snapshots manuais e, depois, restaurar instâncias a partir dos backups ou snapshots. | [Backup, restauração e exportação de dados](CHAP_CommonTasks.BackupRestore.md) |
| **Monitoramento** Você pode monitorar uma instância de banco de dados Oracle usando as métricas, eventos e o monitoramento aprimorado do Amazon RDS do CloudWatch. | [Visualizar métricas no console do Amazon RDS](USER_Monitoring.md) [Visualizar eventos do Amazon RDS](USER_ListEvents.md) |
| **Arquivos de log** Você pode acessar os arquivos de log de sua instância de banco de dados Oracle. | [Monitorar arquivos de log do Amazon RDS](USER_LogAccess.md) |
A seguir, você pode encontrar uma descrição para implantações específicas do Amazon RDS de tarefas comuns de DBA para o RDS Oracle. Para oferecer uma experiência de serviço gerenciada, o Amazon RDS não fornece acesso ao shell para as instâncias de banco de dados. Além disso, o RDS restringe o acesso a determinados procedimentos e tabelas do sistema que exigem privilégios avançados. Em muitas das tarefas, você executa o pacote `rdsadmin`, que é uma ferramenta específica do Amazon RDS que permite administrar seu banco de dados.
Veja a seguir tarefas do DBA comuns para instâncias de bancos de dados executando o Oracle:
+ [Tarefas do sistema](Appendix.Oracle.CommonDBATasks.System.md)
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.html)
+ [Tarefas de banco de dados](Appendix.Oracle.CommonDBATasks.Database.md)
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.html)
+ [Tarefas de log](Appendix.Oracle.CommonDBATasks.Log.md)
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.html)
+ [Tarefas do RMAN](Appendix.Oracle.CommonDBATasks.RMAN.md)
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.html)
+ [Tarefas do Oracle Scheduler](Appendix.Oracle.CommonDBATasks.Scheduler.md)
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.html)
+ [Diagnosticar problemas](Appendix.Oracle.CommonDBATasks.Diagnostics.md)
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.html)
+ [Outras tarefas](Appendix.Oracle.CommonDBATasks.Misc.md)
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.html)
Você também pode usar procedimentos do Amazon RDS para integração do Amazon S3 com o Oracle e para executar tarefas de banco de dados do OEM Management Agent. Para obter mais informações, consulte [Integração do Amazon S3](oracle-s3-integration.md) e [Como executar tarefas de banco de dados com o Management Agent](Oracle.Options.OEMAgent.md#Oracle.Options.OEMAgent.DBTasks).
# Realização de tarefas comuns do sistema para instâncias de banco de dados Oracle
Veja a seguir como executar determinadas tarefas comuns de DBA relacionadas ao sistema nas instâncias de bancos de dados do Amazon RDS que executam o Oracle. Para oferecer uma experiência de serviço gerenciado, o Amazon RDS não fornece acesso ao shell para instâncias de bancos de dados e restringe o acesso a determinados procedimentos e tabelas do sistema que exigem privilégios avançados.
**Topics**
+ [
# Desconectar uma sessão
](Appendix.Oracle.CommonDBATasks.DisconnectingSession.md)
+ [
# Encerrar uma sessão
](Appendix.Oracle.CommonDBATasks.KillingSession.md)
+ [
# Como cancelar uma instrução SQL em uma sessão
](Appendix.Oracle.CommonDBATasks.CancellingSQL.md)
+ [
# Habilitar e desabilitar sessões restritas
](Appendix.Oracle.CommonDBATasks.RestrictedSession.md)
+ [
# Descarregar o grupo compartilhado
](Appendix.Oracle.CommonDBATasks.FlushingSharedPool.md)
+ [
# Concessão de privilégios SELECT ou EXECUTE a objetos SYS
](Appendix.Oracle.CommonDBATasks.TransferPrivileges.md)
+ [
# Revogar privilégios SELECT ou EXECUTE em objetos SYS
](Appendix.Oracle.CommonDBATasks.RevokePrivileges.md)
+ [
# Gerenciar visualizações RDS\$1X\$1 para instâncias de banco de dados Oracle
](Appendix.Oracle.CommonDBATasks.X-dollar.md)
+ [
# Concessão de privilégios a usuários não mestres
](Appendix.Oracle.CommonDBATasks.PermissionsNonMasters.md)
+ [
# Criação de funções personalizadas para verificar senhas
](Appendix.Oracle.CommonDBATasks.CustomPassword.md)
+ [
## Configuração de um servidor DNS personalizado
](#Appendix.Oracle.CommonDBATasks.CustomDNS)
+ [
# Configurar e anular configuração de eventos de diagnóstico do sistema
](Appendix.Oracle.CommonDBATasks.SystemEvents.md)
# Desconectar uma sessão
Para desconectar a sessão atual finalizando o processo de servidor dedicado, use o procedimento do Amazon RDS `rdsadmin.rdsadmin_util.disconnect`. O procedimento `disconnect` tem os seguintes parâmetros.
****
| Nome do parâmetro | Tipo de dados | Padrão | Obrigatório | Descrição |
| --- | --- | --- | --- | --- |
| `sid` | número | — | Sim | O identificador da sessão. |
| `serial` | número | — | Sim | O número de série da sessão. |
| `method` | varchar | 'IMMEDIATE' | Não | Os valores válidos são `'IMMEDIATE'` ou `'POST_TRANSACTION'`. |
O exemplo a seguir desconecta uma sessão.
```
begin
rdsadmin.rdsadmin_util.disconnect(
sid => sid,
serial => serial_number);
end;
/
```
Para obter o identificador da sessão e o número de série da sessão, consulte a visualização `V$SESSION`. O seguinte exemplo obtém todas as sessões para o usuário `AWSUSER`.
```
SELECT SID, SERIAL#, STATUS FROM V$SESSION WHERE USERNAME = 'AWSUSER';
```
O banco de dados deve estar aberto para usar esse método. Para obter mais informações sobre como desconectar uma sessão, consulte [ALTER SYSTEM](http://docs.oracle.com/cd/E11882_01/server.112/e41084/statements_2014.htm#SQLRF53166) (Alterar sistema) na documentação do Oracle.
# Encerrar uma sessão
Para encerrar uma sessão, use o procedimento do Amazon RDS `rdsadmin.rdsadmin_util.kill`. O procedimento `kill` tem os seguintes parâmetros.
****
| Nome do parâmetro | Tipo de dados | Padrão | Obrigatório | Descrição |
| --- | --- | --- | --- | --- |
| `sid` | número | — | Sim | O identificador da sessão. |
| `serial` | número | — | Sim | O número de série da sessão. |
| `method` | varchar | nulo | Não | Os valores válidos são `'IMMEDIATE'` ou `'PROCESS'`. Se você especificar `IMMEDIATE`, terá o mesmo resultado que o produzido ao executar a seguinte instrução: ALTER SYSTEM KILL SESSION 'sid,serial#' IMMEDIATE
Se você especificar `PROCESS`, encerrará os processos associados a uma sessão. Especifique `PROCESS` apenas se o encerramento da sessão com `IMMEDIATE` foi bem-sucedido. |
Para obter o identificador da sessão e o número de série da sessão, consulte a visualização `V$SESSION`. O seguinte exemplo obtém todas as sessões para o usuário *AWSUSER*.
```
SELECT SID, SERIAL#, STATUS FROM V$SESSION WHERE USERNAME = 'AWSUSER';
```
O exemplo a seguir encerra uma sessão.
```
BEGIN
rdsadmin.rdsadmin_util.kill(
sid => sid,
serial => serial_number,
method => 'IMMEDIATE');
END;
/
```
No exemplo a seguir, os processos associados a uma sessão são encerrados.
```
BEGIN
rdsadmin.rdsadmin_util.kill(
sid => sid,
serial => serial_number,
method => 'PROCESS');
END;
/
```
# Como cancelar uma instrução SQL em uma sessão
Para cancelar uma instrução SQL em uma sessão, use o procedimento do Amazon RDS `rdsadmin.rdsadmin_util.cancel`.
**nota**
Esse procedimento é compatível com o Oracle Database 19c (19.0.0) e com todas as versões principais e secundárias posteriores do RDS for Oracle.
O procedimento `cancel` tem os seguintes parâmetros.
****
| Nome do parâmetro | Tipo de dados | Padrão | Obrigatório | Descrição |
| --- | --- | --- | --- | --- |
| `sid` | número | — | Sim | O identificador da sessão. |
| `serial` | número | — | Sim | O número de série da sessão. |
| `sql_id` | varchar2 | nulo | Não | O identificador SQL da instrução SQL |
O exemplo a seguir canela uma instrução SQL em uma sessão.
```
begin
rdsadmin.rdsadmin_util.cancel(
sid => sid,
serial => serial_number,
sql_id => sql_id);
end;
/
```
Para obter o identificador da sessão, o número de série da sessão e o identificador SQL de uma instrução SQL, consulte a visualização `V$SESSION`. O exemplo a seguir obtém todos os identificadores SQL e de sessão para o usuário `AWSUSER`.
```
select SID, SERIAL#, SQL_ID, STATUS from V$SESSION where USERNAME = 'AWSUSER';
```
# Habilitar e desabilitar sessões restritas
Para habilitar e desabilitar sessões restritas, use o procedimento do Amazon RDS `rdsadmin.rdsadmin_util.restricted_session`. O procedimento `restricted_session` tem os seguintes parâmetros.
****
| Nome do parâmetro | Tipo de dados | Padrão | Sim | Descrição |
| --- | --- | --- | --- | --- |
| `p_enable` | booliano | true | Não | Defina como `true` para habilitar sessões restritas, `false` para desabilitar sessões restritas. |
O exemplo a seguir mostra como habilitar e desabilitar sessões restritas.
```
/* Verify that the database is currently unrestricted. */
SELECT LOGINS FROM V$INSTANCE;
LOGINS
-------
ALLOWED
/* Enable restricted sessions */
EXEC rdsadmin.rdsadmin_util.restricted_session(p_enable => true);
/* Verify that the database is now restricted. */
SELECT LOGINS FROM V$INSTANCE;
LOGINS
----------
RESTRICTED
/* Disable restricted sessions */
EXEC rdsadmin.rdsadmin_util.restricted_session(p_enable => false);
/* Verify that the database is now unrestricted again. */
SELECT LOGINS FROM V$INSTANCE;
LOGINS
-------
ALLOWED
```
# Descarregar o grupo compartilhado
Para descarregar o grupo compartilhado, use o procedimento do Amazon RDS `rdsadmin.rdsadmin_util.flush_shared_pool`. O procedimento `flush_shared_pool` não tem parâmetros.
O exemplo a seguir libera o pool compartilhado.
```
EXEC rdsadmin.rdsadmin_util.flush_shared_pool;
```
## Descarregar o cache do buffer
Para descarregar o cache do buffer, use o procedimento do Amazon RDS `rdsadmin.rdsadmin_util.flush_buffer_cache`. O procedimento `flush_buffer_cache` não tem parâmetros.
O exemplo a seguir libera o cache do buffer.
```
EXEC rdsadmin.rdsadmin_util.flush_buffer_cache;
```
## Limpar o cache flash inteligente do banco de dados
Para limpar o cache do flash inteligente do banco de dados, use o procedimento `rdsadmin.rdsadmin_util.flush_flash_cache` do Amazon RDS. O procedimento `flush_flash_cache` não tem parâmetros. O exemplo a seguir libera o cache do flash inteligente do banco de dados.
```
EXEC rdsadmin.rdsadmin_util.flush_flash_cache;
```
Para obter mais informações sobre o uso do cache flash inteligente do banco de dados com o RDS para Oracle, consulte [Armazenar dados temporários em um armazenamento de instância do RDS for Oracle](CHAP_Oracle.advanced-features.instance-store.md).
# Concessão de privilégios SELECT ou EXECUTE a objetos SYS
Normalmente, você transfere privilégios usando funções, que podem conter muitos objetos. Para conceder privilégios a um único objeto, use o procedimento do Amazon RDS `rdsadmin.rdsadmin_util.grant_sys_object`. O procedimento concede apenas privilégios já concedidos ao usuário mestre por uma função ou por uma concessão direta.
O procedimento `grant_sys_object` tem os seguintes parâmetros.
**Importante**
Para todos os valores de parâmetro, use letras maiúsculas, a menos que você tenha criado o usuário com um identificador que diferencia letras maiúsculas de minúsculas. Por exemplo, se você executar `CREATE USER myuser` ou `CREATE USER MYUSER`, o dicionário de dados armazenará `MYUSER`. No entanto, se você usar aspas duplas em `CREATE USER "MyUser"`, o dicionário de dados armazenará `MyUser`.
****
| Nome do parâmetro | Tipo de dados | Padrão | Obrigatório | Descrição |
| --- | --- | --- | --- | --- |
| `p_obj_name` | varchar2 | — | Sim | O nome do objeto ao qual conceder privilégios. O objeto pode ser um diretório, uma função, um pacote, um procedimento, uma sequência, uma tabela ou uma visualização. Os nomes dos objetos devem ser expressos exatamente como eles aparecem em `DBA_OBJECTS`. Como a maioria dos objetos do sistema é definida em maiúsculas, recomendamos que você tente isso primeiro. |
| `p_grantee` | varchar2 | — | Sim | O nome do objeto para o qual conceder privilégios. O objeto pode ser uma esquema ou um função. |
| `p_privilege` | varchar2 | nulo | Sim | — |
| `p_grant_option` | booliano | false | Não | Defina como `true` para usar a opção de concessão. |
O exemplo a seguir concede privilégios de seleção em um objeto chamado `V_$SESSION` a um usuário chamado `USER1`.
```
begin
rdsadmin.rdsadmin_util.grant_sys_object(
p_obj_name => 'V_$SESSION',
p_grantee => 'USER1',
p_privilege => 'SELECT');
end;
/
```
O exemplo a seguir concede privilégios de seleção em um objeto chamado `V_$SESSION` a um usuário chamado `USER1` com a opção de concessão.
```
begin
rdsadmin.rdsadmin_util.grant_sys_object(
p_obj_name => 'V_$SESSION',
p_grantee => 'USER1',
p_privilege => 'SELECT',
p_grant_option => true);
end;
/
```
Para poder conceder privilégios a um objeto, sua conta deve ter esses privilégios concedidos a ela diretamente com a opção de concessão ou por meio de uma função concedida usando `with admin option`. No caso mais comum, você pode querer conceder `SELECT` em uma visualização de DBA que foi concedida à função `SELECT_CATALOG_ROLE`. Se essa função ainda não estiver diretamente concedida ao seu usuário usando `with admin option`, você não poderá transferir o privilégio. Se você tiver privilégios de DBA, poderá conceder a função diretamente a outro usuário.
O exemplo a seguir concede `SELECT_CATALOG_ROLE` e `EXECUTE_CATALOG_ROLE` a `USER1`. Com o `with admin option` é usado, `USER1` agora pode conceder acesso a objetos SYS que foram concedidos a `SELECT_CATALOG_ROLE`.
```
GRANT SELECT_CATALOG_ROLE TO USER1 WITH ADMIN OPTION;
GRANT EXECUTE_CATALOG_ROLE to USER1 WITH ADMIN OPTION;
```
Objetos já concedidos a `PUBLIC` não precisam ser novamente concedidos. Se você usar o procedimento `grant_sys_object` para conceder acesso novamente, a chamada de procedimento será bem-sucedida.
# Revogar privilégios SELECT ou EXECUTE em objetos SYS
Para revogar os privilégios de um único objeto, use o procedimento do Amazon RDS `rdsadmin.rdsadmin_util.revoke_sys_object`. O procedimento revoga apenas os privilégios já concedido à conta mestra por uma função ou por uma concessão direta.
O procedimento `revoke_sys_object` tem os seguintes parâmetros.
****
| Nome do parâmetro | Tipo de dados | Padrão | Obrigatório | Descrição |
| --- | --- | --- | --- | --- |
| `p_obj_name` | varchar2 | — | Sim | O nome do objeto ao qual revogar privilégios. O objeto pode ser um diretório, uma função, um pacote, um procedimento, uma sequência, uma tabela ou uma visualização. Os nomes dos objetos devem ser expressos exatamente como eles aparecem em `DBA_OBJECTS`. A maioria dos objetos do sistema é definida em maiúsculas, então recomendamos que você tente isso primeiro. |
| `p_revokee` | varchar2 | — | Sim | O nome do objeto ao qual revogar privilégios. O objeto pode ser uma esquema ou um função. |
| `p_privilege` | varchar2 | nulo | Sim | — |
O exemplo a seguir revoga privilégios de seleção em um objeto denominado `V_$SESSION` de um usuário denominado `USER1`.
```
begin
rdsadmin.rdsadmin_util.revoke_sys_object(
p_obj_name => 'V_$SESSION',
p_revokee => 'USER1',
p_privilege => 'SELECT');
end;
/
```
# Gerenciar visualizações RDS\$1X\$1 para instâncias de banco de dados Oracle
Talvez seja necessário acessar tabelas `SYS.X$` fixas, que só podem ser acessadas por `SYS`. Para criar visualizações `SYS.RDS_X$` em tabelas `X$` elegíveis, use os procedimentos no pacote `rdsadmin.rdsadmin_util`. O usuário principal recebe automaticamente o privilégio `SELECT … WITH GRANT OPTION` nas visualizações `RDS_X$`.
Os procedimentos `rdsadmin.rdsadmin_util` estão disponíveis nos seguintes casos:
+ Instâncias de banco de dados existentes que nunca foram atualizadas e usam as seguintes versões:
+ `21.0.0.0.ru-2023-10.rur-2023-10.r1` e versões 21c posteriores
+ `19.0.0.0.ru-2023-10.rur-2023-10.r1` e versões 19c posteriores
+ Qualquer nova instância de banco de dados que você criar.
+ Qualquer instância de banco de dados existente que você tenha atualizado.
**Importante**
Internamente, o pacote `rdsadmin.rdsadmin_util` cria visualizações em tabelas `X$`. As tabelas `X$` são objetos internos do sistema que não estão descritos na documentação do Oracle Database. Recomendamos testar visualizações específicas no banco de dados que não é de produção e somente criar visualizações no banco de dados de produção com a orientação do Oracle Support.
## Listar tabelas fixas X\$1 elegíveis para uso em visualizações RDS\$1X\$1
Para listar tabelas X\$1 que são elegíveis para uso em visualizações `RDS_X$`, use o procedimento `rdsadmin.rdsadmin_util.list_allowed_sys_x$_views` do RDS. Este procedimento não aceita parâmetros. As declarações a seguir listam todas as tabelas `X$` elegíveis (exemplo de saída incluído).
```
SQL> SET SERVEROUTPUT ON
SQL> SELECT * FROM TABLE(rdsadmin.rdsadmin_util.list_allowed_sys_x$_views);
'X$BH'
'X$K2GTE'
'X$KCBWBPD'
'X$KCBWDS'
'X$KGLLK'
'X$KGLOB'
'X$KGLPN'
'X$KSLHOT'
'X$KSMSP'
'X$KSPPCV'
'X$KSPPI'
'X$KSPPSV'
'X$KSQEQ'
'X$KSQRS'
'X$KTUXE'
'X$KQRFP'
```
A lista das tabelas `X$` elegíveis pode mudar ao longo do tempo. Para garantir que a lista de tabelas fixas `X$` elegíveis esteja atualizada, execute `list_allowed_sys_x$_views` periodicamente.
## Criar visualizações SYS.RDS\$1X\$1
Para criar uma visualização `RDS_X$` em uma tabela `X$` elegível, use o procedimento `rdsadmin.rdsadmin_util.create_sys_x$_view` do RDS. É possível criar visualizações apenas para as tabelas listadas na saída de `rdsadmin.rdsadmin_util.list_allowed_sys_x$_views`. O procedimento `create_sys_x$_view` tem os parâmetros a seguir.
****
| Nome do parâmetro | Tipo de dados | Padrão | Obrigatório | Descrição |
| --- | --- | --- | --- | --- |
| `p_x$_tbl` | varchar2 | Null | Sim | O nome de uma tabela `X$` válida. O valor deve ser uma das tabelas `X$` relatadas por `list_allowed_sys_x$_views`. |
| `p_force_creation` | Booleano | FALSE | Não | Um valor que indica se é necessário forçar a criação de uma visualização `RDS_X$` que já existe para uma tabela `X$`. Por padrão, o RDS não criará uma visualização se ela já existir. Para forçar a criação, defina esse parâmetro como `TRUE`. |
O exemplo a seguir cria a visualização `SYS.RDS_X$KGLOB` na tabela `X$KGLOB`. O formato do nome da visualização é `RDS_X$tablename`.
```
SQL> SET SERVEROUTPUT ON
SQL> EXEC rdsadmin.rdsadmin_util.create_sys_x$_view('X$KGLOB');
PL/SQL procedure successfully completed.
```
A consulta do dicionário de dados a seguir lista a visualização `SYS.RDS_X$KGLOB` e mostra o status. O usuário principal recebe automaticamente o privilégio `SELECT ... WITH GRANT OPTION` nessa visualização.
```
SQL> SET SERVEROUTPUT ON
SQL> COL OWNER FORMAT A30
SQL> COL OBJECT_NAME FORMAT A30
SQL> COL STATUS FORMAT A30
SQL> SET LINESIZE 200
SQL> SELECT OWNER, OBJECT_NAME, STATUS
FROM DBA_OBJECTS
WHERE OWNER = 'SYS' AND OBJECT_NAME = 'RDS_X$KGLOB';
OWNER OBJECT_NAME STATUS
------------------------------ ------------------------------ ------------------------------
SYS RDS_X$KGLOB VALID
```
**Importante**
Não é garantido que as tabelas `X$` permaneçam as mesmas antes e depois de uma atualização. O RDS para Oracle descarta e recria as visualizações `RDS_X$` nas tabelas `X$` durante uma atualização do mecanismo. Depois, ele concede o privilégio `SELECT ... WITH GRANT OPTION` ao usuário principal. Depois de uma atualização, conceda privilégios aos usuários do banco de dados conforme necessário nas visualizações `RDS_X$` correspondentes.
## Listar visualizações SYS.RDS\$1X\$1
Para listar as visualizações `RDS_X$` existentes, use o procedimento `rdsadmin.rdsadmin_util.list_created_sys_x$_views` do RDS. O procedimento lista somente as visualizações que foram criadas pelo procedimento `create_sys_x$_view`. O exemplo a seguir lista as tabelas `X$` que têm visualizações `RDS_X$` correspondentes (exemplo de saída incluído).
```
SQL> SET SERVEROUTPUT ON
SQL> COL XD_TBL_NAME FORMAT A30
SQL> COL STATUS FORMAT A30
SQL> SET LINESIZE 200
SQL> SELECT * FROM TABLE(rdsadmin.rdsadmin_util.list_created_sys_x$_views);
XD_TBL_NAME STATUS
------------------------------ ------------------------------
X$BH VALID
X$K2GTE VALID
X$KCBWBPD VALID
3 rows selected.
```
## Descartar visualizações RDS\$1X\$1
Para descartar uma visualização `SYS.RDS_X$`, use o procedimento `rdsadmin.rdsadmin_util.drop_sys_x$_view` do RDS. É possível descartar apenas as visualizações na saída de `rdsadmin.rdsadmin_util.list_allowed_sys_x$_views`. O procedimento `drop_sys_x$_view` aceita o parâmetro a seguir.
****
| Nome do parâmetro | Tipo de dados | Padrão | Obrigatório | Descrição |
| --- | --- | --- | --- | --- |
| `p_x$_tbl` | varchar2 | Null | Sim | O nome de uma tabela `X$` fixa válida. O valor deve ser uma das tabelas fixas `X$` relatadas por `list_created_sys_x$_views`. |
O exemplo a seguir cria a visualização `RDS_X$KGLOB` criada na tabela `X$KGLOB`.
```
SQL> SET SERVEROUTPUT ON
SQL> EXEC rdsadmin.rdsadmin_util.drop_sys_x$_view('X$KGLOB');
PL/SQL procedure successfully completed.
```
O exemplo a seguir mostra que a visualização `SYS.RDS_X$KGLOB` foi descartada (exemplo de saída incluído).
```
SQL> SET SERVEROUTPUT ON
SQL> COL OWNER FORMAT A30
SQL> COL OBJECT_NAME FORMAT A30
SQL> COL STATUS FORMAT A30
SQL> SET LINESIZE 200
SQL> SELECT OWNER, OBJECT_NAME, STATUS
FROM DBA_OBJECTS
WHERE OWNER = 'SYS' AND OBJECT_NAME = 'RDS_X$KGLOB';
no rows selected
```
# Concessão de privilégios a usuários não mestres
Você pode conceder privilégios de seleção para muitos objetos no esquema `SYS`, usando a função `SELECT_CATALOG_ROLE`. A função `SELECT_CATALOG_ROLE` concede aos usuários privilégios `SELECT` em visualizações de dicionários de dados. O exemplo a seguir concede a função `SELECT_CATALOG_ROLE` a um usuário chamado `user1`.
```
GRANT SELECT_CATALOG_ROLE TO user1;
```
É possível conceder privilégios `EXECUTE` para muitos objetos no esquema `SYS` usando a função `EXECUTE_CATALOG_ROLE`. A função `EXECUTE_CATALOG_ROLE` concede aos usuários privilégios `EXECUTE` para pacotes e procedimentos no dicionário de dados. O exemplo a seguir concede a função `EXECUTE_CATALOG_ROLE` a um usuário chamado *user1*.
```
GRANT EXECUTE_CATALOG_ROLE TO user1;
```
O exemplo a seguir obtém as permissões permitidas pelas funções `SELECT_CATALOG_ROLE` e `EXECUTE_CATALOG_ROLE`.
```
SELECT *
FROM ROLE_TAB_PRIVS
WHERE ROLE IN ('SELECT_CATALOG_ROLE','EXECUTE_CATALOG_ROLE')
ORDER BY ROLE, TABLE_NAME ASC;
```
O exemplo a seguir cria um usuário não mestre chamado `user1`, concede o privilégio `CREATE SESSION` e concede o privilégio `SELECT` em um banco de dados chamado *sh.sales*.
```
CREATE USER user1 IDENTIFIED BY PASSWORD;
GRANT CREATE SESSION TO user1;
GRANT SELECT ON sh.sales TO user1;
```
# Criação de funções personalizadas para verificar senhas
Você pode criar uma função de verificação de senha personalizada das seguintes maneiras:
+ Para usar a lógica de verificação padrão e armazenar a função no esquema `SYS`, utilize o procedimento `create_verify_function`.
+ Para usar a lógica de verificação padrão ou evitar armazenar a função no esquema `SYS`, utilize o procedimento `create_passthrough_verify_fcn`.
# O procedimento create\$1verify\$1function
Você pode criar uma função personalizada para verificar senhas usando o procedimento do Amazon RDS `rdsadmin.rdsadmin_password_verify.create_verify_function`. O procedimento `create_verify_function` é compatível com todas as versões do RDS para Oracle.
O procedimento `create_verify_function` tem os seguintes parâmetros.
****
| Nome do parâmetro | Tipo de dados | Padrão | Obrigatório | Descrição |
| --- | --- | --- | --- | --- |
| `p_verify_function_name` | varchar2 | — | Sim | O nome da sua função personalizada. Essa função é criada por você no esquema SYS. Você atribui essa função a perfis de usuário. |
| `p_min_length` | número | 8 | Não | O número mínimo de caracteres necessários. |
| `p_max_length` | número | 256 | Não | O número máximo de caracteres permitidos. |
| `p_min_letters` | número | 1 | Não | O número mínimo de letras necessárias. |
| `p_min_uppercase` | número | 0 | Não | O número mínimo de letras maiúsculas necessárias. |
| `p_min_lowercase` | número | 0 | Não | O número mínimo de letras minúsculas necessárias. |
| `p_min_digits` | número | 1 | Não | O número mínimo de dígitos necessários. |
| `p_min_special` | número | 0 | Não | O número mínimo de caracteres especiais necessários. |
| `p_min_different_chars` | número | 3 | Não | O número mínimo de caracteres diferentes exigido entre a senha antiga e nova. |
| `p_disallow_username` | booliano | true | Não | Defina como `true` para não permitir o nome de usuário na senha. |
| `p_disallow_reverse` | booliano | true | Não | Defina como `true` para não permitir o inverso do nome de usuário na senha. |
| `p_disallow_db_name` | booliano | true | Não | Defina como `true` para não permitir o nome do banco de dados ou do servidor na senha. |
| `p_disallow_simple_strings` | booliano | true | Não | Defina como `true` para não permitir strings simples como senha. |
| `p_disallow_whitespace` | booliano | false | Não | Defina como `true` para não permitir caracteres de espaço em branco na senha. |
| `p_disallow_at_sign` | booliano | false | Não | Defina como `true` para não permitir o caractere @ na senha. |
Você pode criar várias funções de verificação de senha.
Existem restrições quanto ao nome da sua função personalizada. Sua função personalizada não pode ter o mesmo nome que um objeto de sistema existente. O nome pode ter no máximo 30 caracteres. Além disso, o nome deve incluir uma das seguintes strings: `PASSWORD`, `VERIFY`, `COMPLEXITY`, `ENFORCE` ou `STRENGTH`.
O exemplo a seguir cria uma função chamada `CUSTOM_PASSWORD_FUNCTION`. A função requer que uma senha tenha pelo menos 12 caracteres, 2 caracteres em maiúsculas, 1 dígito e 1 caractere especial e que a senha não permita o caractere @.
```
begin
rdsadmin.rdsadmin_password_verify.create_verify_function(
p_verify_function_name => 'CUSTOM_PASSWORD_FUNCTION',
p_min_length => 12,
p_min_uppercase => 2,
p_min_digits => 1,
p_min_special => 1,
p_disallow_at_sign => true);
end;
/
```
Para ver o texto da sua função de verificação, consulte `DBA_SOURCE`. O exemplo a seguir obtém o texto de uma função de senha personalizada chamada `CUSTOM_PASSWORD_FUNCTION`.
```
COL TEXT FORMAT a150
SELECT TEXT
FROM DBA_SOURCE
WHERE OWNER = 'SYS'
AND NAME = 'CUSTOM_PASSWORD_FUNCTION'
ORDER BY LINE;
```
Para associar sua função de verificação a um perfil de usuário, use `ALTER PROFILE`. O exemplo a seguir associa uma função de verificação PL/SQL denominada `CUSTOM_PASSWORD_FUNCTION` ao perfil de usuário `DEFAULT`. `PASSWORD_VERIFY_FUNCTION` é o nome do recurso do perfil da Oracle.
```
ALTER PROFILE DEFAULT LIMIT PASSWORD_VERIFY_FUNCTION CUSTOM_PASSWORD_FUNCTION;
```
Para ver quais perfis de usuários estão associados a quais funções de verificação, consulte `DBA_PROFILES`. O exemplo a seguir obtém os perfis associados à função de verificação personalizada chamada `CUSTOM_PASSWORD_FUNCTION`.
```
SELECT * FROM DBA_PROFILES WHERE RESOURCE_NAME = 'PASSWORD_VERIFY_FUNCTION' AND LIMIT = 'CUSTOM_PASSWORD_FUNCTION';
PROFILE RESOURCE_NAME RESOURCE LIMIT
------------------------- -------------------------------- -------- ------------------------
DEFAULT PASSWORD_VERIFY_FUNCTION PASSWORD CUSTOM_PASSWORD_FUNCTION
```
O exemplo a seguir obtém todos os perfis e as funções de verificação de senha às quais eles estão associados.
```
SELECT * FROM DBA_PROFILES WHERE RESOURCE_NAME = 'PASSWORD_VERIFY_FUNCTION';
PROFILE RESOURCE_NAME RESOURCE LIMIT
------------------------- -------------------------------- -------- ------------------------
DEFAULT PASSWORD_VERIFY_FUNCTION PASSWORD CUSTOM_PASSWORD_FUNCTION
RDSADMIN PASSWORD_VERIFY_FUNCTION PASSWORD NULL
```
# O procedimento create\$1passthrough\$1verify\$1fcn
O procedimento `create_passthrough_verify_fcn` é compatível com todas as versões do RDS para Oracle.
Você pode criar uma função personalizada para verificar senhas usando o procedimento do Amazon RDS `rdsadmin.rdsadmin_password_verify.create_passthrough_verify_fcn`. O procedimento `create_passthrough_verify_fcn` tem os seguintes parâmetros.
****
| Nome do parâmetro | Tipo de dados | Padrão | Obrigatório | Descrição |
| --- | --- | --- | --- | --- |
| `p_verify_function_name` | varchar2 | — | Sim | O nome da sua função de verificação personalizada. Esta é uma função de wrapper criada por você no esquema SYS e não contém lógica de verificação. Você atribui essa função a perfis de usuário. |
| `p_target_owner` | varchar2 | — | Sim | O proprietário do esquema da sua função de verificação personalizada. |
| `p_target_function_name` | varchar2 | — | Sim | O nome da sua função personalizada existente que contém a lógica de verificação. Sua função personalizada deve retornar um valor booliano. Sua função deverá retornar `true` se a senha é válida e `false` se a senha for inválida. |
O exemplo a seguir cria uma função de verificação de senha que usa a lógica da função chamada `PASSWORD_LOGIC_EXTRA_STRONG`.
```
begin
rdsadmin.rdsadmin_password_verify.create_passthrough_verify_fcn(
p_verify_function_name => 'CUSTOM_PASSWORD_FUNCTION',
p_target_owner => 'TEST_USER',
p_target_function_name => 'PASSWORD_LOGIC_EXTRA_STRONG');
end;
/
```
Para associar a função de verificação a um perfil de usuário, use `alter profile`. O seguinte exemplo associa a função de verificação ao perfil de usuário `DEFAULT`.
```
ALTER PROFILE DEFAULT LIMIT PASSWORD_VERIFY_FUNCTION CUSTOM_PASSWORD_FUNCTION;
```
## Configuração de um servidor DNS personalizado
O Amazon RDS oferece suporte para acesso à rede de saída nas suas instâncias de bancos de dados que executam o Oracle. Para obter mais informações sobre acesso à rede de saída, inclusive pré-requisitos, consulte [Configurar o acesso UTL\$1HTTP usando certificados e uma carteira Oracle](Oracle.Concepts.ONA.md).
O Amazon RDS Oracle permite a resolução do Serviço de Nomes de Domínio (DNS) de um servidor DNS personalizado que pertence ao cliente. Você pode resolver apenas nomes de domínio totalmente qualificados a partir da sua instância de banco de dados do Amazon RDS por meio do seu servidor DNS personalizado.
Após a configuração do seu servidor de nomes DNS personalizado, demora até 30 minutos para propagar as alterações na sua instância de banco de dados. Depois que as alterações são propagadas para sua a instância de banco de dados, todo o tráfego de rede de saída que requer uma pesquisa de DNS consulta o servidor DNS por meio da porta 53.
Para configurar um servidor DNS personalizado para a instância de banco de dados do Amazon RDS for Oracle, faça o seguinte:
+ Nas opções de DHCP anexadas à nuvem privada virtual (VPC), defina a opção `domain-name-servers` como o endereço IP do seu servidor de nomes DNS. Para obter mais informações, consulte [Conjuntos de opções de DHCP](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_DHCP_Options.html).
**nota**
A opção `domain-name-servers` aceita até quatro valores, mas sua instância de banco de dados do Amazon RDS usa apenas o primeiro valor.
+ Certifique-se de que seu servidor DNS possa resolver todas as consultas de pesquisa, incluindo nomes DNS públicos, nomes DNS privados do Amazon EC2 e nomes DNS específicos do cliente. Se o tráfego de rede de saída contiver pesquisas de DNS que o seu servidor DNS não pode manipular, este deverá ter provedores de DNS upstream configurados.
+ Configure seu servidor DNS para produzir respostas de protocolo UDP de 512 bytes ou menos.
+ Configure seu servidor DNS para produzir respostas de protocolo TCP de 1024 bytes ou menos.
+ Configure seu servidor DNS para permitir tráfego de entrada das suas instâncias de banco de dados do Amazon RDS pela porta 53. Se o seu servidor DNS estiver em uma Amazon VPC, ela deverá ter um grupo de segurança que contenha regras de entrada que permitam tráfego UDP e TCP na porta 53. Se o seu servidor DNS não estiver em uma Amazon VPC, ele deverá ter uma lista de permissões de firewall apropriada para permitir o tráfego de entrada UDP e TCP na porta 53.
Para obter mais informações, consulte [Grupos de segurança para sua VPC](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html) e [Adição e remoção de regras](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html#AddRemoveRules).
+ Configurar a VPC da sua instância de banco de dados do Amazon RDS para permitir o tráfego de saída por meio da porta 53. Sua VPC deve ter um security group que contém regras de saída que permitem o tráfego TCP e UDP na porta 53.
Para obter mais informações, consulte [Grupos de segurança para sua VPC](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html) e [Adição e remoção de regras](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html#AddRemoveRules).
+ O caminho de roteamento entre a instância de banco de dados do Amazon RDS e o servidor DNS deve ser configurado corretamente para permitir o tráfego DNS.
+ Se a instância de banco de dados do Amazon RDS e o servidor DNS não estiverem na mesma VPC, uma conexão de emparelhamento precisará ser configurada entre eles. Para obter mais informações, consulte [O que é emparelhamento de VPC?](https://docs.aws.amazon.com/vpc/latest/peering/Welcome.html)
# Configurar e anular configuração de eventos de diagnóstico do sistema
Para configurar e anular a configuração de eventos de diagnóstico no nível da sessão, você pode usar a instrução Oracle SQL `ALTER SESSION SET EVENTS`. No entanto, para definir eventos no nível do sistema, você não pode usar o Oracle SQL. Em vez disso, use os procedimentos de evento do sistema no pacote `rdsadmin.rdsadmin_util`. Os procedimentos de eventos do sistema estão disponíveis nas seguintes versões do mecanismo:
+ Todas as versões do Oracle Database 21c
+ 19.0.0.0.ru-2020-10.rur-2020-10.r1 e versões posteriores do Oracle Database 19c
Consulte mais informações em [Version 19.0.0.0.ru-2020-10.rur-2020-10.r1](https://docs.aws.amazon.com/AmazonRDS/latest/OracleReleaseNotes/oracle-version-19-0.html#oracle-version-RU-RUR.19.0.0.0.ru-2020-10.rur-2020-10.r1) em *Notas de lançamento do Amazon RDS para Oracle*.
**Importante**
Internamente, o pacote `rdsadmin.rdsadmin_util` define eventos usando a instrução `ALTER SYSTEM SET EVENTS`. Essa instrução `ALTER SYSTEM` não está incluída na documentação do Oracle Database. Alguns eventos de diagnóstico do sistema podem gerar grandes quantidades de informações de monitoramento, causar contenção ou afetar a disponibilidade do banco de dados. Recomendamos que você teste eventos de diagnóstico específicos em seu banco de dados de não produção e defina apenas eventos em seu banco de dados de produção sob orientação do Oracle Support.
## Listar eventos de diagnóstico do sistema permitidos
Para listar os eventos do sistema que você pode definir, use o procedimento do Amazon RDS `rdsadmin.rdsadmin_util.list_allowed_system_events`. Este procedimento não aceita parâmetros.
O exemplo a seguir lista todos os eventos do sistema que você pode definir.
```
SET SERVEROUTPUT ON
EXEC rdsadmin.rdsadmin_util.list_allowed_system_events;
```
A saída de exemplo a seguir lista os números de eventos e suas descrições. Use os procedimentos `set_system_event` do Amazon RDS para definir esses eventos e `unset_system_event` para desconfigurá-los.
```
604 - error occurred at recursive SQL level
942 - table or view does not exist
1401 - inserted value too large for column
1403 - no data found
1410 - invalid ROWID
1422 - exact fetch returns more than requested number of rows
1426 - numeric overflow
1427 - single-row subquery returns more than one row
1476 - divisor is equal to zero
1483 - invalid length for DATE or NUMBER bind variable
1489 - result of string concatenation is too long
1652 - unable to extend temp segment by in tablespace
1858 - a non-numeric character was found where a numeric was expected
4031 - unable to allocate bytes of shared memory ("","","","")
6502 - PL/SQL: numeric or value error
10027 - Specify Deadlock Trace Information to be Dumped
10046 - enable SQL statement timing
10053 - CBO Enable optimizer trace
10173 - Dynamic Sampling time-out error
10442 - enable trace of kst for ORA-01555 diagnostics
12008 - error in materialized view refresh path
12012 - error on auto execute of job
12504 - TNS:listener was not given the SERVICE_NAME in CONNECT_DATA
14400 - inserted partition key does not map to any partition
31693 - Table data object failed to load/unload and is being skipped due to error:
```
**nota**
A lista dos eventos do sistema permitidos pode mudar ao longo do tempo. Para se certificar de que você tem a lista mais recente de eventos qualificados, use `rdsadmin.rdsadmin_util.list_allowed_system_events`.
## Definir eventos de diagnóstico do sistema
Para definir um evento do sistema, use o procedimento do Amazon RDS `rdsadmin.rdsadmin_util.set_system_event`. Você só pode definir eventos listados na saída do `rdsadmin.rdsadmin_util.list_allowed_system_events`. O procedimento `set_system_event` tem os parâmetros a seguir.
****
| Nome do parâmetro | Tipo de dados | Padrão | Obrigatório | Descrição |
| --- | --- | --- | --- | --- |
| `p_event` | número | — | Sim | O número do evento do sistema. O valor deve ser um dos números de eventos relatados por `list_allowed_system_events`. |
| `p_level` | número | — | Sim | O nível do evento. Consulte a documentação do Oracle Database ou o Oracle Support para obter descrições de diferentes valores de nível. |
O procedimento `set_system_event` constrói e executa as instruções `ALTER SYSTEM SET EVENTS` necessárias de acordo com os seguintes princípios:
+ O tipo de evento (`context` ou `errorstack`) é determinado automaticamente.
+ Uma instrução no formulário `ALTER SYSTEM SET EVENTS 'event LEVEL event_level'` define os eventos de contexto. Esta notação é equivalente a `ALTER SYSTEM SET EVENTS 'event TRACE NAME CONTEXT FOREVER, LEVEL event_level'`.
+ Uma instrução no formulário `ALTER SYSTEM SET EVENTS 'event ERRORSTACK (event_level)'` define os eventos de pilha de erros. Esta notação é equivalente a `ALTER SYSTEM SET EVENTS 'event TRACE NAME ERRORSTACK LEVEL event_level'`.
O exemplo a seguir define o evento 942 no nível 3 e o evento 10442 no nível 10. A amostra de saída está incluída.
```
SQL> SET SERVEROUTPUT ON
SQL> EXEC rdsadmin.rdsadmin_util.set_system_event(942,3);
Setting system event 942 with: alter system set events '942 errorstack (3)'
PL/SQL procedure successfully completed.
SQL> EXEC rdsadmin.rdsadmin_util.set_system_event(10442,10);
Setting system event 10442 with: alter system set events '10442 level 10'
PL/SQL procedure successfully completed.
```
## Listar eventos de diagnóstico do sistema definidos
Para listar os eventos do sistema que estão definidos no momento, use o procedimento do Amazon RDS `rdsadmin.rdsadmin_util.list_set_system_events`. Este procedimento relata apenas os eventos definidos no nível do sistema por `set_system_event`.
O exemplo a seguir lista os eventos ativos do sistema.
```
SET SERVEROUTPUT ON
EXEC rdsadmin.rdsadmin_util.list_set_system_events;
```
A saída de exemplo a seguir mostra a lista de eventos, o tipo de evento, o nível no qual os eventos estão definidos no momento e a hora em que o evento foi definido.
```
942 errorstack (3) - set at 2020-11-03 11:42:27
10442 level 10 - set at 2020-11-03 11:42:41
PL/SQL procedure successfully completed.
```
## Desconfigurar eventos de diagnóstico do sistema
Para desconfigurar um evento do sistema, use o procedimento do Amazon RDS `rdsadmin.rdsadmin_util.unset_system_event`. Você só pode desconfigurar eventos listados na saída do `rdsadmin.rdsadmin_util.list_allowed_system_events`. O procedimento `unset_system_event` aceita o seguinte parâmetro.
****
| Nome do parâmetro | Tipo de dados | Padrão | Obrigatório | Descrição |
| --- | --- | --- | --- | --- |
| `p_event` | número | — | Sim | O número do evento do sistema. O valor deve ser um dos números de eventos relatados por `list_allowed_system_events`. |
O exemplo a seguir desconfigura os eventos 942 e 10442. A amostra de saída está incluída.
```
SQL> SET SERVEROUTPUT ON
SQL> EXEC rdsadmin.rdsadmin_util.unset_system_event(942);
Unsetting system event 942 with: alter system set events '942 off'
PL/SQL procedure successfully completed.
SQL> EXEC rdsadmin.rdsadmin_util.unset_system_event(10442);
Unsetting system event 10442 with: alter system set events '10442 off'
PL/SQL procedure successfully completed.
```
# Realização de tarefas comuns de banco de dados para instâncias de banco de dados
Veja a seguir como executar determinadas tarefas comuns de DBA relacionadas aos bancos de dados nas instâncias de bancos de dados do Amazon RDS que executam o Oracle. Para oferecer uma experiência de serviço gerenciada, o Amazon RDS não fornece acesso ao shell para as instâncias de banco de dados. O Amazon RDS também restringe o acesso a alguns procedimentos e tabelas do sistema que exigem privilégios avançados.
**Topics**
+ [
# Alteração do nome global de um banco de dados
](Appendix.Oracle.CommonDBATasks.RenamingGlobalName.md)
+ [
# Trabalhar com espaços para tabela no RDS para Oracle
](Appendix.Oracle.CommonDBATasks.TablespacesAndDatafiles.md)
+ [
# Trabalhar com arquivos temporários no RDS para Oracle
](Appendix.Oracle.CommonDBATasks.using-tempfiles.md)
+ [
# Redimensionar espaços de tabela, arquivos de dados e arquivos temporários no RDS para Oracle
](Appendix.Oracle.CommonDBATasks.ResizeTempSpaceReadReplica.md)
+ [
# Mover dados entre volumes de armazenamento no RDS para Oracle
](Appendix.Oracle.CommonDBATasks.MovingDataBetweenVolumes.md)
+ [
# Trabalhar com tabelas externas no RDS para Oracle
](Appendix.Oracle.CommonDBATasks.External_Tables.md)
# Alteração do nome global de um banco de dados
Para alterar o nome global de um banco de dados, use o procedimento do Amazon RDS `rdsadmin.rdsadmin_util.rename_global_name`. O procedimento `rename_global_name` tem os seguintes parâmetros.
****
| Nome do parâmetro | Tipo de dados | Padrão | Obrigatório | Descrição |
| --- | --- | --- | --- | --- |
| `p_new_global_name` | varchar2 | — | Sim | O novo nome global do banco de dados. |
O banco de dados deve estar aberto para que a alteração de nome ocorra. Para ter mais informações sobre como alterar o nome global de um banco de dados, consulte [ALTER DATABASE](http://docs.oracle.com/cd/E11882_01/server.112/e41084/statements_1004.htm#SQLRF52547) na documentação do Oracle.
O exemplo a seguir altera o nome global de um banco de dados para `new_global_name`.
```
EXEC rdsadmin.rdsadmin_util.rename_global_name(p_new_global_name => 'new_global_name');
```
# Trabalhar com espaços para tabela no RDS para Oracle
É possível usar espaços para tabela com o RDS para Oracle, que é uma unidade lógica de armazenamento que armazena dados de banco de dados.
**Importante**
Se sua instância de banco de dados tiver réplicas, recomendamos usar configurações de grupos de parâmetros em vez de alterações em nível de sessão para gerenciar os locais padrão dos arquivos. As alterações em nível de sessão nos locais de arquivos padrão na instância primária não são exibidas automaticamente nas réplicas. O uso de configurações de grupos de parâmetros garante localizações de arquivos consistentes em suas instâncias primária e de réplica.
**Topics**
+ [
## Especificar locais de arquivos de banco de dados no RDS para Oracle
](#Appendix.Oracle.CommonDBATasks.DatabaseFileLocations)
+ [
## Criar e usar espaços de tabela no RDS para Oracle
](#Appendix.Oracle.CommonDBATasks.CreatingTablespacesAndDatafiles)
+ [
## Criar espaços de tabela em volumes de armazenamento adicionais no RDS para Oracle
](#Appendix.Oracle.CommonDBATasks.CreatingTablespacesWithFileLocations)
+ [
## Definir o espaço para tabela padrão no RDS para Oracle
](#Appendix.Oracle.CommonDBATasks.SettingDefaultTablespace)
+ [
## Definir o espaço para tabela temporário padrão no RDS para Oracle
](#Appendix.Oracle.CommonDBATasks.SettingDefTempTablespace)
+ [
## Criar um espaço de tabela temporário no armazenamento de instância
](#Appendix.Oracle.CommonDBATasks.creating-tts-instance-store)
## Especificar locais de arquivos de banco de dados no RDS para Oracle
O RDS para Oracle usa o Oracle Managed Files (OMF) para nomear arquivos de banco de dados. Quando você cria arquivos de banco de dados, o banco de dados extrai a configuração com base na configuração atual do parâmetro de inicialização `DB_CREATE_FILE_DEST`.
O valor padrão do parâmetro de inicialização `DB_CREATE_FILE_DEST` é `/rdsdbdata/db` para bancos de dados autônomos e `/rdsdbdata/db/pdb` para arquitetura em contêiner (CDB/MT). Se sua instância de banco de dados tiver volumes de armazenamento adicionais, você poderá definir `DB_CREATE_FILE_DEST` seus locais de volume. Por exemplo, se sua instância tiver um volume montado em `/rdsdbdata/db`, você poderá definir `DB_CREATE_FILE_DEST` como esse valor.
Você pode modificar o parâmetro `DB_CREATE_FILE_DEST` em nível de sessão ou em nível de instância do banco de dados Oracle.
### Modificar DB\$1CREATE\$1FILE\$1SET em nível de instância
Para modificar o parâmetro em nível de instância, atualize o parâmetro no grupo de parâmetros atribuído à sua instância de banco de dados e aplique-o. Para obter mais informações, consulte [Parâmetros de inicialização do RDS para Oracle](Oracle.Concepts.FeatureSupport.Parameters.md) e [Modificar parâmetros em um grupo de parâmetros de banco de dados no Amazon RDS](USER_WorkingWithParamGroups.Modifying.md).
### Modificar DB\$1CREATE\$1FILE\$1DEST em nível de sessão
É possível modificar o parâmetro em nível de sessão executando uma instrução `ALTER SESSION`. Essa abordagem é útil quando você deseja criar arquivos de banco de dados em um local específico para uma sessão específica sem afetar toda a instância.
O seguinte exemplo mostra como conferir o valor do parâmetro atual e modificá-lo para a sessão:
```
SHOW PARAMETER db_create_file_dest
NAME TYPE VALUE
------------------------------------ ----------- ------------------------------
db_create_file_dest string /rdsdbdata/db
ALTER SESSION SET db_create_file_dest = '/rdsdbdata2/db';
Session altered.
SHOW PARAMETER db_create_file_dest
NAME TYPE VALUE
------------------------------------ ----------- ------------------------------
db_create_file_dest string /rdsdbdata2/db
```
## Criar e usar espaços de tabela no RDS para Oracle
Quando você cria espaços de tabela, o banco de dados cria os arquivos de dados no volume de armazenamento especificado pelo parâmetro de inicialização `DB_CREATE_FILE_DEST` no momento da criação. Por padrão, se você não especificar o tamanho de um arquivo de dados, os espaços de tabela serão criados com um tamanho padrão de `AUTOEXTEND ON` e sem um tamanho máximo. No exemplo a seguir, o tablespace *users1* é autoextensível.
```
CREATE TABLESPACE users1;
```
Devido a essas configurações padrão, espaços de tabela podem crescer ao ponto de consumirem todo o armazenamento alocado. Recomendamos que você especifique um tamanho máximo apropriado em espaços de tabela permanentes e temporários e que monitore cuidadosamente o uso do espaço.
O exemplo a seguir cria um espaço de tabela chamado *users2* com um tamanho inicial de 1 gigabyte. Como o tamanho do arquivo de dados é especificado, mas `AUTOEXTEND ON` não é especificado, o espaço de tabela não é autoextensível.
```
CREATE TABLESPACE users2 DATAFILE SIZE 1G;
```
O exemplo a seguir cria um espaço de tabela chamado *users3* com um tamanho inicial de 1 gigabyte, extensão automática ativada e um tamanho máximo de 10 gigabytes.
```
CREATE TABLESPACE users3 DATAFILE SIZE 1G AUTOEXTEND ON MAXSIZE 10G;
```
O exemplo a seguir cria um espaço de tabela temporário chamado *temp01*:
```
CREATE TEMPORARY TABLESPACE temp01;
```
É possível redimensionar um espaço de tabela de arquivos grandes usando `ALTER TABLESPACE`. Você pode especificar o tamanho em quilobytes (K), megabytes (M), gigabytes (G) ou terabytes (T). O exemplo a seguir redimensiona um espaço de tabela de arquivos grandes chamado *users\$1bf* para 200 MB.
```
ALTER TABLESPACE users_bf RESIZE 200M;
```
O exemplo a seguir acrescenta um arquivo de dados adicional a um espaço de tabela de arquivos pequenos chamado *users\$1sf*.
```
ALTER TABLESPACE users_sf ADD DATAFILE SIZE 100000M AUTOEXTEND ON NEXT 250m MAXSIZE UNLIMITED;
```
## Criar espaços de tabela em volumes de armazenamento adicionais no RDS para Oracle
Para criar um espaço para tabela em um volume de armazenamento adicional, modifique o parâmetro `DB_CREATE_FILE_DEST` para a localização do volume. O exemplo a seguir define o local do arquivo como `/rdsdbdata2/db`.
```
ALTER SESSION SET db_create_file_dest = '/rdsdbdata2/db';
Session altered.
```
No exemplo a seguir, você vai criar um espaço para tabela no volume adicional `/rdsdbdata2/db`.
```
CREATE TABLESPACE new_tablespace DATAFILE SIZE 10G;
Tablespace created.
SELECT tablespace_name,file_id,file_name FROM dba_data_files
WHERE tablespace_name = 'NEW_TABLESPACE';
TABLESPACE_NAME FILE_ID FILE_NAME
------------------------- ---------- --------------------------------------------------------------------------------
NEW_TABLESPACE 7 /rdsdbdata2/db/ORCL_A/datafile/o1_mf_newtable_a123b4c5_.dbf
```
Para criar um espaço para tabela de arquivos pequenos e distribuir seus arquivos de dados em diferentes volumes de armazenamento, adicione arquivos de dados ao espaço para tabela depois de criá-lo. No exemplo a seguir, você vai criar um espaço para tabela com os arquivos de dados no local padrão de `/rdsdbdata/db`. Depois, vai definir o destino padrão como `/rdsdbdata/db2`. Quando você adiciona um arquivo de dados ao seu espaço para tabela recém-criado, o banco de dados armazena o arquivo em `/rdsdbdata/db2`.
```
ALTER SESSION SET db_create_file_dest = '/rdsdbdata/db';
Session altered.
CREATE SMALLFILE TABLESPACE smalltbs DATAFILE SIZE 10G;
Tablespace created.
SELECT tablespace_name,file_id,file_name FROM dba_data_files
WHERE tablespace_name = 'SMALLTBS';
TABLESPACE_NAME FILE_ID FILE_NAME
------------------------- ---------- --------------------------------------------------------------------------------
SMALLTBS 8 /rdsdbdata/db/ORCL_A/datafile/o1_mf_smalltbs_n563yryk_.dbf
ALTER SESSION SET db_create_file_dest = '/rdsdbdata2/db';
Session altered.
ALTER TABLESPACE smalltbs ADD DATAFILE SIZE 10G;
Tablespace altered.
SELECT tablespace_name,file_id,file_name FROM dba_data_files
WHERE tablespace_name = 'SMALLTBS';
TABLESPACE_NAME FILE_ID FILE_NAME
------------------------- ---------- --------------------------------------------------------------------------------
SMALLTBS 8 /rdsdbdata/db/ORCL_A/datafile/o1_mf_smalltbs_n563yryk_.dbf
SMALLTBS 9 /rdsdbdata2/db/ORCL_A/datafile/o1_mf_smalltbs_n564004g_.dbf
```
## Definir o espaço para tabela padrão no RDS para Oracle
Para definir o espaço padrão tabela padrão, use o procedimento do Amazon RDS `rdsadmin.rdsadmin_util.alter_default_tablespace`. O procedimento `alter_default_tablespace` tem os seguintes parâmetros.
****
| Nome do parâmetro | Tipo de dados | Padrão | Obrigatório | Descrição |
| --- | --- | --- | --- | --- |
| `tablespace_name` | varchar | — | Sim | O nome do espaço de tabela padrão. |
O exemplo a seguir define o espaço de tabela padrão como *users2*:
```
EXEC rdsadmin.rdsadmin_util.alter_default_tablespace(tablespace_name => 'users2');
```
## Definir o espaço para tabela temporário padrão no RDS para Oracle
Para definir o espaço de tabela temporário padrão, use o procedimento do Amazon RDS `rdsadmin.rdsadmin_util.alter_default_temp_tablespace`. O procedimento `alter_default_temp_tablespace` tem os seguintes parâmetros.
****
| Nome do parâmetro | Tipo de dados | Padrão | Obrigatório | Descrição |
| --- | --- | --- | --- | --- |
| `tablespace_name` | varchar | — | Sim | O nome do espaço de tabela temporário padrão. |
O exemplo a seguir define o espaço de tabela temporário padrão como *temp01*.
```
EXEC rdsadmin.rdsadmin_util.alter_default_temp_tablespace(tablespace_name => 'temp01');
```
## Criar um espaço de tabela temporário no armazenamento de instância
Para criar um espaço de tabela temporário no armazenamento de instância, use o procedimento `rdsadmin.rdsadmin_util.create_inst_store_tmp_tblspace` do Amazon RDS. O procedimento `create_inst_store_tmp_tblspace` tem os seguintes parâmetros.
****
| Nome do parâmetro | Tipo de dados | Padrão | Obrigatório | Descrição |
| --- | --- | --- | --- | --- |
| `p_tablespace_name` | varchar | — | Sim | O nome do espaço de tabela temporário. |
O exemplo a seguir cria o espaço de tabela temporário *temp01* no armazenamento de instância.
```
EXEC rdsadmin.rdsadmin_util.create_inst_store_tmp_tblspace(p_tablespace_name => 'temp01');
```
**Importante**
Quando você executa `rdsadmin_util.create_inst_store_tmp_tblspace`, o espaço de tabela temporário recém-criado não é automaticamente definido como o espaço de tabela temporário padrão. Para defini-lo como padrão, consulte [Definir o espaço para tabela temporário padrão no RDS para Oracle](#Appendix.Oracle.CommonDBATasks.SettingDefTempTablespace).
Para obter mais informações, consulte [Armazenar dados temporários em um armazenamento de instância do RDS for Oracle](CHAP_Oracle.advanced-features.instance-store.md).
# Trabalhar com arquivos temporários no RDS para Oracle
## Adicionar um arquivo temporário ao armazenamento de instância em uma réplica de leitura
Quando você cria um espaço de tabela temporário em uma instância de banco de dados principal, a réplica de leitura não cria arquivos temporários. Suponha que exista um espaço de tabela temporário vazio em sua réplica de leitura por um dos seguintes motivos:
+ Você removeu um arquivo temporário do espaço de tabela em sua réplica de leitura. Para ter mais informações, consulte [Descartar arquivos temporários em uma réplica de leitura](Appendix.Oracle.CommonDBATasks.dropping-tempfiles-replica.md).
+ Você criou um espaço de tabela temporário na instância de banco de dados primária. Nesse caso, o RDS para Oracle sincroniza os metadados com a réplica de leitura.
Você pode adicionar um arquivo temporário ao espaço de tabela temporário vazio e armazená-lo no armazenamento de instância. Para criar um arquivo temporário no armazenamento de instância, use o procedimento `rdsadmin.rdsadmin_util.add_inst_store_tempfile` do Amazon RDS. Você pode usar esse procedimento somente em uma réplica de leitura. O procedimento tem os seguintes parâmetros.
****
| Nome do parâmetro | Tipo de dados | Padrão | Obrigatório | Descrição |
| --- | --- | --- | --- | --- |
| `p_tablespace_name` | varchar | — | Sim | O nome do espaço da tabela temporário em sua réplica de leitura. |
No exemplo a seguir, o espaço de tabela temporário vazio *temp01* existe na réplica de leitura. Execute o comando a seguir para criar um arquivo temporário para esse espaço de tabela e armazená-lo no armazenamento de instância.
```
EXEC rdsadmin.rdsadmin_util.add_inst_store_tempfile(p_tablespace_name => 'temp01');
```
Para obter mais informações, consulte [Armazenar dados temporários em um armazenamento de instância do RDS for Oracle](CHAP_Oracle.advanced-features.instance-store.md).
# Descartar arquivos temporários em uma réplica de leitura
Não é possível descartar um espaço de tabela temporário em uma réplica de leitura. Você pode alterar o armazenamento de arquivos temporários em uma réplica de leitura do Amazon EBS para o armazenamento de instância ou do armazenamento de instância para o Amazon EBS. Para conseguir isso, faça o seguinte:
1. Descarte os arquivos temporários atuais no espaço de tabela temporário na réplica de leitura.
1. Crie arquivos temporários em outro armazenamento.
Para descartar os arquivos temporários, use o procedimento `rdsadmin.rdsadmin_util. drop_replica_tempfiles` do Amazon RDS. Você pode usar esse procedimento somente em réplicas de leitura. O procedimento `drop_replica_tempfiles` tem os seguintes parâmetros.
****
| Nome do parâmetro | Tipo de dados | Padrão | Obrigatório | Descrição |
| --- | --- | --- | --- | --- |
| `p_tablespace_name` | varchar | — | Sim | O nome do espaço da tabela temporário em sua réplica de leitura. |
Suponha que um espaço de tabela temporário chamado *temp01* resida no armazenamento de instância da réplica de leitura. Descarte todos os arquivos temporários nesse espaço de tabela executando o comando a seguir.
```
EXEC rdsadmin.rdsadmin_util.drop_replica_tempfiles(p_tablespace_name => 'temp01');
```
Para obter mais informações, consulte [Armazenar dados temporários em um armazenamento de instância do RDS for Oracle](CHAP_Oracle.advanced-features.instance-store.md).
# Redimensionar espaços de tabela, arquivos de dados e arquivos temporários no RDS para Oracle
Por padrão, espaços de tabela Oracle são criados com a opção de extensão automática ativada e sem um tamanho máximo. Devido a essas configurações padrão, os espaços de tabela às vezes podem aumentar demais. Recomendamos que você especifique um tamanho máximo apropriado em espaços de tabela permanentes e temporários e que monitore cuidadosamente o uso do espaço.
## Redimensionar espaços de tabela permanentes
Para redimensionar um espaço de tabela permanente em uma instância de banco de dados do RDS para Oracle, use qualquer um dos seguintes procedimentos do Amazon RDS:
+ `rdsadmin.rdsadmin_util.resize_datafile`
+ `rdsadmin.rdsadmin_util.autoextend_datafile`
O procedimento `resize_datafile` tem os seguintes parâmetros.
****
| Nome do parâmetro | Tipo de dados | Padrão | Obrigatório | Descrição |
| --- | --- | --- | --- | --- |
| `p_data_file_id` | número | — | Sim | O identificador do arquivo de dados a ser redimensionado. |
| `p_size` | varchar2 | — | Sim | O tamanho do arquivo de dados. Especifique o tamanho em bytes (o padrão), em quilobytes (K), em megabytes (M) ou em gigabytes (G). |
O procedimento `autoextend_datafile` tem os seguintes parâmetros.
****
| Nome do parâmetro | Tipo de dados | Padrão | Obrigatório | Descrição |
| --- | --- | --- | --- | --- |
| `p_data_file_id` | número | — | Sim | O identificador do arquivo de dados a ser redimensionado. |
| `p_autoextend_state` | varchar2 | — | Sim | O estado do recurso de extensão automática. Especifique `ON` para estender o arquivo de dados automaticamente e `OFF` para desativar a extensão automática. |
| `p_next` | varchar2 | — | Não | O tamanho do próximo incremento do arquivo de dados. Especifique o tamanho em bytes (o padrão), em quilobytes (K), em megabytes (M) ou em gigabytes (G). |
| `p_maxsize` | varchar2 | — | Não | O espaço máximo em disco permitido para extensão automática. Especifique o tamanho em bytes (o padrão), em quilobytes (K), em megabytes (M) ou em gigabytes (G). Você pode especificar `UNLIMITED` para remover o limite de tamanho do arquivo. |
O exemplo a seguir redimensiona o arquivo de dados de 4 MB a 500 MB.
```
EXEC rdsadmin.rdsadmin_util.resize_datafile(4,'500M');
```
O exemplo a seguir desativa a opção de extensão automática do arquivo de dados 4. Ele também ativa a extensão automática para o arquivo de dados 5, com um incremento de 128 MB e sem tamanho máximo.
```
EXEC rdsadmin.rdsadmin_util.autoextend_datafile(4,'OFF');
EXEC rdsadmin.rdsadmin_util.autoextend_datafile(5,'ON','128M','UNLIMITED');
```
## Redimensionar espaços de tabela temporários
Para redimensionar espaços de tabela temporários em uma instância do RDS para Oracle, inclusive uma réplica de leitura, use qualquer um dos seguintes procedimentos do Amazon RDS:
+ `rdsadmin.rdsadmin_util.resize_temp_tablespace`
+ `rdsadmin.rdsadmin_util.resize_tempfile`
+ `rdsadmin.rdsadmin_util.autoextend_tempfile`
O procedimento `resize_temp_tablespace` tem os seguintes parâmetros.
****
| Nome do parâmetro | Tipo de dados | Padrão | Obrigatório | Descrição |
| --- | --- | --- | --- | --- |
| `p_temp_tablespace_name` | varchar2 | — | Sim | O nome do espaço de tabela temporário a ser redimensionado. |
| `p_size` | varchar2 | — | Sim | O nome do espaço de tabela. Especifique o tamanho em bytes (o padrão), em quilobytes (K), em megabytes (M) ou em gigabytes (G). |
O procedimento `resize_tempfile` tem os seguintes parâmetros.
****
| Nome do parâmetro | Tipo de dados | Padrão | Obrigatório | Descrição |
| --- | --- | --- | --- | --- |
| `p_temp_file_id` | número | — | Sim | O identificador do arquivo temporário a ser redimensionado. |
| `p_size` | varchar2 | — | Sim | O tamanho do arquivo temporário. Especifique o tamanho em bytes (o padrão), em quilobytes (K), em megabytes (M) ou em gigabytes (G). |
O procedimento `autoextend_tempfile` tem os seguintes parâmetros.
****
| Nome do parâmetro | Tipo de dados | Padrão | Obrigatório | Descrição |
| --- | --- | --- | --- | --- |
| `p_temp_file_id` | número | — | Sim | O identificador do arquivo temporário a ser redimensionado. |
| `p_autoextend_state` | varchar2 | — | Sim | O estado do recurso de extensão automática. Especifique `ON` para estender o arquivo temporário automaticamente e `OFF` para desativar a extensão automática. |
| `p_next` | varchar2 | — | Não | O tamanho do próximo incremento do arquivo temporário. Especifique o tamanho em bytes (o padrão), em quilobytes (K), em megabytes (M) ou em gigabytes (G). |
| `p_maxsize` | varchar2 | — | Não | O espaço máximo em disco permitido para extensão automática. Especifique o tamanho em bytes (o padrão), em quilobytes (K), em megabytes (M) ou em gigabytes (G). Você pode especificar `UNLIMITED` para remover o limite de tamanho do arquivo. |
Os exemplos a seguir redimensionam um espaço de tabela temporário chamado `TEMP` para o tamanho de 4 GB.
```
EXEC rdsadmin.rdsadmin_util.resize_temp_tablespace('TEMP','4G');
```
```
EXEC rdsadmin.rdsadmin_util.resize_temp_tablespace('TEMP','4096000000');
```
O exemplo a seguir redimensiona um espaço de tabela temporário com base no arquivo temporário com o identificador de arquivo `1` para o tamanho de 2 MB.
```
EXEC rdsadmin.rdsadmin_util.resize_tempfile(1,'2M');
```
O exemplo a seguir desativa a opção de extensão automática do arquivo temporário 1. Ele também define o tamanho máximo de extensão automática do arquivo temporário de 2 a 10 GB, com um incremento de 100 MB.
```
EXEC rdsadmin.rdsadmin_util.autoextend_tempfile(1,'OFF');
EXEC rdsadmin.rdsadmin_util.autoextend_tempfile(2,'ON','100M','10G');
```
Para ter mais informações sobre réplicas de leitura para instâncias de banco de dados Oracle, consulte [Trabalhar com réplicas de leitura do Amazon RDS para Oracle](oracle-read-replicas.md).
# Mover dados entre volumes de armazenamento no RDS para Oracle
Você pode mover arquivos de dados e objetos de banco de dados entre seus volumes de armazenamento principal e adicional. Antes de mover dados, pense nos seguintes pontos:
+ Os volumes de origem e de destino devem ter espaço livre suficiente.
+ As operações de movimentação de dados consomem E/S em ambos os volumes.
+ Grandes movimentações de dados podem afetar a performance do banco de dados.
+ Se você restaurar um snapshot, a movimentação de dados entre volumes de armazenamento poderá ser lenta se for afetada pelo carregamento lento do EBS.
**Topics**
+ [
## Mover arquivos de dados entre volumes no RDS para Oracle
](#Appendix.Oracle.CommonDBATasks.MovingDatafiles)
+ [
## Mover dados e índices da tabela entre volumes no RDS para Oracle
](#Appendix.Oracle.CommonDBATasks.MovingTableData)
+ [
## Gerenciar o armazenamento LOB usando volumes adicionais
](#Appendix.Oracle.CommonDBATasks.ManagingLargeLOBStorage)
## Mover arquivos de dados entre volumes no RDS para Oracle
Para mover arquivos de dados entre volumes de armazenamento, use o procedimento `rdsadmin.rdsadmin_util.move_datafile` do Amazon RDS. Observe os seguintes requisitos:
+ Você deve usar o Oracle Enterprise Edition para executar o procedimento `move_datafile`.
+ Você não pode mover o espaço para tabela `SYSTEM` e `RDSADMIN`.
O procedimento `move_datafile` tem os seguintes parâmetros.
****
| Nome do parâmetro | Tipo de dados | Obrigatório | Descrição |
| --- | --- | --- | --- |
| `p_data_file_id` | número | Sim | O ID do arquivo de dados a ser movido. |
| `p_location` | varchar2 | Sim | O volume de armazenamento para o qual você deseja mover o arquivo de dados. |
O exemplo a seguir move um espaço para tabela do volume padrão `rdsdbdata` para o volume adicional `rdsdbdata2`.
```
SQL> SELECT tablespace_name,file_id,file_name FROM dba_data_files
WHERE tablespace_name = 'MYNEWTABLESPACE';
TABLESPACE_NAME FILE_ID FILE_NAME
------------------------- ---------- --------------------------------------------------------------------------------
MYNEWTABLESPACE 6 /rdsdbdata/db/ORCL_A/datafile/o1_mf_mynewtab_n123abcd_.dbf
EXECUTE rdsadmin.rdsadmin_util.move_datafile( 6, 'rdsdbdata2');
PL/SQL procedure successfully completed.
SQL> SELECT tablespace_name,file_id,file_name FROM dba_data_files
WHERE tablespace_name = 'MYNEWTABLESPACE';
TABLESPACE_NAME FILE_ID FILE_NAME
------------------------- ---------- --------------------------------------------------------------------------------
MYNEWTABLESPACE 6 /rdsdbdata2/db/ORCL_A/datafile/o1_mf_mynewtab_n356efgh_.dbf
```
## Mover dados e índices da tabela entre volumes no RDS para Oracle
Você pode otimizar o armazenamento do banco de dados criando espaços para tabela em volumes de armazenamento adicionais. Depois, você pode mover objetos, como tabelas, índices e partições, para esses espaços para tabela usando o Oracle SQL padrão. Essa abordagem é valiosa para o ajuste de performance quando seu banco de dados contém dados com diferentes padrões de acesso. Por exemplo, você pode armazenar dados operacionais acessados com frequência em volumes de armazenamento de alta performance e, ao mesmo tempo, mover dados históricos raramente acessados para volumes de armazenamento de menor custo.
No exemplo a seguir, você vai criar um espaço para tabela em um volume de alta performance `rdsdbdata2`. Depois, você vai mover uma tabela para o volume de armazenamento adicional enquanto ela está on-line. Você também vai mover o índice para o mesmo volume. A movimentação de tabelas e a recompilação de índices on-line exigem o Oracle Enterprise Edition.
```
ALTER SESSION SET db_create_file_dest = '/rdsdbdata2/db';
CREATE TABLESPACE perf_tbs DATAFILE SIZE 10G;
ALTER TABLE employees
MOVE TABLESPACE perf_tbs ONLINE;
ALTER INDEX employees_idx
REBUILD ONLINE TABLESPACE perf_tbs;
```
No exemplo a seguir, você vai criar um espaço para tabela em um volume de baixo custo. Depois, você vai mover uma partição da tabela para seu volume de armazenamento de baixo custo usando uma operação on-line.
```
ALTER SESSION SET db_create_file_dest = '/rdsdbdata3/db';
CREATE TABLESPACE hist_tbs DATAFILE SIZE 10G;
ALTER TABLE orders
MOVE PARTITION orders_2022
TABLESPACE hist_tbs ONLINE;
```
No exemplo a seguir, você vai consultar operações longas de sessões ativas.
```
SELECT sid,opname,sofar,totalwork,time_remaining,elapsed_seconds
FROM v$session_longops
WHERE time_remaining > 0;
```
Você pode conferir o uso de espaços para tabela com a consulta a seguir.
```
SELECT tablespace_name, used_percent
FROM dba_tablespace_usage_metrics
ORDER BY used_percent DESC;
```
## Gerenciar o armazenamento LOB usando volumes adicionais
Seu banco de dados pode conter tabelas com objetos BLOB ou CLOB que consomem armazenamento substancial, mas são acessados com pouca frequência. Para otimizar o armazenamento, você pode realocar esses segmentos LOB em um espaço para tabela em um volume de armazenamento adicional.
No exemplo a seguir, você vai criar um espaço para tabela para dados LOB em um volume de baixo custo destinado a dados de baixo acesso. Depois, você vai criar uma tabela que armazene dados nesse volume.
```
ALTER SESSION SET db_create_file_dest = '/rdsdbdata3/db';
CREATE TABLESPACE lob_data DATAFILE SIZE 5G AUTOEXTEND ON NEXT 1G;
CREATE TABLE documents (
doc_id NUMBER PRIMARY KEY,
doc_date DATE,
doc_content CLOB
) TABLESPACE user_data
LOB(doc_content) STORE AS (TABLESPACE lob_data);
```
# Trabalhar com tabelas externas no RDS para Oracle
*Tabelas externas do Oracle *são tabelas com dados que não estão no banco de dados. Em vez disso, os dados estão em arquivos externos que o banco de dados pode acessar. Usando tabelas externas, você pode acessar dados sem carregá-los no banco de dados. Para ter mais informações sobre tabelas externas, consulte [Managing External Tables](http://docs.oracle.com/database/121/ADMIN/tables.htm#ADMIN01507) (Gerenciar tabelas externas) na documentação do Oracle.
Com o Amazon RDS, você pode armazenar arquivos de tabela externos em objetos de diretório. Você pode criar um objeto de diretório ou pode usar um objeto predefinido no banco de dados Oracle, como o diretório DATA\$1PUMP\$1DIR. Para obter informações sobre como criar os objetos de diretório, consulte [Criar e eliminar diretórios no espaço de armazenamento de dados principal](Appendix.Oracle.CommonDBATasks.Misc.md#Appendix.Oracle.CommonDBATasks.NewDirectories). Você pode consultar a visualização ALL\$1DIRECTORIES a fim de listar os objetos de diretório para a instância de banco de dados Oracle do Amazon RDS.
**nota**
Os objetos de diretório apontam para o espaço de armazenamento físico de dados principal (volume do Amazon EBS) usado pela instância. O espaço usado, juntamente com arquivos de dados, logs redo, auditoria, rastreamento e outros arquivos, conta em relação ao armazenamento alocado.
Você pode mover um arquivo de dados externo de um banco de dados Oracle para outro usando o pacote [ DBMS\$1FILE\$1TRANSFER](https://docs.oracle.com/database/121/ARPLS/d_ftran.htm#ARPLS095) ou o pacote [UTL\$1FILE](https://docs.oracle.com/database/121/ARPLS/u_file.htm#ARPLS069). O arquivo de dados externo é movido de um diretório no banco de dados de origem para o diretório especificado no banco de dados de destino. Para obter informações sobre como utilizar o `DBMS_FILE_TRANSFER`, consulte [Importar usando o Oracle Data Pump](Oracle.Procedural.Importing.DataPump.md).
Depois de mover o arquivo de dados externo, você poderá criar uma tabela externa com ele. O seguinte exemplo cria uma tabela externa que usa o arquivo `emp_xt_file1.txt` no diretório USER\$1DIR1.
```
CREATE TABLE emp_xt (
emp_id NUMBER,
first_name VARCHAR2(50),
last_name VARCHAR2(50),
user_name VARCHAR2(20)
)
ORGANIZATION EXTERNAL (
TYPE ORACLE_LOADER
DEFAULT DIRECTORY USER_DIR1
ACCESS PARAMETERS (
RECORDS DELIMITED BY NEWLINE
FIELDS TERMINATED BY ','
MISSING FIELD VALUES ARE NULL
(emp_id,first_name,last_name,user_name)
)
LOCATION ('emp_xt_file1.txt')
)
PARALLEL
REJECT LIMIT UNLIMITED;
```
Suponhamos que você queira migrar dados que estejam em uma instância de banco de dados Oracle do Amazon RDS para um arquivo de dados externo. Nesse caso, você pode preencher o arquivo de dados externo criando uma tabela externa e selecionando os dados da tabela no banco de dados. Por exemplo, a instrução SQL a seguir cria a tabela externa `orders_xt` consultando a tabela `orders` no banco de dados.
```
CREATE TABLE orders_xt
ORGANIZATION EXTERNAL
(
TYPE ORACLE_DATAPUMP
DEFAULT DIRECTORY DATA_PUMP_DIR
LOCATION ('orders_xt.dmp')
)
AS SELECT * FROM orders;
```
Neste exemplo, os dados são preenchidos no arquivo `orders_xt.dmp` no diretório DATA\$1PUMP\$1DIR.
# Verificação de um banco de dados
Para verificar um banco de dados, use o procedimento do Amazon RDS `rdsadmin.rdsadmin_util.checkpoint`. O procedimento `checkpoint` não tem parâmetros.
O exemplo a seguir verifica o banco de dados.
```
EXEC rdsadmin.rdsadmin_util.checkpoint;
```
# Definição da recuperação distribuída
Para definir a recuperação distribuída, use os procedimentos `rdsadmin.rdsadmin_util.enable_distr_recovery` e `disable_distr_recovery` do Amazon RDS. Os procedimentos não têm parâmetros.
O exemplo a seguir habilita a recuperação distribuída.
```
EXEC rdsadmin.rdsadmin_util.enable_distr_recovery;
```
O exemplo a seguir desabilita a recuperação distribuída.
```
EXEC rdsadmin.rdsadmin_util.disable_distr_recovery;
```
# Definição do fuso horário do banco de dados
Você pode definir o fuso horário do banco de dados Oracle do Amazon RDS das seguintes maneiras:
+ A opção `Timezone`
A opção `Timezone` altera o fuso horário no nível do host e afeta todas as colunas e valores de data, como `SYSDATE`. Para ter mais informações, consulte [Fuso horário da Oracle](Appendix.Oracle.Options.Timezone.md).
+ O procedimento do Amazon RDS `rdsadmin.rdsadmin_util.alter_db_time_zone`
O procedimento `alter_db_time_zone` altera o fuso horário para apenas alguns tipos de dados e não altera `SYSDATE`. Existem restrições adicionais na definição do fuso horário, listadas na [documentação do Oracle](http://docs.oracle.com/cd/B19306_01/server.102/b14225/ch4datetime.htm#i1006705).
**nota**
Você também pode definir o fuso horário padrão para o Oracle Scheduler. Para ter mais informações, consulte [Definir o fuso horário para trabalhos do Oracle Scheduler](Appendix.Oracle.CommonDBATasks.Scheduler.md#Appendix.Oracle.CommonDBATasks.Scheduler.TimeZone).
O procedimento `alter_db_time_zone` tem os seguintes parâmetros.
****
| Nome do parâmetro | Tipo de dados | Padrão | Obrigatório | Descrição |
| --- | --- | --- | --- | --- |
| `p_new_tz` | varchar2 | — | Sim | O novo fuso horário como uma região nomeada ou um deslocamento absoluto do Tempo Universal Coordenado (UTC). Os deslocamentos válidos variam de -12:00 a \$114:00. |
O exemplo a seguir altera o fuso horário para UTC mais 3 horas.
```
EXEC rdsadmin.rdsadmin_util.alter_db_time_zone(p_new_tz => '+3:00');
```
O exemplo a seguir altera o fuso horário para o fuso horário de África/Algiers.
```
EXEC rdsadmin.rdsadmin_util.alter_db_time_zone(p_new_tz => 'Africa/Algiers');
```
Depois de alterar o fuso horário usando o procedimento `alter_db_time_zone`, reinicie a instância de banco de dados para que a alteração entre em vigor. Para ter mais informações, consulte [Reinicializar uma instância de banco de dados](USER_RebootInstance.md). Para obter informações sobre como atualizar fusos horários, consulte [Considerações sobre fuso horário](USER_UpgradeDBInstance.Oracle.OGPG.md#USER_UpgradeDBInstance.Oracle.OGPG.DST).
# Gerar relatórios de performance com o AWR (Automatic Workload Repository)
Para reunir dados de performance e gerar relatórios, a Oracle recomenda o AWR (Automatic Workload Repository). O AWR requer o Oracle Database Enterprise Edition e uma licença para os pacotes de Diagnóstico e Ajuste. Para ativar o AWR, defina o parâmetro de inicialização `CONTROL_MANAGEMENT_PACK_ACCESS` como `DIAGNOSTIC` ou `DIAGNOSTIC+TUNING`.
## Trabalhar com relatórios do AWR no RDS
Para gerar relatórios do AWR, é possível executar scripts como `awrrpt.sql`. Esses scripts são instalados no servidor host do banco de dados. No Amazon RDS, não é possível ter acesso direto ao host. No entanto, é possível obter cópias de scripts SQL de outra instalação do Oracle Database.
Também é possível usar o AWR executando procedimentos no pacote PL/SQL `SYS.DBMS_WORKLOAD_REPOSITORY`. É possível usar esse pacote para gerenciar linhas de base e snapshots e também para exibir relatórios do ASH e do AWR. Por exemplo, para gerar um relatório do AWR em formato de texto, execute o procedimento `DBMS_WORKLOAD_REPOSITORY.AWR_REPORT_TEXT`. No entanto, não é possível acessar esses relatórios da AWR a partir do Console de gerenciamento da AWS.
Ao trabalhar com o AWR, recomendamos usar os procedimentos `rdsadmin.rdsadmin_diagnostic_util`. É possível usar esses procedimentos para gerar o seguinte:
+ Relatórios do AWR
+ Relatórios do ASH (Active Session History)
+ Relatórios do ADDM (Automatic Database Diagnostic Monitor)
+ Arquivos de despejo do Oracle Data Pump Export de dados do AWR
Os procedimentos `rdsadmin_diagnostic_util` salvam os relatórios no sistema de arquivos da instância de banco de dados. É possível acessar esses relatórios no console. Também é possível acessar relatórios usando os procedimentos `rdsadmin.rds_file_util` e acessar relatórios copiados para o Amazon S3 usando a opção Integração do S3. Para obter mais informações, consulte [Leitura de arquivos no diretório de uma instância de banco de dados](Appendix.Oracle.CommonDBATasks.Misc.md#Appendix.Oracle.CommonDBATasks.ReadingFiles) e [Integração do Amazon S3](oracle-s3-integration.md).
É possível usar os procedimentos `rdsadmin_diagnostic_util` nas seguintes versões de mecanismo de banco de dados do Amazon RDS for Oracle:
+ Todas as versões do Oracle Database 21c
+ 19.0.0.0.ru-2020-04.rur-2020-04.r1 e versões posteriores do Oracle Database 19c
Para conferir um blog que explica como trabalhar com relatórios de diagnóstico em cenários de replicação, consulte [Gerar relatórios do AWR para réplicas de leitura do Amazon RDS para Oracle](https://aws.amazon.com/blogs/database/generate-awr-reports-for-amazon-rds-for-oracle-read-replicas/).
## Parâmetros comuns para o pacote do utilitário de diagnóstico
Normalmente, você usa os seguintes parâmetros ao gerenciar o AWR e o ADDM com o pacote `rdsadmin_diagnostic_util`.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.AWR.html)
Normalmente, você usa os seguintes parâmetros ao gerenciar o ASH com o pacote rdsadmin\$1diagnostic\$1util.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.AWR.html)
## Gerar um relatório do AWR
Para gerar um relatório do AWR, use o procedimento `rdsadmin.rdsadmin_diagnostic_util.awr_report`.
O exemplo a seguir gera um relatório do AWR para o intervalo de snapshot 101–106. O arquivo de texto de saída é chamado de `awrrpt_101_106.txt`. É possível acessar esse relatório no Console de gerenciamento da AWS.
```
EXEC rdsadmin.rdsadmin_diagnostic_util.awr_report(101,106,'TEXT');
```
O exemplo a seguir gera um relatório HTML para o intervalo de snapshot 63–65. O arquivo HTML de saída é chamado de `awrrpt_63_65.html`. O procedimento grava o relatório no diretório de banco de dados não padrão chamado de `AWR_RPT_DUMP`.
```
EXEC rdsadmin.rdsadmin_diagnostic_util.awr_report(63,65,'HTML','AWR_RPT_DUMP');
```
## Extrair dados do AWR em um arquivo de despejo
Para extrair dados do AWR em um arquivo de despejo, use o procedimento `rdsadmin.rdsadmin_diagnostic_util.awr_extract`. Você pode usar essa função somente em nível de PDB.
O exemplo a seguir extrai o intervalo de snapshot 101–106. O arquivo de despejo de saída é chamado de `awrextract_101_106.dmp`. É possível acessar esse arquivo por meio do console.
```
EXEC rdsadmin.rdsadmin_diagnostic_util.awr_extract(101,106);
```
O exemplo a seguir extrai o intervalo de snapshot 63–65. O arquivo de despejo de saída é chamado de `awrextract_63_65.dmp`. O arquivo é armazenado no diretório de banco de dados não padrão chamado de `AWR_RPT_DUMP`.
```
EXEC rdsadmin.rdsadmin_diagnostic_util.awr_extract(63,65,'AWR_RPT_DUMP');
```
## Gerar um relatório do ADDM
Para gerar um relatório do ADDM, use o procedimento `rdsadmin.rdsadmin_diagnostic_util.addm_report`.
O exemplo a seguir gera um relatório do ADDM para o intervalo de snapshot 101–106. O arquivo de texto de saída é chamado de `addmrpt_101_106.txt`. É possível acessar o relatório por meio do console.
```
EXEC rdsadmin.rdsadmin_diagnostic_util.addm_report(101,106);
```
O exemplo a seguir gera um relatório do ADDM para o intervalo de snapshot 63–65. O arquivo de texto de saída é chamado de `addmrpt_63_65.txt`. O arquivo é armazenado no diretório de banco de dados não padrão chamado de `ADDM_RPT_DUMP`.
```
EXEC rdsadmin.rdsadmin_diagnostic_util.addm_report(63,65,'ADDM_RPT_DUMP');
```
## Gerar um relatório do ASH
Para gerar um relatório do ASH, use o procedimento `rdsadmin.rdsadmin_diagnostic_util.ash_report`.
O exemplo a seguir gera um relatório do ASH que inclui os dados de 14 minutos atrás até a hora atual. O nome do arquivo de saída usa o formato `ashrptbegin_timeend_time.txt`, onde `begin_time` e `end_time` usam o formato `YYYYMMDDHH24MISS`. É possível acessar o arquivo por meio do console.
```
BEGIN
rdsadmin.rdsadmin_diagnostic_util.ash_report(
begin_time => SYSDATE-14/1440,
end_time => SYSDATE,
report_type => 'TEXT');
END;
/
```
O exemplo a seguir gera um relatório do ASH que inclui os dados de 18 de novembro de 2019 às 18:07 a 18 de novembro de 2019 às 18h15. O nome do relatório HTML de saída é `ashrpt_20190918180700_20190918181500.html`. O relatório é armazenado no diretório de banco de dados não padrão chamado de `AWR_RPT_DUMP`.
```
BEGIN
rdsadmin.rdsadmin_diagnostic_util.ash_report(
begin_time => TO_DATE('2019-09-18 18:07:00', 'YYYY-MM-DD HH24:MI:SS'),
end_time => TO_DATE('2019-09-18 18:15:00', 'YYYY-MM-DD HH24:MI:SS'),
report_type => 'html',
dump_directory => 'AWR_RPT_DUMP');
END;
/
```
## Acessar relatórios do AWR no console ou na CLI
Para acessar relatórios do AWR ou exportar arquivos de despejo, é possível usar o Console de gerenciamento da AWS ou a AWS CLI. Para obter mais informações, consulte [Como baixar um arquivo de log de banco de dados](USER_LogAccess.Procedural.Downloading.md).
# Ajuste de vínculos de banco de dados para uso com instâncias de bancos de dados em uma VPC
Para usar links de banco de dados Oracle com instâncias de bancos de dados do Amazon RDS na mesma nuvem privada virtual (VPC) ou em VPCs emparelhadas, as duas instâncias de bancos de dados devem ter uma rota válida entre elas. Verifique a rota válida entre as instâncias de bancos de dados usando suas tabelas de roteamento da VPC e a lista de controle de acesso (ACL) à rede.
O grupo de segurança de cada instância de banco de dados deve permitir a entrada e a saída da outra instância de banco de dados. As regras de entrada e saída podem se referir a security groups da mesma VPC ou de uma VPC emparelhada. Para ter mais informações, consulte [Atualização dos seus grupos de segurança para referenciar grupos de segurança na VPC emparelhada](https://docs.aws.amazon.com/vpc/latest/peering/working-with-vpc-peering.html#vpc-peering-security-groups).
Se você tiver configurado um servidor DNS personalizado usando os conjuntos de opções DHCP na sua VPC, seu servidor DNS personalizado deverá ser capaz de resolver o nome do destino do vínculo de banco de dados. Para ter mais informações, consulte [Configuração de um servidor DNS personalizado](Appendix.Oracle.CommonDBATasks.System.md#Appendix.Oracle.CommonDBATasks.CustomDNS).
Para ter mais informações sobre como usar vínculos de banco de dados com o Oracle Data Pump, consulte [Importar usando o Oracle Data Pump](Oracle.Procedural.Importing.DataPump.md).
# Definir a edição padrão para uma instância de banco de dados
Você pode redefinir objetos de banco de dados em um ambiente privado chamado de edição. Você pode usar a redefinição com base na edição para atualizar os objetos de banco de dados de um aplicativo com tempo de inatividade mínimo.
Você pode definir a edição padrão de uma instância de banco de dados Oracle do Amazon RDS usando o procedimento do Amazon RDS `rdsadmin.rdsadmin_util.alter_default_edition`.
O exemplo a seguir define a edição padrão para a instância de banco de dados Oracle do Amazon RDS como `RELEASE_V1`.
```
EXEC rdsadmin.rdsadmin_util.alter_default_edition('RELEASE_V1');
```
O exemplo a seguir define a edição padrão para a instância de banco de dados Oracle do Amazon RDS como o padrão Oracle.
```
EXEC rdsadmin.rdsadmin_util.alter_default_edition('ORA$BASE');
```
Para ter mais informações sobre a redefinição com base na edição Oracle, consulte [About editions and edition-based redefinition](https://docs.oracle.com/database/121/ADMIN/general.htm#ADMIN13167) na documentação da Oracle.
# Habilitar a auditoria para a tabela SYS.AUD\$1
Para habilitar a auditoria na tabela de trilha de auditoria de banco de dados `SYS.AUD$`, use o procedimento `rdsadmin.rdsadmin_master_util.audit_all_sys_aud_table` do Amazon RDS. A única propriedade de auditoria com suporte é `ALL`. Não é possível auditar ou não auditar instruções ou operações individuais.
A habilitação da auditoria tem suporte para instâncias de banco de dados Oracle que executam as seguintes versões:
+ Oracle Database 21c (21.0.0)
+ Oracle Database 19c (19.0.0)
O procedimento `audit_all_sys_aud_table` tem os seguintes parâmetros.
****
| Nome do parâmetro | Tipo de dados | Padrão | Obrigatório | Descrição |
| --- | --- | --- | --- | --- |
| `p_by_access` | booliano | true | Não | Defina como `true` para auditar `BY ACCESS`. Defina como `false` para auditar `BY SESSION`. |
A consulta a seguir retorna a configuração de auditoria atual para `SYS.AUD$` para um banco de dados:
```
SELECT * FROM DBA_OBJ_AUDIT_OPTS WHERE OWNER='SYS' AND OBJECT_NAME='AUD$';
```
Os comandos a seguir habilitam a auditoria de `ALL` em `SYS.AUD$` `BY ACCESS`.
```
EXEC rdsadmin.rdsadmin_master_util.audit_all_sys_aud_table;
EXEC rdsadmin.rdsadmin_master_util.audit_all_sys_aud_table(p_by_access => true);
```
O comando a seguir habilita a auditoria de `ALL` em `SYS.AUD$` `BY SESSION`.
```
EXEC rdsadmin.rdsadmin_master_util.audit_all_sys_aud_table(p_by_access => false);
```
Para ter mais informações, consulte [AUDIT (traditional auditing)](https://docs.oracle.com/en/database/oracle/oracle-database/12.2/sqlrf/AUDIT-Traditional-Auditing.html#GUID-ADF45B07-547A-4096-8144-50241FA2D8DD) (Auditoria [auditoria tradicional]) na documentação do Oracle.
# Desabilitar a auditoria para a tabela SYS.AUD\$1
Para desabilitar a auditoria na tabela de trilha de auditoria de banco de dados `SYS.AUD$`, use o procedimento `rdsadmin.rdsadmin_master_util.noaudit_all_sys_aud_table` do Amazon RDS. Este procedimento não usa parâmetros.
A consulta a seguir retorna a configuração de auditoria atual para `SYS.AUD$` para um banco de dados:
```
SELECT * FROM DBA_OBJ_AUDIT_OPTS WHERE OWNER='SYS' AND OBJECT_NAME='AUD$';
```
O comando a seguir desabilita a auditoria de `ALL` em `SYS.AUD$`.
```
EXEC rdsadmin.rdsadmin_master_util.noaudit_all_sys_aud_table;
```
Para ter mais informações, consulte [NOAUDIT (traditional auditing)](https://docs.oracle.com/en/database/oracle/oracle-database/12.2/sqlrf/NOAUDIT-Traditional-Auditing.html#GUID-9D8EAF18-4AB3-4C04-8BF7-37BD0E15434D) (Sem auditoria [auditoria tradicional]) na documentação do Oracle.
# Limpar criações de índice online interrompidas
Para limpar criações de índice online com falha, use o procedimento do Amazon RDS `rdsadmin.rdsadmin_dbms_repair.online_index_clean`.
O procedimento `online_index_clean` tem os seguintes parâmetros.
****
| Nome do parâmetro | Tipo de dados | Padrão | Obrigatório | Descrição |
| --- | --- | --- | --- | --- |
| `object_id` | binary\$1integer | `ALL_INDEX_ID` | Não | O ID do objeto do índice. Normalmente, é possível usar o ID do objeto do texto do erro ORA-08104. |
| `wait_for_lock` | binary\$1integer | `rdsadmin.rdsadmin_dbms_repair.lock_wait` | Não | Especifique `rdsadmin.rdsadmin_dbms_repair.lock_wait`, o padrão, para tentar obter um bloqueio no objeto subjacente e tentar novamente até que um limite interno seja atingido se o bloqueio falhar. Especifique `rdsadmin.rdsadmin_dbms_repair.lock_nowait` para tentar obter um bloqueio no objeto subjacente, mas não tentar novamente se o bloqueio falhar. |
O exemplo a seguir limpa uma criação de índice online com falha:
```
declare
is_clean boolean;
begin
is_clean := rdsadmin.rdsadmin_dbms_repair.online_index_clean(
object_id => 1234567890,
wait_for_lock => rdsadmin.rdsadmin_dbms_repair.lock_nowait
);
end;
/
```
Para ter mais informações, consulte [ONLINE\$1INDEX\$1CLEAN function](https://docs.oracle.com/database/121/ARPLS/d_repair.htm#ARPLS67555) (Função ONLINE\$1INDEX\$1CLEAN) na documentação do Oracle.
# Ignorar blocos corrompidos
Para ignorar blocos corrompidos durante as verificações de índices e tabelas, use o pacote `rdsadmin.rdsadmin_dbms_repair`.
Os procedimentos a seguir encapsulam a funcionalidade do procedimento `sys.dbms_repair.admin_table` e não usam parâmetros:
+ `rdsadmin.rdsadmin_dbms_repair.create_repair_table`
+ `rdsadmin.rdsadmin_dbms_repair.create_orphan_keys_table`
+ `rdsadmin.rdsadmin_dbms_repair.drop_repair_table`
+ `rdsadmin.rdsadmin_dbms_repair.drop_orphan_keys_table`
+ `rdsadmin.rdsadmin_dbms_repair.purge_repair_table`
+ `rdsadmin.rdsadmin_dbms_repair.purge_orphan_keys_table`
Os seguintes procedimentos usam o mesmo parâmetro que seus equivalentes no pacote `DBMS_REPAIR` para bancos de dados Oracle:
+ `rdsadmin.rdsadmin_dbms_repair.check_object`
+ `rdsadmin.rdsadmin_dbms_repair.dump_orphan_keys`
+ `rdsadmin.rdsadmin_dbms_repair.fix_corrupt_blocks`
+ `rdsadmin.rdsadmin_dbms_repair.rebuild_freelists`
+ `rdsadmin.rdsadmin_dbms_repair.segment_fix_status`
+ `rdsadmin.rdsadmin_dbms_repair.skip_corrupt_blocks`
Para ter mais informações sobre como lidar com a corrupção de banco de dados, consulte [DBMS\$1REPARE](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/DBMS_REPAIR.html#GUID-B8EC4AB3-4D6A-46C9-857F-4ED53CD9C948) na documentação do Oracle.
**Example Responder a blocos corrompidos**
Este exemplo mostra o fluxo de trabalho básico para responder a blocos corrompidos. Suas etapas dependerão do local e da natureza da corrupção do bloco.
Antes de tentar reparar blocos corrompidos, revise atentamente a documentação [DBMS\$1REPARE](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/DBMS_REPAIR.html#GUID-B8EC4AB3-4D6A-46C9-857F-4ED53CD9C948).
**Como ignorar blocos corrompidos durante as verificações de índices e tabelas**
1. Execute os procedimentos a seguir para criar tabelas de reparo se elas ainda não existirem.
```
EXEC rdsadmin.rdsadmin_dbms_repair.create_repair_table;
EXEC rdsadmin.rdsadmin_dbms_repair.create_orphan_keys_table;
```
1. Execute os procedimentos a seguir para verificar registros existentes e depurá-los, caso seja apropriado.
```
SELECT COUNT(*) FROM SYS.REPAIR_TABLE;
SELECT COUNT(*) FROM SYS.ORPHAN_KEY_TABLE;
SELECT COUNT(*) FROM SYS.DBA_REPAIR_TABLE;
SELECT COUNT(*) FROM SYS.DBA_ORPHAN_KEY_TABLE;
EXEC rdsadmin.rdsadmin_dbms_repair.purge_repair_table;
EXEC rdsadmin.rdsadmin_dbms_repair.purge_orphan_keys_table;
```
1. Execute o procedimento a seguir para verificar blocos corrompidos.
```
SET SERVEROUTPUT ON
DECLARE v_num_corrupt INT;
BEGIN
v_num_corrupt := 0;
rdsadmin.rdsadmin_dbms_repair.check_object (
schema_name => '&corruptionOwner',
object_name => '&corruptionTable',
corrupt_count => v_num_corrupt
);
dbms_output.put_line('number corrupt: '||to_char(v_num_corrupt));
END;
/
COL CORRUPT_DESCRIPTION FORMAT a30
COL REPAIR_DESCRIPTION FORMAT a30
SELECT OBJECT_NAME, BLOCK_ID, CORRUPT_TYPE, MARKED_CORRUPT,
CORRUPT_DESCRIPTION, REPAIR_DESCRIPTION
FROM SYS.REPAIR_TABLE;
SELECT SKIP_CORRUPT
FROM DBA_TABLES
WHERE OWNER = '&corruptionOwner'
AND TABLE_NAME = '&corruptionTable';
```
1. Use o procedimento `skip_corrupt_blocks` para habilitar ou desabilitar a ação de ignorar as tabelas afetadas. Dependendo da situação, também pode ser necessário extrair dados para uma nova tabela e, depois, descartar a tabela que contém o bloco corrompido.
Execute o procedimento a seguir para permitir que sejam ignoradas as tabelas corrompidas.
```
begin
rdsadmin.rdsadmin_dbms_repair.skip_corrupt_blocks (
schema_name => '&corruptionOwner',
object_name => '&corruptionTable',
object_type => rdsadmin.rdsadmin_dbms_repair.table_object,
flags => rdsadmin.rdsadmin_dbms_repair.skip_flag);
end;
/
select skip_corrupt from dba_tables where owner = '&corruptionOwner' and table_name = '&corruptionTable';
```
Execute o procedimento a seguir para não permitir que sejam ignoradas as tabelas corrompidas.
```
begin
rdsadmin.rdsadmin_dbms_repair.skip_corrupt_blocks (
schema_name => '&corruptionOwner',
object_name => '&corruptionTable',
object_type => rdsadmin.rdsadmin_dbms_repair.table_object,
flags => rdsadmin.rdsadmin_dbms_repair.noskip_flag);
end;
/
select skip_corrupt from dba_tables where owner = '&corruptionOwner' and table_name = '&corruptionTable';
```
1. Quando tiver concluído todos os trabalhos de reparação, execute os procedimentos a seguir para descartar as tabelas reparadas.
```
EXEC rdsadmin.rdsadmin_dbms_repair.drop_repair_table;
EXEC rdsadmin.rdsadmin_dbms_repair.drop_orphan_keys_table;
```
## Limpar a lixeira
Quando você remove uma tabela, o banco de dados Oracle não remove imediatamente o espaço de armazenamento. O banco de dados renomeia a tabela e coloca ela e todos os objetos associados em uma lixeira. A limpeza da lixeira remove esses itens e libera o espaço de armazenamento.
Para limpar toda a lixeira, use o procedimento do Amazon RDS `rdsadmin.rdsadmin_util.purge_dba_recyclebin`. No entanto, este procedimento não pode limpar a lixeira de objetos `SYS` e `RDSADMIN`. Se você precisar limpar esses objetos, entre em contato com o AWSSupport.
O exemplo a seguir limpa toda a lixeira.
```
EXEC rdsadmin.rdsadmin_util.purge_dba_recyclebin;
```
# Definir os valores padrão exibidos para a redação completa
Para alterar os valores exibidos padrão para a redação completa na instância Oracle do Amazon RDS, use o procedimento `rdsadmin.rdsadmin_util.dbms_redact_upd_full_rdct_val` do Amazon RDS. Observe que você cria uma política de redação com o pacote `DBMS_REDACT` do PL/SQL, conforme explicado na documentação do Oracle Database. O procedimento `dbms_redact_upd_full_rdct_val` especifica os caracteres a serem exibidos para diferentes tipos de dados afetados por uma política existente.
O procedimento `dbms_redact_upd_full_rdct_val` tem os seguintes parâmetros.
****
| Nome do parâmetro | Tipo de dados | Padrão | Obrigatório | Descrição |
| --- | --- | --- | --- | --- |
| `p_number_val` | número | Null | Não | Modifica o valor padrão para colunas do tipo de dados `NUMBER`. |
| `p_binfloat_val` | binary\$1float | Null | Não | Modifica o valor padrão para colunas do tipo de dados `BINARY_FLOAT`. |
| `p_bindouble_val` | binary\$1double | Null | Não | Modifica o valor padrão para colunas do tipo de dados `BINARY_DOUBLE`. |
| `p_char_val` | char | Null | Não | Modifica o valor padrão para colunas do tipo de dados `CHAR`. |
| `p_varchar_val` | varchar2 | Null | Não | Modifica o valor padrão para colunas do tipo de dados `VARCHAR2`. |
| `p_nchar_val` | nchar | Null | Não | Modifica o valor padrão para colunas do tipo de dados `NCHAR`. |
| `p_nvarchar_val` | nvarchar2 | Null | Não | Modifica o valor padrão para colunas do tipo de dados `NVARCHAR2`. |
| `p_date_val` | date | Null | Não | Modifica o valor padrão para colunas do tipo de dados `DATE`. |
| `p_ts_val` | timestamp | Null | Não | Modifica o valor padrão para colunas do tipo de dados `TIMESTAMP`. |
| `p_tswtz_val` | timestamp with time zone | Null | Não | Modifica o valor padrão para colunas do tipo de dados `TIMESTAMP WITH TIME ZONE`. |
| `p_blob_val` | blob | Null | Não | Modifica o valor padrão para colunas do tipo de dados `BLOB`. |
| `p_clob_val` | clob | Null | Não | Modifica o valor padrão para colunas do tipo de dados `CLOB`. |
| `p_nclob_val` | nclob | Null | Não | Modifica o valor padrão para colunas do tipo de dados `NCLOB`. |
O exemplo a seguir altera o valor editado padrão para \$1 referente ao tipo de dados `CHAR`:
```
EXEC rdsadmin.rdsadmin_util.dbms_redact_upd_full_rdct_val(p_char_val => '*');
```
O exemplo a seguir altera os valores editados padrão para tipos de dados `NUMBER`, `DATE` e `CHAR`:
```
BEGIN
rdsadmin.rdsadmin_util.dbms_redact_upd_full_rdct_val(
p_number_val=>1,
p_date_val=>to_date('1900-01-01','YYYY-MM-DD'),
p_varchar_val=>'X');
END;
/
```
Depois de alterar os valores padrão para a redação completa com o procedimento `dbms_redact_upd_full_rdct_val`, reinicialize a instância de banco de dados para que a alteração seja implementada. Para obter mais informações, consulte [Reinicializar uma instância de banco de dados](USER_RebootInstance.md).
# Realização de tarefas comuns relacionadas ao log para instâncias de banco de dados Oracle
Veja a seguir como executar determinadas tarefas comuns de DBA relacionadas ao registro em log nas instâncias de bancos de dados do Amazon RDS que executam o Oracle. Para oferecer uma experiência de serviço gerenciado, o Amazon RDS não fornece acesso ao shell para instâncias de bancos de dados e restringe o acesso a determinados procedimentos e tabelas do sistema que exigem privilégios avançados.
Para obter mais informações, consulte [Arquivos de log do banco de dados do Amazon RDS para Oracle](USER_LogAccess.Concepts.Oracle.md).
**Topics**
+ [
## Definição do registro em log forçado
](#Appendix.Oracle.CommonDBATasks.SettingForceLogging)
+ [
## Definição do registro em log complementar
](#Appendix.Oracle.CommonDBATasks.AddingSupplementalLogging)
+ [
## Alternância de arquivos de log online
](#Appendix.Oracle.CommonDBATasks.SwitchingLogfiles)
+ [
## Adição de logs redo online
](#Appendix.Oracle.CommonDBATasks.RedoLogs)
+ [
## Descarte de logs redo online
](#Appendix.Oracle.CommonDBATasks.DroppingRedoLogs)
+ [
# Redimensionamento de logs redo online
](Appendix.Oracle.CommonDBATasks.ResizingRedoLogs.md)
+ [
# Retenção de logs redo arquivados
](Appendix.Oracle.CommonDBATasks.RetainRedoLogs.md)
+ [
# Acessando logs de refazimento online e arquivados
](Appendix.Oracle.CommonDBATasks.Log.Download.md)
+ [
# Baixar logs de refazimento arquivados do Amazon S3
](Appendix.Oracle.CommonDBATasks.download-redo-logs.md)
## Definição do registro em log forçado
No modo de registro em log forçado, o Oracle registra todas as alterações no banco de dados, exceto as alterações em espaços de tabela temporários e em segmentos temporários (as cláusulas `NOLOGGING` são ignoradas). Para obter mais informações, consulte [Specifying FORCE LOGGING mode](https://docs.oracle.com/cd/E11882_01/server.112/e25494/create.htm#ADMIN11096) na documentação da Oracle.
Para definir o registro em log forçado, use o procedimento do Amazon RDS `rdsadmin.rdsadmin_util.force_logging`. O procedimento `force_logging` tem os seguintes parâmetros.
****
| Nome do parâmetro | Tipo de dados | Padrão | Sim | Descrição |
| --- | --- | --- | --- | --- |
| `p_enable` | booliano | true | Não | Defina como `true` para colocar o banco de dados no modo de registro em log forçado, `false` para remover o banco de dados do modo de registro em log forçado. |
O exemplo a seguir coloca o banco de dados no modo de registro em log forçado.
```
EXEC rdsadmin.rdsadmin_util.force_logging(p_enable => true);
```
## Definição do registro em log complementar
Se você habilitar o registro em log suplementar, o LogMiner terá as informações necessárias para oferecer suporte a linhas encadeadas e tabelas clusterizadas. Para obter mais informações, consulte [Supplemental logging](https://docs.oracle.com/cd/E11882_01/server.112/e22490/logminer.htm#SUTIL1582) na documentação da Oracle.
Por padrão, o banco de dados Oracle não habilita o registro em log complementar. Para habilitar e desabilitar o registro em log complementar, use o procedimento do Amazon RDS `rdsadmin.rdsadmin_util.alter_supplemental_logging`. Para obter mais informações sobre como o Amazon RDS gerencia a retenção de logs redo arquivados para instâncias de bancos de dados Oracle, consulte [Retenção de logs redo arquivados](Appendix.Oracle.CommonDBATasks.RetainRedoLogs.md).
O procedimento `alter_supplemental_logging` tem os seguintes parâmetros.
****
| Nome do parâmetro | Tipo de dados | Padrão | Obrigatório | Descrição |
| --- | --- | --- | --- | --- |
| `p_action` | varchar2 | — | Sim | `'ADD'` para adicionar o registro em log complementar, `'DROP'` para descartar o registro em log complementar. |
| `p_type` | varchar2 | nulo | Não | O tipo de registro em log complementar. Os valores válidos são `'ALL'`, `'FOREIGN KEY'`, `'PRIMARY KEY'`, `'UNIQUE'` ou `PROCEDURAL`. |
O exemplo a seguir habilita o registro em log complementar.
```
begin
rdsadmin.rdsadmin_util.alter_supplemental_logging(
p_action => 'ADD');
end;
/
```
O exemplo a seguir habilita o registro em log complementar para todas as colunas de tamanho máximo com comprimento fixo.
```
begin
rdsadmin.rdsadmin_util.alter_supplemental_logging(
p_action => 'ADD',
p_type => 'ALL');
end;
/
```
O exemplo a seguir habilita o registro em log complementar para colunas de chave primária.
```
begin
rdsadmin.rdsadmin_util.alter_supplemental_logging(
p_action => 'ADD',
p_type => 'PRIMARY KEY');
end;
/
```
## Alternância de arquivos de log online
Para alternar arquivos de log, use o procedimento do Amazon RDS `rdsadmin.rdsadmin_util.switch_logfile`. O procedimento `switch_logfile` não tem parâmetros.
O exemplo a seguir alterna arquivos de log.
```
EXEC rdsadmin.rdsadmin_util.switch_logfile;
```
## Adição de logs redo online
Uma instância de banco de dados do Amazon RDS executando o Oracle começa com quatro logs redo online, cada um com 128 MB. Para adicionar mais logs redo, use o procedimento do Amazon RDS `rdsadmin.rdsadmin_util.add_logfile`.
O procedimento `add_logfile` tem os seguintes parâmetros.
**nota**
Os parâmetros são mutuamente exclusivos.
****
| Nome do parâmetro | Tipo de dados | Padrão | Obrigatório | Descrição |
| --- | --- | --- | --- | --- |
| `bytes` | positivo | nulo | Não | O tamanho do arquivo de log em bytes. Use esse parâmetro somente se o tamanho do log for inferior a 2.147.483.648 bytes (2 GiB). Caso contrário, o RDS emitirá um erro. Entretanto, para tamanhos de log acima desse valor em bytes, use o parâmetro `p_size`. |
| `p_size` | varchar2 | — | Sim | O tamanho do arquivo de log em quilobytes (K), megabytes (M) ou gigabytes (G). |
O comando a seguir adiciona um arquivo de log de 100 MB.
```
EXEC rdsadmin.rdsadmin_util.add_logfile(p_size => '100M');
```
## Descarte de logs redo online
Para descartar logs redo, use o procedimento do Amazon RDS `rdsadmin.rdsadmin_util.drop_logfile`. O procedimento `drop_logfile` tem os seguintes parâmetros.
****
| Nome do parâmetro | Tipo de dados | Padrão | Obrigatório | Descrição |
| --- | --- | --- | --- | --- |
| `grp` | positivo | — | Sim | O número do grupo do log. |
O exemplo a seguir descarta o log com o número de grupo 3.
```
EXEC rdsadmin.rdsadmin_util.drop_logfile(grp => 3);
```
Você só pode descartar logs que tenham um status de não utilizado ou inativo. O exemplo a seguir obtém os status dos logs.
```
SELECT GROUP#, STATUS FROM V$LOG;
GROUP# STATUS
---------- ----------------
1 CURRENT
2 INACTIVE
3 INACTIVE
4 UNUSED
```
# Redimensionamento de logs redo online
Uma instância de banco de dados do Amazon RDS executando o Oracle começa com quatro logs redo online, cada um com 128 MB. O exemplo a seguir mostra como você pode usar procedimentos do Amazon RDS para redimensionar seus logs de 128 MB cada para 512 MB cada.
```
/* Query V$LOG to see the logs. */
/* You start with 4 logs of 128 MB each. */
SELECT GROUP#, BYTES, STATUS FROM V$LOG;
GROUP# BYTES STATUS
---------- ---------- ----------------
1 134217728 INACTIVE
2 134217728 CURRENT
3 134217728 INACTIVE
4 134217728 INACTIVE
/* Add four new logs that are each 512 MB */
EXEC rdsadmin.rdsadmin_util.add_logfile(bytes => 536870912);
EXEC rdsadmin.rdsadmin_util.add_logfile(bytes => 536870912);
EXEC rdsadmin.rdsadmin_util.add_logfile(bytes => 536870912);
EXEC rdsadmin.rdsadmin_util.add_logfile(bytes => 536870912);
/* Query V$LOG to see the logs. */
/* Now there are 8 logs. */
SELECT GROUP#, BYTES, STATUS FROM V$LOG;
GROUP# BYTES STATUS
---------- ---------- ----------------
1 134217728 INACTIVE
2 134217728 CURRENT
3 134217728 INACTIVE
4 134217728 INACTIVE
5 536870912 UNUSED
6 536870912 UNUSED
7 536870912 UNUSED
8 536870912 UNUSED
/* Drop each inactive log using the group number. */
EXEC rdsadmin.rdsadmin_util.drop_logfile(grp => 1);
EXEC rdsadmin.rdsadmin_util.drop_logfile(grp => 3);
EXEC rdsadmin.rdsadmin_util.drop_logfile(grp => 4);
/* Query V$LOG to see the logs. */
/* Now there are 5 logs. */
select GROUP#, BYTES, STATUS from V$LOG;
GROUP# BYTES STATUS
---------- ---------- ----------------
2 134217728 CURRENT
5 536870912 UNUSED
6 536870912 UNUSED
7 536870912 UNUSED
8 536870912 UNUSED
/* Switch logs so that group 2 is no longer current. */
EXEC rdsadmin.rdsadmin_util.switch_logfile;
/* Query V$LOG to see the logs. */
/* Now one of the new logs is current. */
SQL>SELECT GROUP#, BYTES, STATUS FROM V$LOG;
GROUP# BYTES STATUS
---------- ---------- ----------------
2 134217728 ACTIVE
5 536870912 CURRENT
6 536870912 UNUSED
7 536870912 UNUSED
8 536870912 UNUSED
/* If the status of log 2 is still "ACTIVE", issue a checkpoint to clear it to "INACTIVE". */
EXEC rdsadmin.rdsadmin_util.checkpoint;
/* Query V$LOG to see the logs. */
/* Now the final original log is inactive. */
select GROUP#, BYTES, STATUS from V$LOG;
GROUP# BYTES STATUS
---------- ---------- ----------------
2 134217728 INACTIVE
5 536870912 CURRENT
6 536870912 UNUSED
7 536870912 UNUSED
8 536870912 UNUSED
# Drop the final inactive log.
EXEC rdsadmin.rdsadmin_util.drop_logfile(grp => 2);
/* Query V$LOG to see the logs. */
/* Now there are four 512 MB logs. */
SELECT GROUP#, BYTES, STATUS FROM V$LOG;
GROUP# BYTES STATUS
---------- ---------- ----------------
5 536870912 CURRENT
6 536870912 UNUSED
7 536870912 UNUSED
8 536870912 UNUSED
```
# Retenção de logs redo arquivados
Você pode reter logs de refazimento arquivados localmente emsua instância de banco de dados para uso com produtos como o Oracle LogMiner (`DBMS_LOGMNR`). Depois de ter retido os redo logs, você pode usar o LogMiner para analisar esses logs. Para obter mais informações, consulte [Using LogMiner to analyze redo log files](http://docs.oracle.com/cd/E11882_01/server.112/e22490/logminer.htm) na documentação da Oracle.
Para reter logs redo arquivados, use o procedimento do Amazon RDS `rdsadmin.rdsadmin_util.set_configuration`. Se você usar esse procedimento em uma instância primária no Oracle Data Guard, o RDS alterará a configuração de retenção do log de arquivamento na instância primária e nas réplicas de leitura abertas, mas não nas réplicas montadas. O RDS retém os últimos logs de redo arquivados em réplicas montadas por um curto período. O RDS exclui automaticamente os logs mais antigos baixados para as réplicas montadas.
O procedimento `set_configuration` tem os seguintes parâmetros.
****
| Nome do parâmetro | Tipo de dados | Padrão | Obrigatório | Descrição |
| --- | --- | --- | --- | --- |
| `name` | varchar | — | Sim | O nome da configuração a ser atualizada. Para alterar as horas de retenção do log de redo arquivado, defina o nome como `archivelog retention hours`. |
| `value` | varchar | — | Sim | O valor para a configuração. Defina o valor como o número de horas para reter os logs. |
O exemplo a seguir retém 24 horas de logs redo.
```
begin
rdsadmin.rdsadmin_util.set_configuration(
name => 'archivelog retention hours',
value => '24');
end;
/
commit;
```
**nota**
A confirmação é necessária para que a alteração entre em vigor.
Para visualizar por quanto tempo os logs redo arquivados são mantidos para a instância de banco de dados, use o procedimento do Amazon RDS `rdsadmin.rdsadmin_util.show_configuration`.
O seguinte exemplo mostra o tempo de retenção do log.
```
set serveroutput on
EXEC rdsadmin.rdsadmin_util.show_configuration;
```
A saída mostra a definição atual de `archivelog retention hours`. A seguinte saída mostra que logs redo arquivados são mantidos por 48 horas.
```
NAME:archivelog retention hours
VALUE:48
DESCRIPTION:ArchiveLog expiration specifies the duration in hours before archive/redo log files are automatically deleted.
```
Como os logs redo arquivados são retidos na sua instância de banco de dados, certifique-se de que essa instância tenha armazenamento alocado suficiente para os logs retidos. Para determinar quanto espaço sua instância de banco de dados usou nas últimas X horas, você pode executar a consulta a seguir, substituindo X pelo número de horas.
```
SELECT SUM(BLOCKS * BLOCK_SIZE) bytes
FROM V$ARCHIVED_LOG
WHERE FIRST_TIME >= SYSDATE-(X/24) AND DEST_ID=1;
```
O RDS for Oracle apenas gera logs de refazimento arquivados se o período de retenção de backup de sua instância de banco de dados for maior que zero. Por padrão, o período de retenção de backup é maior que zero.
Quando o período de retenção de logs arquivados expira, o RDS for Oracle remove os logs de refazimento arquivados de sua instância de banco de dados. Para oferecer suporte à restauração point-in-time de sua instância de banco de dados, o Amazon RDS retém os logs de refazimento arquivados fora de sua instância de banco de dados com base no período de retenção de backup. Para modificar o período de retenção de backup, consulte [Modificar uma instância de banco de dados do Amazon RDS](Overview.DBInstance.Modifying.md).
**nota**
Em alguns casos, você pode estar usando o JDBC no Linux para baixar logs redo arquivados e fazer testes com tempos de latência longos e redefinições de conexão. Nesses casos, os problemas podem ser causados pela configuração padrão do gerador de números aleatórios no seu cliente Java. Recomendamos que você configure seus drivers JDBC para usar um gerador de números aleatórios sem bloqueio.
# Acessando logs de refazimento online e arquivados
Talvez você queira acessar seus arquivos de log redo online e arquivados para exploração com ferramentas externas, como o GoldenGate, o Attunity e o Informatica, entre outras. Para acessar esses arquivos, faça o seguinte:
1. Crie objetos de diretório que forneçam acesso somente leitura aos caminhos de arquivos físicos.
Utilizar `rdsadmin.rdsadmin_master_util.create_archivelog_dir` e `rdsadmin.rdsadmin_master_util.create_onlinelog_dir`.
1. Leia os arquivos usando PL/SQL.
É possível ler os arquivos usando PL/SQL. Para obter mais informações sobre como ler arquivos a partir de objetos de diretório, consulte [Listagem de arquivos no diretório de uma instância de banco de dados](Appendix.Oracle.CommonDBATasks.Misc.md#Appendix.Oracle.CommonDBATasks.ListDirectories) e [Leitura de arquivos no diretório de uma instância de banco de dados](Appendix.Oracle.CommonDBATasks.Misc.md#Appendix.Oracle.CommonDBATasks.ReadingFiles).
O acesso a logs de transação é compatível com as seguintes versões:
+ Oracle Database 21c
+ Oracle Database 19c
O código a seguir cria diretórios que fornecem acesso somente leitura aos seus arquivos de log redo online e arquivados:
**Importante**
Esse código também revoga o privilégio `DROP ANY DIRECTORY`.
```
EXEC rdsadmin.rdsadmin_master_util.create_archivelog_dir;
EXEC rdsadmin.rdsadmin_master_util.create_onlinelog_dir;
```
O código a seguir descarta os diretórios para seus arquivos de log redo online e arquivados.
```
EXEC rdsadmin.rdsadmin_master_util.drop_archivelog_dir;
EXEC rdsadmin.rdsadmin_master_util.drop_onlinelog_dir;
```
O código a seguir concede e revoga o privilégio `DROP ANY DIRECTORY`.
```
EXEC rdsadmin.rdsadmin_master_util.revoke_drop_any_directory;
EXEC rdsadmin.rdsadmin_master_util.grant_drop_any_directory;
```
# Baixar logs de refazimento arquivados do Amazon S3
É possível baixar logs de refazimento arquivados em sua instância de banco de dados usando o pacote `rdsadmin.rdsadmin_archive_log_download`. Se os logs de refazimento arquivados não estiverem mais em sua instância de banco de dados, você poderá baixá-los novamente do Amazon S3. Então você pode extrair os logs ou usá-los para recuperar ou replicar seu banco de dados.
**nota**
Não é possível baixar logs de redo arquivados em instâncias de réplica de leitura.
## Baixar logs de refazimento arquivados: etapas básicas
A disponibilidade dos logs de refazimento arquivados depende das seguintes políticas de retenção:
+ Política de retenção de backup: os logs dentro dessa política estão disponíveis no Amazon S3. Os logs fora dessa política são removidos.
+ Política de retenção de logs arquivados: os logs dentro dessa política estão disponíveis em sua instância de banco de dados. Os logs fora dessa política são removidos.
Se os logs não estiverem em sua instância, mas estiverem protegidos pelo período de retenção de backup, use `rdsadmin.rdsadmin_archive_log_download` para baixar novamente. O RDS for Oracle salva os logs no diretório `/rdsdbdata/log/arch` em sua instância de banco de dados.
**Para baixar logs de refazimento arquivados do Amazon S3**
1. Configure seu período de retenção para garantir que os redo logs arquivados que foram baixados sejam retidos pelo tempo em que você precisar deles. Não se esqueça de `COMMIT` a alteração.
O RDS retém os logs baixados de acordo com a política de retenção de logs arquivados, a partir do momento em que os logs foram baixados. Para saber como definir a política de retenção, consulte [Retenção de logs redo arquivados](Appendix.Oracle.CommonDBATasks.RetainRedoLogs.md).
1. Aguarde até 5 minutos para que a alteração da política de retenção de logs arquivados seja implementada.
1. Baixe logs de refazimento arquivados do Amazon S3 usando `rdsadmin.rdsadmin_archive_log_download`.
Para obter mais informações, consulte [Baixar um único log de refazimento arquivado](#Appendix.Oracle.CommonDBATasks.download-redo-logs.single-log) e [Baixar uma série de logs de refazimento arquivados](#Appendix.Oracle.CommonDBATasks.download-redo-logs.series).
**nota**
O RDS verifica automaticamente o armazenamento disponível antes de baixar. Se os logs solicitados consumirem uma alta porcentagem de espaço, você receberá um alerta.
1. Confirme se o download dos logs do Amazon S3 foi concluído corretamente.
Você pode visualizar o status de uma tarefa de download em um arquivo bdump. Os arquivos bdump têm o nome de caminho `/rdsdbdata/log/trace/dbtask-task-id.log`. Na etapa de download anterior, execute uma instrução `SELECT` que retorna o ID da tarefa em um tipo de dados `VARCHAR2`. Para obter mais informações, veja exemplos semelhantes em [Monitorar o status de uma transferência de arquivo](oracle-s3-integration.using.md#oracle-s3-integration.using.task-status).
## Baixar um único log de refazimento arquivado
Para baixar um único log de refazimento arquivado para o diretório `/rdsdbdata/log/arch`, use `rdsadmin.rdsadmin_archive_log_download.download_log_with_seqnum`. Esse procedimento tem o seguinte parâmetro.
****
| Nome do parâmetro | Tipo de dados | Padrão | Obrigatório | Descrição |
| --- | --- | --- | --- | --- |
| `seqnum` | número | — | Sim | O número de sequência do log de refazimento arquivado. |
O exemplo a seguir baixa o log com o número de sequência 20.
```
SELECT rdsadmin.rdsadmin_archive_log_download.download_log_with_seqnum(seqnum => 20)
AS TASK_ID
FROM DUAL;
```
## Baixar uma série de logs de refazimento arquivados
Para baixar uma série de logs de refazimento arquivados para o diretório `/rdsdbdata/log/arch`, use `download_logs_in_seqnum_range`. Você só pode baixar até 300 logs por solicitação. O procedimento `download_logs_in_seqnum_range` tem os seguintes parâmetros.
****
| Nome do parâmetro | Tipo de dados | Padrão | Obrigatório | Descrição |
| --- | --- | --- | --- | --- |
| `start_seq` | número | — | Sim | O número de sequência inicial da série. |
| `end_seq` | número | — | Sim | O número de sequência final da série. |
O exemplo a seguir baixa os logs da sequência 50 a 100.
```
SELECT rdsadmin.rdsadmin_archive_log_download.download_logs_in_seqnum_range(start_seq => 50, end_seq => 100)
AS TASK_ID
FROM DUAL;
```
# Realização de tarefas comuns do RMAN para instâncias de banco de dados Oracle
Na seção a seguir, você pode encontrar como você pode realizar tarefas de DBA do Oracle Recovery Manager (RMAN) em suas instâncias de bancos de dados do Amazon RDS executando o Oracle. Para oferecer uma experiência de serviço gerenciada, o Amazon RDS não fornece acesso ao shell para as instâncias de banco de dados. Ele também restringe o acesso a determinados procedimentos e tabelas do sistema que exigem privilégios avançados.
Use o pacote `rdsadmin.rdsadmin_rman_util` do Amazon RDS para realizar backups do RMAN do banco de dados do Amazon RDS para Oracle em um disco. O pacote `rdsadmin.rdsadmin_rman_util` é compatível com backups de arquivos de banco de dados completos e incrementais, backups de espaços de tabelas e backups de redo logs arquivados.
Após a conclusão de um backup do RMAN, é possível copiar os arquivos de backup do host da instância de banco de dados do Amazon RDS para Oracle. Você pode fazer isso com a finalidade de restaurar para um host não-RDS ou para armazenamento de backups a longo prazo. Por exemplo, você pode copiar os arquivos de backup para um bucket do Amazon S3. Para obter mais informações, consulte como usar [Integração do Amazon S3](oracle-s3-integration.md).
Os arquivos de backup para backups do RMAN permanecerão no host da instância de banco de dados do Amazon RDS até que você os remova manualmente. Você pode usar o procedimento `UTL_FILE.FREMOVE` do Oracle para remover arquivos de um diretório. Para receber mais informações, consulte [FREMOVE procedure](https://docs.oracle.com/database/121/ARPLS/u_file.htm#ARPLS70924) na documentação da Oracle.
Você não pode usar o RMAN para restaurar o RDS para instâncias de banco de dados Oracle. No entanto, é possível usar o RMAN para restaurar um backup em uma instância on-premises ou do Amazon EC2. Para receber mais informações, consulte o artigo de blog [Restaurar uma instância do Amazon RDS para Oracle para uma instância autogerenciada](https://aws.amazon.com/blogs/database/restore-an-amazon-rds-for-oracle-instance-to-a-self-managed-instance/).
**nota**
Para fazer o backup e a restauração para outra instância de banco de dados do Amazon RDS para Oracle, você pode continuar usando os atributos de backup e restauração do Amazon RDS. Para obter mais informações, consulte [Backup, restauração e exportação de dados](CHAP_CommonTasks.BackupRestore.md).
**Topics**
+ [
# Pré-requisitos para backups do RMAN
](Appendix.Oracle.CommonDBATasks.RMAN-requirements.md)
+ [
# Parâmetros comuns para procedimentos do RMAN
](Appendix.Oracle.CommonDBATasks.CommonParameters.md)
+ [
# Validar arquivos de banco de dados no RDS para Oracle
](Appendix.Oracle.CommonDBATasks.ValidateDBFiles.md)
+ [
# Habilitar e desabilitar o controle de alterações de bloco
](Appendix.Oracle.CommonDBATasks.BlockChangeTracking.md)
+ [
# Verificação cruzada de logs redo
](Appendix.Oracle.CommonDBATasks.Crosscheck.md)
+ [
# Fazer backup de logs redo armazenados
](Appendix.Oracle.CommonDBATasks.BackupArchivedLogs.md)
+ [
# Realizar um backup de banco de dados completo
](Appendix.Oracle.CommonDBATasks.BackupDatabaseFull.md)
+ [
# Realizar um backup completo de um banco de dados de locatários
](Appendix.Oracle.CommonDBATasks.BackupTenantDatabaseFull.md)
+ [
# Realizar um backup de banco de dados incremental
](Appendix.Oracle.CommonDBATasks.BackupDatabaseIncremental.md)
+ [
# Realizar um backup incremental de um banco de dados de locatários
](Appendix.Oracle.CommonDBATasks.BackupTenantDatabaseIncremental.md)
+ [
# Backup de um tablespace
](Appendix.Oracle.CommonDBATasks.BackupTablespace.md)
+ [
# Backup de um arquivo de controle
](Appendix.Oracle.CommonDBATasks.backup-control-file.md)
+ [
# Realizar a recuperação de mídia de blocos
](Appendix.Oracle.CommonDBATasks.block-media-recovery.md)
# Pré-requisitos para backups do RMAN
Antes de fazer backup do banco de dados usando o pacote `rdsadmin.rdsadmin_rman_util`, atenda aos seguintes pré-requisitos:
+ Assegure-se de que o banco de dados RDS para Oracle esteja no modo `ARCHIVELOG`. Para habilitar esse modo, defina o período de retenção de backup como um valor diferente de zero.
+ Ao fazer o backup de redo logs arquivados ou realizar um backup completo ou incremental que inclua redo logs arquivados, a retenção de redo logs deve estar definida como um valor diferente de zero. Os redo logs arquivados são necessários para tornar os arquivos do banco de dados consistentes durante a recuperação. Para obter mais informações, consulte [Retenção de logs redo arquivados](Appendix.Oracle.CommonDBATasks.RetainRedoLogs.md).
+ Assegure-se de que sua instância de banco de dados tenha espaço livre suficiente para armazenar os backups. Ao fazer backup do banco de dados, especifique um objeto de diretório Oracle como um parâmetro na chamada de procedimento. O RMAN coloca os arquivos no diretório especificado. Você pode usar o diretórios padrão, como `DATA_PUMP_DIR`, ou criar um novo diretório. Para obter mais informações, consulte [Criar e eliminar diretórios no espaço de armazenamento de dados principal](Appendix.Oracle.CommonDBATasks.Misc.md#Appendix.Oracle.CommonDBATasks.NewDirectories).
Você pode monitorar o espaço livre atual em uma instância do RDS para Oracle usando a métrica `FreeStorageSpace` do CloudWatch. Recomendamos que o espaço livre exceda o tamanho atual do banco de dados, embora o RMAN faça backup somente de blocos formatados e seja compatível com a compactação.
# Parâmetros comuns para procedimentos do RMAN
Você pode usar procedimentos no pacote `rdsadmin.rdsadmin_rman_util` do Amazon RDS para realizar tarefas com o RMAN. Vários parâmetros são comuns aos procedimentos no pacote. O pacote tem os seguintes parâmetros comuns.
****
| Nome do parâmetro | Tipo de dados | Valores válidos | Padrão | Obrigatório | Descrição |
| --- | --- | --- | --- | --- | --- |
| `p_directory_name` | varchar2 | Um nome de diretório de banco de dados válido. | — | Sim | O nome do diretório para conter os arquivos de backup. |
| `p_label` | varchar2 | `a-z`, `A-Z`, `0-9`, `'_'`, `'-'`, `'.'` | — | Não | Uma string exclusiva incluída nos nomes dos arquivos de backup. O limite é de 30 caracteres. |
| `p_owner` | varchar2 | Um proprietário válido do diretório especificado em `p_directory_name`. | — | Sim | O proprietário do diretório para conter os arquivos de backup. |
| `p_tag` | varchar2 | `a-z`, `A-Z`, `0-9`, `'_'`, `'-'`, `'.'` | NULL | Não | Uma string que pode ser usada para distinguir entre backups para indicar a finalidade ou o uso de backups, como backups diários, semanais ou incrementais. O limite é de 30 caracteres. A etiqueta não diferencia maiúsculas de minúsculas. As etiquetas são sempre armazenadas em letras maiúsculas, independentemente de como são inseridas. As etiquetas não precisam ser exclusivas, portanto, vários backups podem ter a mesma etiqueta. Se você não especificar uma tag, o RMAN atribuirá uma tag padrão automaticamente usando o formato `TAGYYYYMMDDTHHMMSS`, em que *YYYY* é o ano, *MM* é o mês, *DD* é o dia, *HH* é a hora (no formato de 24 horas), *MM* são os minutos e *SS* os segundos. A data e a hora referem-se a quando o RMAN iniciou o backup. Por exemplo, um backup pode receber uma etiqueta `TAG20190927T214517` para um backup iniciado em 27/9/2019, às 21h45m17s. O parâmetro `p_tag` é compatível com as seguintes versões de mecanismo de banco de dados do Amazon RDS para Oracle: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.CommonParameters.html) |
| `p_compress` | booleano | `TRUE`, `FALSE` | `FALSE` | Não | Especifique `TRUE` para habilitar a compactação de backup BASIC. Especifique `FALSE` para desabilitar a compactação de backup BASIC. |
| `p_include_archive_logs` | booliano | `TRUE`, `FALSE` | `FALSE` | Não | Especifique `TRUE` para incluir logs redo arquivados no backup. Especifique `FALSE` para excluir logs redo arquivados do backup. Se você incluir logs redo arquivados no backup, defina a retenção para uma hora ou mais usando o procedimento `rdsadmin.rdsadmin_util.set_configuration`. Além disso, chame o procedimento `rdsadmin.rdsadmin_rman_util.crosscheck_archivelog` imediatamente antes de executar o backup. Caso contrário, o backup poderá falhar devido à ausência de arquivos de log redo que foram excluídos por procedimentos de gerenciamento do Amazon RDS. |
| `p_include_controlfile` | booliano | `TRUE`, `FALSE` | `FALSE` | Não | Especifique `TRUE` para incluir o arquivo de controle no backup. Especifique `FALSE` para excluir o arquivo de controle do backup. |
| `p_optimize` | booliano | `TRUE`, `FALSE` | `TRUE` | Não | Especifique `TRUE` para habilitar a otimização de backup, se logs redo arquivados estiverem incluídos, para reduzir o tamanho do backup. Especifique `FALSE` para desabilitar a otimização de backup. |
| `p_parallel` | número | Um inteiro válido entre `1` e `254` para Oracle Database Enterprise Edition (EE) `1` para outras edições do Oracle Database | `1` | Não | Número de canais. |
| `p_rman_to_dbms_output` | booliano | `TRUE`, `FALSE` | `FALSE` | Não | Quando `TRUE`, a saída RMAN é enviada para o pacote `DBMS_OUTPUT` além de um arquivo no diretório `BDUMP`. No SQL\$1Plus, use `SET SERVEROUTPUT ON` para ver a saída. Quando `FALSE`, a saída RMAN é enviada somente para um arquivo no diretório `BDUMP`. |
| `p_section_size_mb` | número | Um inteiro válido | `NULL` | Não | O tamanho da seção em megabytes (MB). Valida em paralelo dividindo cada arquivo no tamanho da seção especificado. Quando `NULL`, o parâmetro é ignorado. |
| `p_validation_type` | varchar2 | `'PHYSICAL'`, `'PHYSICAL+LOGICAL'` | `'PHYSICAL'` | Não | O nível de detecção da corrupção. Especifique `'PHYSICAL'` para verificar se há danos físicos. Um exemplo de dano físico é um bloco com uma diferença no cabeçalho e no rodapé. Especifique `'PHYSICAL+LOGICAL'` para verificar se há inconsistências lógicas além de danos físicos. Um exemplo de dano lógico é um bloco corrompido. |
# Validar arquivos de banco de dados no RDS para Oracle
É possível usar o pacote do Amazon RDS `rdsadmin.rdsadmin_rman_util` para validar os arquivos de banco de dados do Amazon RDS para Oracle, como arquivos de dados, espaços de tabela, arquivos de controle ou arquivos de parâmetro do servidor (SPFILEs).
Para obter mais informações sobre a validação do RMAN, consulte [Validating database files and backups](https://docs.oracle.com/database/121/BRADV/rcmvalid.htm#BRADV90063) (Validar arquivos e backups de bancos de dados) e [ VALIDATE](https://docs.oracle.com/database/121/RCMRF/rcmsynta2025.htm#RCMRF162) (Validar) na documentação do Oracle.
**Topics**
+ [
## Validar um banco de dados
](#Appendix.Oracle.CommonDBATasks.ValidateDB)
+ [
## Validando um banco de dados de inquilinos
](#Appendix.Oracle.CommonDBATasks.ValidateTenantDB)
+ [
## Validar um espaço de tabela
](#Appendix.Oracle.CommonDBATasks.ValidateTablespace)
+ [
## Validar um arquivo de controle
](#Appendix.Oracle.CommonDBATasks.ValidateControlFile)
+ [
## Validar um SPFILE
](#Appendix.Oracle.CommonDBATasks.ValidateSpfile)
+ [
## Validar um arquivo de dados Oracle
](#Appendix.Oracle.CommonDBATasks.ValidateDataFile)
## Validar um banco de dados
Para validar todos os arquivos relevantes usados por um banco de dados Oracle no RDS para Oracle, use o procedimento `rdsadmin.rdsadmin_rman_util.validate_database` do Amazon RDS.
Este procedimento usa os seguintes parâmetros comuns para tarefas RMAN:
+ `p_validation_type`
+ `p_parallel`
+ `p_section_size_mb`
+ `p_rman_to_dbms_output`
Para obter mais informações, consulte [Parâmetros comuns para procedimentos do RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
O seguinte exemplo valida o banco de dados usando os valores padrão dos parâmetros.
```
EXEC rdsadmin.rdsadmin_rman_util.validate_database;
```
O seguinte exemplo valida o banco de dados usando os valores especificado dos parâmetros.
```
BEGIN
rdsadmin.rdsadmin_rman_util.validate_database(
p_validation_type => 'PHYSICAL+LOGICAL',
p_parallel => 4,
p_section_size_mb => 10,
p_rman_to_dbms_output => FALSE);
END;
/
```
Quando o parâmetro `p_rman_to_dbms_output` é definido como `FALSE`, a saída RMAN é gravada em um arquivo no diretório `BDUMP`.
Para visualizar os arquivos no diretório `BDUMP`, execute o seguinte comando `SELECT`.
```
SELECT * FROM table(rdsadmin.rds_file_util.listdir('BDUMP')) order by mtime;
```
Para visualizar o conteúdo de um arquivo no diretório `BDUMP`, execute o seguinte comando `SELECT`.
```
SELECT text FROM table(rdsadmin.rds_file_util.read_text_file('BDUMP','rds-rman-validate-nnn.txt'));
```
Substitua o nome do arquivo pelo nome do arquivo que você deseja visualizar.
## Validando um banco de dados de inquilinos
Para validar os arquivos de dados do banco de dados do inquilino em um banco de dados de contêiner (CDB), use o procedimento do Amazon RDS. `rdsadmin.rdsadmin_rman_util.validate_tenant`
Este procedimento se aplica somente ao banco de dados do locatário atual e usa os seguintes parâmetros comuns para tarefas RMAN:
+ `p_validation_type`
+ `p_parallel`
+ `p_section_size_mb`
+ `p_rman_to_dbms_output`
Para obter mais informações, consulte [Parâmetros comuns para procedimentos do RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md). Esse procedimento não tem suporte para as seguintes versões de mecanismo de banco de dados do for Oracle:
+ Oracle Database 21c (21.0.0)
+ Oracle Database 19c (19.0.0)
O seguinte exemplo valida a instância de banco de dados usando os valores padrão dos parâmetros.
```
EXEC rdsadmin.rdsadmin_rman_util.validate_tenant;
```
O seguinte exemplo valida a instância de banco de dados usando os valores especificado dos parâmetros.
```
BEGIN
rdsadmin.rdsadmin_rman_util.validate_tenant(
p_validation_type => 'PHYSICAL+LOGICAL',
p_parallel => 4,
p_section_size_mb => 10,
p_rman_to_dbms_output => FALSE);
END;
/
```
Quando o parâmetro `p_rman_to_dbms_output` é definido como `FALSE`, a saída RMAN é gravada em um arquivo no diretório `BDUMP`.
Para visualizar os arquivos no diretório `BDUMP`, execute o seguinte comando `SELECT`.
```
SELECT * FROM table(rdsadmin.rds_file_util.listdir('BDUMP')) order by mtime;
```
Para visualizar o conteúdo de um arquivo no diretório `BDUMP`, execute o seguinte comando `SELECT`.
```
SELECT text FROM table(rdsadmin.rds_file_util.read_text_file('BDUMP','rds-rman-validate-nnn.txt'));
```
Substitua o nome do arquivo pelo nome do arquivo que você deseja visualizar.
## Validar um espaço de tabela
Para validar os arquivos associados a um espaço de tabela, use o procedimento do Amazon RDS `rdsadmin.rdsadmin_rman_util.validate_tablespace`.
Este procedimento usa os seguintes parâmetros comuns para tarefas RMAN:
+ `p_validation_type`
+ `p_parallel`
+ `p_section_size_mb`
+ `p_rman_to_dbms_output`
Para obter mais informações, consulte [Parâmetros comuns para procedimentos do RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
Esse procedimento também usa o seguinte parâmetro adicional.
****
| Nome do parâmetro | Tipo de dados | Valores válidos | Padrão | Obrigatório | Descrição |
| --- | --- | --- | --- | --- | --- |
| `p_tablespace_name` | varchar2 | Um nome de espaço de tabela válido | — | Sim | O nome do espaço de tabela. |
## Validar um arquivo de controle
Para validar somente o arquivo de controle usado por uma instância de banco de dados Oracle do Amazon RDS, use o procedimento do Amazon RDS `rdsadmin.rdsadmin_rman_util.validate_current_controlfile`.
Esse procedimento usa o seguinte parâmetro comum para tarefas RMAN:
+ `p_validation_type`
+ `p_rman_to_dbms_output`
Para obter mais informações, consulte [Parâmetros comuns para procedimentos do RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
## Validar um SPFILE
Para validar somente o arquivo de parâmetro do servidor (SPFILE) usado por uma instância de banco de dados Oracle do Amazon RDS, use o procedimento do Amazon RDS `rdsadmin.rdsadmin_rman_util.validate_spfile`.
Esse procedimento usa o seguinte parâmetro comum para tarefas RMAN:
+ `p_validation_type`
+ `p_rman_to_dbms_output`
Para obter mais informações, consulte [Parâmetros comuns para procedimentos do RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
## Validar um arquivo de dados Oracle
Para validar um arquivo de dados, use o procedimento do Amazon RDS `rdsadmin.rdsadmin_rman_util.validate_datafile`.
Este procedimento usa os seguintes parâmetros comuns para tarefas RMAN:
+ `p_validation_type`
+ `p_parallel`
+ `p_section_size_mb`
+ `p_rman_to_dbms_output`
Para obter mais informações, consulte [Parâmetros comuns para procedimentos do RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
Esse procedimento também usa os seguintes parâmetros adicionais.
****
| Nome do parâmetro | Tipo de dados | Valores válidos | Padrão | Obrigatório | Descrição |
| --- | --- | --- | --- | --- | --- |
| `p_datafile` | varchar2 | Um número de ID datafile válido ou um nome datafile válido incluindo o caminho completo | — | Sim | O número do ID do arquivo de dados (de `v$datafile.file#`) ou o nome completo do arquivo de dados, incluindo o caminho (de `v$datafile.name`). |
| `p_from_block` | número | Um inteiro válido | `NULL` | Não | O número do bloco em que a validação começa dentro do arquivo de dados. Quando é `NULL`, `1` é usado. |
| `p_to_block` | número | Um inteiro válido | `NULL` | Não | O número do bloco em que a validação termina dentro do arquivo de dados. Quando é `NULL`, o bloco máximo no arquivo de dados é usado. |
# Habilitar e desabilitar o controle de alterações de bloco
Os registros de monitoramento de alterações de blocos alterou os blocos em um arquivo de monitoramento. Essa técnica pode melhorar a performance de backups incrementais RMAN. Para obter mais informações, consulte [Using Block Change Tracking to Improve Incremental Backup Performance](https://docs.oracle.com/en/database/oracle/oracle-database/19/bradv/backing-up-database.html#GUID-4E1F605A-76A7-48D0-9D9B-7343B4327E2A) (Uso do monitoramento de alterações em bloco para aumentar a performance do backup incremental) na documentação do Oracle Database.
Os recursos do RMAN não são comportados em uma réplica de leitura. No entanto, como parte de sua estratégia de alta disponibilidade, você pode optar por habilitar o rastreamento de blocos em uma réplica somente leitura usando o procedimento `rdsadmin.rdsadmin_rman_util.enable_block_change_tracking`. Se você promover essa réplica somente leitura a uma instância de banco de dados de origem, o rastreamento de alterações de blocos será habilitado para a nova instância de origem. Assim, a instância pode se beneficiar de backups incrementais rápidos.
Os procedimentos de monitoramento de alterações de blocos são compatíveis na Enterprise Edition somente com as seguintes versões do mecanismo de banco de dados:
+ Oracle Database 21c (21.0.0)
+ Oracle Database 19c (19.0.0)
**nota**
Em um CDB de locatário único, as operações a seguir funcionam, mas nenhum mecanismo visível para o cliente pode detectar o status atual das operações. Consulte também [Limitações do RDS for CDBs Oracle](Oracle.Concepts.CDBs.md#Oracle.Concepts.single-tenant-limitations).
Para habilitar o controle de alterações de bloco para uma instância de banco de dados usando o procedimento do Amazon RDS `rdsadmin.rdsadmin_rman_util.enable_block_change_tracking`. Para desativar o monitoramento de alterações de bloco, use `disable_block_change_tracking`. Esses procedimentos não usam parâmetros.
Para determinar se o controle de alterações de bloco está habilitado para a sua instância de banco de dados, execute a consulta a seguir.
```
SELECT STATUS, FILENAME FROM V$BLOCK_CHANGE_TRACKING;
```
O exemplo a seguir habilita o controle de alterações de bloco para uma instância de banco de dados.
```
EXEC rdsadmin.rdsadmin_rman_util.enable_block_change_tracking;
```
O exemplo a seguir desabilita o controle de alterações de bloco para uma instância de banco de dados.
```
EXEC rdsadmin.rdsadmin_rman_util.disable_block_change_tracking;
```
# Verificação cruzada de logs redo
Você pode fazer a verificação cruzada de logs redo arquivados usando o procedimento do Amazon RDS `rdsadmin.rdsadmin_rman_util.crosscheck_archivelog`.
É possível usar esse procedimento para fazer uma verificação cruzada dos logs redo arquivados registrados no arquivo de controle e, opcionalmente, excluir os registros de logs expirados. Quando o RMAN faz um backup, ele cria um registro no arquivo de controle. Com o tempo, esses registros aumentam o tamanho do arquivo de controle. Recomendamos que você remova registros expirados periodicamente.
**nota**
Os backups padrão do Amazon RDS não usam o RMAN e, portanto, não criam registros no arquivo de controle.
Esse procedimento usa o parâmetro comum `p_rman_to_dbms_output` para tarefas do RMAN.
Para obter mais informações, consulte [Parâmetros comuns para procedimentos do RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
Esse procedimento também usa o seguinte parâmetro adicional.
****
| Nome do parâmetro | Tipo de dados | Valores válidos | Padrão | Obrigatório | Descrição |
| --- | --- | --- | --- | --- | --- |
| `p_delete_expired` | booliano | `TRUE`, `FALSE` | `TRUE` | Não | Quando `TRUE`, exclui os registros de logs redo arquivados expirados do arquivo de controle. Quando `FALSE`, retém os registros de logs redo arquivados expirados no arquivo de controle. |
Esse procedimento não tem suporte para as seguintes versões de mecanismo de banco de dados do Amazon RDS para Oracle:
+ Oracle Database 21c (21.0.0)
+ Oracle Database 19c (19.0.0)
O exemplo a seguir marca os registros de log redo arquivados no arquivo de controle como expirados, mas não exclui os registros.
```
BEGIN
rdsadmin.rdsadmin_rman_util.crosscheck_archivelog(
p_delete_expired => FALSE,
p_rman_to_dbms_output => FALSE);
END;
/
```
O exemplo a seguir exclui os registros d logs redo arquivados expirados do arquivo de controle.
```
BEGIN
rdsadmin.rdsadmin_rman_util.crosscheck_archivelog(
p_delete_expired => TRUE,
p_rman_to_dbms_output => FALSE);
END;
/
```
# Fazer backup de logs redo armazenados
Você pode usar o pacote `rdsadmin.rdsadmin_rman_util` do Amazon RDS para fazer backup de logs redo arquivados para uma instância de banco de dados do Amazon RDS Oracle.
Os procedimentos para fazer backup de logs redo arquivados têm suporte para as seguintes versões de mecanismo de banco de dados do Amazon RDS para Oracle:
+ Oracle Database 21c (21.0.0)
+ Oracle Database 19c (19.0.0)
**Topics**
+ [
## Fazer backup de todos os logs redo arquivados
](#Appendix.Oracle.CommonDBATasks.BackupArchivedLogs.All)
+ [
## Fazer backup de um log redo arquivado de um intervalo de datas
](#Appendix.Oracle.CommonDBATasks.BackupArchivedLogs.Date)
+ [
## Fazer backup de um log redo arquivado de um intervalo de SCN
](#Appendix.Oracle.CommonDBATasks.BackupArchivedLogs.SCN)
+ [
## Fazer backup de um log redo arquivado de um intervalo de números de sequência
](#Appendix.Oracle.CommonDBATasks.BackupArchivedLogs.Sequence)
## Fazer backup de todos os logs redo arquivados
Para fazer backup de todos os logs redo arquivados para uma instância de banco de dados Oracle do Amazon RDS, use o procedimento do Amazon RDS `rdsadmin.rdsadmin_rman_util.backup_archivelog_all`.
Este procedimento usa os seguintes parâmetros comuns para tarefas RMAN:
+ `p_owner`
+ `p_directory_name`
+ `p_label`
+ `p_parallel`
+ `p_compress`
+ `p_rman_to_dbms_output`
+ `p_tag`
Para obter mais informações, consulte [Parâmetros comuns para procedimentos do RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
O exemplo a seguir faz backup de todos os logs redo arquivados para a instância de banco de dados.
```
BEGIN
rdsadmin.rdsadmin_rman_util.backup_archivelog_all(
p_owner => 'SYS',
p_directory_name => 'MYDIRECTORY',
p_parallel => 4,
p_tag => 'MY_LOG_BACKUP',
p_rman_to_dbms_output => FALSE);
END;
/
```
## Fazer backup de um log redo arquivado de um intervalo de datas
Para fazer backup de logs redo arquivados específicos para uma instância de banco de dados Oracle do Amazon RDS especificando um intervalo de datas, use o procedimento do Amazon RDS `rdsadmin.rdsadmin_rman_util.backup_archivelog_date`. O intervalo de datas especifica quais logs redo arquivados devem ser incluídos no backup.
Este procedimento usa os seguintes parâmetros comuns para tarefas RMAN:
+ `p_owner`
+ `p_directory_name`
+ `p_label`
+ `p_parallel`
+ `p_compress`
+ `p_rman_to_dbms_output`
+ `p_tag`
Para obter mais informações, consulte [Parâmetros comuns para procedimentos do RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
Esse procedimento também usa os seguintes parâmetros adicionais.
****
| Nome do parâmetro | Tipo de dados | Valores válidos | Padrão | Obrigatório | Descrição |
| --- | --- | --- | --- | --- | --- |
| `p_from_date` | data | Uma data entre `start_date` e `next_date` de um log redo arquivado que existe no disco. O valor deve ser menor que ou igual ao valor especificado para `p_to_date`. | — | Sim | A data de início dos backups de log arquivados. |
| `p_to_date` | data | Uma data entre `start_date` e `next_date` de um log redo arquivado que existe no disco. O valor deve ser maior que ou igual ao valor especificado para `p_from_date`. | — | Sim | A data de término dos backups de logs arquivados. |
O exemplo a seguir faz backup de logs redo arquivados no intervalo de datas para a instância de banco de dados.
```
BEGIN
rdsadmin.rdsadmin_rman_util.backup_archivelog_date(
p_owner => 'SYS',
p_directory_name => 'MYDIRECTORY',
p_from_date => '03/01/2019 00:00:00',
p_to_date => '03/02/2019 00:00:00',
p_parallel => 4,
p_tag => 'MY_LOG_BACKUP',
p_rman_to_dbms_output => FALSE);
END;
/
```
## Fazer backup de um log redo arquivado de um intervalo de SCN
Para fazer backup de logs redo arquivados específicos para uma instância de banco de dados do Oracle do Amazon RDS, especificando um intervalo de SCNs (números de alteração de sistema), use o procedimento do Amazon RDS `rdsadmin.rdsadmin_rman_util.backup_archivelog_scn`. O intervalo de SCNs especifica quais logs redo arquivados devem ser incluídos no backup.
Este procedimento usa os seguintes parâmetros comuns para tarefas RMAN:
+ `p_owner`
+ `p_directory_name`
+ `p_label`
+ `p_parallel`
+ `p_compress`
+ `p_rman_to_dbms_output`
+ `p_tag`
Para obter mais informações, consulte [Parâmetros comuns para procedimentos do RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
Esse procedimento também usa os seguintes parâmetros adicionais.
****
| Nome do parâmetro | Tipo de dados | Valores válidos | Padrão | Obrigatório | Descrição |
| --- | --- | --- | --- | --- | --- |
| `p_from_scn` | número | Um SCN de um log redo arquivado que existe no disco. O valor deve ser menor que ou igual ao valor especificado para `p_to_scn`. | — | Sim | O SCN inicial para os backups de logs arquivados. |
| `p_to_scn` | número | Um SCN de um log redo arquivado que existe no disco. O valor deve ser maior que ou igual ao valor especificado para `p_from_scn`. | — | Sim | O SCN final para os backups de logs arquivados. |
O exemplo a seguir faz backup de logs redo arquivados no intervalo de SCNs para a instância de banco de dados.
```
BEGIN
rdsadmin.rdsadmin_rman_util.backup_archivelog_scn(
p_owner => 'SYS',
p_directory_name => 'MYDIRECTORY',
p_from_scn => 1533835,
p_to_scn => 1892447,
p_parallel => 4,
p_tag => 'MY_LOG_BACKUP',
p_rman_to_dbms_output => FALSE);
END;
/
```
## Fazer backup de um log redo arquivado de um intervalo de números de sequência
Para fazer backup de logs redo arquivados específicos para uma instância de banco de dados Oracle do Amazon RDS, especificando um intervalo de números de sequência, use o procedimento do Amazon RDS `rdsadmin.rdsadmin_rman_util.backup_archivelog_sequence`. O intervalo de números de sequência especifica quais logs redo arquivados devem ser incluídos no backup.
Este procedimento usa os seguintes parâmetros comuns para tarefas RMAN:
+ `p_owner`
+ `p_directory_name`
+ `p_label`
+ `p_parallel`
+ `p_compress`
+ `p_rman_to_dbms_output`
+ `p_tag`
Para obter mais informações, consulte [Parâmetros comuns para procedimentos do RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
Esse procedimento também usa os seguintes parâmetros adicionais.
****
| Nome do parâmetro | Tipo de dados | Valores válidos | Padrão | Obrigatório | Descrição |
| --- | --- | --- | --- | --- | --- |
| `p_from_sequence` | número | Um número de sequência de um log redo arquivado que existe no disco. O valor deve ser menor que ou igual ao valor especificado para `p_to_sequence`. | — | Sim | O número de sequência inicial dos backups de log arquivados. |
| `p_to_sequence` | número | Um número de sequência de um log redo arquivado que existe no disco. O valor deve ser maior que ou igual ao valor especificado para `p_from_sequence`. | — | Sim | O número de sequência final dos backups de log arquivados. |
O exemplo a seguir faz backup de logs redo arquivados no intervalo de números de sequência para a instância de banco de dados.
```
BEGIN
rdsadmin.rdsadmin_rman_util.backup_archivelog_sequence(
p_owner => 'SYS',
p_directory_name => 'MYDIRECTORY',
p_from_sequence => 11160,
p_to_sequence => 11160,
p_parallel => 4,
p_tag => 'MY_LOG_BACKUP',
p_rman_to_dbms_output => FALSE);
END;
/
```
# Realizar um backup de banco de dados completo
Você pode realizar um backup de todos os blocos de arquivos de dados incluídos no backup usando o procedimento do Amazon RDS `rdsadmin.rdsadmin_rman_util.backup_database_full`.
Este procedimento usa os seguintes parâmetros comuns para tarefas RMAN:
+ `p_owner`
+ `p_directory_name`
+ `p_label`
+ `p_parallel`
+ `p_section_size_mb`
+ `p_include_archive_logs`
+ `p_optimize`
+ `p_compress`
+ `p_rman_to_dbms_output`
+ `p_tag`
Para obter mais informações, consulte [Parâmetros comuns para procedimentos do RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
Esse procedimento não tem suporte para as seguintes versões de mecanismo de banco de dados do Amazon RDS para Oracle:
+ Oracle Database 21c (21.0.0)
+ Oracle Database 19c (19.0.0)
O exemplo a seguir realiza um backup completo da instância de banco de dados usando os valores especificados para os parâmetros.
```
BEGIN
rdsadmin.rdsadmin_rman_util.backup_database_full(
p_owner => 'SYS',
p_directory_name => 'MYDIRECTORY',
p_parallel => 4,
p_section_size_mb => 10,
p_tag => 'FULL_DB_BACKUP',
p_rman_to_dbms_output => FALSE);
END;
/
```
# Realizar um backup completo de um banco de dados de locatários
Você pode realizar um backup de todos os blocos de dados incluídos em um banco de dados de locatário em um banco de dados de contêiner (CDB). Use o procedimento do Amazon RDS `rdsadmin.rdsadmin_rman_util.backup_tenant_full`. Este procedimento se aplica somente ao backup do banco de dados atual e usa os seguintes parâmetros comuns para tarefas RMAN:
+ `p_owner`
+ `p_directory_name`
+ `p_label`
+ `p_parallel`
+ `p_section_size_mb`
+ `p_include_archive_logs`
+ `p_optimize`
+ `p_compress`
+ `p_rman_to_dbms_output`
+ `p_tag`
Para obter mais informações, consulte [Parâmetros comuns para procedimentos do RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
O parâmetro `rdsadmin_rman_util.backup_tenant_full` é compatível com as seguintes versões de mecanismo de banco de dados Amazon RDS for Oracle:
+ Oracle Database 21c (21.0.0)
+ Oracle Database 19c (19.0.0)
O exemplo a seguir realiza um backup completo da instância de banco de dados usando os valores especificados para os parâmetros.
```
BEGIN
rdsadmin.rdsadmin_rman_util.backup_tenant_full(
p_owner => 'SYS',
p_directory_name => 'MYDIRECTORY',
p_parallel => 4,
p_section_size_mb => 10,
p_tag => 'FULL_TENANT_DB_BACKUP',
p_rman_to_dbms_output => FALSE);
END;
/
```
# Realizar um backup de banco de dados incremental
Você pode realizar um backup incremental da sua instância de banco de dados usando o procedimento `rdsadmin.rdsadmin_rman_util.backup_database_incremental` do Amazon RDS.
Para obter mais informações sobre backups incrementais, consulte [Incremental backups](https://docs.oracle.com/database/121/RCMRF/rcmsynta006.htm#GUID-73642FF2-43C5-48B2-9969-99001C52EB50__BGBHABHH) (Backups incrementais) na documentação do Oracle.
Este procedimento usa os seguintes parâmetros comuns para tarefas RMAN:
+ `p_owner`
+ `p_directory_name`
+ `p_label`
+ `p_parallel`
+ `p_section_size_mb`
+ `p_include_archive_logs`
+ `p_include_controlfile`
+ `p_optimize`
+ `p_compress`
+ `p_rman_to_dbms_output`
+ `p_tag`
Para obter mais informações, consulte [Parâmetros comuns para procedimentos do RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
Esse procedimento não tem suporte para as seguintes versões de mecanismo de banco de dados do Amazon RDS para Oracle:
+ Oracle Database 21c (21.0.0)
+ Oracle Database 19c (19.0.0)
Esse procedimento também usa o seguinte parâmetro adicional.
****
| Nome do parâmetro | Tipo de dados | Valores válidos | Padrão | Obrigatório | Descrição |
| --- | --- | --- | --- | --- | --- |
| `p_level` | número | `0`, `1` | `0` | Não | Especifique `0` para habilitar um backup incremental completo. Especifique `1` para habilitar um backup incremental não cumulativo. |
O exemplo a seguir realiza um backup incremental da instância de banco de dados usando os valores especificados para os parâmetros.
```
BEGIN
rdsadmin.rdsadmin_rman_util.backup_database_incremental(
p_owner => 'SYS',
p_directory_name => 'MYDIRECTORY',
p_level => 1,
p_parallel => 4,
p_section_size_mb => 10,
p_tag => 'MY_INCREMENTAL_BACKUP',
p_rman_to_dbms_output => FALSE);
END;
/
```
# Realizar um backup incremental de um banco de dados de locatários
Você pode realizar um backup incremental do banco de dados do inquilino atual no seu CDB. Use o procedimento do Amazon RDS `rdsadmin.rdsadmin_rman_util.backup_tenant_incremental`.
Para obter mais informações sobre backups incrementais, consulte [Incremental backups](https://docs.oracle.com/database/121/RCMRF/rcmsynta006.htm#GUID-73642FF2-43C5-48B2-9969-99001C52EB50__BGBHABHH) (Backups incrementais) na documentação do Oracle.
Este procedimento se aplica somente ao banco de dados do locatário atual e usa os seguintes parâmetros comuns para tarefas RMAN:
+ `p_owner`
+ `p_directory_name`
+ `p_label`
+ `p_parallel`
+ `p_section_size_mb`
+ `p_include_archive_logs`
+ `p_include_controlfile`
+ `p_optimize`
+ `p_compress`
+ `p_rman_to_dbms_output`
+ `p_tag`
Para ter mais informações, consulte [Parâmetros comuns para procedimentos do RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
Esse procedimento não tem suporte para as seguintes versões de mecanismo de banco de dados do Amazon RDS para Oracle:
+ Oracle Database 21c (21.0.0)
+ Oracle Database 19c (19.0.0)
Esse procedimento também usa o seguinte parâmetro adicional.
****
| Nome do parâmetro | Tipo de dados | Valores válidos | Padrão | Obrigatório | Descrição |
| --- | --- | --- | --- | --- | --- |
| `p_level` | número | `0`, `1` | `0` | Não | Especifique `0` para habilitar um backup incremental completo. Especifique `1` para habilitar um backup incremental não cumulativo. |
O exemplo a seguir realiza um backup incremental da instância de banco de dados usando os valores especificados para os parâmetros.
```
BEGIN
rdsadmin.rdsadmin_rman_util.backup_tenant_incremental(
p_owner => 'SYS',
p_directory_name => 'MYDIRECTORY',
p_level => 1,
p_parallel => 4,
p_section_size_mb => 10,
p_tag => 'MY_INCREMENTAL_BACKUP',
p_rman_to_dbms_output => FALSE);
END;
/
```
# Backup de um tablespace
Você pode realizar um backup de um espaço de tabela usando o procedimento do Amazon RDS `rdsadmin.rdsadmin_rman_util.backup_tablespace`.
Este procedimento usa os seguintes parâmetros comuns para tarefas RMAN:
+ `p_owner`
+ `p_directory_name`
+ `p_label`
+ `p_parallel`
+ `p_section_size_mb`
+ `p_include_archive_logs`
+ `p_include_controlfile`
+ `p_optimize`
+ `p_compress`
+ `p_rman_to_dbms_output`
+ `p_tag`
Para obter mais informações, consulte [Parâmetros comuns para procedimentos do RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
Esse procedimento também usa o seguinte parâmetro adicional.
****
| Nome do parâmetro | Tipo de dados | Valores válidos | Padrão | Obrigatório | Descrição |
| --- | --- | --- | --- | --- | --- |
| `p_tablespace_name` | varchar2 | Um nome de espaço de tabela válido. | — | Sim | O nome do espaço de tabela para backup. |
Esse procedimento não tem suporte para as seguintes versões de mecanismo de banco de dados do Amazon RDS para Oracle:
+ Oracle Database 21c (21.0.0)
+ Oracle Database 19c (19.0.0)
O exemplo a seguir realiza um backup de espaço de tabela usando os valores especificados para os parâmetros.
```
BEGIN
rdsadmin.rdsadmin_rman_util.backup_tablespace(
p_owner => 'SYS',
p_directory_name => 'MYDIRECTORY',
p_tablespace_name => 'MYTABLESPACE',
p_parallel => 4,
p_section_size_mb => 10,
p_tag => 'MYTABLESPACE_BACKUP',
p_rman_to_dbms_output => FALSE);
END;
/
```
# Backup de um arquivo de controle
Você pode fazer backup de um arquivo de controle usando o procedimento do Amazon RDS `rdsadmin.rdsadmin_rman_util.backup_current_controlfile`.
Este procedimento usa os seguintes parâmetros comuns para tarefas RMAN:
+ `p_owner`
+ `p_directory_name`
+ `p_label`
+ `p_compress`
+ `p_rman_to_dbms_output`
+ `p_tag`
Para obter mais informações, consulte [Parâmetros comuns para procedimentos do RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
Esse procedimento não tem suporte para as seguintes versões de mecanismo de banco de dados do Amazon RDS para Oracle:
+ Oracle Database 21c (21.0.0)
+ Oracle Database 19c (19.0.0)
O exemplo a seguir realiza um backup de um arquivo de controle usando os valores especificados para os parâmetros.
```
BEGIN
rdsadmin.rdsadmin_rman_util.backup_current_controlfile(
p_owner => 'SYS',
p_directory_name => 'MYDIRECTORY',
p_tag => 'CONTROL_FILE_BACKUP',
p_rman_to_dbms_output => FALSE);
END;
/
```
# Realizar a recuperação de mídia de blocos
É possível recuperar blocos de dados individuais, conhecidos como recuperação de mídia de blocos, usando os procedimentos `rdsadmin.rdsadmin_rman_util.recover_datafile_block` do Amazon RDS. É possível usar esse procedimento sobrecarregado para recuperar um ou vários blocos de dados.
Esse procedimento usa o seguinte parâmetro comum para tarefas RMAN:
+ `p_rman_to_dbms_output`
Para obter mais informações, consulte [Parâmetros comuns para procedimentos do RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
Esse procedimento usa os parâmetros adicionais a seguir.
****
| Nome do parâmetro | Tipo de dados | Valores válidos | Padrão | Obrigatório | Descrição |
| --- | --- | --- | --- | --- | --- |
| `p_datafile` | `NUMBER` | Um número de ID válido do arquivo de dados. | — | Sim | O arquivo de dados contendo os blocos corrompidos. Especifique o arquivo de dados de uma das seguintes formas: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.block-media-recovery.html) |
| `p_block` | `NUMBER` | Um número inteiro válido. | — | Sim | O número de um bloco individual a ser recuperado. Os seguintes parâmetros são mutuamente exclusivos: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.block-media-recovery.html) |
| `p_from_block` | `NUMBER` | Um número inteiro válido. | — | Sim | O primeiro número de bloco em um intervalo de blocos a serem recuperados. Os seguintes parâmetros são mutuamente exclusivos: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.block-media-recovery.html) |
| `p_to_block` | `NUMBER` | Um número inteiro válido. | — | Sim | O último número de bloco em um intervalo de blocos a serem recuperados. Os seguintes parâmetros são mutuamente exclusivos: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.block-media-recovery.html) |
Esse procedimento não tem suporte para as seguintes versões de mecanismo de banco de dados do Amazon RDS para Oracle:
+ Oracle Database 21c (21.0.0)
+ Oracle Database 19c (19.0.0)
O exemplo a seguir recupera o bloco 100 no arquivo de dados 5.
```
BEGIN
rdsadmin.rdsadmin_rman_util.recover_datafile_block(
p_datafile => 5,
p_block => 100,
p_rman_to_dbms_output => TRUE);
END;
/
```
O exemplo a seguir recupera os blocos 100 a 150 no arquivo de dados 5.
```
BEGIN
rdsadmin.rdsadmin_rman_util.recover_datafile_block(
p_datafile => 5,
p_from_block => 100,
p_to_block => 150,
p_rman_to_dbms_output => TRUE);
END;
/
```
# Realização de tarefas comuns de agendamento para instâncias de banco de dados Oracle
Alguns trabalhos pertencentes ao `SYS` podem interferir nas operações normais de banco de dados. Nesses casos, o Oracle Support recomenda que você modifique a programação. Se você precisar habilitar ou desabilitar trabalhos do `SYS`, teste a operação em jobs programados em um ambiente de teste antes de implementá-la em um ambiente de produção. Para realizar tarefas para trabalhos do Oracle Scheduler pertencentes ao `SYS`, use o pacote `rdsadmin.rdsadmin_dbms_scheduler` do Amazon RDS.
Os procedimentos `rdsadmin.rdsadmin_dbms_scheduler` são compatíveis com as versões de mecanismo de banco de dados do Amazon RDS para Oracle na tabela a seguir. Ao usar esse pacote, você pode especificar os trabalhos do `SYS` listados na tabela.
| Versão do banco de dados | Trabalhos habilitados por padrão | Trabalhos desabilitados por padrão |
| --- | --- | --- |
| Oracle Database 19c | BSLN_MAINTAIN_STATS_JOB
CLEANUP_NON_EXIST_OBJ
CLEANUP_ONLINE_IND_BUILD
CLEANUP_ONLINE_PMO
CLEANUP_TAB_IOT_PMO
CLEANUP_TRANSIENT_PKG
CLEANUP_TRANSIENT_TYPE
DRA_REEVALUATE_OPEN_FAILURES
FILE_SIZE_UPD
ORA$AUTOTASK_CLEAN
PMO_DEFERRED_GIDX_MAINT_JOB
PURGE_LOG
RSE$CLEAN_RECOVERABLE_SCRIPT
SM$CLEAN_AUTO_SPLIT_MERGE
| FGR$AUTOPURGE_JOB
FILE_WATCHER
HM_CREATE_OFFLINE_DICTIONARY
LOAD_OPATCH_INVENTORY
ORA$PREPLUGIN_BACKUP_JOB
XMLDB_NFS_CLEANUP_JOB
|
| Oracle Database 21c | BSLN_MAINTAIN_STATS_JOB
CLEANUP_NON_EXIST_OBJ
CLEANUP_ONLINE_IND_BUILD
CLEANUP_ONLINE_PMO
CLEANUP_TAB_IOT_PMO
CLEANUP_TRANSIENT_PKG
CLEANUP_TRANSIENT_TYPE
DRA_REEVALUATE_OPEN_FAILURES
FILE_SIZE_UPD
ORA$AUTOTASK_CLEAN
PMO_DEFERRED_GIDX_MAINT_JOB
PURGE_LOG
| FGR$AUTOPURGE_JOB
FILE_WATCHER
HM_CREATE_OFFLINE_DICTIONARY
LOAD_OPATCH_INVENTORY
ORA$PREPLUGIN_BACKUP_JOB
ORA$_ATSK_AUTOSTS
XMLDB_NFS_CLEANUP_JOB
|
## Parâmetros comuns para os procedimentos do Oracle Scheduler
Para realizar tarefas com o Oracle Scheduler, use os procedimentos no pacote do Amazon RDS `rdsadmin.rdsadmin_dbms_scheduler`. Vários parâmetros são comuns aos procedimentos no pacote. O pacote tem os seguintes parâmetros comuns.
****
| Nome do parâmetro | Tipo de dados | Valores válidos | Padrão | Obrigatório | Descrição |
| --- | --- | --- | --- | --- | --- |
| `name` | varchar2 | Os procedimentos listados na tabela em [Realização de tarefas comuns de agendamento para instâncias de banco de dados Oracle](#Appendix.Oracle.CommonDBATasks.Scheduler) | — | Sim | O nome do trabalho a ser modificado. |
| `attribute` | varchar2 | `'REPEAT_INTERVAL'`,`'SCHEDULE_NAME'` | – | Sim | Atributo a ser modificado. Para modificar o intervalo de repetição do trabalho, especifique `'REPEAT_INTERVAL'`. Para modificar o nome da programação do trabalho, especifique `'SCHEDULE_NAME'`. |
| `value` | varchar2 | Um intervalo de programação ou nome de programação válidos, dependendo do atributo usado. | – | Sim | O novo valor do atributo. |
## Modificação de trabalhos DBMS\$1SCHEDULER
Para modificar determinados componentes do Oracle Scheduler, use o procedimento do Oracle `dbms_scheduler.set_attribute`. Para obter mais informações, consulte [DBMS\$1SCHEDULER](https://docs.oracle.com/database/121/ARPLS/d_sched.htm#ARPLS72235) e [Procedimento SET\$1ATTRIBUTE](https://docs.oracle.com/database/121/ARPLS/d_sched.htm#ARPLS72399) na documentação da Oracle.
Ao trabalhar com instâncias de bancos de dados do Amazon RDS, anteponha o nome do esquema `SYS` ao nome do objeto. O exemplo a seguir define o atributo de plano de recurso para o objeto da janela de segunda-feira.
```
BEGIN
DBMS_SCHEDULER.SET_ATTRIBUTE(
name => 'SYS.MONDAY_WINDOW',
attribute => 'RESOURCE_PLAN',
value => 'resource_plan_1');
END;
/
```
## Modificando janelas de manutenção de AutoTask
As instâncias do Amazon RDS for Oracle são criadas com configurações padrão para janelas de manutenção. Tarefas de manutenção automatizadas, como coleta de estatísticas do otimizador, são executadas durante essas janelas. Por padrão, as janelas de manutenção ativam o Oracle Database Resource Manager.
Para modificar a janela, use o pacote `DBMS_SCHEDULER`. Talvez seja necessário modificar as configurações da janela de manutenção pelos seguintes motivos:
+ Você deseja que os trabalhos de manutenção sejam executados em um momento diferente, com configurações diferentes ou não. Por exemplo, talvez você queira modificar a duração da janela ou alterar o tempo e o intervalo de repetição.
+ Você quer evitar o impacto sobre a performance causado pela habilitação do Gerenciador de recursos durante a manutenção. Por exemplo, se o plano de manutenção padrão for especificado e se a janela de manutenção for aberta enquanto o banco de dados estiver sob carga, você poderá observar eventos de espera como `resmgr:cpu quantum`. Este evento de espera está relacionado ao Gerenciador de recursos de banco de dados. Você tem as seguintes opções:
+ Certifique-se de que as janelas de manutenção estejam ativas durante horários fora do pico de utilização da sua instância de banco de dados.
+ Desabilite o plano de manutenção padrão definindo o atributo `resource_plan` como uma string vazia.
+ Defina o parâmetro `resource_manager_plan` no grupo de parâmetros do banco de dados como `FORCE:`. Se sua instância usa o Enterprise Edition, essa configuração impede que os planos do Gerenciador de recursos de banco de dados sejam ativados.
**Para modificar as configurações da janela de manutenção**
1. Conecte ao banco de dados usando um cliente Oracle SQL.
1. Consulte a configuração atual para uma janela do programador.
O exemplo a seguir consulta a configuração para `MONDAY_WINDOW`.
```
SELECT ENABLED, RESOURCE_PLAN, DURATION, REPEAT_INTERVAL
FROM DBA_SCHEDULER_WINDOWS
WHERE WINDOW_NAME='MONDAY_WINDOW';
```
A saída a seguir mostra que a janela está usando os valores padrão.
```
ENABLED RESOURCE_PLAN DURATION REPEAT_INTERVAL
--------------- ------------------------------ ---------------- ------------------------------
TRUE DEFAULT_MAINTENANCE_PLAN +000 04:00:00 freq=daily;byday=MON;byhour=22
;byminute=0; bysecond=0
```
1. Modifique a janela usando o pacote `DBMS_SCHEDULER`.
O exemplo a seguir define o plano de recursos como nulo para que o Gerenciador de recursos não seja executado durante a janela de manutenção.
```
BEGIN
-- disable the window to make changes
DBMS_SCHEDULER.DISABLE(name=>'"SYS"."MONDAY_WINDOW"',force=>TRUE);
-- specify the empty string to use no plan
DBMS_SCHEDULER.SET_ATTRIBUTE(name=>'"SYS"."MONDAY_WINDOW"', attribute=>'RESOURCE_PLAN', value=>'');
-- re-enable the window
DBMS_SCHEDULER.ENABLE(name=>'"SYS"."MONDAY_WINDOW"');
END;
/
```
O exemplo a seguir define a duração máxima da janela como 2 horas.
```
BEGIN
DBMS_SCHEDULER.DISABLE(name=>'"SYS"."MONDAY_WINDOW"',force=>TRUE);
DBMS_SCHEDULER.SET_ATTRIBUTE(name=>'"SYS"."MONDAY_WINDOW"', attribute=>'DURATION', value=>'0 2:00:00');
DBMS_SCHEDULER.ENABLE(name=>'"SYS"."MONDAY_WINDOW"');
END;
/
```
O exemplo a seguir define o intervalo de repetição para todas as segundas-feiras às 10 horas da manhã.
```
BEGIN
DBMS_SCHEDULER.DISABLE(name=>'"SYS"."MONDAY_WINDOW"',force=>TRUE);
DBMS_SCHEDULER.SET_ATTRIBUTE(name=>'"SYS"."MONDAY_WINDOW"', attribute=>'REPEAT_INTERVAL', value=>'freq=daily;byday=MON;byhour=10;byminute=0;bysecond=0');
DBMS_SCHEDULER.ENABLE(name=>'"SYS"."MONDAY_WINDOW"');
END;
/
```
## Definir o fuso horário para trabalhos do Oracle Scheduler
Para modificar o fuso horário do Oracle Scheduler, você pode usar o procedimento do Oracl `dbms_scheduler.set_scheduler_attribute`. Para obter mais informações sobre o pacote `dbms_scheduler`, consulte [DBMS\$1SCHEDULER](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/DBMS_SCHEDULER.html) e [SET\$1SCHEDULER\$1ATTRIBUTE](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/DBMS_SCHEDULER.html#GUID-2AB97BF7-7154-4E6C-933F-B2659B18A907) na documentação do Oracle.
**Como modificar a configuração atual de fuso horário**
1. Conecte-se ao banco de dados usando um cliente como o SQL Developer. Para obter mais informações, consulte [Conectar-se à sua instância de banco de dados usando o Oracle SQL Developer](USER_ConnectToOracleInstance.SQLDeveloper.md).
1. Defina o fuso horário padrão da seguinte maneira, substituindo seu fuso horário por `time_zone_name`.
```
BEGIN
DBMS_SCHEDULER.SET_SCHEDULER_ATTRIBUTE(
attribute => 'default_timezone',
value => 'time_zone_name'
);
END;
/
```
No exemplo a seguir, altere o fuso horário para Ásia/Xangai.
Comece consultando o fuso horário atual, como mostrado a seguir.
```
SELECT VALUE FROM DBA_SCHEDULER_GLOBAL_ATTRIBUTE WHERE ATTRIBUTE_NAME='DEFAULT_TIMEZONE';
```
A saída mostra que o fuso horário atual é ETC/UTC.
```
VALUE
-------
Etc/UTC
```
Depois, você define o fuso horário como Ásia/Xangai.
```
BEGIN
DBMS_SCHEDULER.SET_SCHEDULER_ATTRIBUTE(
attribute => 'default_timezone',
value => 'Asia/Shanghai'
);
END;
/
```
Para obter mais informações sobre como alterar o fuso horário do sistema, consulte [Fuso horário da Oracle](Appendix.Oracle.Options.Timezone.md).
## Desativar trabalhos do Oracle Scheduler de propriedade do SYS
Para desativar um trabalho do Oracle Scheduler pertencente ao SYS, use o procedimento `rdsadmin.rdsadmin_dbms_scheduler.disable`.
Esse procedimento usa o parâmetro comum `name` para tarefas do Oracle Scheduler. Para obter mais informações, consulte [Parâmetros comuns para os procedimentos do Oracle Scheduler](#Appendix.Oracle.CommonDBATasks.Scheduler.CommonParameters).
O exemplo a seguir desabilita o trabalho `SYS.CLEANUP_ONLINE_IND_BUILD` do Oracle Scheduler.
```
BEGIN
rdsadmin.rdsadmin_dbms_scheduler.disable('SYS.CLEANUP_ONLINE_IND_BUILD');
END;
/
```
## Ativar trabalhos do Oracle Scheduler de propriedade do SYS
Para ativar um trabalho do Oracle Scheduler pertencente ao SYS, use o procedimento `rdsadmin.rdsadmin_dbms_scheduler.enable`.
Esse procedimento usa o parâmetro comum `name` para tarefas do Oracle Scheduler. Para obter mais informações, consulte [Parâmetros comuns para os procedimentos do Oracle Scheduler](#Appendix.Oracle.CommonDBATasks.Scheduler.CommonParameters).
O exemplo a seguir habilita o trabalho `SYS.CLEANUP_ONLINE_IND_BUILD` do Oracle Scheduler.
```
BEGIN
rdsadmin.rdsadmin_dbms_scheduler.enable('SYS.CLEANUP_ONLINE_IND_BUILD');
END;
/
```
## Modificar o intervalo de repetição do Oracle Scheduler para trabalhos do tipo CALENDAR
Para modificar o intervalo de repetição de um trabalho do Oracle Scheduler pertencente ao SYS do tipo `CALENDAR`, use o procedimento `rdsadmin.rdsadmin_dbms_scheduler.disable`.
Este procedimento usa os seguintes parâmetros comuns para tarefas do Oracle Scheduler:
+ `name`
+ `attribute`
+ `value`
Para obter mais informações, consulte [Parâmetros comuns para os procedimentos do Oracle Scheduler](#Appendix.Oracle.CommonDBATasks.Scheduler.CommonParameters).
O exemplo a seguir modifica o intervalo de repetição do trabalho `SYS.CLEANUP_ONLINE_IND_BUILD` do Oracle Scheduler.
```
BEGIN
rdsadmin.rdsadmin_dbms_scheduler.set_attribute(
name => 'SYS.CLEANUP_ONLINE_IND_BUILD',
attribute => 'repeat_interval',
value => 'freq=daily;byday=FRI,SAT;byhour=20;byminute=0;bysecond=0');
END;
/
```
## Modificar o intervalo de repetição do Oracle Scheduler para trabalhos do tipo NAMED
Alguns trabalhos do Oracle Scheduler usam um nome de programação em vez de um intervalo. Para esse tipo de trabalho, é necessário criar outra programação nomeada no esquema do usuário mestre. Use o procedimento `sys.dbms_scheduler.create_schedule` padrão do Oracle para fazer isso. Além disso, use o `rdsadmin.rdsadmin_dbms_scheduler.set_attribute procedure` para atribuir a nova programação nomeada ao trabalho.
Este procedimento usa o seguinte parâmetro comum para tarefas do Oracle Scheduler:
+ `name`
+ `attribute`
+ `value`
Para obter mais informações, consulte [Parâmetros comuns para os procedimentos do Oracle Scheduler](#Appendix.Oracle.CommonDBATasks.Scheduler.CommonParameters).
O exemplo a seguir modifica o intervalo de repetição do trabalho `SYS.BSLN_MAINTAIN_STATS_JOB` do Oracle Scheduler.
```
BEGIN
DBMS_SCHEDULER.CREATE_SCHEDULE (
schedule_name => 'rds_master_user.new_schedule',
start_date => SYSTIMESTAMP,
repeat_interval => 'freq=daily;byday=MON,TUE,WED,THU,FRI;byhour=0;byminute=0;bysecond=0',
end_date => NULL,
comments => 'Repeats daily forever');
END;
/
BEGIN
rdsadmin.rdsadmin_dbms_scheduler.set_attribute (
name => 'SYS.BSLN_MAINTAIN_STATS_JOB',
attribute => 'schedule_name',
value => 'rds_master_user.new_schedule');
END;
/
```
## Desativar a confirmação automática para a criação de trabalhos do Oracle Scheduler
Quando o `DBMS_SCHEDULER.CREATE_JOB` cria trabalhos do Oracle Scheduler, ele os cria imediatamente e confirma as alterações. Talvez seja necessário incorporar a criação de trabalhos do Oracle Scheduler na transação do usuário para fazer o seguinte:
+ Reverter o trabalho do Oracle Schedule quando a transação do usuário é revertida.
+ Criar o trabalho do Oracle Scheduler quando a transação principal do usuário é confirmada.
Você pode usar o procedimento `rdsadmin.rdsadmin_dbms_scheduler.set_no_commit_flag` para ativar esse comportamento. Este procedimento não usa parâmetros. Você pode usar esse procedimento nas seguintes versões do RDS para Oracle:
+ 21.0.0.0.ru-2022-07.rur-2022-07.r1 e posteriores
+ 19.0.0.0.ru-2022-07.rur-2022-07.r1 e posteriores
O exemplo a seguir desativa a confirmação automática do Oracle Scheduler, cria um trabalho do Oracle Scheduler e, depois, reverte a transação. Como a confirmação automática está desativada, o banco de dados também reverte a criação do trabalho do Oracle Scheduler.
```
BEGIN
rdsadmin.rdsadmin_dbms_scheduler.set_no_commit_flag;
DBMS_SCHEDULER.CREATE_JOB(job_name => 'EMPTY_JOB',
job_type => 'PLSQL_BLOCK',
job_action => 'begin null; end;',
auto_drop => false);
ROLLBACK;
END;
/
PL/SQL procedure successfully completed.
SELECT * FROM DBA_SCHEDULER_JOBS WHERE JOB_NAME='EMPTY_JOB';
no rows selected
```
# Diagnosticar problemas com instâncias de banco de dados do RDS para Oracle
O Oracle Database inclui uma infraestrutura de diagnóstico de falhas que pode ser usada para investigar problemas do banco de dados. Na terminologia do Oracle, um *problema* é um erro crítico, como um erro de código ou uma corrupção de dados. Um *incidente* é a ocorrência de um problema. Se o mesmo erro ocorrer três vezes, a infraestrutura mostrará três incidentes desse problema. Para ter mais informações, consulte [Diagnosing and resolving problems](https://docs.oracle.com/en/database/oracle/oracle-database/19/admin/diagnosing-and-resolving-problems.html#GUID-8DEB1BE0-8FB9-4FB2-A19A-17CF6F5791C3) (Diagnosticar e resolver problemas) na documentação do Oracle Database.
O utilitário ADRCI (Automatic Diagnostic Repository Command Interpreter) é uma ferramenta da linha de comando Oracle usada para gerenciar dados de diagnóstico. Por exemplo, é possível usar essa ferramenta para investigar problemas e empacotar dados de diagnóstico. Um *pacote de incidente* inclui dados de diagnóstico de um incidente ou de todos os incidentes que fazem referência a um problema específico. Você pode fazer upload de um pacote de incidente, que é implementado como um arquivo .zip, para o suporte do Oracle.
Para oferecer uma experiência de serviço gerenciada, o Amazon RDS não fornece acesso ao shell para ADRCI. Use o pacote `rdsadmin.rdsadmin_adrci_util` do Amazon RDS para realizar tarefas de diagnóstico da instância de banco de dados do RDS para Oracle.
Usando as funções em `rdsadmin_adrci_util`, é possível listar e empacotar problemas e incidentes, além de mostrar arquivos de rastreamento. Todas as funções retornam um ID de tarefa. Esse ID faz parte do nome do arquivo de log que contém a saída de ADRCI, como em `dbtask-task_id.log`. O arquivo de log reside no diretório BDUMP. É possível baixar o arquivo de log seguindo o procedimento descrito em [Como baixar um arquivo de log de banco de dados](USER_LogAccess.Procedural.Downloading.md).
## Parâmetros comuns para procedimentos de diagnóstico
Para executar tarefas de diagnóstico, use funções no pacote do Amazon RDS `rdsadmin.rdsadmin_adrci_util`. O pacote tem os seguintes parâmetros comuns.
****
| Nome do parâmetro | Tipo de dados | Valores válidos | Padrão | Obrigatório | Descrição |
| --- | --- | --- | --- | --- | --- |
| `incident_id` | número | Um ID de incidente válido ou nulo | Nulo | Não | Se o valor for nulo, a função mostrará todos os incidentes. Se o valor não for nulo e representar um ID de incidente válido, a função mostrará o incidente especificado. |
| `problem_id` | número | Um ID de problema válido ou nulo | Nulo | Não | Se o valor for nulo, a função mostrará todos os problemas. Se o valor não for nulo e representar um ID de problema válido, a função mostrará o problema especificado. |
| `last` | número | Um inteiro válido maior que 0 ou nulo | Nulo | Não | Se o valor for nulo, a função exibirá no máximo 50 itens. Se o valor não for nulo, a função exibirá o número especificado. |
## Listar incidentes
Para listar incidentes de diagnóstico para o Oracle, use a função do Amazon RDS `rdsadmin.rdsadmin_adrci_util.list_adrci_incidents`. Você pode listar incidentes no modo básico ou detalhado. Por padrão, a função lista os 50 incidentes mais recentes.
Essa função usa os seguintes parâmetros comuns:
+ `incident_id`
+ `problem_id`
+ `last`
Se você especificar `incident_id` e `problem_id`, `incident_id` substituirá `problem_id`. Para ter mais informações, consulte [Parâmetros comuns para procedimentos de diagnóstico](#Appendix.Oracle.CommonDBATasks.CommonDiagParameters).
Essa função usa o parâmetro adicional a seguir.
****
| Nome do parâmetro | Tipo de dados | Valores válidos | Padrão | Obrigatório | Descrição |
| --- | --- | --- | --- | --- | --- |
| `detail` | booliano | TRUE ou FALSE | `FALSE` | Não | Se for `TRUE`, a função listará incidentes no modo detalhado. Se for `FALSE`, a função listará incidentes no modo básico. |
Para listar todos os incidentes, consulte a função `rdsadmin.rdsadmin_adrci_util.list_adrci_incidents` sem argumentos. A consulta retorna o ID da tarefa.
```
SQL> SELECT rdsadmin.rdsadmin_adrci_util.list_adrci_incidents AS task_id FROM DUAL;
TASK_ID
------------------
1590786706158-3126
```
Ou chame a função `rdsadmin.rdsadmin_adrci_util.list_adrci_incidents` sem argumentos e armazene a saída em uma variável de cliente SQL. Você pode usar a variável em outras instruções.
```
SQL> VAR task_id VARCHAR2(80);
SQL> EXEC :task_id := rdsadmin.rdsadmin_adrci_util.list_adrci_incidents;
PL/SQL procedure successfully completed.
```
Para ler o arquivo de log, chame o procedimento do Amazon RDS `rdsadmin.rds_file_util.read_text_file`. Forneça o ID da tarefa como parte do nome do arquivo. A saída a seguir mostra três incidentes: 53523, 53522 e 53521.
```
SQL> SELECT * FROM TABLE(rdsadmin.rds_file_util.read_text_file('BDUMP', 'dbtask-'||:task_id||'.log'));
TEXT
-------------------------------------------------------------------------------------------------------------------------
2020-05-29 21:11:46.193 UTC [INFO ] Listing ADRCI incidents.
2020-05-29 21:11:46.256 UTC [INFO ]
ADR Home = /rdsdbdata/log/diag/rdbms/orcl_a/ORCL:
*************************************************************************
INCIDENT_ID PROBLEM_KEY CREATE_TIME
----------- ----------------------------------------------------------- ----------------------------------------
53523 ORA 700 [EVENT_CREATED_INCIDENT] [942] [SIMULATED_ERROR_003 2020-05-29 20:15:20.928000 +00:00
53522 ORA 700 [EVENT_CREATED_INCIDENT] [942] [SIMULATED_ERROR_002 2020-05-29 20:15:15.247000 +00:00
53521 ORA 700 [EVENT_CREATED_INCIDENT] [942] [SIMULATED_ERROR_001 2020-05-29 20:15:06.047000 +00:00
3 rows fetched
2020-05-29 21:11:46.256 UTC [INFO ] The ADRCI incidents were successfully listed.
2020-05-29 21:11:46.256 UTC [INFO ] The task finished successfully.
14 rows selected.
```
Para listar determinado incidente, especifique seu ID usando o parâmetro `incident_id`. No exemplo a seguir, o arquivo de log é consultado somente para o incidente 53523.
```
SQL> EXEC :task_id := rdsadmin.rdsadmin_adrci_util.list_adrci_incidents(incident_id=>53523);
PL/SQL procedure successfully completed.
SQL> SELECT * FROM TABLE(rdsadmin.rds_file_util.read_text_file('BDUMP', 'dbtask-'||:task_id||'.log'));
TEXT
------------------------------------------------------------------------------------------------------------------
2020-05-29 21:15:25.358 UTC [INFO ] Listing ADRCI incidents.
2020-05-29 21:15:25.426 UTC [INFO ]
ADR Home = /rdsdbdata/log/diag/rdbms/orcl_a/ORCL:
*************************************************************************
INCIDENT_ID PROBLEM_KEY CREATE_TIME
-------------------- ----------------------------------------------------------- ---------------------------------
53523 ORA 700 [EVENT_CREATED_INCIDENT] [942] [SIMULATED_ERROR_003 2020-05-29 20:15:20.928000 +00:00
1 rows fetched
2020-05-29 21:15:25.427 UTC [INFO ] The ADRCI incidents were successfully listed.
2020-05-29 21:15:25.427 UTC [INFO ] The task finished successfully.
12 rows selected.
```
## Listar problemas
Para listar problemas de diagnóstico para o Oracle, use a função do Amazon RDS `rdsadmin.rdsadmin_adrci_util.list_adrci_problems`.
Por padrão, a função lista os 50 problemas mais recentes.
Essa função usa os parâmetros comuns `problem_id` e `last`. Para ter mais informações, consulte [Parâmetros comuns para procedimentos de diagnóstico](#Appendix.Oracle.CommonDBATasks.CommonDiagParameters).
Para obter o ID da tarefa para todos os problemas, chame a função `rdsadmin.rdsadmin_adrci_util.list_adrci_problems` sem argumentos e armazene a saída em uma variável de cliente SQL.
```
SQL> EXEC :task_id := rdsadmin.rdsadmin_adrci_util.list_adrci_problems;
PL/SQL procedure successfully completed.
```
Para ler o arquivo de log, chame a função `rdsadmin.rds_file_util.read_text_file`, fornecendo o ID da tarefa como parte do nome do arquivo. Na saída a seguir, o arquivo de log mostra três problemas: 1, 2 e 3.
```
SQL> SELECT * FROM TABLE(rdsadmin.rds_file_util.read_text_file('BDUMP', 'dbtask-'||:task_id||'.log'));
TEXT
----------------------------------------------------------------------------------------------------------------------
2020-05-29 21:18:50.764 UTC [INFO ] Listing ADRCI problems.
2020-05-29 21:18:50.829 UTC [INFO ]
ADR Home = /rdsdbdata/log/diag/rdbms/orcl_a/ORCL:
*************************************************************************
PROBLEM_ID PROBLEM_KEY LAST_INCIDENT LASTINC_TIME
---------- ----------------------------------------------------------- ------------- ---------------------------------
2 ORA 700 [EVENT_CREATED_INCIDENT] [942] [SIMULATED_ERROR_003 53523 2020-05-29 20:15:20.928000 +00:00
3 ORA 700 [EVENT_CREATED_INCIDENT] [942] [SIMULATED_ERROR_002 53522 2020-05-29 20:15:15.247000 +00:00
1 ORA 700 [EVENT_CREATED_INCIDENT] [942] [SIMULATED_ERROR_001 53521 2020-05-29 20:15:06.047000 +00:00
3 rows fetched
2020-05-29 21:18:50.829 UTC [INFO ] The ADRCI problems were successfully listed.
2020-05-29 21:18:50.829 UTC [INFO ] The task finished successfully.
14 rows selected.
```
No exemplo a seguir, somente o problema 3 é listado.
```
SQL> EXEC :task_id := rdsadmin.rdsadmin_adrci_util.list_adrci_problems(problem_id=>3);
PL/SQL procedure successfully completed.
```
Para ler o arquivo de log do problema 3, chame `rdsadmin.rds_file_util.read_text_file`. Forneça o ID da tarefa como parte do nome do arquivo.
```
SQL> SELECT * FROM TABLE(rdsadmin.rds_file_util.read_text_file('BDUMP', 'dbtask-'||:task_id||'.log'));
TEXT
-------------------------------------------------------------------------
2020-05-29 21:19:42.533 UTC [INFO ] Listing ADRCI problems.
2020-05-29 21:19:42.599 UTC [INFO ]
ADR Home = /rdsdbdata/log/diag/rdbms/orcl_a/ORCL:
*************************************************************************
PROBLEM_ID PROBLEM_KEY LAST_INCIDENT LASTINC_TIME
---------- ----------------------------------------------------------- ------------- ---------------------------------
3 ORA 700 [EVENT_CREATED_INCIDENT] [942] [SIMULATED_ERROR_002 53522 2020-05-29 20:15:15.247000 +00:00
1 rows fetched
2020-05-29 21:19:42.599 UTC [INFO ] The ADRCI problems were successfully listed.
2020-05-29 21:19:42.599 UTC [INFO ] The task finished successfully.
12 rows selected.
```
## Criar pacotes de incidente
É possível criar pacotes de incidente usando a função do Amazon RDS `rdsadmin.rdsadmin_adrci_util.create_adrci_package`. A saída é um arquivo .zip que você pode fornecer ao suporte do Oracle.
Essa função usa os seguintes parâmetros comuns:
+ `problem_id`
+ `incident_id`
Especifique um dos parâmetros anteriores. Se você especificar ambos os parâmetros, `incident_id` substituirá `problem_id`. Para ter mais informações, consulte [Parâmetros comuns para procedimentos de diagnóstico](#Appendix.Oracle.CommonDBATasks.CommonDiagParameters).
Para criar um pacote para um incidente específico, chame a função `rdsadmin.rdsadmin_adrci_util.create_adrci_package` do Amazon RDS com o parâmetro `incident_id`. O exemplo a seguir cria um pacote para o incidente 53523.
```
SQL> EXEC :task_id := rdsadmin.rdsadmin_adrci_util.create_adrci_package(incident_id=>53523);
PL/SQL procedure successfully completed.
```
Para ler o arquivo de log, chame `rdsadmin.rds_file_util.read_text_file`. Você pode fornecer o ID da tarefa como parte do nome do arquivo. A saída mostra que você gerou o pacote de incidente `ORA700EVE_20200529212043_COM_1.zip`.
```
SQL> SELECT * FROM TABLE(rdsadmin.rds_file_util.read_text_file('BDUMP', 'dbtask-'||:task_id||'.log'));
TEXT
--------------------------------------------------------------------------------------------------------------------------------------
2020-05-29 21:20:43.031 UTC [INFO ] The ADRCI package is being created.
2020-05-29 21:20:47.641 UTC [INFO ] Generated package 1 in file /rdsdbdata/log/trace/ORA700EVE_20200529212043_COM_1.zip, mode complete
2020-05-29 21:20:47.642 UTC [INFO ] The ADRCI package was successfully created.
2020-05-29 21:20:47.642 UTC [INFO ] The task finished successfully.
```
Para empacotar dados de diagnóstico de determinado problema, especifique seu ID usando o parâmetro `problem_id`. No exemplo a seguir, os dados são empacotados apenas para o problema 3.
```
SQL> EXEC :task_id := rdsadmin.rdsadmin_adrci_util.create_adrci_package(problem_id=>3);
PL/SQL procedure successfully completed.
```
Para ler a saída da tarefa, chame `rdsadmin.rds_file_util.read_text_file`, fornecendo o ID da tarefa como parte do nome do arquivo. A saída mostra que você gerou o pacote de incidente `ORA700EVE_20200529212111_COM_1.zip`.
```
SQL> SELECT * FROM TABLE(rdsadmin.rds_file_util.read_text_file('BDUMP', 'dbtask-'||:task_id||'.log'));
TEXT
------------------------------------------------------------------------------------------------------------------------------------------------------------
2020-05-29 21:21:11.050 UTC [INFO ] The ADRCI package is being created.
2020-05-29 21:21:15.646 UTC [INFO ] Generated package 2 in file /rdsdbdata/log/trace/ORA700EVE_20200529212111_COM_1.zip, mode complete
2020-05-29 21:21:15.646 UTC [INFO ] The ADRCI package was successfully created.
2020-05-29 21:21:15.646 UTC [INFO ] The task finished successfully.
```
Também é possível baixar o arquivo de log. Para obter mais informações, consulte [Como baixar um arquivo de log de banco de dados](USER_LogAccess.Procedural.Downloading.md).
## Mostrar arquivos de rastreamento
Você pode usar a função do Amazon RDS `rdsadmin.rdsadmin_adrci_util.show_adrci_tracefile` para listar arquivos de rastreamento no diretório de rastreamento e todos os diretórios de incidentes na página inicial atual do ADR. Você também pode mostrar o conteúdo dos arquivos de rastreamento e dos arquivos de rastreamento de incidentes.
Essa função usa o parâmetro a seguir.
****
| Nome do parâmetro | Tipo de dados | Valores válidos | Padrão | Obrigatório | Descrição |
| --- | --- | --- | --- | --- | --- |
| `filename` | varchar2 | Um nome de arquivo de rastreamento válido | Nulo | Não | Se o valor for nulo, a função mostrará todos os arquivos de rastreamento. Se não for nulo, a função mostrará o arquivo especificado. |
Para mostrar o arquivo de rastreamento, chame a função `rdsadmin.rdsadmin_adrci_util.show_adrci_tracefile` do Amazon RDS.
```
SQL> EXEC :task_id := rdsadmin.rdsadmin_adrci_util.show_adrci_tracefile;
PL/SQL procedure successfully completed.
```
Para listar os nomes dos arquivos de rastreamento, chame o procedimento `rdsadmin.rds_file_util.read_text_file` do Amazon RDS, fornecendo o ID da tarefa como parte do nome do arquivo.
```
SQL> SELECT * FROM TABLE(rdsadmin.rds_file_util.read_text_file('BDUMP', 'dbtask-'||:task_id||'.log')) WHERE TEXT LIKE '%/alert_%';
TEXT
---------------------------------------------------------------
diag/rdbms/orcl_a/ORCL/trace/alert_ORCL.log.2020-05-28
diag/rdbms/orcl_a/ORCL/trace/alert_ORCL.log.2020-05-27
diag/rdbms/orcl_a/ORCL/trace/alert_ORCL.log.2020-05-26
diag/rdbms/orcl_a/ORCL/trace/alert_ORCL.log.2020-05-25
diag/rdbms/orcl_a/ORCL/trace/alert_ORCL.log.2020-05-24
diag/rdbms/orcl_a/ORCL/trace/alert_ORCL.log.2020-05-23
diag/rdbms/orcl_a/ORCL/trace/alert_ORCL.log.2020-05-22
diag/rdbms/orcl_a/ORCL/trace/alert_ORCL.log.2020-05-21
diag/rdbms/orcl_a/ORCL/trace/alert_ORCL.log
9 rows selected.
```
No exemplo a seguir, é gerada uma saída para `alert_ORCL.log`.
```
SQL> EXEC :task_id := rdsadmin.rdsadmin_adrci_util.show_adrci_tracefile('diag/rdbms/orcl_a/ORCL/trace/alert_ORCL.log');
PL/SQL procedure successfully completed.
```
Para ler o arquivo de log, chame `rdsadmin.rds_file_util.read_text_file`. Forneça o ID da tarefa como parte do nome do arquivo. A saída mostra as primeiras 10 linhas de alert\$1ORCL.log.
```
SQL> SELECT * FROM TABLE(rdsadmin.rds_file_util.read_text_file('BDUMP', 'dbtask-'||:task_id||'.log')) WHERE ROWNUM <= 10;
TEXT
-----------------------------------------------------------------------------------------
2020-05-29 21:24:02.083 UTC [INFO ] The trace files are being displayed.
2020-05-29 21:24:02.128 UTC [INFO ] Thu May 28 23:59:10 2020
Thread 1 advanced to log sequence 2048 (LGWR switch)
Current log# 3 seq# 2048 mem# 0: /rdsdbdata/db/ORCL_A/onlinelog/o1_mf_3_hbl2p8xs_.log
Thu May 28 23:59:10 2020
Archived Log entry 2037 added for thread 1 sequence 2047 ID 0x5d62ce43 dest 1:
Fri May 29 00:04:10 2020
Thread 1 advanced to log sequence 2049 (LGWR switch)
Current log# 4 seq# 2049 mem# 0: /rdsdbdata/db/ORCL_A/onlinelog/o1_mf_4_hbl2qgmh_.log
Fri May 29 00:04:10 2020
10 rows selected.
```
Também é possível baixar o arquivo de log. Para obter mais informações, consulte [Como baixar um arquivo de log de banco de dados](USER_LogAccess.Procedural.Downloading.md).
# Realização de tarefas comuns diversas para instâncias de banco de dados Oracle
Veja a seguir como executar diversas tarefas de DBA nas instâncias de banco de dados do Amazon RDS que executam o Oracle. Para oferecer uma experiência de serviço gerenciado, o Amazon RDS não fornece acesso ao shell para instâncias de bancos de dados e restringe o acesso a determinados procedimentos e tabelas do sistema que exigem privilégios avançados.
**Topics**
+ [
## Criar e eliminar diretórios no espaço de armazenamento de dados principal
](#Appendix.Oracle.CommonDBATasks.NewDirectories)
+ [
## Listagem de arquivos no diretório de uma instância de banco de dados
](#Appendix.Oracle.CommonDBATasks.ListDirectories)
+ [
## Leitura de arquivos no diretório de uma instância de banco de dados
](#Appendix.Oracle.CommonDBATasks.ReadingFiles)
+ [
## Acessar arquivos do Opatch
](#Appendix.Oracle.CommonDBATasks.accessing-opatch-files)
+ [
## Gerenciando de tarefas do advisor
](#Appendix.Oracle.CommonDBATasks.managing-advisor-tasks)
+ [
# Transportar espaços para tabela
](rdsadmin_transport_util.md)
## Criar e eliminar diretórios no espaço de armazenamento de dados principal
Para criar diretórios, use o procedimento do Amazon RDS `rdsadmin.rdsadmin_util.create_directory`. É possível criar até 10.000 diretórios, todas localizados no seu espaço de armazenamento físico de dados principal. Para criar diretórios, use o procedimento do Amazon RDS `rdsadmin.rdsadmin_util.drop_directory`.
Os procedimentos `create_directory` e `drop_directory` têm o parâmetro necessário a seguir.
****
| Nome do parâmetro | Tipo de dados | Padrão | Obrigatório | Descrição |
| --- | --- | --- | --- | --- |
| `p_directory_name` | VARCHAR2 | — | Sim | O nome do diretório. |
O exemplo a seguir cria um novo diretório chamado `PRODUCT_DESCRIPTIONS`.
```
EXEC rdsadmin.rdsadmin_util.create_directory(p_directory_name => 'product_descriptions');
```
O dicionário de dados armazena o nome do diretório em maiúsculas. Você pode listar os diretórios consultando `DBA_DIRECTORIES`. O sistema escolhe automaticamente o nome do caminho do host real. O exemplo a seguir obtém o caminho do diretório para o diretório chamado `PRODUCT_DESCRIPTIONS`:
```
SELECT DIRECTORY_PATH
FROM DBA_DIRECTORIES
WHERE DIRECTORY_NAME='PRODUCT_DESCRIPTIONS';
DIRECTORY_PATH
----------------------------------------
/rdsdbdata/userdirs/01
```
O nome de usuário mestre para a instância de banco de dados tem privilégios de leitura e gravação no novo diretório e pode conceder acesso a outros usuários. Privilégios `EXECUTE` não estão disponíveis para diretórios em uma instância de banco de dados. Os diretórios são criados no seu espaço de armazenamento físico de dados principal e consumirão espaço e largura de banda de E/S.
O exemplo a seguir elimina o diretório chamado `PRODUCT_DESCRIPTIONS`.
```
EXEC rdsadmin.rdsadmin_util.drop_directory(p_directory_name => 'product_descriptions');
```
**nota**
Também é possível descartar um diretório usando o comando do Oracle SQ `DROP DIRECTORY`.
Descartar um diretório não remove seu conteúdo. Como o procedimento `rdsadmin.rdsadmin_util.create_directory` pode reutilizar nomes de caminhos, os arquivos em diretórios eliminados podem aparecer em um diretório recém-criado. Antes de eliminar um diretório, recomendamos que você use `UTL_FILE.FREMOVE` para remover arquivos do diretório. Para obter mais informações, consulte [Procedimento FREMOVE](https://docs.oracle.com/database/121/ARPLS/u_file.htm#ARPLS70924) na documentação da Oracle.
## Listagem de arquivos no diretório de uma instância de banco de dados
Para listar os arquivos em um diretório, use o procedimento do Amazon RDS `rdsadmin.rds_file_util.listdir`. Esse procedimento não é compatível com uma réplica da Oracle. O procedimento `listdir` tem os seguintes parâmetros.
****
| Nome do parâmetro | Tipo de dados | Padrão | Obrigatório | Descrição |
| --- | --- | --- | --- | --- |
| `p_directory` | varchar2 | — | Sim | O nome do diretório a ser listado. |
O exemplo a seguir concede privilégios de leitura/gravação no diretório `PRODUCT_DESCRIPTIONS` para o usuário `rdsadmin` e, em seguida, lista os arquivos neste diretório.
```
GRANT READ,WRITE ON DIRECTORY PRODUCT_DESCRIPTIONS TO rdsadmin;
SELECT * FROM TABLE(rdsadmin.rds_file_util.listdir(p_directory => 'PRODUCT_DESCRIPTIONS'));
```
## Leitura de arquivos no diretório de uma instância de banco de dados
Para ler um arquivo de texto, use o procedimento do Amazon RDS `rdsadmin.rds_file_util.read_text_file`. O procedimento `read_text_file` tem os seguintes parâmetros.
****
| Nome do parâmetro | Tipo de dados | Padrão | Obrigatório | Descrição |
| --- | --- | --- | --- | --- |
| `p_directory` | varchar2 | — | Sim | O nome do diretório que contém o arquivo. |
| `p_filename` | varchar2 | — | Sim | O nome do arquivo a ser lido. |
O exemplo a seguir cria o arquivo `rice.txt` no diretório `PRODUCT_DESCRIPTIONS`.
```
declare
fh sys.utl_file.file_type;
begin
fh := utl_file.fopen(location=>'PRODUCT_DESCRIPTIONS', filename=>'rice.txt', open_mode=>'w');
utl_file.put(file=>fh, buffer=>'AnyCompany brown rice, 15 lbs');
utl_file.fclose(file=>fh);
end;
/
```
O exemplo a seguir lê o arquivo `rice.txt` do diretório `PRODUCT_DESCRIPTIONS`.
```
SELECT * FROM TABLE
(rdsadmin.rds_file_util.read_text_file(
p_directory => 'PRODUCT_DESCRIPTIONS',
p_filename => 'rice.txt'));
```
## Acessar arquivos do Opatch
O Opatch é um utilitário do Oracle que permite a aplicação e a reversão de patches para o software do Oracle. O mecanismo do Oracle para determinar quais patches foram aplicados a um banco de dados é o comando `opatch lsinventory`. Para abrir solicitações de serviço para clientes de Traga sua própria licença (BYOL – Bring Your Own Licence), o suporte do Oracle solicita o arquivo `lsinventory` e, às vezes, o arquivo `lsinventory_detail` gerado pelo Opatch.
Para oferecer uma experiência de serviço gerenciada, o Amazon RDS não fornece acesso ao shell para o Opatch. Em vez disso, o `lsinventory-dbv.txt` no diretório BDUMP contém as informações de patch relacionadas à versão atual do mecanismo. Quando você executa um upgrade principal ou secundário, o Amazon RDS atualiza `lsinventory-dbv.txt` em até uma hora após a aplicação do patch. Para verificar os patches aplicados, leia `lsinventory-dbv.txt`. Essa ação é semelhante a executar o comando `opatch lsinventory`.
**nota**
Os exemplos nesta seção pressupõem que o diretório BDUMP seja chamado `BDUMP`. Em uma réplica de leitura, o nome do diretório BDUMP é diferente. Para saber como obter o nome BDUMP consultando `V$DATABASE.DB_UNIQUE_NAME` em uma réplica de leitura, consulte [Listar arquivos](USER_LogAccess.Concepts.Oracle.md#USER_LogAccess.Concepts.Oracle.WorkingWithTracefiles.ViewingBackgroundDumpDest).
Os arquivos de inventário usam a convenção de nomenclatura do Amazon RDS `lsinventory-dbv.txt` e `lsinventory_detail-dbv.txt`, onde *dbv* é o nome completo da versão do banco de dados. O arquivo `lsinventory-dbv.txt` está disponível em todas as versões do banco de dados. O `lsinventory_detail-dbv.txt` correspondente está disponível em 19.0.0.0, ru-2020-01.rur-2020-01.r1 ou posterior.
Por exemplo, se a versão do seu banco de dados for 19.0.0.0.ru-2021-07.rur-2021-07.r1, os arquivos de inventário terão os nomes a seguir.
```
lsinventory-19.0.0.0.ru-2021-07.rur-2021-07.r1.txt
lsinventory_detail-19.0.0.0.ru-2021-07.rur-2021-07.r1.txt
```
Baixe os arquivos que correspondem à versão atual do mecanismo de banco de dados.
### Console
**Como baixar um arquivo de inventário usando o console**
1. Abra o console do Amazon RDS em [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. No painel de navegação, escolha **Databases (Bancos de dados)**.
1. Escolha o nome da instância de banco de dados que contém o arquivo de log que você deseja visualizar.
1. Escolha a guia **Logs & events (Logs e eventos)**.
1. Role para baixo até a seção **Logs**.
1. Na seção **Logs**, procure por `lsinventory`.
1. Escolha o arquivo que você deseja acessar e selecione **Download** (Baixar).
### SQL
Para ler o `lsinventory-dbv.txt` em um cliente SQL, é possível usar uma instrução `SELECT`. Para esta técnica, use uma das seguintes funções `rdsadmin`: `rdsadmin.rds_file_util.read_text_file` ou `rdsadmin.tracefile_listing`.
Na consulta de exemplo a seguir, substitua *dbv* pela versão do seu banco de dados Oracle. Por exemplo, a versão do seu banco de dados pode ser 19.0.0.0.ru-2020-04.rur-2020-04.r1.
```
SELECT text
FROM TABLE(rdsadmin.rds_file_util.read_text_file('BDUMP', 'lsinventory-dbv.txt'));
```
### PL/SQL
Para ler o `lsinventory-dbv.txt` em um cliente SQL, é possível escrever um programa PL/SQL. Esse programa usa `utl_file` para ler o arquivo e `dbms_output` para imprimi-lo. Esses são pacotes fornecidos pelo Oracle.
No programa de exemplo a seguir, substitua *dbv* pela versão do seu banco de dados Oracle. Por exemplo, a versão do seu banco de dados pode ser 19.0.0.0.ru-2020-04.rur-2020-04.r1.
```
SET SERVEROUTPUT ON
DECLARE
v_file SYS.UTL_FILE.FILE_TYPE;
v_line VARCHAR2(1000);
v_oracle_home_type VARCHAR2(1000);
c_directory VARCHAR2(30) := 'BDUMP';
c_output_file VARCHAR2(30) := 'lsinventory-dbv.txt';
BEGIN
v_file := SYS.UTL_FILE.FOPEN(c_directory, c_output_file, 'r');
LOOP
BEGIN
SYS.UTL_FILE.GET_LINE(v_file, v_line,1000);
DBMS_OUTPUT.PUT_LINE(v_line);
EXCEPTION
WHEN no_data_found THEN
EXIT;
END;
END LOOP;
END;
/
```
Ou consulte `rdsadmin.tracefile_listing` e transfira a saída para um arquivo. O exemplo a seguir transfere a saída para `/tmp/tracefile.txt`.
```
SPOOL /tmp/tracefile.txt
SELECT *
FROM rdsadmin.tracefile_listing
WHERE FILENAME LIKE 'lsinventory%';
SPOOL OFF;
```
## Gerenciando de tarefas do advisor
O banco de dados Oracle inclui vários advisors. Cada advisor suporta tarefas automatizadas e manuais. Você pode usar procedimentos no pacote `rdsadmin.rdsadmin_util` para gerenciar algumas tarefas do advisor.
Os procedimentos de tarefas do advisor estão disponíveis nas seguintes versões do mecanismo:
+ Oracle Database 21c (21.0.0)
+ Versão 19.0.0.0.ru-2021-01.rur-2021-01.r1 e versões posteriores do Oracle Database 19c
Para obter mais informações, consulte [Versão 19.0.0.0.ru-2021-01.rur-2021-01.r1](https://docs.aws.amazon.com/AmazonRDS/latest/OracleReleaseNotes/oracle-version-19-0.html#oracle-version-RU-RUR.19.0.0.0.ru-2021-01.rur-2021-01.r1) em *Notas de lançamento do Amazon RDS for Oracle*.
**Topics**
+ [
### Definição de parâmetros para tarefas do advisor
](#Appendix.Oracle.CommonDBATasks.setting-task-parameters)
+ [
### Desativação de AUTO\$1STATS\$1ADVISOR\$1TASK
](#Appendix.Oracle.CommonDBATasks.dropping-advisor-task)
+ [
### Reativação de AUTO\$1STATS\$1ADVISOR\$1TASK
](#Appendix.Oracle.CommonDBATasks.recreating-advisor-task)
### Definição de parâmetros para tarefas do advisor
Para definir parâmetros para algumas tarefas do advisor, use o procedimento do Amazon RDS `rdsadmin.rdsadmin_util.advisor_task_set_parameter`. O procedimento `advisor_task_set_parameter` tem os seguintes parâmetros.
****
| Nome do parâmetro | Tipo de dados | Padrão | Obrigatório | Descrição |
| --- | --- | --- | --- | --- |
| `p_task_name` | varchar2 | — | Sim | O nome da tarefa do advisor cujos parâmetros você deseja alterar. Os valores a seguir são válidos: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.Misc.html) |
| `p_parameter` | varchar2 | — | Sim | O nome do parâmetro da tarefa. Para localizar parâmetros válidos para uma tarefa do advisor, execute a seguinte consulta. Substitua *p\$1task\$1name* com um valor válido para `p_task_name`: COL PARAMETER_NAME FORMAT a30
COL PARAMETER_VALUE FORMAT a30
SELECT PARAMETER_NAME, PARAMETER_VALUE
FROM DBA_ADVISOR_PARAMETERS
WHERE TASK_NAME='p_task_name'
AND PARAMETER_VALUE != 'UNUSED'
ORDER BY PARAMETER_NAME;
|
| `p_value` | varchar2 | — | Sim | O valor de um parâmetro de tarefa. Para localizar valores válidos para parâmetros de tarefa, execute a seguinte consulta. Substitua *p\$1task\$1name* com um valor válido para `p_task_name`: COL PARAMETER_NAME FORMAT a30
COL PARAMETER_VALUE FORMAT a30
SELECT PARAMETER_NAME, PARAMETER_VALUE
FROM DBA_ADVISOR_PARAMETERS
WHERE TASK_NAME='p_task_name'
AND PARAMETER_VALUE != 'UNUSED'
ORDER BY PARAMETER_NAME;
|
Os seguintes programas PL/SQL definem `ACCEPT_PLANS` como `FALSE` para `SYS_AUTO_SPM_EVOLVE_TASK`. A tarefa automatizada do Gerenciamento de Plano SQL verifica os planos e gera um relatório de suas descobertas, mas não evolui os planos automaticamente. Você pode usar um relatório para identificar novas listas de referência do plano SQL e aceitá-las manualmente.
```
BEGIN
rdsadmin.rdsadmin_util.advisor_task_set_parameter(
p_task_name => 'SYS_AUTO_SPM_EVOLVE_TASK',
p_parameter => 'ACCEPT_PLANS',
p_value => 'FALSE');
END;
```
Os seguintes programas PL/SQL definem `EXECUTION_DAYS_TO_EXPIRE` como `10` para `AUTO_STATS_ADVISOR_TASK`. A tarefa predefinida `AUTO_STATS_ADVISOR_TASK` é executada automaticamente na janela de manutenção uma vez por dia. O exemplo define o período de retenção para a execução da tarefa como 10 dias.
```
BEGIN
rdsadmin.rdsadmin_util.advisor_task_set_parameter(
p_task_name => 'AUTO_STATS_ADVISOR_TASK',
p_parameter => 'EXECUTION_DAYS_TO_EXPIRE',
p_value => '10');
END;
```
### Desativação de AUTO\$1STATS\$1ADVISOR\$1TASK
Para desativar `AUTO_STATS_ADVISOR_TASK`, use o procedimento do Amazon RDS `rdsadmin.rdsadmin_util.advisor_task_drop`. O procedimento `advisor_task_drop` aceita o parâmetro a seguir.
****
| Nome do parâmetro | Tipo de dados | Padrão | Obrigatório | Descrição |
| --- | --- | --- | --- | --- |
| `p_task_name` | varchar2 | — | Sim | O nome da tarefa do advisor a ser desabilitada. O único valor válido é `AUTO_STATS_ADVISOR_TASK`. |
Execute o seguinte comando: `AUTO_STATS_ADVISOR_TASK`.
```
EXEC rdsadmin.rdsadmin_util.advisor_task_drop('AUTO_STATS_ADVISOR_TASK')
```
Você pode reabilitar `AUTO_STATS_ADVISOR_TASK` usando `rdsadmin.rdsadmin_util.dbms_stats_init`.
### Reativação de AUTO\$1STATS\$1ADVISOR\$1TASK
Para reativar `AUTO_STATS_ADVISOR_TASK`, use o procedimento do Amazon RDS `rdsadmin.rdsadmin_util.dbms_stats_init`. O procedimento `dbms_stats_init` não recebe parâmetros.
O comando a seguir reativa `AUTO_STATS_ADVISOR_TASK`.
```
EXEC rdsadmin.rdsadmin_util.dbms_stats_init()
```
# Transportar espaços para tabela
Use o pacote `rdsadmin.rdsadmin_transport_util` do Amazon RDS para copiar um conjunto de espaços para tabela de um banco de dados Oracle on-premises para uma instância de banco de dados do RDS para Oracle. No nível físico, o atributo de espaço para tabelas copia incrementalmente os arquivos de dados de origem e os arquivos de metadados para a instância de destino. Você pode transferir os arquivos usando o Amazon EFS ou o Amazon S3. Para ter mais informações, consulte [Migrar usando espaços de tabela transportáveis da Oracle](oracle-migrating-tts.md).
**Topics**
+ [
# Importar espaços para tabela transportados para a instância de banco de dados
](rdsadmin_transport_util_import_xtts_tablespaces.md)
+ [
# Importar metadados de espaços para tabela transportáveis para a instância de banco de dados
](rdsadmin_transport_util_import_xtts_metadata.md)
+ [
# Listar arquivos órfãos após a importação de um espaço para tabela
](rdsadmin_transport_util_list_xtts_orphan_files.md)
+ [
# Excluir arquivos de dados órfãos após a importação de espaços para tabela
](rdsadmin_transport_util_cleanup_incomplete_xtts_import.md)
# Importar espaços para tabela transportados para a instância de banco de dados
Use o procedimento `rdsadmin.rdsadmin_transport_util.import_xtts_tablespaces` para restaurar espaços para tabela que você exportou anteriormente de uma instância de banco de dados de origem. Na fase de transporte, você fará backup dos espaços para tabela somente leitura, exportará os metadados do Data Pump, transferirá esses arquivos para a instância de banco de dados de destino e, depois, importará os espaços para tabela. Para obter mais informações, consulte [Fase 4: Transportar os espaços de tabela](oracle-migrating-tts.md#oracle-migrating-tts.final-br-phase).
## Sintaxe
```
FUNCTION import_xtts_tablespaces(
p_tablespace_list IN CLOB,
p_directory_name IN VARCHAR2,
p_platform_id IN NUMBER DEFAULT 13,
p_parallel IN INTEGER DEFAULT 0) RETURN VARCHAR2;
```
## Parâmetros
****
| Nome do parâmetro | Tipo de dados | Padrão | Obrigatório | Descrição |
| --- | --- | --- | --- | --- |
| `p_tablespace_list` | `CLOB` | — | Sim | A lista de espaços para tabela a serem importados. |
| `p_directory_name` | `VARCHAR2` | — | Sim | O diretório que contém os backups de espaços para tabela. |
| `p_platform_id` | `NUMBER` | `13` | Não | Forneça um ID de plataforma que corresponda ao especificado durante a fase de backup. Para encontrar uma lista de plataformas, consulte `V$TRANSPORTABLE_PLATFORM`. A plataforma padrão é Linux x86 de 64 bits, que é pouco comum. |
| `p_parallel` | `INTEGER` | `0` | Não | O grau de paralelismo. Por padrão, o paralelismo está desabilitado. |
## Exemplos
O exemplo a seguir importa os espaços de tabela *TBS1*, *TBS2* e *TBS3* do diretório *DATA\$1PUMP\$1DIR*. A plataforma de origem é de sistemas baseados em AIX (64 bits), que tem o ID da plataforma de `6`. É possível encontrar os IDs da plataforma consultando `V$TRANSPORTABLE_PLATFORM`.
```
VAR task_id CLOB
BEGIN
:task_id:=rdsadmin.rdsadmin_transport_util.import_xtts_tablespaces(
'TBS1,TBS2,TBS3',
'DATA_PUMP_DIR',
p_platform_id => 6);
END;
/
PRINT task_id
```
# Importar metadados de espaços para tabela transportáveis para a instância de banco de dados
Use o procedimento `rdsadmin.rdsadmin_transport_util.import_xtts_metadata` para importar os metadados de espaços para tabela transportáveis para a instância de banco de dados do RDS para Oracle. Durante a operação, o status da importação de metadados é mostrado na tabela `rdsadmin.rds_xtts_operation_info`. Para obter mais informações, consulte [Etapa 5: Importar os metadados de espaços de tabela na instância de banco de dados de destino](oracle-migrating-tts.md#oracle-migrating-tts.transport.import-dmp).
## Sintaxe
```
PROCEDURE import_xtts_metadata(
p_datapump_metadata_file IN SYS.DBA_DATA_FILES.FILE_NAME%TYPE,
p_directory_name IN VARCHAR2,
p_exclude_stats IN BOOLEAN DEFAULT FALSE,
p_remap_tablespace_list IN CLOB DEFAULT NULL,
p_remap_user_list IN CLOB DEFAULT NULL);
```
## Parâmetros
****
| Nome do parâmetro | Tipo de dados | Padrão | Obrigatório | Descrição |
| --- | --- | --- | --- | --- |
| `p_datapump_metadata_file` | `SYS.DBA_DATA_FILES.FILE_NAME%TYPE` | — | Sim | O nome do arquivo Oracle Data Pump que contém os metadados de seus espaços para tabela transportáveis. |
| `p_directory_name` | `VARCHAR2` | — | Sim | O diretório que contém o arquivo Data Pump. |
| `p_exclude_stats` | `BOOLEAN` | `FALSE` | Não | Sinalizador que indica se as estatísticas devem ser excluídas. |
| `p_remap_tablespace_list` | `CLOB` | NULL | Não | Uma lista de espaços para tabela a serem associados novamente durante a importação de metadados. Use o formato `from_tbs:to_tbs`. Por exemplo, especifique `users:user_data`. |
| `p_remap_user_list` | `CLOB` | NULL | Não | Uma lista de esquemas de usuário a serem novamente associados durante a importação de metadados. Use o formato `from_schema_name:to_schema_name`. Por exemplo, especifique `hr:human_resources`. |
## Exemplos
O exemplo importa os metadados de espaço para tabelas do arquivo *xttdump.dmp*, que está localizado no diretório *DATA\$1PUMP\$1DIR*.
```
BEGIN
rdsadmin.rdsadmin_transport_util.import_xtts_metadata('xttdump.dmp','DATA_PUMP_DIR');
END;
/
```
# Listar arquivos órfãos após a importação de um espaço para tabela
Use o procedimento `rdsadmin.rdsadmin_transport_util.list_xtts_orphan_files` para listar arquivos de dados que ficaram órfãos após a importação de espaços para tabela. Depois de identificar os arquivos de dados, você pode excluí-los chamando `rdsadmin.rdsadmin_transport_util.cleanup_incomplete_xtts_import`.
## Sintaxe
```
FUNCTION list_xtts_orphan_files RETURN xtts_orphan_files_list_t PIPELINED;
```
## Exemplos
O exemplo a seguir executa o procedimento `rdsadmin.rdsadmin_transport_util.list_xtts_orphan_files`. A saída mostra dois arquivos de dados que estão órfãos.
```
SQL> SELECT * FROM TABLE(rdsadmin.rdsadmin_transport_util.list_xtts_orphan_files);
FILENAME FILESIZE
-------------- ---------
datafile_7.dbf 104865792
datafile_8.dbf 104865792
```
# Excluir arquivos de dados órfãos após a importação de espaços para tabela
Use o procedimento `rdsadmin.rdsadmin_transport_util.list_xtts_orphan_files` para excluir arquivos de dados que ficaram órfãos após a importação de espaços para tabela. A execução desse comando gera um arquivo de log que usa o formato do nome `rds-xtts-delete_xtts_orphaned_files-YYYY-MM-DD.HH24-MI-SS.FF.log` no diretório `BDUMP`. Use o procedimento `rdsadmin.rdsadmin_transport_util.cleanup_incomplete_xtts_import` para encontrar os arquivos órfãos. Você pode ler o arquivo de log chamando o procedimento `rdsadmin.rds_file_util.read_text_file`. Para obter mais informações, consulte [Fase 6: Limpar os arquivos restantes](oracle-migrating-tts.md#oracle-migrating-tts.cleanup).
## Sintaxe
```
PROCEDURE cleanup_incomplete_xtts_import(
p_directory_name IN VARCHAR2);
```
## Parâmetros
****
| Nome do parâmetro | Tipo de dados | Padrão | Obrigatório | Descrição |
| --- | --- | --- | --- | --- |
| `p_directory_name` | `VARCHAR2` | — | Sim | O diretório que contém os arquivos de dados órfãos. |
## Exemplos
O exemplo a seguir exclui os arquivos de dados órfãos no *DATA\$1PUMP\$1DIR*.
```
BEGIN
rdsadmin.rdsadmin_transport_util.cleanup_incomplete_xtts_import('DATA_PUMP_DIR');
END;
/
```
O exemplo a seguir lê o arquivo de log gerado pelo comando anterior.
```
SELECT *
FROM TABLE(rdsadmin.rds_file_util.read_text_file(
p_directory => 'BDUMP',
p_filename => 'rds-xtts-delete_xtts_orphaned_files-2023-06-01.09-33-11.868894000.log'));
TEXT
--------------------------------------------------------------------------------
orphan transported datafile datafile_7.dbf deleted.
orphan transported datafile datafile_8.dbf deleted.
```