Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Administration de votre instance de base de données RDS for Oracle
Voici les tâches de gestion courantes que vous effectuez avec une instance de base de données RDS for Oracle. Certaines tâches sont les mêmes pour toutes les instances de base de données RDS. D'autres tâches sont spécifiques à RDS for Oracle.
Les tâches suivantes sont communes à toutes les bases de données RDS, mais Oracle Database a des considérations spéciales. Par exemple, vous vous connectez à une base de données Oracle avec les clients Oracle SQL\$1Plus et SQL Developer.
****
| Type de tâche | Documentation |
| --- | --- |
| **Classes d’instance, stockage et PIOPS** Si vous créez une instance de production, découvrez comment fonctionnent les classes d'instance, les types de stockage et les IOPS provisionnées dans Amazon RDS. | [Classes d’instance de base de données RDS for Oracle](Oracle.Concepts.InstanceClasses.md) [Types de stockage Amazon RDS](CHAP_Storage.md#Concepts.Storage) |
| **Déploiements multi-AZ** Une instance de base de données de production doit utiliser des déploiements multi-AZ. Les déploiements Multi-AZ améliorent la disponibilité, la durabilité des donnés et la tolérance aux pannes pour les instances de bases de données. | [Configuration et gestion d’un déploiement multi-AZ pour Amazon RDS](Concepts.MultiAZ.md) |
| **Amazon VPC** Si votre AWS compte possède un cloud privé virtuel (VPC) par défaut, votre instance de base de données est automatiquement créée dans le VPC par défaut. Si votre compte n'a pas de VPC par défaut et que vous voulez que l'instance de base de données soit dans un VPC, créez le VPC et les groupes de sous-réseaux avant de créer l'instance. | [Utilisation d’une instance de base de données dans un VPC](USER_VPC.WorkingWithRDSInstanceinaVPC.md) |
| **Groupes de sécurité** Par défaut, les instances de base de données utilisent un pare-feu qui empêche l’accès. Veillez à créer un groupe de sécurité avec les adresses IP et la configuration réseau voulues pour accéder à l'instance de base de données. | [Contrôle d’accès par groupe de sécurité](Overview.RDSSecurityGroups.md) |
| **Groupes de paramètres** Si votre instance de base de données doit nécessiter des paramètres de base de données spécifiques, créez un groupe de paramètres avant de créer l'instance de base de données. | [Groupes de paramètres pour Amazon RDS](USER_WorkingWithParamGroups.md) |
| **Groupes d’options** Si votre instance de base de données nécessite des options spécifiques, créez un groupe d'options avant de créer l'instance de base de données. | [Ajout d'options aux instances de base de données Oracle](Appendix.Oracle.Options.md) |
| **Connexion à votre instance de base de données** Après avoir créé un groupe de sécurité et l'avoir associé à une instance de base de données, vous pouvez vous connecter à l'instance de base de données en utilisant une application cliente SQL standard quelconque telle qu'Oracle SQL\$1Plus. | [Connexion à votre instance de base de données Oracle](USER_ConnectToOracleInstance.md) |
| **Sauvegarde et restauration** Vous pouvez configurer votre instance de base de données pour que les sauvegardes soient exécutées automatiquement ou que les instantanés soient créés manuellement, puis que les instances soient restaurées à partir des sauvegardes ou des instantanés. | [Sauvegarde, restauration et exportation de données](CHAP_CommonTasks.BackupRestore.md) |
| **Surveillance** Vous pouvez surveiller une instance de base de données Oracle à l'aide des métriques, des événements et de la surveillance améliorée d' CloudWatch Amazon RDS. | [Affichage des métriques dans la console Amazon RDS](USER_Monitoring.md) [Affichage d’événements Amazon RDS](USER_ListEvents.md) |
| **Les fichiers journaux** Vous pouvez accéder aux fichiers journaux de votre instance de base de données Oracle. | [Surveillance des fichiers journaux Amazon RDS](USER_LogAccess.md) |
Vous trouverez ci-après une description d'implémentations spécifiques d'Amazon RDS de tâches courantes d'administrateur de base de données pour RDS Oracle. Pour offrir une expérience de service géré, Amazon RDS ne fournit pas l'accès shell aux instances de base de données. RDS restreint également l'accès à certaines procédures système et tables qui requièrent des privilèges avancés. Dans de nombreuses tâches, vous exécutez le package `rdsadmin`, un outil spécifique d'Amazon RDS qui vous permet d'administrer votre base de données.
Les tâches DBA courantes pour les instances de base de données exécutant Oracle sont les suivantes :
+ [Tâches système](Appendix.Oracle.CommonDBATasks.System.md)
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.html)
+ [Tâches de base de données](Appendix.Oracle.CommonDBATasks.Database.md)
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.html)
+ [Tâches de journal](Appendix.Oracle.CommonDBATasks.Log.md)
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.html)
+ [Tâches RMAN](Appendix.Oracle.CommonDBATasks.RMAN.md)
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.html)
+ [Tâches Oracle Scheduler](Appendix.Oracle.CommonDBATasks.Scheduler.md)
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.html)
+ [Diagnostic des problèmes](Appendix.Oracle.CommonDBATasks.Diagnostics.md)
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.html)
+ [Autres tâches](Appendix.Oracle.CommonDBATasks.Misc.md)
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.html)
Vous pouvez également utiliser les procédures Amazon RDS for l'intégration de Amazon S3 avec Oracle et pour l'exécution de tâches de base de données OEM Management Agent. Pour plus d’informations, consultez [Intégration Amazon S3](oracle-s3-integration.md) et [Exécution de tâches de base de données avec l'option Management Agent](Oracle.Options.OEMAgent.md#Oracle.Options.OEMAgent.DBTasks).
# Exécution des tâches système courantes pour les instances de bases de données Oracle
Vous trouverez ci-dessous des informations sur la façon d'effectuer certaines tâches DBA courantes liées au système sur vos instances de base de données Amazon RDS exécutant Oracle. Pour offrir une expérience de service géré, Amazon RDS ne fournit pas l'accès shell aux instances de base de données et limite l'accès à certaines tables et procédures système qui requièrent des privilèges avancés.
**Topics**
+ [Déconnexion d'une session](Appendix.Oracle.CommonDBATasks.DisconnectingSession.md)
+ [Terminer une session](Appendix.Oracle.CommonDBATasks.KillingSession.md)
+ [Annulation d'une instruction SQL dans une session](Appendix.Oracle.CommonDBATasks.CancellingSQL.md)
+ [Activation et désactivation de sessions restreintes](Appendix.Oracle.CommonDBATasks.RestrictedSession.md)
+ [Vidage du pool partagé](Appendix.Oracle.CommonDBATasks.FlushingSharedPool.md)
+ [Octroi des privilèges SELECT ou EXECUTE aux objets SYS](Appendix.Oracle.CommonDBATasks.TransferPrivileges.md)
+ [Retrait des privilèges SELECT ou EXECUTE sur les objets SYS](Appendix.Oracle.CommonDBATasks.RevokePrivileges.md)
+ [Gestion des vues RDS\$1X\$1 pour les instances de base de données Oracle](Appendix.Oracle.CommonDBATasks.X-dollar.md)
+ [Attribution de privilèges à des utilisateurs non-maîtres](Appendix.Oracle.CommonDBATasks.PermissionsNonMasters.md)
+ [Création de fonctions personnalisées pour vérifier les mots de passe](Appendix.Oracle.CommonDBATasks.CustomPassword.md)
+ [Configuration d'un serveur DNS personnalisé](#Appendix.Oracle.CommonDBATasks.CustomDNS)
+ [Activation et désactivation des événements de diagnostic système](Appendix.Oracle.CommonDBATasks.SystemEvents.md)
# Déconnexion d'une session
Pour déconnecter la session en cours en mettant fin au processus serveur dédié, utilisez la procédure Amazon RDS `rdsadmin.rdsadmin_util.disconnect`. La procédure `disconnect` possède les paramètres suivants.
****
| Nom du paramètre | Type de données | Par défaut | Obligatoire | Description |
| --- | --- | --- | --- | --- |
| `sid` | nombre | — | Oui | Identifiant de session. |
| `serial` | nombre | — | Oui | Numéro de série de la session. |
| `method` | varchar | 'IMMEDIATE' | Non | Les valeurs valides sont `'IMMEDIATE'` ou `'POST_TRANSACTION'`. |
L'exemple suivant déconnecte une session.
```
begin
rdsadmin.rdsadmin_util.disconnect(
sid => sid,
serial => serial_number);
end;
/
```
Pour obtenir l'identifiant et le numéro de série de la session, interrogez la vue `V$SESSION`. L'exemple suivant obtient toutes les sessions pour l'utilisateur `AWSUSER`.
```
SELECT SID, SERIAL#, STATUS FROM V$SESSION WHERE USERNAME = 'AWSUSER';
```
La base de données doit être ouverte pour pouvoir utiliser cette méthode. Pour plus d'informations sur la déconnexion d'une session, consultez [ALTER SYSTEM (MODIFIER SYSTÈME)](http://docs.oracle.com/cd/E11882_01/server.112/e41084/statements_2014.htm#SQLRF53166) dans la documentation Oracle.
# Terminer une session
Pour arrêter une session, utilisez la procédure Amazon RDS `rdsadmin.rdsadmin_util.kill`. La procédure `kill` possède les paramètres suivants.
****
| Nom du paramètre | Type de données | Par défaut | Obligatoire | Description |
| --- | --- | --- | --- | --- |
| `sid` | nombre | — | Oui | Identifiant de session. |
| `serial` | nombre | — | Oui | Numéro de série de la session. |
| `method` | varchar | null | Non | Les valeurs valides sont `'IMMEDIATE'` ou `'PROCESS'`. Si vous spécifiez `IMMEDIATE`, cela a le même effet que d'exécuter l'instruction suivante : ALTER SYSTEM KILL SESSION 'sid,serial#' IMMEDIATE
Si vous spécifiez `PROCESS`, vous résiliez les processus associés à une séance. Spécifiez `PROCESS` uniquement si la résiliation de la session à l'aide de `IMMEDIATE`n'a pas abouti. |
Pour obtenir l'identifiant et le numéro de série de la session, interrogez la vue `V$SESSION`. L'exemple suivant obtient toutes les sessions pour l'utilisateur *AWSUSER*.
```
SELECT SID, SERIAL#, STATUS FROM V$SESSION WHERE USERNAME = 'AWSUSER';
```
L'exemple suivant met fin à une session.
```
BEGIN
rdsadmin.rdsadmin_util.kill(
sid => sid,
serial => serial_number,
method => 'IMMEDIATE');
END;
/
```
L'exemple suivant résilie les processus associés à une séance.
```
BEGIN
rdsadmin.rdsadmin_util.kill(
sid => sid,
serial => serial_number,
method => 'PROCESS');
END;
/
```
# Annulation d'une instruction SQL dans une session
Pour annuler une instruction SQL dans une session, utilisez la procédure Amazon RDS `rdsadmin.rdsadmin_util.cancel`.
**Note**
Cette procédure est prise en charge pour Oracle Database 19c (19.0.0) et toutes les versions majeures et mineures ultérieures de RDS for Oracle.
La procédure `cancel` possède les paramètres suivants.
****
| Nom du paramètre | Type de données | Par défaut | Obligatoire | Description |
| --- | --- | --- | --- | --- |
| `sid` | nombre | — | Oui | Identifiant de session. |
| `serial` | nombre | — | Oui | Numéro de série de la session. |
| `sql_id` | varchar2 | null | Non | Identifiant SQL de l'instruction SQL. |
L'exemple suivant annuler une instruction SQL dans une session.
```
begin
rdsadmin.rdsadmin_util.cancel(
sid => sid,
serial => serial_number,
sql_id => sql_id);
end;
/
```
Pour obtenir l'identifiant et le numéro de série de la session ainsi que l'identifiant SQL d'une instruction SQL, interrogez la vue `V$SESSION`. L'exemple suivant obtient toutes les sessions et les identifiants SQL pour l'utilisateur `AWSUSER`.
```
select SID, SERIAL#, SQL_ID, STATUS from V$SESSION where USERNAME = 'AWSUSER';
```
# Activation et désactivation de sessions restreintes
Pour activer et désactiver des sessions restreintes, utilisez la procédure Amazon RDS `rdsadmin.rdsadmin_util.restricted_session`. La procédure `restricted_session` possède les paramètres suivants.
****
| Nom du paramètre | Type de données | Par défaut | Oui | Description |
| --- | --- | --- | --- | --- |
| `p_enable` | booléen | true | Non | Définissez ce paramètre sur `true` pour activer les sessions restreintes ou sur `false` pour les désactiver. |
L'exemple suivant montre comment activer et désactiver les sessions restreintes.
```
/* 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
```
# Vidage du pool partagé
Pour vider le pool partagé, utilisez la procédure Amazon RDS `rdsadmin.rdsadmin_util.flush_shared_pool`. La procédure `flush_shared_pool` ne comporte aucun paramètre.
L'exemple suivant vide le pool partagé.
```
EXEC rdsadmin.rdsadmin_util.flush_shared_pool;
```
## Vidage du cache de tampon
Pour vider le cache de tampon, utilisez la procédure Amazon RDS `rdsadmin.rdsadmin_util.flush_buffer_cache`. La procédure `flush_buffer_cache` ne comporte aucun paramètre.
L'exemple suivant vide le cache des tampons.
```
EXEC rdsadmin.rdsadmin_util.flush_buffer_cache;
```
## Vider le cache Smart Flash de la base de données
Pour vider le cache Smart Flash de la base de données, utilisez la procédure Amazon RDS `rdsadmin.rdsadmin_util.flush_flash_cache`. La procédure `flush_flash_cache` ne comporte aucun paramètre. L'exemple suivant vide le cache Smart Flash de la base de données.
```
EXEC rdsadmin.rdsadmin_util.flush_flash_cache;
```
Pour plus d'informations sur l'utilisation du cache Smart Flash de la base de données avec RDS for Oracle, consultez [Stockage de données temporaires dans un stockage d'instances RDS for Oracle](CHAP_Oracle.advanced-features.instance-store.md).
# Octroi des privilèges SELECT ou EXECUTE aux objets SYS
Généralement, vous transférez les privilèges en utilisant des rôles, qui peuvent contenir de nombreux objets. Pour accorder des privilèges à un objet unique, utilisez la procédure Amazon RDS `rdsadmin.rdsadmin_util.grant_sys_object`. La procédure accorde uniquement les privilèges qui ont déjà été accordés à l'utilisateur principal par le biais d'un rôle ou d'une attribution directe.
La procédure `grant_sys_object` possède les paramètres suivants.
**Important**
Pour toutes les valeurs de paramètre, utilisez les majuscules sauf si vous avez créé l'utilisateur avec un identifiant sensible à la casse. Par exemple, si vous exécutez `CREATE USER myuser` ou `CREATE USER MYUSER`, le dictionnaire de données stocke `MYUSER`. Toutefois, si vous utilisez des guillemets doubles dans `CREATE USER "MyUser"`, le dictionnaire de données stocke `MyUser`.
****
| Nom du paramètre | Type de données | Par défaut | Obligatoire | Description |
| --- | --- | --- | --- | --- |
| `p_obj_name` | varchar2 | — | Oui | Nom de l'objet pour lequel des privilèges seront accordés. L'objet peut être un répertoire, une fonction, un package, une procédure, une séquence, une table ou une vue. Les noms d'objet doivent être orthographiés correctement lorsqu'ils apparaissent dans `DBA_OBJECTS`. La plupart des objets système sont définis en majuscules, si bien que nous vous recommandons d'essayer cela en premier lieu. |
| `p_grantee` | varchar2 | — | Oui | Nom de l'objet auquel des privilèges seront accordés. L'objet peut être un schéma ou un rôle. |
| `p_privilege` | varchar2 | null | Oui | — |
| `p_grant_option` | booléen | false | Non | Définissez ce paramètre sur `true` pour l'utiliser avec l'option d'attribution. |
L'exemple suivant accorde des privilèges select sur un objet nommé `V_$SESSION` à un utilisateur nommé `USER1`.
```
begin
rdsadmin.rdsadmin_util.grant_sys_object(
p_obj_name => 'V_$SESSION',
p_grantee => 'USER1',
p_privilege => 'SELECT');
end;
/
```
L'exemple suivant accorde des privilèges select sur un objet nommé `V_$SESSION` à un utilisateur nommé `USER1` avec l'option d'attribution.
```
begin
rdsadmin.rdsadmin_util.grant_sys_object(
p_obj_name => 'V_$SESSION',
p_grantee => 'USER1',
p_privilege => 'SELECT',
p_grant_option => true);
end;
/
```
Pour pouvoir attribuer des privilèges sur un objet, votre compte doit avoir ces privilèges directement attribués avec l'option appropriée ou via un rôle accordé avec `with admin option`. Le plus souvent, vous voudrez attribuer `SELECT` sur une vue DBA qui a été attribuée au rôle `SELECT_CATALOG_ROLE`. Si ce rôle n'est pas déjà directement attribué à votre utilisateur avec `with admin option`, vous ne pouvez pas transférer le privilège. Si vous disposez du privilège DBA, vous pouvez accorder le rôle directement à un autre utilisateur.
L'exemple suivant accorde les rôles `SELECT_CATALOG_ROLE` et `EXECUTE_CATALOG_ROLE` à `USER1`. Étant donné que `with admin option` est utilisé, `USER1` peut désormais accorder l'accès aux objets SYS qui ont été attribués à `SELECT_CATALOG_ROLE`.
```
GRANT SELECT_CATALOG_ROLE TO USER1 WITH ADMIN OPTION;
GRANT EXECUTE_CATALOG_ROLE to USER1 WITH ADMIN OPTION;
```
Les objets déjà attribués à `PUBLIC` n'ont pas besoin d'être réattribués. Si vous utilisez la procédure `grant_sys_object` pour accorder de nouveau l'accès, l'appel de procédure réussit.
# Retrait des privilèges SELECT ou EXECUTE sur les objets SYS
Pour retirer des privilèges sur un objet unique, utilisez la procédure Amazon RDS `rdsadmin.rdsadmin_util.revoke_sys_object`. La procédure révoque uniquement les privilèges qui ont déjà été accordés au compte principal par le biais d'un rôle ou d'une attribution directe.
La procédure `revoke_sys_object` possède les paramètres suivants.
****
| Nom du paramètre | Type de données | Par défaut | Obligatoire | Description |
| --- | --- | --- | --- | --- |
| `p_obj_name` | varchar2 | — | Oui | Nom de l'objet pour lequel des privilèges seront révoqués. L'objet peut être un répertoire, une fonction, un package, une procédure, une séquence, une table ou une vue. Les noms d'objet doivent être orthographiés correctement lorsqu'ils apparaissent dans `DBA_OBJECTS`. La plupart des objets système sont définis en majuscules, c'est pourquoi nous vous recommandons d'essayer cette méthode en premier lieu. |
| `p_revokee` | varchar2 | — | Oui | Nom de l'objet pour lequel des privilèges seront révoqués. L'objet peut être un schéma ou un rôle. |
| `p_privilege` | varchar2 | null | Oui | — |
L'exemple suivant révoque des privilèges select sur un objet nommé `V_$SESSION` à un utilisateur nommé `USER1`.
```
begin
rdsadmin.rdsadmin_util.revoke_sys_object(
p_obj_name => 'V_$SESSION',
p_revokee => 'USER1',
p_privilege => 'SELECT');
end;
/
```
# Gestion des vues RDS\$1X\$1 pour les instances de base de données Oracle
Vous devrez peut-être accéder à des tables `SYS.X$` fixes, qui ne sont accessibles que par `SYS`. Pour créer des vues `SYS.RDS_X$` sur les tables `X$` éligibles, utilisez les procédures du package `rdsadmin.rdsadmin_util`. Votre utilisateur principal se voit automatiquement octroyer le privilège `SELECT … WITH GRANT OPTION` sur les vues `RDS_X$`.
Les procédures `rdsadmin.rdsadmin_util` sont disponibles dans les cas suivants :
+ Les instances de base de données existantes qui n’ont jamais été mises à niveau et qui utilisent les versions suivantes :
+ `21.0.0.0.ru-2023-10.rur-2023-10.r1` versions 21c et ultérieures
+ `19.0.0.0.ru-2023-10.rur-2023-10.r1` versions 19c et ultérieures
+ Toute nouvelle instance de base de données que vous créez
+ Toute instance de base de données existante que vous avez mise à niveau
**Important**
En interne, le package `rdsadmin.rdsadmin_util` crée des vues sur les tables `X$`. Les tables `X$` sont des objets système internes qui ne sont pas décrits dans la documentation Oracle Database. Nous vous recommandons de tester des vues spécifiques dans votre base de données hors production, et de ne créer des vues dans votre base de données de production que sous la direction du support Oracle.
## Liste des tables fixes X\$1 pouvant être utilisées dans les vues RDS\$1X\$1
Pour répertorier les tables X\$1 pouvant être utilisées dans les vues `RDS_X$`, utilisez la procédure RDS `rdsadmin.rdsadmin_util.list_allowed_sys_x$_views`. Cette procédure n'accepte aucun paramètre. Les déclarations suivantes répertorient toutes les tables `X$` éligibles (échantillon de sortie inclus).
```
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'
```
La liste des tables `X$` éligibles peut changer au fil du temps. Pour vous assurer que votre liste de tables fixes `X$` éligibles est à jour, réexécutez `list_allowed_sys_x$_views` régulièrement.
## Création de vues SYS.RDS\$1X\$1
Pour créer une vue `RDS_X$` sur une table `X$` éligible, utilisez la procédure RDS `rdsadmin.rdsadmin_util.create_sys_x$_view`. Vous ne pouvez créer des vues que pour les tables répertoriées dans la sortie de `rdsadmin.rdsadmin_util.list_allowed_sys_x$_views`. La procédure `create_sys_x$_view` accepte les paramètres suivants.
****
| Nom du paramètre | Type de données | Par défaut | Obligatoire | Description |
| --- | --- | --- | --- | --- |
| `p_x$_tbl` | varchar2 | Null | Oui | Nom d’espace de table `X$` valide. La valeur doit correspondre à l’une des tables `X$` signalées par `list_allowed_sys_x$_views`. |
| `p_force_creation` | Booléen | FALSE | Non | Une valeur indiquant s’il faut forcer la création d’une vue `RDS_X$` qui existe déjà pour une table `X$`. Par défaut, RDS ne crée pas de vue si elle existe déjà. Pour forcer la création, définissez ce paramètre sur`TRUE`. |
L’exemple suivant crée une vue `SYS.RDS_X$KGLOB` à partir de la table `X$KGLOB`. Le format du nom de vue est `RDS_X$tablename`.
```
SQL> SET SERVEROUTPUT ON
SQL> EXEC rdsadmin.rdsadmin_util.create_sys_x$_view('X$KGLOB');
PL/SQL procedure successfully completed.
```
La requête de dictionnaire de données suivante répertorie la vue `SYS.RDS_X$KGLOB` et indique son état. Votre utilisateur principal se voit automatiquement octroyer le privilège `SELECT ... WITH GRANT OPTION` sur cette vue.
```
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
```
**Important**
Il n’est pas garanti que les tables `X$` resteront les mêmes avant et après une mise à niveau. RDS for Oracle supprime et recrée les vues `RDS_X$` sur les tables `X$` lors d’une mise à niveau du moteur. Il accorde ensuite le privilège `SELECT ... WITH GRANT OPTION` à l’utilisateur principal. Après une mise à niveau, accordez des privilèges aux utilisateurs de la base de données selon les besoins sur les vues `RDS_X$` correspondantes.
## Création d’une liste de vues SYS.RDS\$1X\$1
Pour répertorier les vues `RDS_X$` existantes, utilisez la procédure RDS `rdsadmin.rdsadmin_util.list_created_sys_x$_views`. La procédure répertorie uniquement les vues créées par la procédure `create_sys_x$_view`. L’exemple suivant répertorie les tables `X$` associées aux vues `RDS_X$` correspondantes (exemple de sortie inclus).
```
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.
```
## Suppression des vues RDS\$1X\$1
Pour supprimer une vue `SYS.RDS_X$`, utilisez la procédure RDS `rdsadmin.rdsadmin_util.drop_sys_x$_view`. Vous ne pouvez supprimer que les événements répertoriés dans la sortie de `rdsadmin.rdsadmin_util.list_allowed_sys_x$_views`. La procédure `drop_sys_x$_view` accepte les paramètres suivants.
****
| Nom du paramètre | Type de données | Par défaut | Obligatoire | Description |
| --- | --- | --- | --- | --- |
| `p_x$_tbl` | varchar2 | Null | Oui | Nom de table fixe `X$` valide. La valeur doit correspondre à l’une des tables fixes `X$` signalées par `list_created_sys_x$_views`. |
L’exemple suivant supprime la vue `RDS_X$KGLOB` créée à partir de la table `X$KGLOB`.
```
SQL> SET SERVEROUTPUT ON
SQL> EXEC rdsadmin.rdsadmin_util.drop_sys_x$_view('X$KGLOB');
PL/SQL procedure successfully completed.
```
L’exemple suivant montre que la vue `SYS.RDS_X$KGLOB` a été supprimée (exemple de sortie inclus).
```
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
```
# Attribution de privilèges à des utilisateurs non-maîtres
Vous pouvez accorder des privilèges select pour de nombreux objets dans le schéma `SYS` grâce au rôle `SELECT_CATALOG_ROLE`. Le rôle `SELECT_CATALOG_ROLE` accorde aux utilisateurs des privilèges `SELECT` sur les vues du dictionnaire de données. L'exemple suivant accorde le rôle `SELECT_CATALOG_ROLE` à un utilisateur nommé `user1`.
```
GRANT SELECT_CATALOG_ROLE TO user1;
```
Vous pouvez accorder des privilèges `EXECUTE` pour de nombreux objets dans le schéma `SYS` grâce au rôle `EXECUTE_CATALOG_ROLE`. Le rôle `EXECUTE_CATALOG_ROLE` accorde aux utilisateurs des privilèges `EXECUTE` pour les packages et les procédures du dictionnaire de données. L'exemple suivant accorde le rôle `EXECUTE_CATALOG_ROLE` à un utilisateur nommé *user1*.
```
GRANT EXECUTE_CATALOG_ROLE TO user1;
```
L'exemple suivant obtient les autorisations permises par les rôles `SELECT_CATALOG_ROLE` et `EXECUTE_CATALOG_ROLE`.
```
SELECT *
FROM ROLE_TAB_PRIVS
WHERE ROLE IN ('SELECT_CATALOG_ROLE','EXECUTE_CATALOG_ROLE')
ORDER BY ROLE, TABLE_NAME ASC;
```
L'exemple suivant crée un utilisateur non maître nommé `user1`, accorde le privilège `CREATE SESSION`, puis accorde le privilège `SELECT` sur une base de données nommée *sh.sales*.
```
CREATE USER user1 IDENTIFIED BY PASSWORD;
GRANT CREATE SESSION TO user1;
GRANT SELECT ON sh.sales TO user1;
```
# Création de fonctions personnalisées pour vérifier les mots de passe
Vous pouvez créer une fonction de vérification de mot de passe personnalisée des manières suivantes :
+ Pour utiliser la logique de vérification standard et stocker votre fonction dans le schéma `SYS`, utilisez la procédure `create_verify_function`.
+ Pour utiliser la logique de vérification personnalisée, ou pour éviter de stocker votre fonction dans le schéma `SYS`, utilisez la procédure `create_passthrough_verify_fcn`.
# Procédure create\$1verify\$1function
Vous pouvez créer une fonction personnalisée pour vérifier les mots de passe en utilisant la procédure Amazon RDS `rdsadmin.rdsadmin_password_verify.create_verify_function`. La procédure `create_verify_function` est prise en charge pour toutes les versions de RDS for Oracle.
La procédure `create_verify_function` possède les paramètres suivants.
****
| Nom du paramètre | Type de données | Par défaut | Obligatoire | Description |
| --- | --- | --- | --- | --- |
| `p_verify_function_name` | varchar2 | — | Oui | Nom de la fonction personnalisée. Cette fonction est automatiquement créée dans le schéma SYS. Elle est affectée à des profils utilisateur. |
| `p_min_length` | nombre | 8 | Non | Nombre minimal de caractères requis. |
| `p_max_length` | nombre | 256 | Non | Nombre maximal de caractères autorisés. |
| `p_min_letters` | nombre | 1 | Non | Nombre minimal de lettres requises. |
| `p_min_uppercase` | nombre | 0 | Non | Nombre minimal de lettres majuscules requises. |
| `p_min_lowercase` | nombre | 0 | Non | Nombre minimal de lettres minuscules requises. |
| `p_min_digits` | nombre | 1 | Non | Nombre minimal de chiffres requis. |
| `p_min_special` | nombre | 0 | Non | Nombre minimal de caractères spéciaux requis. |
| `p_min_different_chars` | nombre | 3 | Non | Nombre minimal de caractères différents requis entre l'ancien et le nouveau mot de passe. |
| `p_disallow_username` | booléen | true | Non | Définissez ce paramètre sur `true` pour interdire le nom d'utilisateur dans le mot de passe. |
| `p_disallow_reverse` | booléen | true | Non | Définissez ce paramètre sur `true` pour interdire le nom d'utilisateur inversé dans le mot de passe. |
| `p_disallow_db_name` | booléen | true | Non | Définissez ce paramètre sur `true` pour interdire le nom de la base de données ou du serveur dans le mot de passe. |
| `p_disallow_simple_strings` | booléen | true | Non | Définissez ce paramètre sur `true` pour interdire l'utilisation de chaînes simples comme mot de passe. |
| `p_disallow_whitespace` | booléen | false | Non | Définissez ce paramètre sur `true` pour interdire les espaces dans le mot de passe. |
| `p_disallow_at_sign` | booléen | false | Non | Définissez ce paramètre sur `true` pour interdire le caractère @ dans le mot de passe. |
Vous pouvez créer plusieurs fonctions de vérification de mot de passe.
Il existe des restrictions sur le nom de votre fonction personnalisée. Votre fonction personnalisée ne peut pas avoir le même nom qu'un objet système existant. Ce nom ne peut pas comporter plus de 30 caractères. De plus, le nom doit inclure l'une des chaînes suivantes : `PASSWORD`, `VERIFY`, `COMPLEXITY`, `ENFORCE` ou `STRENGTH`.
L'exemple suivant crée une fonction nommée `CUSTOM_PASSWORD_FUNCTION`. La fonction exige qu'un mot de passe comporte au moins 12 caractères, 2 majuscules, 1 chiffre et 1 caractère spécial, et interdit le caractère @.
```
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;
/
```
Pour voir le texte de votre fonction de vérification, interrogez `DBA_SOURCE`. L'exemple suivant récupère le texte d'une fonction de mot de passe personnalisé nommée `CUSTOM_PASSWORD_FUNCTION`.
```
COL TEXT FORMAT a150
SELECT TEXT
FROM DBA_SOURCE
WHERE OWNER = 'SYS'
AND NAME = 'CUSTOM_PASSWORD_FUNCTION'
ORDER BY LINE;
```
Pour associer votre fonction de vérification à un profil utilisateur, utilisez `ALTER PROFILE`. L'exemple suivant associe une PL/SQL fonction de vérification nommée `CUSTOM_PASSWORD_FUNCTION` au profil `DEFAULT` utilisateur. `PASSWORD_VERIFY_FUNCTION`est le nom de la ressource du profil Oracle.
```
ALTER PROFILE DEFAULT LIMIT PASSWORD_VERIFY_FUNCTION CUSTOM_PASSWORD_FUNCTION;
```
Pour voir quels profils utilisateur sont associés à quelles fonctions de vérification, effectuez une requête`DBA_PROFILES`. L'exemple suivant obtient les profils qui sont associés à la fonction de vérification personnalisée nommée `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
```
L'exemple suivant récupère tous les profils et les fonctions de vérification de mot de passe associées.
```
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
```
# Procédure create\$1passthrough\$1verify\$1fcn
La procédure `create_passthrough_verify_fcn` est prise en charge pour toutes les versions de RDS for Oracle.
Vous pouvez créer une fonction personnalisée pour vérifier les mots de passe en utilisant la procédure Amazon RDS `rdsadmin.rdsadmin_password_verify.create_passthrough_verify_fcn`. La procédure `create_passthrough_verify_fcn` possède les paramètres suivants.
****
| Nom du paramètre | Type de données | Par défaut | Obligatoire | Description |
| --- | --- | --- | --- | --- |
| `p_verify_function_name` | varchar2 | — | Oui | Nom de la fonction de vérification personnalisée. Il s'agit d'une fonction de wrapper qui est automatiquement créée dans le schéma SYS et qui ne contient pas de logique de vérification. Elle est affectée à des profils utilisateur. |
| `p_target_owner` | varchar2 | — | Oui | Propriétaire de schéma de la fonction de vérification personnalisée. |
| `p_target_function_name` | varchar2 | — | Oui | Nom de la fonction personnalisée existante qui contient la logique de vérification. Votre fonction personnalisée doit renvoyer une valeur booléenne. La fonction doit renvoyer la valeur `true` si le mot de passe est valide, ou `false` s'il ne l'est pas. |
L'exemple suivant crée une fonction de vérification de mot de passe qui utilise la logique provenant de la fonction nommée `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;
/
```
Pour associer la fonction de vérification à un profil utilisateur, utilisez `alter profile`. L'exemple suivant associe la fonction de vérification au profil utilisateur `DEFAULT`.
```
ALTER PROFILE DEFAULT LIMIT PASSWORD_VERIFY_FUNCTION CUSTOM_PASSWORD_FUNCTION;
```
## Configuration d'un serveur DNS personnalisé
Amazon RDS prend en charge l'accès réseau sortant sur vos instances de bases de données exécutant Oracle. Pour plus d'informations sur l'utilisation de l'accès réseau sortant et les prérequis, consultez [Configuration de l'accès UTL\$1HTTP à l'aide de certificats et d'un portefeuille Oracle](Oracle.Concepts.ONA.md).
Amazon RDS Oracle permet la résolution DNS (Domain Name Service) à partir d'un serveur DNS personnalisé appartenant au client. Vous pouvez résoudre uniquement les deux noms de domaine complets à partir de votre instance de base de données Amazon RDS via votre serveur DNS personnalisé.
Une fois que votre serveur de nom DNS personnalisé est configuré, la propagation des modifications dans votre instance de base de données peut prendre jusqu'à 30 minutes. Une fois que les modifications sont propagées dans votre instance de base de données, l'ensemble du trafic réseau sortant nécessitant une recherche DNS interroge votre serveur DNS via le port 53.
Pour configurer un serveur DNS personnalisé pour votre instance de base de données Amazon RDS for Oracle, procédez comme suit :
+ À partir du jeu d'options DHCP liées à votre VPC (cloud privé virtuel), définissez l'option `domain-name-servers` sur l'adresse IP de votre serveur de noms DNS. Pour plus d’informations, consultez [Jeux d’options DHCP](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_DHCP_Options.html).
**Note**
L'option `domain-name-servers` autorise jusqu'à quatre valeurs, mais votre instance de base de données Amazon RDS utilise uniquement la première valeur.
+ Assurez-vous que votre serveur DNS peut résoudre toutes les requêtes de recherche, notamment les noms DNS publics, les noms DNS privés Amazon EC2 et les noms DNS spécifiés par le client. Si le trafic réseau sortant contient une recherche DNS que votre serveur DNS ne peut pas gérer, votre serveur DNS doit avoir des fournisseurs DNS en amont appropriés, configurés.
+ Configurez votre serveur DNS pour produire des réponses UDP (User Datagram Protocol) de 512 octets ou moins.
+ Configurez votre serveur DNS pour produire des réponses TCP (Transmission Control Protocol) de 1024 octets ou moins.
+ Configurez votre serveur DNS pour permettre le trafic entrant à partir de vos instances de bases de données Amazon RDS sur le port 53. Si votre serveur DNS est dans un Amazon VPC, le VPC doit avoir un groupe de sécurité qui contient des règles entrantes permettant le trafic UDP et TCP sur le port 53. Si votre serveur DNS n'est pas dans un Amazon VPC, il doit avoir une liste blanche des pare-feux appropriés pour permettre le trafic UDP et TCP sur le port 53.
Pour plus d'informations, veuillez consulter [Groupes de sécurité pour votre VPC](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html) et [Ajout et suppression de règles](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html#AddRemoveRules).
+ Configurez le VPC de votre instance de base de données Amazon RDS for permettre le trafic sortant via le port 53. Votre serveur VPC doit avoir un groupe de sécurité qui contient des règles sortantes permettant le trafic UDP et TCP sur le port 53.
Pour plus d'informations, veuillez consulter [Groupes de sécurité pour votre VPC](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html) et [Ajout et suppression de règles](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html#AddRemoveRules).
+ Le chemin d'acheminement entre l'instance de base de données Amazon RDS et le serveur DNS doit être configuré correctement pour permettre un trafic DNS.
+ Si l'instance de base de données Amazon RDS et le serveur DNS ne sont pas dans le même VPC, une connexion d'appairage doit être configurée entre les deux. Pour plus d’informations, consultez [Qu’est-ce que l’appairage de VPC ?](https://docs.aws.amazon.com/vpc/latest/peering/Welcome.html)
# Activation et désactivation des événements de diagnostic système
Pour activer et désactiver les événements de diagnostic au niveau session, vous pouvez utiliser l'instruction Oracle SQL `ALTER SESSION SET EVENTS`. En revanche, pour activer les événements au niveau système, vous ne pouvez pas utiliser Oracle SQL. Pour cela, utilisez les procédures d'événements système du package `rdsadmin.rdsadmin_util`. Les procédures d'événements système sont disponibles dans les versions suivantes du moteur :
+ Toutes les versions de Oracle Database 21c
+ 19.0.0.0.ru-2020-10.rur-2020-10.r1 et versions ultérieures de Oracle Database 19c
Pour plus d’informations, consultez [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) dans *Notes de mise à jour d’Amazon RDS for Oracle*.
**Important**
En interne, le package `rdsadmin.rdsadmin_util` active les événements à l'aide de l'instruction `ALTER SYSTEM SET EVENTS`. Cette instruction `ALTER SYSTEM` ne figure pas dans la documentation Oracle Database. Certains événements de diagnostic système peuvent générer de grandes quantités d'informations de suivi, provoquer des conflits ou affecter la disponibilité de la base de données. Nous vous recommandons de tester des événements de diagnostic spécifiques dans votre base de données hors production, et de n'activer des événements dans votre base de données de production que sous la direction du support Oracle.
## Liste des événements de diagnostic système autorisés
Pour dresser la liste des événements système que vous pouvez activer, utilisez la procédure Amazon RDS `rdsadmin.rdsadmin_util.list_allowed_system_events`. Cette procédure n'accepte aucun paramètre.
L'exemple suivant répertorie tous les événements système que vous pouvez activer.
```
SET SERVEROUTPUT ON
EXEC rdsadmin.rdsadmin_util.list_allowed_system_events;
```
L'exemple de sortie suivant répertorie les numéros des événements et leur description. Utilisez les procédures Amazon RDS `set_system_event` pour activer ces événements et `unset_system_event` pour les désactiver.
```
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:
```
**Note**
La liste des événements système autorisés peut changer au fil du temps. Pour vous assurer que vous disposez de la liste la plus récente des événements éligibles, utilisez `rdsadmin.rdsadmin_util.list_allowed_system_events`.
## Activation des événements de diagnostic système
Pour activer un événement système, utilisez la procédure Amazon RDS `rdsadmin.rdsadmin_util.set_system_event`. Vous ne pouvez activer que les événements répertoriés dans la sortie de `rdsadmin.rdsadmin_util.list_allowed_system_events`. La procédure `set_system_event` accepte les paramètres suivants.
****
| Nom du paramètre | Type de données | Par défaut | Obligatoire | Description |
| --- | --- | --- | --- | --- |
| `p_event` | nombre | — | Oui | Numéro de l'événement système. La valeur doit correspondre à l'un des numéros d'événement signalés par `list_allowed_system_events`. |
| `p_level` | nombre | — | Oui | Niveau de l'événement. Pour obtenir les descriptions des différentes valeurs de niveau, consultez la documentation Oracle Database ou contactez le support Oracle. |
La procédure `set_system_event` permet de créer et d'exécuter les instructions `ALTER SYSTEM SET EVENTS` requises selon les principes suivants :
+ Le type d'événement (`context` ou `errorstack`) est déterminé automatiquement.
+ Une instruction du formulaire `ALTER SYSTEM SET EVENTS 'event LEVEL event_level'` active les événements de contexte. Cette notation équivaut à `ALTER SYSTEM SET EVENTS 'event TRACE NAME CONTEXT FOREVER, LEVEL event_level'`.
+ Une instruction du formulaire `ALTER SYSTEM SET EVENTS 'event ERRORSTACK (event_level)'` active les événements de pile d'erreurs. Cette notation équivaut à `ALTER SYSTEM SET EVENTS 'event TRACE NAME ERRORSTACK LEVEL event_level'`.
L'exemple suivant active l'événement 942 au niveau 3, et l'événement 10442 au niveau 10. Un exemple de sortie est inclus.
```
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.
```
## Liste des événements de diagnostic système activés
Pour dresser la liste des événements système activés, utilisez la procédure Amazon RDS `rdsadmin.rdsadmin_util.list_set_system_events`. Cette procédure signale uniquement les événements activés au niveau système par `set_system_event`.
L'exemple suivant répertorie les événements système actifs.
```
SET SERVEROUTPUT ON
EXEC rdsadmin.rdsadmin_util.list_set_system_events;
```
L'exemple de sortie suivant contient la liste des événements, le type d'événement, le niveau auquel les événements sont activés et l'heure à laquelle ils ont été activés.
```
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.
```
## Désactivation des événements de diagnostic système
Pour désactiver un événement système, utilisez la procédure Amazon RDS `rdsadmin.rdsadmin_util.unset_system_event`. Vous ne pouvez désactiver que les événements répertoriés dans la sortie de `rdsadmin.rdsadmin_util.list_allowed_system_events`. La procédure `unset_system_event` accepte les paramètres suivants.
****
| Nom du paramètre | Type de données | Par défaut | Obligatoire | Description |
| --- | --- | --- | --- | --- |
| `p_event` | nombre | — | Oui | Numéro de l'événement système. La valeur doit correspondre à l'un des numéros d'événement signalés par `list_allowed_system_events`. |
L'exemple suivant désactive les événements 942 et 10442. Un exemple de sortie est inclus.
```
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.
```
# Exécution des tâches de base de données courantes pour les instances de base de données Oracle
Vous trouverez ci-dessous des informations sur la façon d'effectuer certaines tâches DBA courantes liées aux bases de données sur vos instances de base de données Amazon RDS exécutant Oracle. Pour offrir une expérience de service géré, Amazon RDS ne fournit pas l'accès shell aux instances de base de données. Amazon RDS restreint également l'accès à certaines procédures système et tables qui requièrent des privilèges avancés.
**Topics**
+ [Modification du nom global d'une base de données](Appendix.Oracle.CommonDBATasks.RenamingGlobalName.md)
+ [Utilisation des tablespaces dans RDS pour Oracle](Appendix.Oracle.CommonDBATasks.TablespacesAndDatafiles.md)
+ [Utilisation de fichiers temporaires dans RDS pour Oracle](Appendix.Oracle.CommonDBATasks.using-tempfiles.md)
+ [Redimensionnement des espaces disque logiques, des fichiers de données et des fichiers temporaires dans RDS pour Oracle](Appendix.Oracle.CommonDBATasks.ResizeTempSpaceReadReplica.md)
+ [Déplacement de données entre volumes de stockage dans RDS pour Oracle](Appendix.Oracle.CommonDBATasks.MovingDataBetweenVolumes.md)
+ [Utilisation de tables externes dans RDS pour Oracle](Appendix.Oracle.CommonDBATasks.External_Tables.md)
# Modification du nom global d'une base de données
Pour modifier le nom global d'une base de données, utilisez la procédure Amazon RDS `rdsadmin.rdsadmin_util.rename_global_name`. La procédure `rename_global_name` possède les paramètres suivants.
****
| Nom du paramètre | Type de données | Par défaut | Obligatoire | Description |
| --- | --- | --- | --- | --- |
| `p_new_global_name` | varchar2 | — | Oui | Nouveau nom global de la base de données. |
La base de données doit être ouverte pour que la modification du nom puisse se produire. Pour plus d'informations sur la modification du nom global d'une base de données, consultez [ALTER DATABASE](http://docs.oracle.com/cd/E11882_01/server.112/e41084/statements_1004.htm#SQLRF52547) dans la documentation Oracle.
L'exemple suivant remplace le nom global de la base de données par `new_global_name`.
```
EXEC rdsadmin.rdsadmin_util.rename_global_name(p_new_global_name => 'new_global_name');
```
# Utilisation des tablespaces dans RDS pour Oracle
Vous pouvez utiliser des tablespaces avec RDS pour Oracle, qui est une unité de stockage logique qui stocke les données de la base de données.
**Important**
Si votre instance de base de données possède des répliques, nous vous recommandons d'utiliser des paramètres de groupe de paramètres plutôt que des modifications au niveau de la session pour gérer les emplacements de fichiers par défaut. Les modifications apportées au niveau de la session aux emplacements de fichiers par défaut dans l'instance principale ne sont pas automatiquement reflétées dans les répliques. L'utilisation de paramètres de groupes de paramètres garantit la cohérence de l'emplacement des fichiers entre vos instances principales et répliquées.
**Topics**
+ [Spécification de l'emplacement des fichiers de base de données dans RDS pour Oracle](#Appendix.Oracle.CommonDBATasks.DatabaseFileLocations)
+ [Création et dimensionnement de tablespaces dans RDS pour Oracle](#Appendix.Oracle.CommonDBATasks.CreatingTablespacesAndDatafiles)
+ [Création de tablespaces sur des volumes de stockage supplémentaires dans RDS pour Oracle](#Appendix.Oracle.CommonDBATasks.CreatingTablespacesWithFileLocations)
+ [Définition du tablespace par défaut dans RDS pour Oracle](#Appendix.Oracle.CommonDBATasks.SettingDefaultTablespace)
+ [Définition du tablespace temporaire par défaut dans RDS pour Oracle](#Appendix.Oracle.CommonDBATasks.SettingDefTempTablespace)
+ [Création d'un espace de table temporaire sur le stockage d'instances](#Appendix.Oracle.CommonDBATasks.creating-tts-instance-store)
## Spécification de l'emplacement des fichiers de base de données dans RDS pour Oracle
RDS pour Oracle utilise Oracle Managed Files (OMF) pour nommer les fichiers de base de données. Lorsque vous créez des fichiers de base de données, la base de données détermine le paramètre en fonction du réglage actuel du paramètre d'`DB_CREATE_FILE_DEST`initialisation.
La valeur par défaut du paramètre d'`DB_CREATE_FILE_DEST`initialisation est `/rdsdbdata/db` pour les bases de données autonomes et `/rdsdbdata/db/pdb` pour l'architecture conteneurisée (CDB/MT). Si votre instance de base de données possède des volumes de stockage supplémentaires, vous pouvez `DB_CREATE_FILE_DEST` définir l'emplacement de vos volumes. Par exemple, si un volume est monté sur votre instance`/rdsdbdata/db`, vous pouvez `DB_CREATE_FILE_DEST` définir cette valeur.
Vous pouvez modifier le `DB_CREATE_FILE_DEST` paramètre au niveau de la session ou au niveau de l'instance de base de données Oracle.
### Modification de DB\$1CREATE\$1FILE\$1SET au niveau de l'instance
Pour modifier le paramètre au niveau de l'instance, mettez-le à jour dans le groupe de paramètres attribué à votre instance de base de données et appliquez-le. Pour plus d’informations, consultez [Paramètres d’initialisation RDS for Oracle](Oracle.Concepts.FeatureSupport.Parameters.md) et [Modification de paramètres dans un groupe de paramètres de base de données dans Amazon RDS](USER_WorkingWithParamGroups.Modifying.md).
### Modification de DB\$1CREATE\$1FILE\$1DEST au niveau de la session
Vous pouvez modifier le paramètre au niveau de la session en exécutant une `ALTER SESSION` instruction. Cette approche est utile lorsque vous souhaitez créer des fichiers de base de données dans un emplacement spécifique pour une session donnée sans affecter l'ensemble de l'instance.
L'exemple suivant montre comment vérifier la valeur actuelle du paramètre et la modifier pour la session :
```
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
```
## Création et dimensionnement de tablespaces dans RDS pour Oracle
Lorsque vous créez des tablespaces, la base de données crée les fichiers de données dans le volume de stockage spécifié par le paramètre d'`DB_CREATE_FILE_DEST`initialisation au moment de la création. Par défaut, si vous ne spécifiez pas de taille de fichier de données, les espaces de table sont créés avec `AUTOEXTEND ON` par défaut et sans taille maximum. Dans l'exemple suivant, le tablespace *users1* est autoextensible.
```
CREATE TABLESPACE users1;
```
A cause de ces paramètres par défaut, les espaces de table peuvent se développer pour utiliser l'ensemble du stockage alloué. Nous vous recommandons de spécifier une taille maximum appropriée sur les espaces de table permanents et temporaires, et de surveiller attentivement l'utilisation de l'espace.
L'exemple suivant crée un tablespace nommé *users2* avec une taille initiale de 1 gigaoctet. Puisque la taille du fichier de données est spécifiée, mais pas `AUTOEXTEND ON`, l'espace de tables n'est pas auto-extensible.
```
CREATE TABLESPACE users2 DATAFILE SIZE 1G;
```
L'exemple suivant crée un tablespace nommé *users3* avec une taille initiale de 1 gigaoctet, l'extension automatique activée et une taille maximale de 10 gigaoctets.
```
CREATE TABLESPACE users3 DATAFILE SIZE 1G AUTOEXTEND ON MAXSIZE 10G;
```
L'exemple suivant crée un tablespace temporaire nommé. *temp01*
```
CREATE TEMPORARY TABLESPACE temp01;
```
Vous pouvez redimensionner un espace de table bigfile en utilisant `ALTER TABLESPACE`. Vous pouvez spécifier la taille en kilo-octets (Ko), mégaoctets (Mo), gigaoctets (Go) ou téraoctets (To). L'exemple suivant redimensionne un espace de table bigfile nommé *users\$1bf* pour qu'il fasse 200 Mo.
```
ALTER TABLESPACE users_bf RESIZE 200M;
```
L'exemple suivant ajoute un fichier de données supplémentaire à un tablespace de type smallfile nommé. *users\$1sf*
```
ALTER TABLESPACE users_sf ADD DATAFILE SIZE 100000M AUTOEXTEND ON NEXT 250m MAXSIZE UNLIMITED;
```
## Création de tablespaces sur des volumes de stockage supplémentaires dans RDS pour Oracle
Pour créer un espace disque logique sur un volume de stockage supplémentaire, modifiez le `DB_CREATE_FILE_DEST` paramètre en fonction de l'emplacement du volume. L'exemple suivant définit l'emplacement du fichier sur`/rdsdbdata2/db`.
```
ALTER SESSION SET db_create_file_dest = '/rdsdbdata2/db';
Session altered.
```
Dans l'exemple suivant, vous créez un tablespace sur le volume supplémentaire. `/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
```
Pour créer un espace disque logique de petite taille et répartir ses fichiers de données sur différents volumes de stockage, ajoutez des fichiers de données au tablespace après l'avoir créé. Dans l'exemple suivant, vous créez un tablespace avec les fichiers de données à l'emplacement par défaut de. `/rdsdbdata/db` Vous définissez ensuite la destination par défaut sur`/rdsdbdata/db2`. Lorsque vous ajoutez un fichier de données au tablespace que vous venez de créer, la base de données stocke le fichier dans. `/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
```
## Définition du tablespace par défaut dans RDS pour Oracle
Pour définir l'espace de table par défaut, utilisez la procédure Amazon RDS `rdsadmin.rdsadmin_util.alter_default_tablespace`. La procédure `alter_default_tablespace` possède les paramètres suivants.
****
| Nom du paramètre | Type de données | Par défaut | Obligatoire | Description |
| --- | --- | --- | --- | --- |
| `tablespace_name` | varchar | — | Oui | Nom de l'espace de table par défaut. |
L'exemple suivant définit le tablespace par défaut sur : *users2*
```
EXEC rdsadmin.rdsadmin_util.alter_default_tablespace(tablespace_name => 'users2');
```
## Définition du tablespace temporaire par défaut dans RDS pour Oracle
Pour définir l'espace de table temporaire par défaut, utilisez la procédure Amazon RDS `rdsadmin.rdsadmin_util.alter_default_temp_tablespace`. La procédure `alter_default_temp_tablespace` possède les paramètres suivants.
****
| Nom du paramètre | Type de données | Par défaut | Obligatoire | Description |
| --- | --- | --- | --- | --- |
| `tablespace_name` | varchar | — | Oui | Nom de l'espace de table temporaire par défaut. |
L'exemple suivant définit le tablespace temporaire par défaut sur. *temp01*
```
EXEC rdsadmin.rdsadmin_util.alter_default_temp_tablespace(tablespace_name => 'temp01');
```
## Création d'un espace de table temporaire sur le stockage d'instances
Pour créer un espace de table temporaire sur le stockage d'instances, utilisez la procédure Amazon RDS `rdsadmin.rdsadmin_util.create_inst_store_tmp_tblspace`. La procédure `create_inst_store_tmp_tblspace` possède les paramètres suivants.
****
| Nom du paramètre | Type de données | Par défaut | Obligatoire | Description |
| --- | --- | --- | --- | --- |
| `p_tablespace_name` | varchar | — | Oui | Nom de l'espace de table temporaire. |
L'exemple suivant crée le tablespace temporaire *temp01* dans le magasin d'instances.
```
EXEC rdsadmin.rdsadmin_util.create_inst_store_tmp_tblspace(p_tablespace_name => 'temp01');
```
**Important**
Lorsque vous exécutez `rdsadmin_util.create_inst_store_tmp_tblspace`, l'espace de table temporaire nouvellement créé n'est pas automatiquement défini comme l'espace de table temporaire par défaut. Pour le définir comme valeur par défaut, consultez [Définition du tablespace temporaire par défaut dans RDS pour Oracle](#Appendix.Oracle.CommonDBATasks.SettingDefTempTablespace).
Pour de plus amples informations, veuillez consulter [Stockage de données temporaires dans un stockage d'instances RDS for Oracle](CHAP_Oracle.advanced-features.instance-store.md).
# Utilisation de fichiers temporaires dans RDS pour Oracle
## Ajout d'un fichier temporaire au stockage d'instances sur un réplica en lecture
Lorsque vous créez un espace de table temporaire sur une instance de base de données principale, le réplica en lecture ne crée pas de fichiers temporaires. Supposons qu'un espace de table temporaire vide existe sur votre réplica en lecture pour l'une des raisons suivantes :
+ Vous avez déposé un fichier temporaire de l'espace de table sur votre réplica en lecture. Pour de plus amples informations, veuillez consulter [Dépôt de fichiers temporaires sur un réplica en lecture](Appendix.Oracle.CommonDBATasks.dropping-tempfiles-replica.md).
+ Vous avez créé un nouvel espace de table temporaire sur l'instance de base de données principale. Dans ce cas, RDS for Oracle synchronise les métadonnées avec le réplica en lecture.
Vous pouvez ajouter un fichier temporaire à l'espace de table temporaire vide et stocker le fichier temporaire dans le stockage d'instances. Pour créer un fichier temporaire dans le stockage d'instances, utilisez la procédure Amazon RDS `rdsadmin.rdsadmin_util.add_inst_store_tempfile`. Vous pouvez utiliser cette procédure uniquement sur un réplica en lecture. La procédure possède les paramètres suivants.
****
| Nom du paramètre | Type de données | Par défaut | Obligatoire | Description |
| --- | --- | --- | --- | --- |
| `p_tablespace_name` | varchar | — | Oui | Nom de l'espace de table temporaire sur votre réplica en lecture. |
Dans l'exemple suivant, le tablespace temporaire vide *temp01* existe sur votre réplique de lecture. Exécutez la commande suivante pour créer un fichier temporaire pour cet espace de table et le stocker dans le stockage d'instances.
```
EXEC rdsadmin.rdsadmin_util.add_inst_store_tempfile(p_tablespace_name => 'temp01');
```
Pour de plus amples informations, veuillez consulter [Stockage de données temporaires dans un stockage d'instances RDS for Oracle](CHAP_Oracle.advanced-features.instance-store.md).
# Dépôt de fichiers temporaires sur un réplica en lecture
Vous ne pouvez pas créer un espace de table temporaire existant sur un réplica en lecture. Vous pouvez modifier le stockage du fichier temporaire sur un réplica en lecture depuis Amazon EBS vers le stockage d'instances, ou depuis le stockage d'instances vers Amazon EBS. Pour atteindre ces objectifs, procédez comme suit :
1. Déposez les fichiers temporaires actuels dans l'espace de table temporaire du réplica en lecture.
1. Créez de nouveaux fichiers temporaires sur différents stockages.
Pour supprimer les fichiers temporaires, utilisez la procédure Amazon RDS `rdsadmin.rdsadmin_util. drop_replica_tempfiles`. Vous pouvez utiliser cette procédure uniquement sur des réplicas en lecture. La procédure `drop_replica_tempfiles` possède les paramètres suivants.
****
| Nom du paramètre | Type de données | Par défaut | Obligatoire | Description |
| --- | --- | --- | --- | --- |
| `p_tablespace_name` | varchar | — | Oui | Nom de l'espace de table temporaire sur votre réplica en lecture. |
Supposons qu'un tablespace temporaire nommé *temp01* réside dans le magasin d'instances de votre réplique de lecture. Déposez tous les fichiers temporaires dans cet espace de table en exécutant la commande suivante.
```
EXEC rdsadmin.rdsadmin_util.drop_replica_tempfiles(p_tablespace_name => 'temp01');
```
Pour de plus amples informations, veuillez consulter [Stockage de données temporaires dans un stockage d'instances RDS for Oracle](CHAP_Oracle.advanced-features.instance-store.md).
# Redimensionnement des espaces disque logiques, des fichiers de données et des fichiers temporaires dans RDS pour Oracle
Par défaut, les espaces de table Oracle sont créés avec l'option « auto extend » activée et sans aucune restriction de taille maximum. À cause de ces paramètres par défaut, les espaces de table peuvent parfois trop se développer. Nous vous recommandons de spécifier une taille maximum appropriée sur les espaces de table permanents et temporaires, et de surveiller attentivement l'utilisation de l'espace.
## Redimensionnement des espaces de table permanents
Pour redimensionner un espace de table permanent dans une instance de base de données RDS for Oracle, utilisez l'une des procédures Amazon RDS suivantes :
+ `rdsadmin.rdsadmin_util.resize_datafile`
+ `rdsadmin.rdsadmin_util.autoextend_datafile`
La procédure `resize_datafile` possède les paramètres suivants.
****
| Nom du paramètre | Type de données | Par défaut | Obligatoire | Description |
| --- | --- | --- | --- | --- |
| `p_data_file_id` | nombre | — | Oui | L'identifiant du fichier de données à redimensionner. |
| `p_size` | varchar2 | — | Oui | La taille du fichier de données. Spécifiez la taille en octets (par défaut), kilooctets (Ko), mégaoctets (Mo) ou gigaoctets (Go). |
La procédure `autoextend_datafile` possède les paramètres suivants.
****
| Nom du paramètre | Type de données | Par défaut | Obligatoire | Description |
| --- | --- | --- | --- | --- |
| `p_data_file_id` | nombre | — | Oui | L'identifiant du fichier de données à redimensionner. |
| `p_autoextend_state` | varchar2 | — | Oui | L'état de la fonction d'auto-extension. Spécifiez `ON` pour étendre automatiquement le fichier de données et `OFF` pour désactiver l'extension automatique. |
| `p_next` | varchar2 | — | Non | La taille de la prochaine incrémentation du fichier de données. Spécifiez la taille en octets (par défaut), kilooctets (Ko), mégaoctets (Mo) ou gigaoctets (Go). |
| `p_maxsize` | varchar2 | — | Non | L'espace disque maximal autorisé pour l'extension automatique. Spécifiez la taille en octets (par défaut), kilooctets (Ko), mégaoctets (Mo) ou gigaoctets (Go). Vous pouvez spécifier `UNLIMITED` pour supprimer la limite de taille de fichier. |
L'exemple suivant redimensionne le fichier de données 4 à 500 Mo.
```
EXEC rdsadmin.rdsadmin_util.resize_datafile(4,'500M');
```
L'exemple suivant désactive l'option d'auto-extension pour le fichier de données 4. Il active également l'extension automatique pour le fichier de données 5, avec une incrémentation de 128 Mo et aucune taille maximum.
```
EXEC rdsadmin.rdsadmin_util.autoextend_datafile(4,'OFF');
EXEC rdsadmin.rdsadmin_util.autoextend_datafile(5,'ON','128M','UNLIMITED');
```
## Redimensionnement des espaces de table temporaires
Pour redimensionner un espace de table permanent dans une instance de base de données RDS for Oracle, incluant un réplica en lecture, utilisez l'une des procédures Amazon RDS suivantes :
+ `rdsadmin.rdsadmin_util.resize_temp_tablespace`
+ `rdsadmin.rdsadmin_util.resize_tempfile`
+ `rdsadmin.rdsadmin_util.autoextend_tempfile`
La procédure `resize_temp_tablespace` possède les paramètres suivants.
****
| Nom du paramètre | Type de données | Par défaut | Obligatoire | Description |
| --- | --- | --- | --- | --- |
| `p_temp_tablespace_name` | varchar2 | — | Oui | Nom de l'espace de table temporaire à redimensionner. |
| `p_size` | varchar2 | — | Oui | La taille de l'espace de table. Spécifiez la taille en octets (par défaut), kilooctets (Ko), mégaoctets (Mo) ou gigaoctets (Go). |
La procédure `resize_tempfile` possède les paramètres suivants.
****
| Nom du paramètre | Type de données | Par défaut | Obligatoire | Description |
| --- | --- | --- | --- | --- |
| `p_temp_file_id` | nombre | — | Oui | L'identifiant du fichier temporaire à redimensionner. |
| `p_size` | varchar2 | — | Oui | La taille du fichier temporaire. Spécifiez la taille en octets (par défaut), kilooctets (Ko), mégaoctets (Mo) ou gigaoctets (Go). |
La procédure `autoextend_tempfile` possède les paramètres suivants.
****
| Nom du paramètre | Type de données | Par défaut | Obligatoire | Description |
| --- | --- | --- | --- | --- |
| `p_temp_file_id` | nombre | — | Oui | L'identifiant du fichier temporaire à redimensionner. |
| `p_autoextend_state` | varchar2 | — | Oui | L'état de la fonction d'auto-extension. Spécifiez `ON` pour étendre automatiquement le fichier temporaire et `OFF` pour désactiver l'extension automatique. |
| `p_next` | varchar2 | — | Non | La taille de la prochaine incrémentation du fichier temporaire. Spécifiez la taille en octets (par défaut), kilooctets (Ko), mégaoctets (Mo) ou gigaoctets (Go). |
| `p_maxsize` | varchar2 | — | Non | L'espace disque maximal autorisé pour l'extension automatique. Spécifiez la taille en octets (par défaut), kilooctets (Ko), mégaoctets (Mo) ou gigaoctets (Go). Vous pouvez spécifier `UNLIMITED` pour supprimer la limite de taille de fichier. |
Les exemples suivants redimensionnent un espace de table temporaire nommé `TEMP` pour qu'il fasse 4 Go.
```
EXEC rdsadmin.rdsadmin_util.resize_temp_tablespace('TEMP','4G');
```
```
EXEC rdsadmin.rdsadmin_util.resize_temp_tablespace('TEMP','4096000000');
```
L'exemple suivant redimensionne un espace de table temporaire basé sur le fichier temporaire avec l'identifiant de fichier `1` pour qu'il fasse 2 Mo.
```
EXEC rdsadmin.rdsadmin_util.resize_tempfile(1,'2M');
```
L'exemple suivant désactive l'option d'auto-extension pour le fichier temporaire 1. Il définit également la taille maximale d'extension automatique du fichier temporaire 2 à 10 Go, avec une incrémentation de 100 Mo.
```
EXEC rdsadmin.rdsadmin_util.autoextend_tempfile(1,'OFF');
EXEC rdsadmin.rdsadmin_util.autoextend_tempfile(2,'ON','100M','10G');
```
Pour plus d'informations sur les réplicas en lecture pour les instances de base de données Oracle, consultez [Utilisation de réplicas en lecture pour Amazon RDS for Oracle](oracle-read-replicas.md).
# Déplacement de données entre volumes de stockage dans RDS pour Oracle
Vous pouvez déplacer des fichiers de données et des objets de base de données entre vos volumes de stockage principaux et supplémentaires. Avant de déplacer des données, tenez compte des points suivants :
+ Les volumes source et cible doivent disposer d'un espace libre suffisant.
+ Les opérations de déplacement de données consomment I/O sur les deux volumes.
+ Les mouvements de données importants peuvent avoir un impact sur les performances des bases de données.
+ Si vous restaurez un instantané, le déplacement des données entre les volumes de stockage peut être lent s'il est affecté par le chargement différé d'EBS.
**Topics**
+ [Déplacement de fichiers de données entre volumes dans RDS pour Oracle](#Appendix.Oracle.CommonDBATasks.MovingDatafiles)
+ [Déplacement des données de table et des index entre les volumes dans RDS pour Oracle](#Appendix.Oracle.CommonDBATasks.MovingTableData)
+ [Gestion du stockage LOB à l'aide de volumes supplémentaires](#Appendix.Oracle.CommonDBATasks.ManagingLargeLOBStorage)
## Déplacement de fichiers de données entre volumes dans RDS pour Oracle
Pour déplacer des fichiers de données entre des volumes de stockage, utilisez la procédure `rdsadmin.rdsadmin_util.move_datafile` Amazon RDS. Notez les critères suivants :
+ Vous devez utiliser Oracle Enterprise Edition pour exécuter la `move_datafile` procédure.
+ Vous ne pouvez pas déplacer le tablespace `SYSTEM` et. `RDSADMIN`
La procédure `move_datafile` possède les paramètres suivants.
****
| Nom du paramètre | Type de données | Obligatoire | Description |
| --- | --- | --- | --- |
| `p_data_file_id` | nombre | Oui | ID du fichier de données à déplacer. |
| `p_location` | varchar2 | Oui | Volume de stockage vers lequel vous souhaitez déplacer le fichier de données. |
L'exemple suivant déplace un tablespace du volume par défaut `rdsdbdata` vers le volume supplémentaire. `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
```
## Déplacement des données de table et des index entre les volumes dans RDS pour Oracle
Vous pouvez optimiser le stockage des bases de données en créant des tablespaces sur des volumes de stockage supplémentaires. Vous pouvez ensuite déplacer des objets tels que des tables, des index et des partitions vers ces tablespaces à l'aide d'Oracle SQL standard. Cette approche est utile pour optimiser les performances lorsque votre base de données contient des données présentant des modèles d'accès différents. Par exemple, vous pouvez stocker les données opérationnelles fréquemment consultées sur des volumes de stockage à hautes performances tout en transférant les données historiques rarement consultées vers des volumes de stockage moins coûteux.
Dans l'exemple suivant, vous créez un nouveau tablespace sur un volume à hautes performances. `rdsdbdata2` Vous déplacez ensuite une table vers votre volume de stockage supplémentaire pendant que la table est en ligne. Vous déplacez également l'index vers le même volume. Le déplacement de tables et la reconstruction d'index en ligne nécessitent 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;
```
Dans l'exemple suivant, vous créez un tablespace sur un volume à faible coût. Vous déplacez ensuite une partition de table vers votre volume de stockage à faible coût à l'aide d'une opération en ligne.
```
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;
```
Dans l'exemple suivant, vous interrogez les opérations longues des sessions actives.
```
SELECT sid,opname,sofar,totalwork,time_remaining,elapsed_seconds
FROM v$session_longops
WHERE time_remaining > 0;
```
Vous pouvez vérifier l'utilisation de vos tablespaces à l'aide de la requête suivante.
```
SELECT tablespace_name, used_percent
FROM dba_tablespace_usage_metrics
ORDER BY used_percent DESC;
```
## Gestion du stockage LOB à l'aide de volumes supplémentaires
Votre base de données peut contenir des tables contenant des objets BLOB ou CLOB qui consomment beaucoup d'espace de stockage mais sont rarement consultés. Pour optimiser le stockage, vous pouvez déplacer ces segments LOB vers un tablespace sur un volume de stockage supplémentaire.
Dans l'exemple suivant, vous créez un tablespace pour les données LOB sur un volume à faible coût destiné aux données à accès restreint. Vous créez ensuite une table qui stocke les données sur ce 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);
```
# Utilisation de tables externes dans RDS pour Oracle
Les *tables externes Oracle *sont des tables contenant des données ne figurant pas dans la base de données. À la place, les données se trouvent dans des fichiers externes auxquels la base de données peut accéder. L'utilisation de tables externes vous permet d'accéder aux données sans les charger dans la base de données. Pour de plus amples informations sur les tables externes, veuillez consulter [Managing External Tables](http://docs.oracle.com/database/121/ADMIN/tables.htm#ADMIN01507) dans la documentation Oracle.
Avec Amazon RDS, vous pouvez stocker des fichiers de table externe dans des objets de répertoire. Vous pouvez créer un objet de répertoire ou vous pouvez en utiliser un qui est prédéfini dans la base de données Oracle, comme le répertoire DATA\$1PUMP\$1DIR. Pour plus d'informations sur la création d'objets de répertoire, consultez [Création et suppression de répertoires dans l'espace de stockage de données principal](Appendix.Oracle.CommonDBATasks.Misc.md#Appendix.Oracle.CommonDBATasks.NewDirectories). Vous pouvez interroger la vue ALL\$1DIRECTORIES pour répertorier tous les objets de répertoire de votre instance de base de données Amazon RDS Oracle.
**Note**
Les objets de répertoire pointent vers le même espace de stockage de données (volume Amazon EBS) utilisé par votre instance. L'espace utilisé—ainsi que les fichiers de données, journaux redo, d'audit, de suivi et autres—sont déduits du stockage alloué.
Vous pouvez déplacer un fichier de données externes d'une base de données Oracle à une autre à l'aide du package [ DBMS\$1FILE\$1TRANSFER](https://docs.oracle.com/database/121/ARPLS/d_ftran.htm#ARPLS095) ou du package [UTL\$1FILE](https://docs.oracle.com/database/121/ARPLS/u_file.htm#ARPLS069). Le fichier de données externes est déplacé d'un répertoire de la base de données source vers le répertoire spécifié sur la base de données de destination. Pour obtenir des informations sur l'utilisation d'`DBMS_FILE_TRANSFER`, veuillez consulter [Importation à l'aide d'Oracle Data Pump](Oracle.Procedural.Importing.DataPump.md).
Après avoir déplacé le fichier de données externe, celui-ci peut vous permettre de créer une table externe. L'exemple suivant crée une table externe qui utilise le `emp_xt_file1.txt` fichier du DIR1 répertoire USER\$1.
```
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;
```
Supposons que vous souhaitiez déplacer des données se trouvant dans une instance de base de données Amazon RDS Oracle vers un fichier de données externe. Dans ce as, vous pouvez remplir le fichier de données externe en créant une table externe et en sélectionnant les données de la table de la base de données. Par exemple, l'instruction SQL suivante crée la table externe `orders_xt` en interrogeant la table `orders` de la base de données.
```
CREATE TABLE orders_xt
ORGANIZATION EXTERNAL
(
TYPE ORACLE_DATAPUMP
DEFAULT DIRECTORY DATA_PUMP_DIR
LOCATION ('orders_xt.dmp')
)
AS SELECT * FROM orders;
```
Dans cet exemple, les données sont renseignées dans le fichier `orders_xt.dmp` du répertoire DATA\$1PUMP\$1DIR.
# Création d'un point de contrôle de base de données
Pour créer un point de contrôle sur la base de données, utilisez la procédure Amazon RDS `rdsadmin.rdsadmin_util.checkpoint`. La procédure `checkpoint` ne comporte aucun paramètre.
L'exemple suivant crée un point de contrôle sur la base de données.
```
EXEC rdsadmin.rdsadmin_util.checkpoint;
```
# Définition d'une récupération distribuée
Pour définir une récupération distribuée, utilisez les procédures Amazon RDS `rdsadmin.rdsadmin_util.enable_distr_recovery` et `disable_distr_recovery`. Ces procédures ne comportent aucun paramètre.
L'exemple suivant active la récupération distribuée.
```
EXEC rdsadmin.rdsadmin_util.enable_distr_recovery;
```
L'exemple suivant désactive la récupération distribuée.
```
EXEC rdsadmin.rdsadmin_util.disable_distr_recovery;
```
# Définition du fuseau horaire de la base de données
Vous pouvez définir le fuseau horaire de votre base de données Oracle Amazon RDS des manières suivantes :
+ L'option `Timezone`
L'option `Timezone` modifie le fuseau horaire au niveau de l'hôte et impacte toutes les valeurs et colonnes date, telles que `SYSDATE`. Pour plus d'informations, consultez [Fuseau horaire Oracle](Appendix.Oracle.Options.Timezone.md).
+ La procédure Amazon RDS `rdsadmin.rdsadmin_util.alter_db_time_zone`
La procédure `alter_db_time_zone` modifie le fuseau horaire uniquement pour certains types de données, et ne change pas `SYSDATE`. Il existe des restrictions supplémentaires sur la définition du fuseau horaire, répertoriées dans la [documentation Oracle](http://docs.oracle.com/cd/B19306_01/server.102/b14225/ch4datetime.htm#i1006705).
**Note**
Vous pouvez également définir le fuseau horaire par défaut pour Oracle Scheduler. Pour plus d'informations, consultez [Définition du fuseau horaire pour les tâches d'Oracle Scheduler](Appendix.Oracle.CommonDBATasks.Scheduler.md#Appendix.Oracle.CommonDBATasks.Scheduler.TimeZone).
La procédure `alter_db_time_zone` possède les paramètres suivants.
****
| Nom du paramètre | Type de données | Par défaut | Obligatoire | Description |
| --- | --- | --- | --- | --- |
| `p_new_tz` | varchar2 | — | Oui | Nouveau fuseau horaire correspondant à une région nommée ou à un décalage absolu par rapport à l'heure UTC (Coordinated Universal Time). Les décalages valides s'étendent de -12h00 à \$114h00. |
L'exemple suivant remplace le fuseau horaire par l'heure UTC plus trois heures.
```
EXEC rdsadmin.rdsadmin_util.alter_db_time_zone(p_new_tz => '+3:00');
```
L'exemple suivant remplace le fuseau horaire par le Africa/Algiers fuseau horaire.
```
EXEC rdsadmin.rdsadmin_util.alter_db_time_zone(p_new_tz => 'Africa/Algiers');
```
Après avoir modifié le fuseau horaire grâce à la procédure `alter_db_time_zone`, redémarrez l'instance de base de données pour que la modification prenne effet. Pour plus d'informations, consultez [Redémarrage d'une instance de base de données cluster de base de données](USER_RebootInstance.md). Pour de plus amples informations sur la mise à niveau des fuseaux horaires, veuillez consulter [Considérations relatives au fuseau horaire](USER_UpgradeDBInstance.Oracle.OGPG.md#USER_UpgradeDBInstance.Oracle.OGPG.DST)
# Génération de rapports de performance avec AWR (Automatic Workload Repository)
Pour collecter des données de performance et générer des rapports, Oracle recommande AWR (Automatic Workload Repository). AWR nécessite Oracle Database Enterprise Edition et une licence pour les packs Diagnostics et Tuning. Pour activer AWR, définissez le paramètre d'initialisation `CONTROL_MANAGEMENT_PACK_ACCESS` sur `DIAGNOSTIC` ou `DIAGNOSTIC+TUNING`.
## Utilisation des rapports AWR dans RDS
Pour générer des rapports AWR, vous pouvez exécuter des scripts tels que `awrrpt.sql`. Ces scripts sont installés sur le serveur hôte de base de données. Dans Amazon RDS, vous n'avez pas d'accès direct à l'hôte. Toutefois, vous pouvez obtenir des copies de scripts SQL à partir d'une autre installation d'Oracle Database.
Vous pouvez également utiliser AWR en exécutant des procédures dans le `SYS.DBMS_WORKLOAD_REPOSITORY` PL/SQL package. Vous pouvez utiliser ce package pour gérer les références et les instantanés, mais aussi pour afficher les rapports ASH et AWR. Par exemple, pour générer un rapport AWR au format texte, exécutez la procédure `DBMS_WORKLOAD_REPOSITORY.AWR_REPORT_TEXT`. Toutefois, vous ne pouvez pas accéder à ces rapports AWR à partir de la AWS Management Console.
Lorsque vous travaillez avec AWR, nous vous recommandons d'utiliser les procédures `rdsadmin.rdsadmin_diagnostic_util`. Vous pouvez utiliser ces procédures pour générer les éléments suivants :
+ Rapports AWR
+ Rapports ASH (Active Session History)
+ Rapports ADDM (Automatic Database Diagnostic Monitor)
+ Fichiers de vidage Oracle Data Pump Export des données AWR
Les procédures `rdsadmin_diagnostic_util` enregistrent les rapports dans le système de fichiers de l'instance de base de données. Vous pouvez accéder à ces rapports à partir de la console. Vous pouvez également accéder aux rapports à l'aide des procédures `rdsadmin.rds_file_util`. Vous pouvez accéder aux rapports copiés dans Amazon S3 à l'aide de l'option S3 Integration. Pour plus d’informations, consultez [Lecture de fichiers dans un répertoire d'instance de base de données](Appendix.Oracle.CommonDBATasks.Misc.md#Appendix.Oracle.CommonDBATasks.ReadingFiles) et [Intégration Amazon S3](oracle-s3-integration.md).
Vous pouvez utiliser les procédures `rdsadmin_diagnostic_util` pour les versions suivantes du moteur de base de données Amazon RDS for Oracle :
+ Toutes les versions de Oracle Database 21c
+ 19.0.0.0.ru-2020-04.rur-2020-04.r1 et versions ultérieures de Oracle Database 19c
Pour consulter un blog expliquant comment utiliser les rapports de diagnostic dans un scénario de réplication, consultez [Générer des rapports AWR pour les réplicas en lecture Amazon RDS for Oracle](https://aws.amazon.com/blogs/database/generate-awr-reports-for-amazon-rds-for-oracle-read-replicas/) (langue française non garantie).
## Paramètres communs pour le package d'utilitaires de diagnostic
Vous utilisez généralement les paramètres suivants lors de la gestion d'AWR et d'ADDM avec le package `rdsadmin_diagnostic_util`.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.AWR.html)
Vous utilisez généralement les paramètres suivants lors de la gestion d'ASH avec le package rdsadmin\$1diagnostic\$1util.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.AWR.html)
## Génération d'un rapport AWR
Pour générer un rapport AWR, utilisez la procédure `rdsadmin.rdsadmin_diagnostic_util.awr_report`.
L'exemple suivant génère un rapport AWR pour la plage d'instantanés comprise entre 101 et 106. Le fichier texte en sortie est nommé `awrrpt_101_106.txt`. Vous pouvez accéder à ce rapport à partir d AWS Management Console.
```
EXEC rdsadmin.rdsadmin_diagnostic_util.awr_report(101,106,'TEXT');
```
L'exemple suivant génère un rapport HTML pour la plage d'instantanés comprise entre 63 et 65. Le fichier HTML en sortie est nommé `awrrpt_63_65.html`. La procédure écrit le rapport dans un répertoire de base de données autre que le répertoire par défaut et nommé `AWR_RPT_DUMP`.
```
EXEC rdsadmin.rdsadmin_diagnostic_util.awr_report(63,65,'HTML','AWR_RPT_DUMP');
```
## Extraction de données AWR dans un fichier de vidage
Pour extraire des données AWR dans un fichier de vidage, utilisez la procédure `rdsadmin.rdsadmin_diagnostic_util.awr_extract`. Vous ne pouvez utiliser cette fonction qu'au niveau du PDB.
L'exemple suivant extrait la plage d'instantanés comprise entre 101 et 106. Le fichier de vidage en sortie est nommé `awrextract_101_106.dmp`. Vous pouvez accéder à ce fichier via la console.
```
EXEC rdsadmin.rdsadmin_diagnostic_util.awr_extract(101,106);
```
L'exemple suivant extrait la plage d'instantanés comprise entre 63 et 65. Le fichier de vidage en sortie est nommé `awrextract_63_65.dmp`. Le fichier est stocké dans un répertoire de base de données autre que le répertoire par défaut et nommé `AWR_RPT_DUMP`.
```
EXEC rdsadmin.rdsadmin_diagnostic_util.awr_extract(63,65,'AWR_RPT_DUMP');
```
## Génération d'un rapport ADDM
Pour générer un rapport ADDM, utilisez la procédure `rdsadmin.rdsadmin_diagnostic_util.addm_report`.
L'exemple suivant génère un rapport HTML pour la plage d'instantanés comprise entre 101 et 106. Le fichier texte en sortie est nommé `addmrpt_101_106.txt`. Vous pouvez accéder au rapport via la console.
```
EXEC rdsadmin.rdsadmin_diagnostic_util.addm_report(101,106);
```
L'exemple suivant génère un rapport ADDM pour la plage d'instantanés comprise entre 63 et 65. Le fichier texte en sortie est nommé `addmrpt_63_65.txt`. Le fichier est stocké dans un répertoire de base de données autre que le répertoire par défaut et nommé `ADDM_RPT_DUMP`.
```
EXEC rdsadmin.rdsadmin_diagnostic_util.addm_report(63,65,'ADDM_RPT_DUMP');
```
## Génération d'un rapport ASH
Pour générer un rapport ASH, utilisez la procédure `rdsadmin.rdsadmin_diagnostic_util.ash_report`.
L'exemple suivant génère un rapport ASH qui inclut les données des 14 dernières minutes. Le nom du fichier en sortie utilise le format `ashrptbegin_timeend_time.txt`, où `begin_time` et `end_time` utilisent le format `YYYYMMDDHH24MISS`. Vous pouvez accéder au fichier via la console.
```
BEGIN
rdsadmin.rdsadmin_diagnostic_util.ash_report(
begin_time => SYSDATE-14/1440,
end_time => SYSDATE,
report_type => 'TEXT');
END;
/
```
L'exemple suivant génère un rapport ASH qui inclut les données depuis le 18 novembre 2019 à 18h07 jusqu'au 18 novembre 2019 à 18h15. Le nom du rapport HTML en sortie est `ashrpt_20190918180700_20190918181500.html`. Le rapport est stocké dans un répertoire de base de données autre que le répertoire par défaut et nommé `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;
/
```
## Accès aux rapports AWR à partir de la console ou de la CLI
Pour accéder aux rapports AWR ou exporter des fichiers de vidage, vous pouvez utiliser le AWS Management Console ou AWS CLI. Pour de plus amples informations, veuillez consulter [Téléchargement d'un fichier journal de base de données](USER_LogAccess.Procedural.Downloading.md).
# Réglage des liens de base de données pour une utilisation avec les instances de base de données dans un VPC
Pour utiliser les liens de base de données Oracle avec des instances de base de données Amazon RDS au sein du même cloud privé virtuel (VPC) ou en mode VPCs pair, les deux instances de base de données doivent disposer d'un itinéraire valide entre elles. Vérifiez l'itinéraire valide entre les instances de bases de données à l'aide de vos tables de routage VPC et la liste de contrôle d'accès (ACL) réseau.
Le groupe de sécurité de chaque instance de base de données doit autoriser le trafic entrant dans l'autre instance de base de données et le trafic sortant de cette instance. Les règles entrantes et sortantes peuvent faire référence à des groupes de sécurité à partir du même VPC ou d'un VPC appairé. Pour de plus amples informations, veuillez consulter [Mise à jour de vos groupes de sécurité pour référencer des groupes de sécurité du VPC appairé](https://docs.aws.amazon.com/vpc/latest/peering/working-with-vpc-peering.html#vpc-peering-security-groups).
Si vous avez configuré un serveur DNS personnalisé grâce aux jeux d'options DHCP de votre VPC, votre serveur DNS personnalisé doit pouvoir résoudre le nom de la cible du lien de la base de données. Pour plus d'informations, consultez [Configuration d'un serveur DNS personnalisé](Appendix.Oracle.CommonDBATasks.System.md#Appendix.Oracle.CommonDBATasks.CustomDNS).
Pour plus d'informations sur l'utilisation des liens de base de données avec Oracle Data Pump, consultez [Importation à l'aide d'Oracle Data Pump](Oracle.Procedural.Importing.DataPump.md).
# Définition de l'édition par défaut d'une instance de base de données
Vous pouvez redéfinir les objets de base de données dans un environnement privé appelé une édition. Vous pouvez utiliser la redéfinition basée sur l'édition pour mettre à niveau les objets de base de données d'une application avec un temps d'arrêt minimal.
Vous pouvez définir l'édition par défaut d'une instance de bases de données Amazon RDS Oracle à l'aide de la procédure Amazon RDS `rdsadmin.rdsadmin_util.alter_default_edition`.
L'exemple suivant définit l'édition par défaut de l'instance de bases de données Amazon RDS Oracle sur `RELEASE_V1`.
```
EXEC rdsadmin.rdsadmin_util.alter_default_edition('RELEASE_V1');
```
L'exemple suivant redéfinit l'édition par défaut de l'instance de base de données Amazon RDS Oracle sur la valeur par défaut d'Oracle.
```
EXEC rdsadmin.rdsadmin_util.alter_default_edition('ORA$BASE');
```
Pour de plus amples informations concernant la redéfinition basée sur l'édition d'Oracle, veuillez consulter [About Editions and Edition-Based Redefinition](https://docs.oracle.com/database/121/ADMIN/general.htm#ADMIN13167) dans la documentation Oracle.
# Activation de l'audit pour la table SYS.AUD\$1
Pour activer l'audit sur la table de suivi d'audit de base de données `SYS.AUD$`, utilisez la procédure Amazon RDS`rdsadmin.rdsadmin_master_util.audit_all_sys_aud_table`. La seule propriété d'audit prise en charge est `ALL`. Vous ne pouvez pas auditer ou ne pas auditer des instructions ou des opérations individuelles.
L'activation de l'audit est prise en charge pour les instances de base de données Oracle qui exécutent les versions suivantes :
+ Oracle Database 21c (21.0.0)
+ Oracle Database 19c (19.0.0)
La procédure `audit_all_sys_aud_table` possède les paramètres suivants.
****
| Nom du paramètre | Type de données | Par défaut | Obligatoire | Description |
| --- | --- | --- | --- | --- |
| `p_by_access` | booléen | true | Non | Définissez ce paramètre sur `true` pour auditer `BY ACCESS`. Définissez ce paramètre sur `false` pour auditer `BY SESSION`. |
La requête suivante retourne la configuration d'audit actuelle de `SYS.AUD$` pour une base de données.
```
SELECT * FROM DBA_OBJ_AUDIT_OPTS WHERE OWNER='SYS' AND OBJECT_NAME='AUD$';
```
Les commandes suivantes activent l'audit de `ALL` sur `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);
```
La commande suivante active l'audit de `ALL` sur `SYS.AUD$` `BY SESSION`.
```
EXEC rdsadmin.rdsadmin_master_util.audit_all_sys_aud_table(p_by_access => false);
```
Pour de plus amples informations, veuillez consulter [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) dans la documentation Oracle.
# Désactivation de l'audit pour la table SYS.AUD\$1
Pour désactiver l'audit sur la table de suivi d'audit de base de données `SYS.AUD$`, utilisez la procédure Amazon RDS `rdsadmin.rdsadmin_master_util.noaudit_all_sys_aud_table`. Cette procédure ne prend aucun paramètre.
La requête suivante retourne la configuration d'audit actuelle pour `SYS.AUD$`, pour une base de données :
```
SELECT * FROM DBA_OBJ_AUDIT_OPTS WHERE OWNER='SYS' AND OBJECT_NAME='AUD$';
```
La commande suivante désactive l'audit de `ALL` sur `SYS.AUD$`.
```
EXEC rdsadmin.rdsadmin_master_util.noaudit_all_sys_aud_table;
```
Pour de plus amples informations, veuillez consulter [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) dans la documentation Oracle.
# Nettoyage de builds d'index en ligne interrompues
Pour nettoyer des builds d'index en ligne qui ont échoué, utilisez la procédure Amazon RDS `rdsadmin.rdsadmin_dbms_repair.online_index_clean`.
La procédure `online_index_clean` possède les paramètres suivants.
****
| Nom du paramètre | Type de données | Par défaut | Obligatoire | Description |
| --- | --- | --- | --- | --- |
| `object_id` | binary\$1integer | `ALL_INDEX_ID` | Non | ID d'objet de l'index. En général, vous pouvez utiliser l'ID d'objet du texte d'erreur ORA-08104. |
| `wait_for_lock` | binary\$1integer | `rdsadmin.rdsadmin_dbms_repair.lock_wait` | Non | Spécifiez `rdsadmin.rdsadmin_dbms_repair.lock_wait`, la valeur par défaut pour tenter de verrouiller l'objet sous-jacent et réessayer jusqu'à ce qu'une limite interne soit atteinte si le verrouillage échoue. Spécifiez `rdsadmin.rdsadmin_dbms_repair.lock_nowait` pour essayer d'obtenir un verrouillage sur l'objet sous-jacent, sans réessayer si le verouillage échoue. |
L'exemple suivant nettoie une build d'index en ligne ayant échoué.
```
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;
/
```
Pour de plus amples informations, veuillez consulter [ONLINE\$1INDEX\$1CLEAN Function](https://docs.oracle.com/database/121/ARPLS/d_repair.htm#ARPLS67555) dans la documentation d'Oracle.
# Ignorer les blocs corrompus
Pour ignorer les blocs corrompus pendant les analyses d'index et de table, utilisez le package `rdsadmin.rdsadmin_dbms_repair`.
Les procédures suivantes encapsulent la fonctionnalité de la procédure `sys.dbms_repair.admin_table` et ne prennent aucun paramètre :
+ `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`
Les procédures suivantes prennent les mêmes paramètres que leurs homologues du package `DBMS_REPAIR` pour les bases de données 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`
Pour de plus amples informations sur la gestion de la corruption de base de données, veuillez consulter [DBMS\$1REPAIR](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/DBMS_REPAIR.html#GUID-B8EC4AB3-4D6A-46C9-857F-4ED53CD9C948) dans la documentation Oracle.
**Example Réponse aux blocs corrompus**
Cet exemple présente le flux de travail de base pour répondre aux blocs corrompus. Vos étapes dépendront de l'emplacement et de la nature de votre corruption de bloc.
Avant de tenter de réparer les blocs corrompus, consultez attentivement la documentation [DBMS\$1REPAIR](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/DBMS_REPAIR.html#GUID-B8EC4AB3-4D6A-46C9-857F-4ED53CD9C948).
**Pour ignorer les blocs corrompus pendant les analyses d'index et de table**
1. Exécutez les procédures suivantes pour créer des tables de réparation si elles n'existent pas déjà.
```
EXEC rdsadmin.rdsadmin_dbms_repair.create_repair_table;
EXEC rdsadmin.rdsadmin_dbms_repair.create_orphan_keys_table;
```
1. Exécutez les procédures suivantes pour vérifier s'il existe des enregistrements et les purger si nécessaire.
```
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. Exécutez la procédure suivante pour rechercher les blocs corrompus.
```
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. Utilisez la procédure `skip_corrupt_blocks` pour activer ou désactiver l'ignorance de corruption pour les tables affectées. Selon la situation, vous devrez peut-être également extraire des données dans une nouvelle table, puis supprimer la table contenant le bloc corrompu.
Exécutez la procédure suivante pour permettre d'ignorer la corruption pour les tables affectées.
```
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';
```
Exécutez la procédure suivante pour ne pas ignorer la corruption.
```
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. Une fois tous les travaux de réparation terminés, exécutez les procédures suivantes pour supprimer les tables de réparation.
```
EXEC rdsadmin.rdsadmin_dbms_repair.drop_repair_table;
EXEC rdsadmin.rdsadmin_dbms_repair.drop_orphan_keys_table;
```
## Purge de la corbeille
Lorsque vous supprimez une table, votre base de données Oracle ne supprime pas immédiatement son espace de stockage. La base de données renomme la table et la place, ainsi que les objets associés, dans une corbeille. La purge de la corbeille supprime ces éléments et libère leur espace de stockage.
Pour purger l'intégralité de la corbeille, suivez la procédure Amazon RDS `rdsadmin.rdsadmin_util.purge_dba_recyclebin`. Toutefois, cette procédure ne peut pas purger la corbeille des objets `SYS` et `RDSADMIN`. Si vous devez purger ces objets, contactez AWS Support.
L'exemple suivant purge l'ensemble de la corbeille.
```
EXEC rdsadmin.rdsadmin_util.purge_dba_recyclebin;
```
# Définition des valeurs affichées par défaut pour une édition complète
Pour modifier les valeurs affichées par défaut pour une édition complète sur votre instance Amazon RDS for Oracle, utilisez la procédure Amazon RDS `rdsadmin.rdsadmin_util.dbms_redact_upd_full_rdct_val`. Notez que vous créez une politique de rédaction avec le `DBMS_REDACT` PL/SQL package, comme expliqué dans la documentation de la base de données Oracle. La procédure `dbms_redact_upd_full_rdct_val` spécifie les caractères à afficher pour les différents types de données affectés par une politique existante.
La procédure `dbms_redact_upd_full_rdct_val` possède les paramètres suivants.
****
| Nom du paramètre | Type de données | Par défaut | Obligatoire | Description |
| --- | --- | --- | --- | --- |
| `p_number_val` | nombre | Null | Non | Modifie la valeur par défaut des colonnes de type de données `NUMBER`. |
| `p_binfloat_val` | binary\$1float | Null | Non | Modifie la valeur par défaut des colonnes de type de données `BINARY_FLOAT`. |
| `p_bindouble_val` | binary\$1double | Null | Non | Modifie la valeur par défaut des colonnes de type de données `BINARY_DOUBLE`. |
| `p_char_val` | char | Null | Non | Modifie la valeur par défaut des colonnes de type de données `CHAR`. |
| `p_varchar_val` | varchar2 | Null | Non | Modifie la valeur par défaut des colonnes de type de données `VARCHAR2`. |
| `p_nchar_val` | nchar | Null | Non | Modifie la valeur par défaut des colonnes de type de données `NCHAR`. |
| `p_nvarchar_val` | nvarchar2 | Null | Non | Modifie la valeur par défaut des colonnes de type de données `NVARCHAR2`. |
| `p_date_val` | date | Null | Non | Modifie la valeur par défaut des colonnes de type de données `DATE`. |
| `p_ts_val` | timestamp | Null | Non | Modifie la valeur par défaut des colonnes de type de données `TIMESTAMP`. |
| `p_tswtz_val` | timestamp with time zone | Null | Non | Modifie la valeur par défaut des colonnes de type de données `TIMESTAMP WITH TIME ZONE`. |
| `p_blob_val` | blob | Null | Non | Modifie la valeur par défaut des colonnes de type de données `BLOB`. |
| `p_clob_val` | clob | Null | Non | Modifie la valeur par défaut des colonnes de type de données `CLOB`. |
| `p_nclob_val` | nclob | Null | Non | Modifie la valeur par défaut des colonnes de type de données `NCLOB`. |
L'exemple suivant remplace la valeur expurgée par défaut par \$1 pour le type de données `CHAR` :
```
EXEC rdsadmin.rdsadmin_util.dbms_redact_upd_full_rdct_val(p_char_val => '*');
```
L'exemple suivant modifie les valeurs expurgées par défaut pour les types de données `NUMBER`, `DATE` et `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;
/
```
Après avoir modifié les valeurs par défaut pour l'édition complète avec la procédure `dbms_redact_upd_full_rdct_val`, redémarrez votre instance de base de données pour que la modification prenne effet. Pour de plus amples informations, veuillez consulter [Redémarrage d'une instance de base de données cluster de base de données](USER_RebootInstance.md).
# Exécution des tâches courantes liées au journal pour les instances de base de données Oracle
Vous trouverez ci-dessous des informations sur la façon d'effectuer certaines tâches DBA courantes liées à la journalisation sur vos instances de base de données Amazon RDS exécutant Oracle. Pour offrir une expérience de service géré, Amazon RDS ne fournit pas l'accès shell aux instances de base de données et limite l'accès à certaines tables et procédures système qui requièrent des privilèges avancés.
Pour plus d'informations, consultez [Fichiers journaux de base de données Amazon RDS for Oracle](USER_LogAccess.Concepts.Oracle.md).
**Topics**
+ [Configuration du mode FORCE LOGGING](#Appendix.Oracle.CommonDBATasks.SettingForceLogging)
+ [Configuration d'une journalisation supplémentaire](#Appendix.Oracle.CommonDBATasks.AddingSupplementalLogging)
+ [Changement de fichiers journaux en ligne](#Appendix.Oracle.CommonDBATasks.SwitchingLogfiles)
+ [Ajout de journaux redo en ligne](#Appendix.Oracle.CommonDBATasks.RedoLogs)
+ [Suppression de journaux redo en ligne](#Appendix.Oracle.CommonDBATasks.DroppingRedoLogs)
+ [Redimensionnement de journaux redo en ligne](Appendix.Oracle.CommonDBATasks.ResizingRedoLogs.md)
+ [Conservation des journaux redo archivés](Appendix.Oracle.CommonDBATasks.RetainRedoLogs.md)
+ [Accès aux journaux de reprise en ligne et archivés](Appendix.Oracle.CommonDBATasks.Log.Download.md)
+ [Téléchargement des journaux de reprise archivés à partir d'Amazon S3](Appendix.Oracle.CommonDBATasks.download-redo-logs.md)
## Configuration du mode FORCE LOGGING
En mode FORCE LOGGING, Oracle enregistre toutes les modifications apportées à la base de données, à l'exception de celles apportées aux espaces de table temporaires et aux segments temporaires (`NOLOGGING` des clauses sont ignorées). Pour plus d’informations, consultez [Specifying FORCE LOGGING Mode](https://docs.oracle.com/cd/E11882_01/server.112/e25494/create.htm#ADMIN11096) dans la documentation Oracle.
Pour définir le mode FORCE LOGGING, utilisez la procédure Amazon RDS `rdsadmin.rdsadmin_util.force_logging`. La procédure `force_logging` possède les paramètres suivants.
****
| Nom du paramètre | Type de données | Par défaut | Oui | Description |
| --- | --- | --- | --- | --- |
| `p_enable` | booléen | true | Non | Définissez ce paramètre sur `true` pour mettre la base de données en mode FORCE LOGGING ou sur `false` pour sortir la base de données de ce mode. |
L'exemple suivant met la base de données en mode FORCE LOGGING.
```
EXEC rdsadmin.rdsadmin_util.force_logging(p_enable => true);
```
## Configuration d'une journalisation supplémentaire
Si vous activez la journalisation supplémentaire, LogMiner dispose des informations nécessaires pour prendre en charge les lignes chaînées et les tables en cluster. Pour plus d’informations, consultez [journalisation supplémentaire](https://docs.oracle.com/cd/E11882_01/server.112/e22490/logminer.htm#SUTIL1582) dans la documentation Oracle.
Oracle Database n'active pas la journalisation supplémentaire par défaut. Pour activer et désactiver la journalisation supplémentaire, utilisez la procédure Amazon RDS `rdsadmin.rdsadmin_util.alter_supplemental_logging`. Pour plus d'informations sur la façon dont Amazon RDS gère la conservation des journaux redo archivés pour les instances de base de données Oracle, consultez [Conservation des journaux redo archivés](Appendix.Oracle.CommonDBATasks.RetainRedoLogs.md).
La procédure `alter_supplemental_logging` possède les paramètres suivants.
****
| Nom du paramètre | Type de données | Par défaut | Obligatoire | Description |
| --- | --- | --- | --- | --- |
| `p_action` | varchar2 | — | Oui | `'ADD'` pour ajouter la journalisation supplémentaire, `'DROP'` pour la supprimer. |
| `p_type` | varchar2 | null | Non | Type de journalisation supplémentaire. Les valeurs valides sont `'ALL'`, `'FOREIGN KEY'`, `'PRIMARY KEY'`, `'UNIQUE'` et `PROCEDURAL`. |
L'exemple suivant active la journalisation supplémentaire.
```
begin
rdsadmin.rdsadmin_util.alter_supplemental_logging(
p_action => 'ADD');
end;
/
```
L'exemple suivant active la journalisation supplémentaire pour toutes les colonnes de taille maximale et de longueur fixe.
```
begin
rdsadmin.rdsadmin_util.alter_supplemental_logging(
p_action => 'ADD',
p_type => 'ALL');
end;
/
```
L'exemple suivant active la journalisation supplémentaire pour les colonnes de clés primaires.
```
begin
rdsadmin.rdsadmin_util.alter_supplemental_logging(
p_action => 'ADD',
p_type => 'PRIMARY KEY');
end;
/
```
## Changement de fichiers journaux en ligne
Pour changer des fichiers journaux, utilisez la procédure Amazon RDS `rdsadmin.rdsadmin_util.switch_logfile`. La procédure `switch_logfile` ne comporte aucun paramètre.
L'exemple suivant change des fichiers journaux.
```
EXEC rdsadmin.rdsadmin_util.switch_logfile;
```
## Ajout de journaux redo en ligne
Une instance de base de données Amazon RDS exécutant Oracle démarre avec quatre journaux redo en ligne de 128 Mo chacun. Pour ajouter des journaux redo supplémentaires, utilisez la procédure Amazon RDS `rdsadmin.rdsadmin_util.add_logfile`.
La procédure `add_logfile` possède les paramètres suivants.
**Note**
Les paramètres s'excluent mutuellement.
****
| Nom du paramètre | Type de données | Par défaut | Obligatoire | Description |
| --- | --- | --- | --- | --- |
| `bytes` | positives | null | Non | Taille du fichier journal en octets. Utilisez ce paramètre uniquement si la taille du journal est inférieure à 2147483648 octets (2 Gio). Dans le cas contraire, RDS émet une erreur. Pour les tailles de journal supérieures à cette valeur d’octet, utilisez plutôt le paramètre `p_size`. |
| `p_size` | varchar2 | — | Oui | Taille du fichier journal en kilo-octets (Ko), mégaoctets (Mo) ou gigaoctets (Go). |
La commande suivante ajoute un fichier journal de 100 Mo.
```
EXEC rdsadmin.rdsadmin_util.add_logfile(p_size => '100M');
```
## Suppression de journaux redo en ligne
Pour supprimer des journaux redo, utilisez la procédure Amazon RDS `rdsadmin.rdsadmin_util.drop_logfile`. La procédure `drop_logfile` possède les paramètres suivants.
****
| Nom du paramètre | Type de données | Par défaut | Obligatoire | Description |
| --- | --- | --- | --- | --- |
| `grp` | positives | — | Oui | Numéro de groupe du journal. |
L'exemple suivant supprime le journal doté du numéro de groupe 3.
```
EXEC rdsadmin.rdsadmin_util.drop_logfile(grp => 3);
```
Vous pouvez uniquement supprimer des journaux dont le statut est inutilisé ou inactif. L'exemple suivant permet d'obtenir les statuts des journaux.
```
SELECT GROUP#, STATUS FROM V$LOG;
GROUP# STATUS
---------- ----------------
1 CURRENT
2 INACTIVE
3 INACTIVE
4 UNUSED
```
# Redimensionnement de journaux redo en ligne
Une instance de base de données Amazon RDS exécutant Oracle démarre avec quatre journaux redo en ligne de 128 Mo chacun. L'exemple suivant montre comment vous pouvez utiliser les procédures Amazon RDS for redimensionner vos journaux en remplaçant leur taille de 128 Mo par 512 Mo.
```
/* 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
```
# Conservation des journaux redo archivés
Vous pouvez conserver les journaux de restauration archivés localement sur votre instance de base de données pour les utiliser avec des produits tels qu'Oracle LogMiner (`DBMS_LOGMNR`). Une fois que vous avez conservé les journaux redo, vous pouvez les utiliser LogMiner pour analyser les journaux. Pour plus d'informations, consultez la section [Utilisation LogMiner pour analyser les fichiers de journalisation](http://docs.oracle.com/cd/E11882_01/server.112/e22490/logminer.htm) dans la documentation Oracle.
Pour conserver les journaux redo archivés, utilisez la procédure Amazon RDS `rdsadmin.rdsadmin_util.set_configuration`. Si vous utilisez cette procédure sur une instance principale dans Oracle Data Guard, RDS modifie le paramètre de conservation du journal d’archivage sur l’instance principale et sur les réplicas en lecture ouvertes, mais pas sur les réplicas montés. RDS conserve les derniers journaux de rétablissement des archives sur les réplicas montés pendant une courte période. RDS supprime automatiquement les anciens journaux téléchargés sur les réplicas montés.
La procédure `set_configuration` possède les paramètres suivants.
****
| Nom du paramètre | Type de données | Par défaut | Obligatoire | Description |
| --- | --- | --- | --- | --- |
| `name` | varchar | — | Oui | Nom de la configuration à mettre à jour. Pour modifier les heures de conservation du journal de rétablissement archivé, définissez le nom sur `archivelog retention hours`. |
| `value` | varchar | — | Oui | Valeur pour la configuration. Définissez comme valeur le nombre d’heures pendant lesquelles les journaux sont conservés. |
L'exemple suivant conserve les journaux redo pendant 24 heures.
```
begin
rdsadmin.rdsadmin_util.set_configuration(
name => 'archivelog retention hours',
value => '24');
end;
/
commit;
```
**Note**
La validation est obligatoire pour que la modification prenne effet.
Pour voir combien de temps les journaux redo archivés sont conservés pour votre instance de base de données, utilisez la procédure Amazon RDS `rdsadmin.rdsadmin_util.show_configuration`.
L'exemple suivant affiche la durée de conservation des journaux.
```
set serveroutput on
EXEC rdsadmin.rdsadmin_util.show_configuration;
```
La sortie affiche le paramètre actuel pour `archivelog retention hours`. La sortie suivante montre que les journaux redo archivés sont conservés pendant 48 heures.
```
NAME:archivelog retention hours
VALUE:48
DESCRIPTION:ArchiveLog expiration specifies the duration in hours before archive/redo log files are automatically deleted.
```
Étant donné que les journaux redo archivés sont conservés sur votre instance de base de données, vérifiez que votre instance de base de données dispose d'un stockage alloué suffisant pour les journaux conservés. Pour déterminer la quantité d'espace que votre instance de base de données a utilisée au cours des X dernières heures, vous pouvez exécuter la requête suivante en remplaçant X par le nombre d'heures.
```
SELECT SUM(BLOCKS * BLOCK_SIZE) bytes
FROM V$ARCHIVED_LOG
WHERE FIRST_TIME >= SYSDATE-(X/24) AND DEST_ID=1;
```
RDS for Oracle ne génère des journaux de reprise archivés que si la période de rétention des sauvegardes de votre instance de base de données est supérieure à zéro. Par défaut, la période de rétention des sauvegardes est supérieure à zéro.
Lorsque la période de rétention des journaux archivés expire, RDS for Oracle supprime les journaux de reprise archivés de votre instance de base de données. Pour prendre en charge la restauration de votre instance de base de données à un moment donné, Amazon RDS conserve les journaux de reprise archivés en dehors de votre instance de base de données pendant la période de rétention des sauvegardes. Pour modifier la période de rétention des sauvegardes pour votre instance de base de données, consultez [Modification d'une instance de base de données Amazon RDS](Overview.DBInstance.Modifying.md).
**Note**
Dans certains cas, vous pouvez utiliser JDBC sur Linux pour télécharger les journaux redo archivés et connaître des temps de latence élevés et des réinitalisations de connexion. Dans ces cas, les problèmes peuvent être causés par le paramétrage du générateur de nombres aléatoires sur votre client Java. Nous vous recommandons de définir vos pilotes JDBC pour l'utilisation d'un générateur de nombres aléatoires sans blocage.
# Accès aux journaux de reprise en ligne et archivés
Vous souhaiterez peut-être accéder à vos fichiers de journalisation en ligne et archivés pour le minage à l'aide d'outils externes tels que GoldenGate Attunity, Informatica, etc. Pour accéder à ces fichiers, procédez comme suit :
1. Créez des objets de répertoire qui donnent un accès en lecture seule aux chemins d'accès de fichiers physiques.
Utilisation de `rdsadmin.rdsadmin_master_util.create_archivelog_dir` et `rdsadmin.rdsadmin_master_util.create_onlinelog_dir`.
1. Lisez les fichiers à l'aide de PL/SQL.
Vous pouvez lire les fichiers en utilisant PL/SQL. Pour de plus amples informations sur la lecture de fichiers à partir d'objets de répertoire, veuillez consulter [Établissement de la liste des fichiers situés dans un répertoire d'instance de base de données](Appendix.Oracle.CommonDBATasks.Misc.md#Appendix.Oracle.CommonDBATasks.ListDirectories) et [Lecture de fichiers dans un répertoire d'instance de base de données](Appendix.Oracle.CommonDBATasks.Misc.md#Appendix.Oracle.CommonDBATasks.ReadingFiles).
L'accès aux journaux des transactions est pris en charge pour les versions suivantes :
+ Oracle Database 21c
+ Oracle Database 19c
Le code suivant crée des répertoires qui fournissent un accès en lecture seule à vos fichiers de journalisation Redo en ligne et archivés :
**Important**
Ce code retire également le privilège `DROP ANY DIRECTORY`.
```
EXEC rdsadmin.rdsadmin_master_util.create_archivelog_dir;
EXEC rdsadmin.rdsadmin_master_util.create_onlinelog_dir;
```
Le code suivant supprime les répertoires pour vos fichiers journaux redo en ligne et archivés.
```
EXEC rdsadmin.rdsadmin_master_util.drop_archivelog_dir;
EXEC rdsadmin.rdsadmin_master_util.drop_onlinelog_dir;
```
Le code suivant accorde et révoque le privilège `DROP ANY DIRECTORY`.
```
EXEC rdsadmin.rdsadmin_master_util.revoke_drop_any_directory;
EXEC rdsadmin.rdsadmin_master_util.grant_drop_any_directory;
```
# Téléchargement des journaux de reprise archivés à partir d'Amazon S3
Vous pouvez télécharger les journaux de reprise archivés sur votre instance de base de données à l'aide du package `rdsadmin.rdsadmin_archive_log_download`. Si les journaux de reprise archivés ne sont plus sur votre instance de base de données, vous pouvez les télécharger à nouveau à partir d'Amazon S3. Ensuite, vous pouvez les exploiter ou les utiliser pour récupérer ou répliquer votre base de données.
**Note**
Vous ne pouvez pas télécharger des Journaux de reprise archivés sur des instances de réplica en lecture.
## Téléchargement des journaux de reprise archivés : étapes de base
La disponibilité de vos journaux de reprise archivés dépend des politiques de rétention suivantes :
+ Politique de conservation des sauvegardes : les journaux liés à cette politique sont disponibles dans Amazon S3. Les journaux étrangers à cette politique sont supprimés.
+ Politique de conservation des journaux archivés : les journaux liés à cette politique sont disponibles sur votre instance de base de données. Les journaux étrangers à cette politique sont supprimés.
Si les journaux ne figurent pas sur votre instance mais sont protégés par votre période de rétention des sauvegardes, utilisez `rdsadmin.rdsadmin_archive_log_download` pour les télécharger à nouveau. RDS for Oracle enregistre les journaux dans le répertoire `/rdsdbdata/log/arch` sur votre instance de base de données.
**Pour télécharger des journaux de reprise archivés à partir d'Amazon S3**
1. Configurez votre période de conservation pour vous assurer que les journaux redo archivés que vous avez téléchargés sont conservés pendant la durée où vous en avez besoin. Veillez à valider (`COMMIT`) votre changement.
RDS conserve vos journaux téléchargés conformément à la politique de conservation des journaux archivés, à compter du moment où les journaux ont été téléchargés. Pour découvrir comment définir la politique de rétention, consultez [Conservation des journaux redo archivés](Appendix.Oracle.CommonDBATasks.RetainRedoLogs.md).
1. Attendez jusqu'à 5 minutes pour que la modification de la politique de rétention des journaux archivés prenne effet.
1. Téléchargez les journaux de reprise archivés à partir d'Amazon S3 à l'aide de `rdsadmin.rdsadmin_archive_log_download`.
Pour plus d’informations, consultez [Téléchargement d'un journal de reprise archivé unique](#Appendix.Oracle.CommonDBATasks.download-redo-logs.single-log) et [Téléchargement d'une série de journaux de reprise archivés](#Appendix.Oracle.CommonDBATasks.download-redo-logs.series).
**Note**
RDS vérifie automatiquement le stockage disponible avant le téléchargement. Si les journaux demandés consomment un pourcentage élevé d'espace, vous recevez une alerte.
1. Vérifiez que les journaux ont bien été téléchargés à partir d'Amazon S3.
Vous pouvez consulter l'état de votre tâche de téléchargement dans un fichier bdump. Les fichiers bdump ont le nom des chemin d'accès `/rdsdbdata/log/trace/dbtask-task-id.log`. A l'étape de téléchargement précédente, vous avez exécuté une instruction `SELECT` qui renvoie l'ID de tâche dans un type de données `VARCHAR2`. Pour plus d'informations, consultez des exemples similaires dans [Surveillance du statut d'un transfert de fichiers](oracle-s3-integration.using.md#oracle-s3-integration.using.task-status).
## Téléchargement d'un journal de reprise archivé unique
Pour télécharger un journal de reprise archivé unique dans le répertoire `/rdsdbdata/log/arch`, utilisez `rdsadmin.rdsadmin_archive_log_download.download_log_with_seqnum`. Cette procédure utilise le paramétrage suivant.
****
| Nom du paramètre | Type de données | Par défaut | Obligatoire | Description |
| --- | --- | --- | --- | --- |
| `seqnum` | nombre | — | Oui | Numéro de séquence du journal de reprise archivé. |
L'exemple suivant télécharge le journal avec le numéro de séquence 20.
```
SELECT rdsadmin.rdsadmin_archive_log_download.download_log_with_seqnum(seqnum => 20)
AS TASK_ID
FROM DUAL;
```
## Téléchargement d'une série de journaux de reprise archivés
Pour télécharger une série de journaux de reprise archivés dans le répertoire `/rdsdbdata/log/arch`, utilisez `download_logs_in_seqnum_range`. Votre téléchargement est limité à 300 journaux par requête. La procédure `download_logs_in_seqnum_range` possède les paramètres suivants.
****
| Nom du paramètre | Type de données | Par défaut | Obligatoire | Description |
| --- | --- | --- | --- | --- |
| `start_seq` | nombre | — | Oui | Numéro de séquence initial de la série. |
| `end_seq` | nombre | — | Oui | Numéro de séquence final de la série. |
L'exemple suivant télécharge les journaux portant les numéros de séquence 50 à 100.
```
SELECT rdsadmin.rdsadmin_archive_log_download.download_logs_in_seqnum_range(start_seq => 50, end_seq => 100)
AS TASK_ID
FROM DUAL;
```
# Exécution des tâches RMAN courantes pour les instances de base de données Oracle
Dans la section suivante, vous trouverez comment effectuer les tâches DBA Oracle Recovery Manager (RMAN) sur vos instances de base de données Amazon RDS exécutant Oracle. Pour offrir une expérience de service géré, Amazon RDS ne fournit pas l'accès shell aux instances de base de données. Il restreint également l'accès à certaines procédures système et tables qui requièrent des privilèges avancés.
Utilisez le package Amazon RDS `rdsadmin.rdsadmin_rman_util` pour effectuer les sauvegardes RMAN sur disque de votre base de données Amazon RDS for Oracle. Le package `rdsadmin.rdsadmin_rman_util` prend en charge les sauvegardes de fichiers de base de données complètes et incrémentielles, les sauvegardes d'espace de table et les sauvegardes des journaux redo archivés.
Une fois qu'une sauvegarde RMAN est terminée, vous pouvez copier les fichiers de sauvegarde hors de l'hôte d'instance de base de données Amazon RDS for Oracle. Vous pouvez faire cela en vue d'une restauration vers un hôte non-RDS ou pour le stockage à long terme des sauvegardes. Par exemple, vous pouvez copier les fichiers de sauvegarde dans un compartiment Amazon S3. Pour de plus amples informations, reportez-vous à l'utilisation d'[Intégration Amazon S3](oracle-s3-integration.md).
Les fichiers de sauvegarde RMAN restent sur l'hôte d'instance de base de données Amazon RDS jusqu'à ce que vous les supprimiez manuellement. Vous pouvez utiliser la procédure Oracle `UTL_FILE.FREMOVE` pour supprimer les fichiers d'un répertoire. Pour plus d'informations, consultez [Procédure FREMOVE](https://docs.oracle.com/database/121/ARPLS/u_file.htm#ARPLS70924) (langue française non garantie) dans la documentation Oracle Database.
Vous ne pouvez pas utiliser RMAN pour restaurer les instances de base de données RDS for Oracle. Toutefois, vous pouvez utiliser RMAN pour restaurer une sauvegarde sur une instance Amazon EC2 ou sur site. Pour plus d'informations, consultez l'article de blog [Restaurer une instance Amazon RDS for Oracle vers une instance autogérée](https://aws.amazon.com/blogs/database/restore-an-amazon-rds-for-oracle-instance-to-a-self-managed-instance/) (langue française non garantie).
**Note**
Pour une sauvegarde et une restauration vers une autre instance de base de données Amazon RDS for Oracle, vous pouvez continuer à utiliser les fonctions Amazon RDS de sauvegarde et de restauration. Pour de plus amples informations, veuillez consulter [Sauvegarde, restauration et exportation de données](CHAP_CommonTasks.BackupRestore.md).
**Topics**
+ [Prérequis pour les sauvegardes RMAN](Appendix.Oracle.CommonDBATasks.RMAN-requirements.md)
+ [Paramètres communs pour les procédures RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md)
+ [Validation de fichiers de base de données dans RDS for Oracle](Appendix.Oracle.CommonDBATasks.ValidateDBFiles.md)
+ [Activation et désactivation du suivi des modifications de bloc](Appendix.Oracle.CommonDBATasks.BlockChangeTracking.md)
+ [Recoupement des journaux redo archivés](Appendix.Oracle.CommonDBATasks.Crosscheck.md)
+ [Sauvegarde des journaux de rétablissement archivés](Appendix.Oracle.CommonDBATasks.BackupArchivedLogs.md)
+ [Réalisation d'une sauvegarde complète de base de données](Appendix.Oracle.CommonDBATasks.BackupDatabaseFull.md)
+ [Réalisation d'une sauvegarde complète d'une base de données locataire](Appendix.Oracle.CommonDBATasks.BackupTenantDatabaseFull.md)
+ [Réalisation d'une sauvegarde incrémentielle de base de données](Appendix.Oracle.CommonDBATasks.BackupDatabaseIncremental.md)
+ [Réalisation d'une sauvegarde incrémentielle d'une base de données locataire](Appendix.Oracle.CommonDBATasks.BackupTenantDatabaseIncremental.md)
+ [Sauvegarde d'un espace de table](Appendix.Oracle.CommonDBATasks.BackupTablespace.md)
+ [Sauvegarde d'un fichier de contrôle](Appendix.Oracle.CommonDBATasks.backup-control-file.md)
+ [Exécution de la récupération de supports par blocs](Appendix.Oracle.CommonDBATasks.block-media-recovery.md)
# Prérequis pour les sauvegardes RMAN
Avant de sauvegarder votre base de données à l'aide du package `rdsadmin.rdsadmin_rman_util`, assurez-vous que vous répondez aux prérequis suivants :
+ Assurez-vous que votre base de données RDS for Oracle est en mode `ARCHIVELOG`. Pour activer ce mode, définissez la période de conservation des sauvegardes sur une valeur différente de zéro.
+ Lorsque vous sauvegardez les journaux redo archivés ou effectuez une sauvegarde complète ou incrémentielle incluant des journaux redo archivés, et lorsque vous effectuez la sauvegarde de la base de données, veillez à ce que la conservation des journaux redo soit définie sur une valeur non nulle. Les journaux redo archivés sont nécessaires pour assurer la cohérence des fichiers de base de données pendant la restauration. Pour de plus amples informations, veuillez consulter [Conservation des journaux redo archivés](Appendix.Oracle.CommonDBATasks.RetainRedoLogs.md).
+ Assurez-vous que votre instance de base de données dispose de suffisamment d'espace disponible pour stocker les sauvegardes. Lorsque vous sauvegardez votre base de données, vous spécifiez un objet de répertoire Oracle en tant que paramètre dans l'appel de procédure. RMAN place les fichiers dans le répertoire spécifié. Vous pouvez utiliser les répertoires par défaut, tels que `DATA_PUMP_DIR`, ou créer un répertoire. Pour de plus amples informations, veuillez consulter [Création et suppression de répertoires dans l'espace de stockage de données principal](Appendix.Oracle.CommonDBATasks.Misc.md#Appendix.Oracle.CommonDBATasks.NewDirectories).
Vous pouvez surveiller l'espace libre actuel dans une instance RDS pour Oracle à l'aide de la CloudWatch métrique`FreeStorageSpace`. Nous recommandons que votre espace disponible dépasse la taille actuelle de la base de données, bien que RMAN ne sauvegarde que les blocs formatés et prenne en charge la compression.
# Paramètres communs pour les procédures RMAN
Vous pouvez utiliser des procédures dans le package Amazon RDS `rdsadmin.rdsadmin_rman_util` pour effectuer des tâches avec RMAN. Plusieurs paramètres sont communs aux procédures figurant dans le package. Le package possède les paramètres communs suivants.
****
| Nom du paramètre | Type de données | Valeurs valides | Par défaut | Obligatoire | Description |
| --- | --- | --- | --- | --- | --- |
| `p_directory_name` | varchar2 | Nom de répertoire de base de données valide. | — | Oui | Nom du répertoire devant contenir les fichiers de sauvegarde. |
| `p_label` | varchar2 | `a-z`, `A-Z`, `0-9`, `'_'`, `'-'`, `'.'` | — | Non | Chaîne unique incluse dans les noms de fichiers de sauvegarde. La limite est de 30 caractères. |
| `p_owner` | varchar2 | Propriétaire valide du répertoire spécifié dans `p_directory_name`. | — | Oui | Propriétaire du répertoire devant contenir les fichiers de sauvegarde. |
| `p_tag` | varchar2 | `a-z`, `A-Z`, `0-9`, `'_'`, `'-'`, `'.'` | NULL | Non | Chaîne pouvant être utilisée pour distinguer les sauvegardes afin d'indiquer leur but ou leur utilisation, telles que les sauvegardes journalière, hebdomadaire, ou de niveau progressif. La limite est de 30 caractères. L'identification n'est pas sensible à la casse. Les balises sont toujours enregistrées en majuscules, quelle que soit la casse utilisée lors de leur saisie. Les identifications n'ont pas besoin d'être uniques, de sorte que plusieurs sauvegardes peuvent avoir la même. Si vous ne spécifiez aucune balise, RMAN attribue automatiquement une balise par défaut en utilisant le format`TAGYYYYMMDDTHHMMSS`, où *YYYY* sont l'année, *MM* le mois, *DD* le jour, *HH* l'heure (au format 24 heures), *MM* les minutes et les *SS* secondes. La date et l'heure font référence au moment où RMAN a démarré la sauvegarde. Par exemple, une sauvegarde peut se voir attribuer une balise `TAG20190927T214517`, pour une sauvegarde démarrée le 27 septembre 2019 à 21:45:17. Le paramètre `p_tag` est pris en charge pour les versions suivantes du moteur de base de données Amazon RDS for Oracle : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.CommonParameters.html) |
| `p_compress` | boolean | `TRUE`, `FALSE` | `FALSE` | Non | Spécifiez `TRUE` pour activer la compression de sauvegarde DE BASE. Spécifiez `FALSE` pour désactiver la compression de sauvegarde DE BASE. |
| `p_include_archive_logs` | booléen | `TRUE`, `FALSE` | `FALSE` | Non | Spécifiez `TRUE` pour inclure les journaux redo archivés dans la sauvegarde. Spécifiez `FALSE` pour exclure les journaux redo archivés de la sauvegarde. Si vous incluez les journaux redo archivés dans la sauvegarde, définissez la conservation sur une heure ou plus à l'aide de la procédure `rdsadmin.rdsadmin_util.set_configuration`. De plus, appelez la procédure `rdsadmin.rdsadmin_rman_util.crosscheck_archivelog` immédiatement avant d'exécuter la sauvegarde. Dans le cas contraire, la sauvegarde peut échouer en raison de fichiers journaux redo archivés manquants qui ont été supprimés par les procédures de gestion Amazon RDS. |
| `p_include_controlfile` | booléen | `TRUE`, `FALSE` | `FALSE` | Non | Spécifiez `TRUE` pour inclure le fichier de contrôle dans la sauvegarde. Spécifiez `FALSE` pour exclure le fichier de contrôle de la sauvegarde. |
| `p_optimize` | booléen | `TRUE`, `FALSE` | `TRUE` | Non | Spécifiez `TRUE` pour activer l'optimisation de la sauvegarde, si des journaux redo archivés sont inclus, afin de réduire la taille de la sauvegarde. Spécifiez `FALSE` pour désactiver l'optimisation de la sauvegarde. |
| `p_parallel` | nombre | Entier valide compris entre `1` et `254` pour Oracle Database Enterprise Edition (EE) `1` pour d'autres éditions d'Oracle Database | `1` | Non | Nombre de canaux. |
| `p_rman_to_dbms_output` | booléen | `TRUE`, `FALSE` | `FALSE` | Non | Lorsque la valeur est `TRUE`, la sortie RMAN est envoyée au package `DBMS_OUTPUT` ainsi qu'à un fichier du répertoire `BDUMP`. Dans SQL\$1Plus, utilisez `SET SERVEROUTPUT ON` pour voir la sortie. Lorsque la valeur est `FALSE`, la sortie RMAN est envoyée uniquement à un fichier dans le répertoire `BDUMP`. |
| `p_section_size_mb` | nombre | Entier valide | `NULL` | Non | Taille de la section en mégaoctets (Mo). Valide en parallèle en divisant chaque fichier dans la taille de section spécifiée. Lorsque la valeur est `NULL`, le paramètre est ignoré. |
| `p_validation_type` | varchar2 | `'PHYSICAL'`, `'PHYSICAL+LOGICAL'` | `'PHYSICAL'` | Non | Niveau de détection de la corruption. Spécifiez `'PHYSICAL'` pour rechercher de la corruption physique. Par exemple, la corruption physique peut être un bloc dont l'en-tête et le pied de page ne correspondent pas. Spécifiez `'PHYSICAL+LOGICAL'` pour rechercher les incohérences logiques en plus de la corruption physique. Un bloc corrompu est un exemple de corruption logique. |
# Validation de fichiers de base de données dans RDS for Oracle
Vous pouvez utiliser le package Amazon RDS `rdsadmin.rdsadmin_rman_util` pour valider les fichiers de base de données Amazon RDS for Oracle, tels que les fichiers de données, les tablespaces, les fichiers de contrôle et les fichiers de paramètres du serveur (). SPFILEs
Pour plus d’informations sur la validation RMAN, consultez [ Validating Database Files and Backups](https://docs.oracle.com/database/121/BRADV/rcmvalid.htm#BRADV90063) et [ VALIDATE](https://docs.oracle.com/database/121/RCMRF/rcmsynta2025.htm#RCMRF162) dans la documentation Oracle.
**Topics**
+ [Validation d’une base de données](#Appendix.Oracle.CommonDBATasks.ValidateDB)
+ [Validation d'une base de données locataire](#Appendix.Oracle.CommonDBATasks.ValidateTenantDB)
+ [Validation d'un espace de table](#Appendix.Oracle.CommonDBATasks.ValidateTablespace)
+ [Validation d'un fichier de contrôle](#Appendix.Oracle.CommonDBATasks.ValidateControlFile)
+ [Validation d'un fichier SPFILE](#Appendix.Oracle.CommonDBATasks.ValidateSpfile)
+ [Validation d’un fichier de données Oracle](#Appendix.Oracle.CommonDBATasks.ValidateDataFile)
## Validation d’une base de données
Pour valider tous les fichiers pertinents utilisés par une base de données Oracle dans RDS for Oracle, utilisez la procédure Amazon RDS `rdsadmin.rdsadmin_rman_util.validate_database`.
Cette procédure utilise les paramètres courants suivants pour les tâches RMAN :
+ `p_validation_type`
+ `p_parallel`
+ `p_section_size_mb`
+ `p_rman_to_dbms_output`
Pour de plus amples informations, veuillez consulter [Paramètres communs pour les procédures RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
L’exemple suivant valide la base de données actuelle à l’aide des valeurs par défaut pour les paramètres.
```
EXEC rdsadmin.rdsadmin_rman_util.validate_database;
```
L’exemple suivant valide la base de données actuelle à l’aide des valeurs spécifiées pour les paramètres.
```
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;
/
```
Lorsque le paramètre `p_rman_to_dbms_output` est défini sur `FALSE`, la sortie RMAN est écrite dans un fichier, dans le répertoire `BDUMP`.
Pour afficher les fichiers dans le répertoire `BDUMP`, exécutez l'instruction `SELECT` suivante.
```
SELECT * FROM table(rdsadmin.rds_file_util.listdir('BDUMP')) order by mtime;
```
Pour afficher le contenu d'un fichier dans le répertoire `BDUMP`, exécutez l'instruction `SELECT` suivante.
```
SELECT text FROM table(rdsadmin.rds_file_util.read_text_file('BDUMP','rds-rman-validate-nnn.txt'));
```
Remplacez le nom du fichier par celui du fichier que vous souhaitez afficher.
## Validation d'une base de données locataire
Pour valider les fichiers de données de la base de données locataire dans une base de données de conteneurs (CDB), utilisez la procédure Amazon RDS `rdsadmin.rdsadmin_rman_util.validate_tenant`.
Cette procédure s'applique uniquement à la base de données locataire actuelle et utilise les paramètres courants suivants pour les tâches RMAN :
+ `p_validation_type`
+ `p_parallel`
+ `p_section_size_mb`
+ `p_rman_to_dbms_output`
Pour de plus amples informations, veuillez consulter [Paramètres communs pour les procédures RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md). Cette procédure est prise en charge pour les versions suivantes du moteur de base de données :
+ CDB Oracle Database 21c (21.0.0)
+ CDB Oracle Database 19c (19.0.0)
L'exemple suivant valide la base de données locataire actuelle à l'aide des valeurs par défaut pour les paramètres.
```
EXEC rdsadmin.rdsadmin_rman_util.validate_tenant;
```
L'exemple suivant valide la base de données locataire actuelle à l'aide des valeurs spécifiées pour les paramètres.
```
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;
/
```
Lorsque le paramètre `p_rman_to_dbms_output` est défini sur `FALSE`, la sortie RMAN est écrite dans un fichier, dans le répertoire `BDUMP`.
Pour afficher les fichiers dans le répertoire `BDUMP`, exécutez l'instruction `SELECT` suivante.
```
SELECT * FROM table(rdsadmin.rds_file_util.listdir('BDUMP')) order by mtime;
```
Pour afficher le contenu d'un fichier dans le répertoire `BDUMP`, exécutez l'instruction `SELECT` suivante.
```
SELECT text FROM table(rdsadmin.rds_file_util.read_text_file('BDUMP','rds-rman-validate-nnn.txt'));
```
Remplacez le nom du fichier par celui du fichier que vous souhaitez afficher.
## Validation d'un espace de table
Pour valider les fichiers associés à un espace de table, utilisez la procédure Amazon RDS `rdsadmin.rdsadmin_rman_util.validate_tablespace`.
Cette procédure utilise les paramètres courants suivants pour les tâches RMAN :
+ `p_validation_type`
+ `p_parallel`
+ `p_section_size_mb`
+ `p_rman_to_dbms_output`
Pour plus d'informations, consultez [Paramètres communs pour les procédures RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
Cette procédure utilise également le paramètre supplémentaire suivant.
****
| Nom du paramètre | Type de données | Valeurs valides | Par défaut | Obligatoire | Description |
| --- | --- | --- | --- | --- | --- |
| `p_tablespace_name` | varchar2 | Nom d'espace de table valide | — | Oui | Nom de l'espace de table. |
## Validation d'un fichier de contrôle
Pour valider uniquement le fichier de contrôle utilisé par une instance de base de données Amazon RDS Oracle, utilisez la procédure Amazon RDS `rdsadmin.rdsadmin_rman_util.validate_current_controlfile`.
Cette procédure utilise le paramètre courant suivant pour les tâches RMAN :
+ `p_validation_type`
+ `p_rman_to_dbms_output`
Pour plus d'informations, consultez [Paramètres communs pour les procédures RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
## Validation d'un fichier SPFILE
Pour valider uniquement le fichier de paramètres serveur (SPFILE) utilisé par une instance de base de données Amazon RDS Oracle, utilisez la procédure Amazon RDS `rdsadmin.rdsadmin_rman_util.validate_spfile`.
Cette procédure utilise le paramètre courant suivant pour les tâches RMAN :
+ `p_validation_type`
+ `p_rman_to_dbms_output`
Pour de plus amples informations, veuillez consulter [Paramètres communs pour les procédures RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
## Validation d’un fichier de données Oracle
Pour valider un fichier de données, utilisez la procédure Amazon RDS `rdsadmin.rdsadmin_rman_util.validate_datafile`.
Cette procédure utilise les paramètres courants suivants pour les tâches RMAN :
+ `p_validation_type`
+ `p_parallel`
+ `p_section_size_mb`
+ `p_rman_to_dbms_output`
Pour plus d’informations, consultez [Paramètres communs pour les procédures RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
Cette procédure utilise également les paramètres supplémentaires suivants.
****
| Nom du paramètre | Type de données | Valeurs valides | Par défaut | Obligatoire | Description |
| --- | --- | --- | --- | --- | --- |
| `p_datafile` | varchar2 | Numéro d'ID de fichier de données valide ou nom de fichier de données valide comprenant le chemin complet | — | Oui | Numéro d'ID de fichier de données (issu de `v$datafile.file#`) ou nom de fichier de données complet comprenant le chemin (issu de `v$datafile.name`). |
| `p_from_block` | nombre | Entier valide | `NULL` | Non | Numéro du bloc par lequel la validation commence à l'intérieur du fichier de données. Lorsqu'il est `NULL`, `1` est utilisé. |
| `p_to_block` | nombre | Entier valide | `NULL` | Non | Numéro du bloc par lequel la validation finit à l'intérieur du fichier de données. Lorsqu'il est `NULL`, le bloc le plus grand du fichier de données est utilisé. |
# Activation et désactivation du suivi des modifications de bloc
Le suivi des modifications de bloc enregistre les blocs dans un fichier de suivi. Cette technique peut améliorer les performances des sauvegardes incrémentielles RMAN. Pour plus d'informations, consultez [Utilisation du suivi des modifications de bloc pour améliorer les performances des sauvegardes incrémentielles](https://docs.oracle.com/en/database/oracle/oracle-database/19/bradv/backing-up-database.html#GUID-4E1F605A-76A7-48D0-9D9B-7343B4327E2A) dans la documentation Oracle Database.
Les fonctionnalités RMAN ne sont pas prises en charge dans un réplica en lecture. Toutefois, dans le cadre de votre stratégie de haute disponibilité, vous pouvez choisir d'activer le suivi des blocs dans un réplica en lecture seule à l'aide de la procédure `rdsadmin.rdsadmin_rman_util.enable_block_change_tracking`. Si vous promouvez ce réplica en lecture seule en instance de base de données source, le suivi des modifications de bloc est activé pour la nouvelle instance source. Ainsi, votre instance peut bénéficier de sauvegardes incrémentielles rapides.
Les procédures de suivi des modifications de bloc sont prises en charge dans la version Enterprise Edition uniquement pour les versions suivantes du moteur de base de données :
+ Oracle Database 21c (21.0.0)
+ Oracle Database 19c (19.0.0)
**Note**
Dans une base de données de conteneur (CDB) à locataire unique, les opérations suivantes fonctionnent, mais aucun mécanisme visible par le client ne peut détecter l'état actuel des opérations. Voir aussi [Limites de RDS pour Oracle CDBs](Oracle.Concepts.CDBs.md#Oracle.Concepts.single-tenant-limitations).
Pour activer le suivi des modifications de bloc pour une instance de base de données, utilisez la procédure Amazon RDS `rdsadmin.rdsadmin_rman_util.enable_block_change_tracking`. Pour désactiver le suivi des modifications de bloc, utilisez `disable_block_change_tracking`. Ces procédures ne prennent aucun paramètre.
Pour déterminer si le suivi des modifications de bloc est activé pour votre instance de base de données, exécutez la requête suivante.
```
SELECT STATUS, FILENAME FROM V$BLOCK_CHANGE_TRACKING;
```
L'exemple suivant active le suivi des modifications de bloc pour une instance de base de données.
```
EXEC rdsadmin.rdsadmin_rman_util.enable_block_change_tracking;
```
L'exemple suivant désactive le suivi des modifications de bloc pour une instance de base de données.
```
EXEC rdsadmin.rdsadmin_rman_util.disable_block_change_tracking;
```
# Recoupement des journaux redo archivés
Vous pouvez recouper les journaux redo archivés en utilisant la procédure Amazon RDS `rdsadmin.rdsadmin_rman_util.crosscheck_archivelog`.
Vous pouvez utiliser cette procédure pour recouper les journaux redo archivés inscrits dans le fichier de contrôle et supprimer éventuellement les enregistrements de journaux ayant expiré. Quand RMAN effectue une sauvegarde, il crée un enregistrement dans le fichier de contrôle. Au fil du temps, ces enregistrements augmentent la taille du fichier de contrôle. Nous vous recommandons de supprimer périodiquement les enregistrements expirés.
**Note**
Les sauvegardes Amazon RDS standard n'utilisent pas RMAN et ne créent donc pas d'enregistrement dans le fichier de contrôle.
Cette procédure utilise le paramètre courant `p_rman_to_dbms_output` pour les tâches RMAN.
Pour plus d'informations, consultez [Paramètres communs pour les procédures RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
Cette procédure utilise également le paramètre supplémentaire suivant.
****
| Nom du paramètre | Type de données | Valeurs valides | Par défaut | Obligatoire | Description |
| --- | --- | --- | --- | --- | --- |
| `p_delete_expired` | booléen | `TRUE`, `FALSE` | `TRUE` | Non | Lorsque la valeur est `TRUE`, supprimez les enregistrements de journaux redo archivés expirés du fichier de contrôle. Lorsque la valeur est `FALSE`, conservez les enregistrements de journaux redo archivés expirés dans le fichier de contrôle. |
Cette procédure est prise en charge pour les versions suivantes du moteur de base de données Amazon RDS for Oracle :
+ Oracle Database 21c (21.0.0)
+ Oracle Database 19c (19.0.0)
L'exemple suivant marque les enregistrements de journaux redo archivés dans le fichier de contrôle comme ayant expiré, mais ne les supprime pas.
```
BEGIN
rdsadmin.rdsadmin_rman_util.crosscheck_archivelog(
p_delete_expired => FALSE,
p_rman_to_dbms_output => FALSE);
END;
/
```
L'exemple suivant supprime les enregistrements de journaux redo archivés expirés du fichier de contrôle.
```
BEGIN
rdsadmin.rdsadmin_rman_util.crosscheck_archivelog(
p_delete_expired => TRUE,
p_rman_to_dbms_output => FALSE);
END;
/
```
# Sauvegarde des journaux de rétablissement archivés
Vous pouvez utiliser le package Amazon RDS `rdsadmin.rdsadmin_rman_util` pour sauvegarder les journaux redo archivés pour une instance de base de données Oracle Amazon RDS.
Les procédures de sauvegarde des journaux redo archivés sont prises en charge pour les versions suivantes du moteur de base de données Amazon RDS for Oracle :
+ Oracle Database 21c (21.0.0)
+ Oracle Database 19c (19.0.0)
**Topics**
+ [Sauvegarde de tous les journaux redo archivés](#Appendix.Oracle.CommonDBATasks.BackupArchivedLogs.All)
+ [Sauvegarde d'un journal redo archivé à partir d'une plage de dates](#Appendix.Oracle.CommonDBATasks.BackupArchivedLogs.Date)
+ [Sauvegarde d'un journal redo archivé à partir d'une plage de numéros SCN](#Appendix.Oracle.CommonDBATasks.BackupArchivedLogs.SCN)
+ [Sauvegarde d'un journal redo archivé à partir d'une plage de numéros de séquence](#Appendix.Oracle.CommonDBATasks.BackupArchivedLogs.Sequence)
## Sauvegarde de tous les journaux redo archivés
Pour sauvegarder tous les journaux redo archivés pour une instance de base de données Amazon RDS Oracle, utilisez la procédure Amazon RDS `rdsadmin.rdsadmin_rman_util.backup_archivelog_all`.
Cette procédure utilise les paramètres courants suivants pour les tâches RMAN :
+ `p_owner`
+ `p_directory_name`
+ `p_label`
+ `p_parallel`
+ `p_compress`
+ `p_rman_to_dbms_output`
+ `p_tag`
Pour plus d’informations, consultez [Paramètres communs pour les procédures RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
L'exemple suivant sauvegarde tous les journaux redo archivés pour l'instance de base de données.
```
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;
/
```
## Sauvegarde d'un journal redo archivé à partir d'une plage de dates
Pour sauvegarder des journaux redo archivés spécifiques pour une instance de base de données Amazon RDS Oracle, utilisez la procédure Amazon RDS `rdsadmin.rdsadmin_rman_util.backup_archivelog_date`. La plage de dates indique quels journaux redo archivés sauvegarder.
Cette procédure utilise les paramètres courants suivants pour les tâches RMAN :
+ `p_owner`
+ `p_directory_name`
+ `p_label`
+ `p_parallel`
+ `p_compress`
+ `p_rman_to_dbms_output`
+ `p_tag`
Pour plus d’informations, consultez [Paramètres communs pour les procédures RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
Cette procédure utilise également les paramètres supplémentaires suivants.
****
| Nom du paramètre | Type de données | Valeurs valides | Par défaut | Obligatoire | Description |
| --- | --- | --- | --- | --- | --- |
| `p_from_date` | date | Date comprise entre `start_date` et `next_date` d'un journal redo archivé qui existe sur le disque. Cette valeur doit être inférieure ou égale à la valeur spécifiée pour `p_to_date`. | — | Oui | Date de début des sauvegardes des journaux archivés. |
| `p_to_date` | date | Date comprise entre `start_date` et `next_date` d'un journal redo archivé qui existe sur le disque. Cette valeur doit être supérieure ou égale à la valeur spécifiée pour `p_from_date`. | — | Oui | Date de fin des sauvegardes des journaux archivés. |
L'exemple suivant sauvegarde les journaux redo archivés dans la plage de dates pour l'instance de base de données.
```
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;
/
```
## Sauvegarde d'un journal redo archivé à partir d'une plage de numéros SCN
Pour sauvegarder des journaux redo archivés spécifiques pour une instance de base de données Amazon RDS Oracle, utilisez la procédure Amazon RDS `rdsadmin.rdsadmin_rman_util.backup_archivelog_scn`. La plage de numéros SCN indique quels journaux redo archivés sauvegarder.
Cette procédure utilise les paramètres courants suivants pour les tâches RMAN :
+ `p_owner`
+ `p_directory_name`
+ `p_label`
+ `p_parallel`
+ `p_compress`
+ `p_rman_to_dbms_output`
+ `p_tag`
Pour plus d’informations, consultez [Paramètres communs pour les procédures RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
Cette procédure utilise également les paramètres supplémentaires suivants.
****
| Nom du paramètre | Type de données | Valeurs valides | Par défaut | Obligatoire | Description |
| --- | --- | --- | --- | --- | --- |
| `p_from_scn` | nombre | Numéro SCN d'un journal redo archivé qui existe sur le disque. Cette valeur doit être inférieure ou égale à la valeur spécifiée pour `p_to_scn`. | — | Oui | Numéro SCN de début des sauvegardes des journaux archivés. |
| `p_to_scn` | nombre | Numéro SCN d'un journal redo archivé qui existe sur le disque. Cette valeur doit être supérieure ou égale à la valeur spécifiée pour `p_from_scn`. | — | Oui | Numéro SCN de fin des sauvegardes des journaux archivés. |
L'exemple suivant sauvegarde les journaux redo archivés dans la plage de numéros SCN pour l'instance de base de données.
```
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;
/
```
## Sauvegarde d'un journal redo archivé à partir d'une plage de numéros de séquence
Pour sauvegarder des journaux redo archivés spécifiques pour une instance de base de données Amazon RDS Oracle, utilisez la procédure Amazon RDS `rdsadmin.rdsadmin_rman_util.backup_archivelog_sequence`. La plage de numéros de séquence indique quels journaux redo archivés sauvegarder.
Cette procédure utilise les paramètres courants suivants pour les tâches RMAN :
+ `p_owner`
+ `p_directory_name`
+ `p_label`
+ `p_parallel`
+ `p_compress`
+ `p_rman_to_dbms_output`
+ `p_tag`
Pour plus d’informations, consultez [Paramètres communs pour les procédures RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
Cette procédure utilise également les paramètres supplémentaires suivants.
****
| Nom du paramètre | Type de données | Valeurs valides | Par défaut | Obligatoire | Description |
| --- | --- | --- | --- | --- | --- |
| `p_from_sequence` | nombre | Numéro de séquence d'un journal redo archivé qui existe sur le disque. Cette valeur doit être inférieure ou égale à la valeur spécifiée pour `p_to_sequence`. | — | Oui | Numéro de séquence de début des sauvegardes des journaux archivés. |
| `p_to_sequence` | nombre | Numéro de séquence d'un journal redo archivé qui existe sur le disque. Cette valeur doit être supérieure ou égale à la valeur spécifiée pour `p_from_sequence`. | — | Oui | Numéro de séquence de fin des sauvegardes des journaux archivés. |
L'exemple suivant sauvegarde les journaux redo archivés dans la plage de numéros de séquence pour l'instance de base de données.
```
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;
/
```
# Réalisation d'une sauvegarde complète de base de données
Vous pouvez effectuer une sauvegarde de tous les blocs de fichiers de données inclus dans la sauvegarde en utilisant la procédure Amazon RDS `rdsadmin.rdsadmin_rman_util.backup_database_full`.
Cette procédure utilise les paramètres courants suivants pour les tâches 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`
Pour plus d'informations, consultez [Paramètres communs pour les procédures RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
Cette procédure est prise en charge pour les versions suivantes du moteur de base de données Amazon RDS for Oracle :
+ Oracle Database 21c (21.0.0)
+ Oracle Database 19c (19.0.0)
L'exemple suivant effectue une sauvegarde complète de l'instance de base de données à l'aide des valeurs spécifiées pour les paramètres.
```
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;
/
```
# Réalisation d'une sauvegarde complète d'une base de données locataire
Vous pouvez effectuer une sauvegarde de tous les blocs de données inclus dans une base de données locataire dans une base de données de conteneur (CDB). Utiliser la procédure Amazon RDS `rdsadmin.rdsadmin_rman_util.backup_tenant_full`. Cette procédure s'applique uniquement à la sauvegarde de la base de données actuelle et utilise les paramètres courants suivants pour les tâches 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`
Pour de plus amples informations, veuillez consulter [Paramètres communs pour les procédures RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
La procédure `rdsadmin_rman_util.backup_tenant_full` est prise en charge pour les versions suivantes du moteur de base de données RDS for Oracle :
+ CDB Oracle Database 21c (21.0.0)
+ CDB Oracle Database 19c (19.0.0)
L'exemple suivant effectue une sauvegarde complète de la base de données locataire actuelle à l'aide des valeurs spécifiées pour les paramètres.
```
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;
/
```
# Réalisation d'une sauvegarde incrémentielle de base de données
Vous pouvez effectuer une sauvegarde incrémentielle de votre instance de base de données en utilisant la procédure Amazon RDS `rdsadmin.rdsadmin_rman_util.backup_database_incremental`.
Pour de plus amples informations sur les sauvegardes incrémentielles, veuillez consulter [Incremental Backups](https://docs.oracle.com/database/121/RCMRF/rcmsynta006.htm#GUID-73642FF2-43C5-48B2-9969-99001C52EB50__BGBHABHH) dans la documentation Oracle.
Cette procédure utilise les paramètres courants suivants pour les tâches 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`
Pour plus d'informations, consultez [Paramètres communs pour les procédures RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
Cette procédure est prise en charge pour les versions suivantes du moteur de base de données Amazon RDS for Oracle :
+ Oracle Database 21c (21.0.0)
+ Oracle Database 19c (19.0.0)
Cette procédure utilise également le paramètre supplémentaire suivant.
****
| Nom du paramètre | Type de données | Valeurs valides | Par défaut | Obligatoire | Description |
| --- | --- | --- | --- | --- | --- |
| `p_level` | nombre | `0`, `1` | `0` | Non | Spécifiez `0` pour activer une sauvegarde incrémentielle complète. Spécifiez `1` pour activer une sauvegarde incrémentielle non cumulative. |
L'exemple suivant effectue une sauvegarde incrémentielle de l'instance de base de données à l'aide des valeurs spécifiées pour les paramètres.
```
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;
/
```
# Réalisation d'une sauvegarde incrémentielle d'une base de données locataire
Vous pouvez effectuer une sauvegarde incrémentielle de la base de données locataire actuelle dans votre CDB. Utiliser la procédure Amazon RDS `rdsadmin.rdsadmin_rman_util.backup_tenant_incremental`.
Pour de plus amples informations sur les sauvegardes incrémentielles, consultez [Incremental Backups](https://docs.oracle.com/database/121/RCMRF/rcmsynta006.htm#GUID-73642FF2-43C5-48B2-9969-99001C52EB50__BGBHABHH) dans la documentation Oracle Database.
Cette procédure s'applique uniquement à la base de données locataire actuelle et utilise les paramètres courants suivants pour les tâches 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`
Pour de plus amples informations, consultez [Paramètres communs pour les procédures RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
Cette procédure est prise en charge pour les versions suivantes du moteur de base de données Amazon RDS for Oracle :
+ CDB Oracle Database 21c (21.0.0)
+ CDB Oracle Database 19c (19.0.0)
Cette procédure utilise également le paramètre supplémentaire suivant.
****
| Nom du paramètre | Type de données | Valeurs valides | Par défaut | Obligatoire | Description |
| --- | --- | --- | --- | --- | --- |
| `p_level` | nombre | `0`, `1` | `0` | Non | Spécifiez `0` pour activer une sauvegarde incrémentielle complète. Spécifiez `1` pour activer une sauvegarde incrémentielle non cumulative. |
L'exemple suivant effectue une sauvegarde incrémentielle de la base de données locataire actuelle à l'aide des valeurs spécifiées pour les paramètres.
```
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;
/
```
# Sauvegarde d'un espace de table
Vous pouvez sauvegarder un espace de table en utilisant la procédure Amazon RDS `rdsadmin.rdsadmin_rman_util.backup_tablespace`.
Cette procédure utilise les paramètres courants suivants pour les tâches 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`
Pour plus d'informations, consultez [Paramètres communs pour les procédures RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
Cette procédure utilise également le paramètre supplémentaire suivant.
****
| Nom du paramètre | Type de données | Valeurs valides | Par défaut | Obligatoire | Description |
| --- | --- | --- | --- | --- | --- |
| `p_tablespace_name` | varchar2 | Nom d'espace de table valide. | — | Oui | Nom de l'espace de table à sauvegarder. |
Cette procédure est prise en charge pour les versions suivantes du moteur de base de données Amazon RDS for Oracle :
+ Oracle Database 21c (21.0.0)
+ Oracle Database 19c (19.0.0)
L'exemple suivant effectue une sauvegarde d'espace de table à l'aide des valeurs spécifiées pour les paramètres.
```
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;
/
```
# Sauvegarde d'un fichier de contrôle
Vous pouvez sauvegarder un fichier de contrôle en utilisant la procédure Amazon RDS `rdsadmin.rdsadmin_rman_util.backup_current_controlfile`.
Cette procédure utilise les paramètres courants suivants pour les tâches RMAN :
+ `p_owner`
+ `p_directory_name`
+ `p_label`
+ `p_compress`
+ `p_rman_to_dbms_output`
+ `p_tag`
Pour plus d'informations, consultez [Paramètres communs pour les procédures RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
Cette procédure est prise en charge pour les versions suivantes du moteur de base de données Amazon RDS for Oracle :
+ Oracle Database 21c (21.0.0)
+ Oracle Database 19c (19.0.0)
L'exemple suivant sauvegarde un fichier de contrôle à l'aide des valeurs spécifiées pour les paramètres.
```
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;
/
```
# Exécution de la récupération de supports par blocs
Vous pouvez récupérer des blocs de données individuels, ce que l’on appelle la récupération de supports par blocs, à l’aide des procédures `rdsadmin.rdsadmin_rman_util.recover_datafile_block` Amazon RDS. Vous pouvez utiliser cette procédure surchargée pour récupérer un bloc de données individuel ou une série de blocs de données.
Cette procédure utilise le paramètre courant suivant pour les tâches RMAN :
+ `p_rman_to_dbms_output`
Pour plus d’informations, consultez [Paramètres communs pour les procédures RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
Cette procédure utilise les paramètres supplémentaires suivants.
****
| Nom du paramètre | Type de données | Valeurs valides | Par défaut | Obligatoire | Description |
| --- | --- | --- | --- | --- | --- |
| `p_datafile` | `NUMBER` | Numéro d’identification de fichier de données valide. | — | Oui | Le fichier de données contenant les blocs corrompus. Spécifiez le fichier de données de l’une des manières suivantes : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.block-media-recovery.html) |
| `p_block` | `NUMBER` | Entier valide. | — | Oui | Le numéro d’un bloc individuel à récupérer. Les paramètres suivants s’excluent mutuellement : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.block-media-recovery.html) |
| `p_from_block` | `NUMBER` | Entier valide. | — | Oui | Le premier numéro de bloc d’une plage de blocs à récupérer. Les paramètres suivants s’excluent mutuellement : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.block-media-recovery.html) |
| `p_to_block` | `NUMBER` | Entier valide. | — | Oui | Le dernier numéro de bloc d’une plage de blocs à récupérer. Les paramètres suivants s’excluent mutuellement : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.block-media-recovery.html) |
Cette procédure est prise en charge pour les versions suivantes du moteur de base de données Amazon RDS for Oracle :
+ Oracle Database 21c (21.0.0)
+ Oracle Database 19c (19.0.0)
L’exemple suivant permet de récupérer le bloc 100 dans le fichier de données 5.
```
BEGIN
rdsadmin.rdsadmin_rman_util.recover_datafile_block(
p_datafile => 5,
p_block => 100,
p_rman_to_dbms_output => TRUE);
END;
/
```
L’exemple suivant permet de récupérer les blocs 100 à 150 dans le fichier de données 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;
/
```
# Exécution des tâches de planification courantes pour les instances de base de données Oracle
Certaines tâches Oracle Scheduler détenues par `SYS` peuvent interférer avec les opérations de base de données normales. Dans de tels cas, Oracle Support vous recommande de modifier le calendrier. Si vous devez activer ou désactiver des tâches `SYS`, testez le fonctionnement sur des tâches planifiées dans un environnement de test avant de l’implémenter dans un environnement de production. Utilisez le package Amazon RDS `rdsadmin.rdsadmin_dbms_scheduler` pour effectuer des tâches pour les tâches Oracle Scheduler détenues par `SYS`.
Les procédures `rdsadmin.rdsadmin_dbms_scheduler` sont prises en charge pour les versions du moteur de base de données Amazon RDS for Oracle indiqué dans le tableau suivant. Lorsque vous utilisez ce package, vous pouvez spécifier les tâches `SYS` répertoriées dans le tableau.
| Version de base de données | Tâches activées par défaut. | Tâches désactivés par défaut. |
| --- | --- | --- |
| 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
|
## Paramètres communs pour les procédures d'Oracle Scheduler
Pour effectuer des tâches avec Oracle Scheduler, utilisez les procédures du package Amazon RDS `rdsadmin.rdsadmin_dbms_scheduler`. Plusieurs paramètres sont communs aux procédures figurant dans le package. Le package possède les paramètres communs suivants.
****
| Nom du paramètre | Type de données | Valeurs valides | Par défaut | Obligatoire | Description |
| --- | --- | --- | --- | --- | --- |
| `name` | varchar2 | Les procédures répertoriées dans le tableau de [Exécution des tâches de planification courantes pour les instances de base de données Oracle](#Appendix.Oracle.CommonDBATasks.Scheduler) | — | Oui | Nom du travail à modifier. |
| `attribute` | varchar2 | `'REPEAT_INTERVAL'`,`'SCHEDULE_NAME'` | – | Oui | Attribut à modifier. Pour modifier l'intervalle de répétition du travail, spécifiez `'REPEAT_INTERVAL'`. Pour modifier le nom de planification du travail, spécifiez `'SCHEDULE_NAME'`. |
| `value` | varchar2 | Intervalle ou nom de planification valide, selon l'attribut utilisé. | – | Oui | Nouvelle valeur de l'attribut. |
## Modification des travaux DBMS\$1SCHEDULER
Utilisez la procédure Oracle `dbms_scheduler.set_attribute` pour modifier certains composants d'Oracle Scheduler. Pour plus d’informations, consultez [DBMS\$1SCHEDULER](https://docs.oracle.com/database/121/ARPLS/d_sched.htm#ARPLS72235) et la [procédure SET\$1ATTRIBUTE](https://docs.oracle.com/database/121/ARPLS/d_sched.htm#ARPLS72399) dans la documentation Oracle.
Lorsque vous utilisez des instances de base de données Amazon RDS, ajoutez le nom du schéma `SYS` au début du nom de l'objet. L'exemple suivant définit l'attribut du plan de la ressource pour l'objet monday window.
```
BEGIN
DBMS_SCHEDULER.SET_ATTRIBUTE(
name => 'SYS.MONDAY_WINDOW',
attribute => 'RESOURCE_PLAN',
value => 'resource_plan_1');
END;
/
```
## Modification des fenêtres AutoTask de maintenance
Les instances Amazon RDS for Oracle sont créées avec les paramètres par défaut pour les fenêtres de maintenance. Les tâches de maintenance automatisées, telles que la collecte de statistiques de l'optimiseur, s'exécutent lors de ces fenêtres. Par défaut, les fenêtres de maintenance activent le gestionnaire de ressources Oracle Database.
Pour modifier la fenêtre, utilisez le package `DBMS_SCHEDULER`. Vous devrez peut-être modifier les paramètres de la fenêtre de maintenance pour les raisons suivantes :
+ Vous voulez que les tâches de maintenance s'exécutent à un moment différent, avec des paramètres différents, ou pas du tout. Par exemple, vous souhaitez modifier la durée de la fenêtre ou modifier l'heure et l'intervalle de répétition.
+ Vous souhaitez éviter les répercussions sur les performances de l'activation du gestionnaire de ressources pendant la maintenance. Par exemple, si le plan de maintenance par défaut est spécifié et si la fenêtre de maintenance s'ouvre alors que la base de données est en cours de chargement, des événements d'attente tels que `resmgr:cpu quantum` peuvent apparaître. Cet événement d'attente est lié au gestionnaire de ressources de base de données. Vous avez les options suivantes :
+ Vérifiez que les fenêtres de maintenance sont actives pendant les heures creuses pour votre instance de base de données.
+ Désactivez le plan de maintenance par défaut en réglant l'attribut `resource_plan` sur une chaîne vide.
+ Définissez le paramètre `resource_manager_plan` de votre groupe de paramètres sur `FORCE:`. Si votre instance utilise Enterprise Edition, ce paramètre empêche l'activation des plans du gestionnaire de ressources de base de données.
**Pour modifier les paramètres de votre fenêtre de maintenance**
1. Connectez-vous à votre base de données à l'aide d'un client SQL Oracle.
1. Interrogez la configuration actuelle pour une fenêtre de planificateur.
L'exemple suivant interroge la configuration pour `MONDAY_WINDOW`.
```
SELECT ENABLED, RESOURCE_PLAN, DURATION, REPEAT_INTERVAL
FROM DBA_SCHEDULER_WINDOWS
WHERE WINDOW_NAME='MONDAY_WINDOW';
```
La sortie suivante indique que la fenêtre utilise les valeurs par défaut.
```
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. Modifiez la fenêtre à l'aide du package `DBMS_SCHEDULER`.
L'exemple suivant définit le plan de ressources sur null, afin que le gestionnaire de ressources ne s'exécute pas pendant la fenêtre de maintenance.
```
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;
/
```
L'exemple suivant définit la durée maximale de la fenêtre sur 2 heures.
```
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;
/
```
L'exemple suivant définit l'intervalle de répétition sur tous les lundis, à 10 heures.
```
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;
/
```
## Définition du fuseau horaire pour les tâches d'Oracle Scheduler
Pour modifier le fuseau horaire d'Oracle Scheduler, vous pouvez utiliser la procédure Oracle `dbms_scheduler.set_scheduler_attribute`. Pour plus d’informations sur le package `dbms_scheduler`, consultez [DBMS\$1SCHLENDER](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/DBMS_SCHEDULER.html) et [SET\$1SCHENDER\$1ATTRIBUTE](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/DBMS_SCHEDULER.html#GUID-2AB97BF7-7154-4E6C-933F-B2659B18A907) dans la documentation Oracle.
**Pour modifier le paramètre de fuseau horaire actuel**
1. Connectez-vous à la base de données à l'aide d'un client tel que SQL Developer. Pour plus d'informations, consultez [Connexion à votre instance de base de données à l'aide d'Oracle SQL Developer](USER_ConnectToOracleInstance.SQLDeveloper.md).
1. Définissez le fuseau horaire par défaut comme suit, en remplaçant votre fuseau horaire par `time_zone_name`.
```
BEGIN
DBMS_SCHEDULER.SET_SCHEDULER_ATTRIBUTE(
attribute => 'default_timezone',
value => 'time_zone_name'
);
END;
/
```
Dans l'exemple suivant, vous changez le fuseau horaire pour Asia/Shanghai.
Commencez par interroger le fuseau horaire actuel, comme indiqué ci-dessous.
```
SELECT VALUE FROM DBA_SCHEDULER_GLOBAL_ATTRIBUTE WHERE ATTRIBUTE_NAME='DEFAULT_TIMEZONE';
```
La sortie indique que le fuseau horaire actuel est ETC/UTC.
```
VALUE
-------
Etc/UTC
```
Ensuite, vous définissez le fuseau horaire sur Asia/Shanghai.
```
BEGIN
DBMS_SCHEDULER.SET_SCHEDULER_ATTRIBUTE(
attribute => 'default_timezone',
value => 'Asia/Shanghai'
);
END;
/
```
Pour plus d'informations sur la modification du fuseau horaire système, consultez [Fuseau horaire Oracle](Appendix.Oracle.Options.Timezone.md).
## Désactivation de travaux Oracle Scheduler détenus par SYS
Pour désactiver un travail Oracle Scheduler détenu par l'utilisateur SYS, utilisez la procédure `rdsadmin.rdsadmin_dbms_scheduler.disable`.
Cette procédure utilise le paramètre commun `name` pour les tâches Oracle Scheduler. Pour plus d'informations, consultez [Paramètres communs pour les procédures d'Oracle Scheduler](#Appendix.Oracle.CommonDBATasks.Scheduler.CommonParameters).
L'exemple suivant désactive le travail Oracle Scheduler `SYS.CLEANUP_ONLINE_IND_BUILD`.
```
BEGIN
rdsadmin.rdsadmin_dbms_scheduler.disable('SYS.CLEANUP_ONLINE_IND_BUILD');
END;
/
```
## Activation de travaux Oracle Scheduler détenus par SYS
Pour activer un travail Oracle Scheduler détenu par SYS, utilisez la procédure `rdsadmin.rdsadmin_dbms_scheduler.enable`.
Cette procédure utilise le paramètre commun `name` pour les tâches Oracle Scheduler. Pour plus d'informations, consultez [Paramètres communs pour les procédures d'Oracle Scheduler](#Appendix.Oracle.CommonDBATasks.Scheduler.CommonParameters).
L'exemple suivant active le travail Oracle Scheduler `SYS.CLEANUP_ONLINE_IND_BUILD`.
```
BEGIN
rdsadmin.rdsadmin_dbms_scheduler.enable('SYS.CLEANUP_ONLINE_IND_BUILD');
END;
/
```
## Modification de l'intervalle de répétition Oracle Scheduler pour les travaux du type CALENDAR
Pour modifier l'intervalle de répétition d'un travail Oracle Scheduler relevant de SYS de type `CALENDAR`, utilisez la procédure `rdsadmin.rdsadmin_dbms_scheduler.disable`.
Cette procédure utilise les paramètres communs suivants pour les tâches Oracle Scheduler :
+ `name`
+ `attribute`
+ `value`
Pour plus d'informations, consultez [Paramètres communs pour les procédures d'Oracle Scheduler](#Appendix.Oracle.CommonDBATasks.Scheduler.CommonParameters).
L'exemple suivant modifier l'intervalle de répétition du travail Oracle Scheduler `SYS.CLEANUP_ONLINE_IND_BUILD`.
```
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;
/
```
## Modification de l'intervalle de répétition Oracle Scheduler pour les travaux du type NAMED
Certains travaux Oracle Scheduler utilisent non pas un intervalle, mais un nom de planification. Pour ce type de travaux, vous devez créer une planification nommée dans le schéma d'utilisateur principal. Pour cela, utilisez la procédure Oracle standard `sys.dbms_scheduler.create_schedule`. De même, utilisez `rdsadmin.rdsadmin_dbms_scheduler.set_attribute procedure` pour affecter la nouvelle planification nommée à la tâche.
Cette procédure utilise le paramètre commun suivant pour les tâches Oracle Scheduler :
+ `name`
+ `attribute`
+ `value`
Pour plus d'informations, consultez [Paramètres communs pour les procédures d'Oracle Scheduler](#Appendix.Oracle.CommonDBATasks.Scheduler.CommonParameters).
L'exemple suivant modifier l'intervalle de répétition du travail Oracle Scheduler `SYS.BSLN_MAINTAIN_STATS_JOB`.
```
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;
/
```
## Désactivation de la validation automatique pour la création de travaux Oracle Scheduler
Quand `DBMS_SCHEDULER.CREATE_JOB` crée des travaux Oracle Scheduler, il les crée immédiatement et valide les modifications. Vous devrez peut-être intégrer la création de travaux Oracle Scheduler dans la transaction utilisateur pour effectuer les opérations suivantes :
+ Annuler le travail Oracle Scheduler lorsque la transaction utilisateur est annulée.
+ Créer la tâche Oracle Scheduler lorsque la transaction utilisateur principale est validée.
Vous pouvez utiliser la procédure `rdsadmin.rdsadmin_dbms_scheduler.set_no_commit_flag` pour activer ce comportement. Cette procédure ne prend aucun paramètre. Vous pouvez utiliser cette procédure dans les versions suivantes de RDS for Oracle :
+ 21.0.0.0.ru-2022-07.rur-2022-07.r1 et versions ultérieures
+ 19.0.0.0.ru-2022-07.rur-2022-07.r1 et versions ultérieures
L'exemple suivant désactive la validation automatique pour Oracle Scheduler, crée un travail Oracle Scheduler, puis annule la transaction. Comme la validation automatique est désactivée, la base de données annule également la création du travail 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
```
# Diagnostic des problèmes liés à RDS pour les instances de base de données Oracle
Oracle Database inclut une infrastructure de diagnostic des pannes que vous pouvez utiliser pour analyser les problèmes de base de données. Dans la terminologie Oracle, un *problème* est une erreur critique, par exemple, un bogue de code ou une corruption de données. Un *incident* est la survenue d'un problème. Si la même erreur se produit trois fois, l'infrastructure affiche trois incidents de ce problème. Pour plus d’informations, consultez [Diagnostic et résolution de problèmes](https://docs.oracle.com/en/database/oracle/oracle-database/19/admin/diagnosing-and-resolving-problems.html#GUID-8DEB1BE0-8FB9-4FB2-A19A-17CF6F5791C3) dans la documentation Oracle Database.
L'utilitaire ADRCI (Automatic Diagnostic Repository Command Interpreter) est un outil de ligne de commande Oracle qui vous permet de gérer les données de diagnostic. Par exemple, vous pouvez utiliser cet outil pour analyser les problèmes et regrouper les données de diagnostic. Un *package d'incidents* inclut les données de diagnostic d'un incident ou de tous les incidents qui se rapportent à un problème spécifique. Vous pouvez charger un package d'incidents, qui est implémenté en tant que fichier .zip, vers le support Oracle.
Pour offrir une expérience de service géré, Amazon RDS ne fournit pas l'accès shell à ADRCI. Pour effectuer des tâches de diagnostic pour votre instance de base de données RDS for Oracle, utilisez plutôt le package Amazon RDS `rdsadmin.rdsadmin_adrci_util`.
Grâce aux fonctions incluses dans `rdsadmin_adrci_util`, vous pouvez répertorier et regrouper les problèmes et les incidents, et également afficher les fichiers de trace. Toutes les fonctions renvoient un ID de tâche. Cet ID fait partie du nom du fichier journal qui contient la sortie ADRCI, comme dans `dbtask-task_id.log`. Le fichier journal réside dans le répertoire BDUMP. Vous pouvez télécharger le fichier journal à l’aide de la procédure suivante décrite dans [Téléchargement d'un fichier journal de base de données](USER_LogAccess.Procedural.Downloading.md).
## Paramètres courants pour les procédures de diagnostic
Pour effectuer des tâches de diagnostic, utilisez les fonctions du package Amazon RDS `rdsadmin.rdsadmin_adrci_util`. Le package possède les paramètres communs suivants.
****
| Nom du paramètre | Type de données | Valeurs valides | Par défaut | Obligatoire | Description |
| --- | --- | --- | --- | --- | --- |
| `incident_id` | nombre | Un ID d'incident valide ou null | Null | Non | Si la valeur est null, la fonction affiche tous les incidents. Si la valeur n'est pas null et représente un ID d'incident valide, la fonction affiche l'incident spécifié. |
| `problem_id` | nombre | Un ID de problème valide ou null | Null | Non | Si la valeur est null, la fonction affiche tous les problèmes. Si la valeur n'est pas null et représente un ID de problème valide, la fonction affiche le problème spécifié. |
| `last` | nombre | Un entier valide supérieur à 0 ou null | Null | Non | Si la valeur est null, la fonction affiche au maximum 50 éléments. Si la valeur n'est pas null, la fonction affiche le nombre spécifié. |
## Répertorier les incidents
Pour répertorier les incidents de diagnostic pour Oracle, utilisez la fonction Amazon RDS `rdsadmin.rdsadmin_adrci_util.list_adrci_incidents`. Vous pouvez répertorier les incidents en mode basique ou détaillé. Par défaut, la fonction répertorie les 50 incidents les plus récents.
Cette fonction utilise les paramètres communs suivants :
+ `incident_id`
+ `problem_id`
+ `last`
Si vous spécifiez `incident_id` et `problem_id`, alors `incident_id` remplace `problem_id`. Pour de plus amples informations, veuillez consulter [Paramètres courants pour les procédures de diagnostic](#Appendix.Oracle.CommonDBATasks.CommonDiagParameters).
Cette fonction utilise le paramètre supplémentaire suivant.
****
| Nom du paramètre | Type de données | Valeurs valides | Par défaut | Obligatoire | Description |
| --- | --- | --- | --- | --- | --- |
| `detail` | booléen | TRUE ou FALSE | `FALSE` | Non | Si `TRUE`, la fonction répertorie les incidents en mode détail. Si `FALSE`, la fonction répertorie les incidents en mode basique. |
Pour répertorier tous les incidents, effectuez une requête à la fonction `rdsadmin.rdsadmin_adrci_util.list_adrci_incidents` sans aucun argument. La requête renvoie l'ID de tâche.
```
SQL> SELECT rdsadmin.rdsadmin_adrci_util.list_adrci_incidents AS task_id FROM DUAL;
TASK_ID
------------------
1590786706158-3126
```
Ou appelez la fonction `rdsadmin.rdsadmin_adrci_util.list_adrci_incidents` sans aucun argument et stockez la sortie dans une variable client SQL. Vous pouvez utiliser la variable dans d'autres instructions.
```
SQL> VAR task_id VARCHAR2(80);
SQL> EXEC :task_id := rdsadmin.rdsadmin_adrci_util.list_adrci_incidents;
PL/SQL procedure successfully completed.
```
Pour lire le fichier journal, appelez la procédure Amazon RDS `rdsadmin.rds_file_util.read_text_file`. Indiquez l'ID de tâche dans le nom du fichier. La sortie suivante montre trois incidents : 53523, 53522 et 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.
```
Pour répertorier un incident particulier, spécifiez son ID à l'aide du paramètre `incident_id`. Dans l'exemple suivant, vous interroger le fichier journal pour l'incident 53523 uniquement.
```
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.
```
## Répertorier les problèmes
Pour répertorier les problèmes de diagnostic pour Oracle, utilisez la fonction Amazon RDS `rdsadmin.rdsadmin_adrci_util.list_adrci_problems`.
Par défaut, la fonction répertorie les 50 problèmes les plus récents.
Cette fonction utilise les paramètres courants `problem_id` et `last`. Pour de plus amples informations, veuillez consulter [Paramètres courants pour les procédures de diagnostic](#Appendix.Oracle.CommonDBATasks.CommonDiagParameters).
Pour obtenir l'ID de tâche pour tous les problèmes, appelez la fonction `rdsadmin.rdsadmin_adrci_util.list_adrci_problems` sans argument et stockez la sortie dans une variable client SQL.
```
SQL> EXEC :task_id := rdsadmin.rdsadmin_adrci_util.list_adrci_problems;
PL/SQL procedure successfully completed.
```
Pour lire le fichier journal, appelez la fonction `rdsadmin.rds_file_util.read_text_file`, en fournissant l'ID de tâche dans le nom du fichier. Dans la sortie suivante, le fichier journal présente trois problèmes : 1, 2 et 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.
```
Dans l'exemple suivant, vous répertoriez uniquement le problème 3.
```
SQL> EXEC :task_id := rdsadmin.rdsadmin_adrci_util.list_adrci_problems(problem_id=>3);
PL/SQL procedure successfully completed.
```
Pour lire le fichier journal du problème 3, appelez `rdsadmin.rds_file_util.read_text_file`. Indiquez l'ID de tâche dans le nom du fichier.
```
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.
```
## Création de packages d'incidents
Vous pouvez créer des packages d'incident à l'aide de la fonction Amazon RDS `rdsadmin.rdsadmin_adrci_util.create_adrci_package`. La sortie est un fichier .zip que vous pouvez fournir au support Oracle.
Cette fonction utilise les paramètres communs suivants :
+ `problem_id`
+ `incident_id`
Assurez-vous de spécifier l'un des paramètres précédents. Si vous spécifiez les deux paramètres, `incident_id` remplace `problem_id`. Pour plus d'informations, consultez [Paramètres courants pour les procédures de diagnostic](#Appendix.Oracle.CommonDBATasks.CommonDiagParameters).
Pour créer un package pour un incident spécifique, appelez la fonction Amazon RDS `rdsadmin.rdsadmin_adrci_util.create_adrci_package` avec le paramètre `incident_id`. L'exemple suivant crée un package pour l'incident 53523.
```
SQL> EXEC :task_id := rdsadmin.rdsadmin_adrci_util.create_adrci_package(incident_id=>53523);
PL/SQL procedure successfully completed.
```
Pour lire le fichier journal, appelez le fichier `rdsadmin.rds_file_util.read_text_file`. Vous pouvez fournir l'ID de tâche dans le nom du fichier. La sortie indique que vous avez généré le package d'incidents `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.
```
Pour regrouper les données de diagnostic concernant un problème particulier, spécifiez son ID à l'aide du paramètre `problem_id`. Dans l'exemple suivant, vous regrouper les données pour le problème 3 uniquement.
```
SQL> EXEC :task_id := rdsadmin.rdsadmin_adrci_util.create_adrci_package(problem_id=>3);
PL/SQL procedure successfully completed.
```
Pour lire la sortie de la tâche, appelez `rdsadmin.rds_file_util.read_text_file`, en fournissant l'ID de la tâche dans le nom du fichier. La sortie indique que vous avez généré le package d'incidents `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.
```
Vous pouvez également télécharger le fichier journal. Pour de plus amples informations, veuillez consulter [Téléchargement d'un fichier journal de base de données](USER_LogAccess.Procedural.Downloading.md).
## Affichage des fichiers de trace
Vous pouvez utiliser la fonction Amazon RDS `rdsadmin.rdsadmin_adrci_util.show_adrci_tracefile` pour répertorier les fichiers de suivi dans l'annuaire de suivi et tous les annuaires d'incidents sous la page d'accueil ADR actuelle. Vous pouvez également afficher le contenu des fichiers de suivi et des fichiers de suivi des incidents.
Cette fonction utilise le paramètre suivant.
****
| Nom du paramètre | Type de données | Valeurs valides | Par défaut | Obligatoire | Description |
| --- | --- | --- | --- | --- | --- |
| `filename` | varchar2 | Un nom de fichier de trace valide | Null | Non | Si la valeur est null, la fonction affiche tous les fichiers de trace. Si elle n'est pas null, la fonction affiche le fichier spécifié. |
Pour afficher le fichier de suivi, appelez la fonction Amazon RDS `rdsadmin.rdsadmin_adrci_util.show_adrci_tracefile`.
```
SQL> EXEC :task_id := rdsadmin.rdsadmin_adrci_util.show_adrci_tracefile;
PL/SQL procedure successfully completed.
```
Pour répertorier les noms des fichiers de trace, appelez la procédure Amazon RDS `rdsadmin.rds_file_util.read_text_file`, en fournissant l'ID de tâche dans le nom du fichier.
```
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.
```
Dans l’exemple suivant, vous générez la sortie pour `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.
```
Pour lire le fichier journal, appelez `rdsadmin.rds_file_util.read_text_file`. Indiquez l'ID de tâche dans le nom du fichier. La sortie affiche les 10 premières lignes d'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.
```
Vous pouvez également télécharger le fichier journal. Pour de plus amples informations, veuillez consulter [Téléchargement d'un fichier journal de base de données](USER_LogAccess.Procedural.Downloading.md).
# Exécution des tâches diverses pour les instances de base de données Oracle
Vous trouverez ci-dessous des informations sur la façon d'effectuer diverses tâches DBA sur vos instances de base de données Amazon RDS exécutant Oracle. Pour offrir une expérience de service géré, Amazon RDS ne fournit pas l'accès shell aux instances de base de données et limite l'accès à certaines tables et procédures système qui requièrent des privilèges avancés.
**Topics**
+ [Création et suppression de répertoires dans l'espace de stockage de données principal](#Appendix.Oracle.CommonDBATasks.NewDirectories)
+ [Établissement de la liste des fichiers situés dans un répertoire d'instance de base de données](#Appendix.Oracle.CommonDBATasks.ListDirectories)
+ [Lecture de fichiers dans un répertoire d'instance de base de données](#Appendix.Oracle.CommonDBATasks.ReadingFiles)
+ [Accès aux fichiers Opatch](#Appendix.Oracle.CommonDBATasks.accessing-opatch-files)
+ [Gestion des tâches de conseiller](#Appendix.Oracle.CommonDBATasks.managing-advisor-tasks)
+ [Transport des espaces de table](rdsadmin_transport_util.md)
## Création et suppression de répertoires dans l'espace de stockage de données principal
Pour créer des répertoires, utilisez la procédure Amazon RDS `rdsadmin.rdsadmin_util.create_directory`. Vous pouvez créer jusqu'à 10 000 répertoires, tous situés dans votre espace principal de stockage des données. Pour supprimer des répertoires, utilisez la procédure Amazon RDS `rdsadmin.rdsadmin_util.drop_directory`.
Les procédures `create_directory` et `drop_directory` ont le paramètre requis suivant.
****
| Nom du paramètre | Type de données | Par défaut | Obligatoire | Description |
| --- | --- | --- | --- | --- |
| `p_directory_name` | VARCHAR2 | — | Oui | Nom du répertoire. |
L'exemple suivant crée un répertoire nommé `PRODUCT_DESCRIPTIONS`.
```
EXEC rdsadmin.rdsadmin_util.create_directory(p_directory_name => 'product_descriptions');
```
Le dictionnaire de données stocke le nom du répertoire en majuscules. Vous pouvez lister les répertoires en interrogeant `DBA_DIRECTORIES`. Le système choisit le nom du chemin réel de l'hôte automatiquement. L’exemple suivant récupère le chemin du répertoire nommé `PRODUCT_DESCRIPTIONS` :
```
SELECT DIRECTORY_PATH
FROM DBA_DIRECTORIES
WHERE DIRECTORY_NAME='PRODUCT_DESCRIPTIONS';
DIRECTORY_PATH
----------------------------------------
/rdsdbdata/userdirs/01
```
Le nom d'utilisateur maître de l'instance de base de données possède des privilèges de lecture et d'écriture dans le nouveau répertoire et peut accorder l'accès à d'autres utilisateurs. Les privilèges `EXECUTE` ne sont pas disponibles pour les répertoires sur une instance de base de données. Les répertoires sont créés dans votre espace de stockage de données principal et consommeront de l'espace et de la I/O bande passante.
L'exemple suivant supprime le répertoire nommé `PRODUCT_DESCRIPTIONS`.
```
EXEC rdsadmin.rdsadmin_util.drop_directory(p_directory_name => 'product_descriptions');
```
**Note**
Vous pouvez également supprimer un répertoire à l'aide de la commande SQL Oracle `DROP DIRECTORY`.
La suppression d'un répertoire ne supprime pas son contenu. Étant donné que la procédure `rdsadmin.rdsadmin_util.create_directory` peut réutiliser les noms de chemin, les fichiers figurant dans les répertoires supprimés peuvent apparaître dans un répertoire nouvellement créé. Avant de supprimer un répertoire, nous vous recommandons d'utiliser `UTL_FILE.FREMOVE` pour supprimer les fichiers du répertoire. Pour plus d’informations, consultez [FREMOVE Procedure](https://docs.oracle.com/database/121/ARPLS/u_file.htm#ARPLS70924) dans la documentation Oracle.
## Établissement de la liste des fichiers situés dans un répertoire d'instance de base de données
Pour lister les fichiers contenus dans un répertoire, utilisez la procédure Amazon RDS `rdsadmin.rds_file_util.listdir`. Cette procédure n’est pas prise en charge sur un réplica Oracle. La procédure `listdir` possède les paramètres suivants.
****
| Nom du paramètre | Type de données | Par défaut | Obligatoire | Description |
| --- | --- | --- | --- | --- |
| `p_directory` | varchar2 | — | Oui | Nom du répertoire à lister. |
L'exemple suivant accorde des read/write privilèges sur le répertoire `PRODUCT_DESCRIPTIONS` à l'utilisateur`rdsadmin`, puis répertorie les fichiers de ce répertoire.
```
GRANT READ,WRITE ON DIRECTORY PRODUCT_DESCRIPTIONS TO rdsadmin;
SELECT * FROM TABLE(rdsadmin.rds_file_util.listdir(p_directory => 'PRODUCT_DESCRIPTIONS'));
```
## Lecture de fichiers dans un répertoire d'instance de base de données
Pour lire un fichier texte, utilisez la procédure Amazon RDS `rdsadmin.rds_file_util.read_text_file`. La procédure `read_text_file` possède les paramètres suivants.
****
| Nom du paramètre | Type de données | Par défaut | Obligatoire | Description |
| --- | --- | --- | --- | --- |
| `p_directory` | varchar2 | — | Oui | Nom du répertoire qui contient le fichier. |
| `p_filename` | varchar2 | — | Oui | Nom du fichier à lire. |
L'exemple suivant lit le fichier `rice.txt` dans le répertoire `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;
/
```
L'exemple suivant lit le fichier `rice.txt` figurant dans le répertoire `PRODUCT_DESCRIPTIONS`.
```
SELECT * FROM TABLE
(rdsadmin.rds_file_util.read_text_file(
p_directory => 'PRODUCT_DESCRIPTIONS',
p_filename => 'rice.txt'));
```
## Accès aux fichiers Opatch
Opatch est un utilitaire Oracle qui permet l'application et la restauration de correctifs sur le logiciel Oracle. Le mécanisme Oracle qui permet de déterminer les correctifs ayant été appliqués à une base de données est la commande `opatch lsinventory`. Pour ouvrir des demandes de service pour les clients Bring Your Own Licence (BYOL), le support Oracle demande le fichier `lsinventory` et parfois le fichier `lsinventory_detail` généré par Opatch.
Pour offrir une expérience de service géré, Amazon RDS ne fournit pas l'accès shell à Opatch. En lieu et place, le `lsinventory-dbv.txt` dans le répertoire BDUMP contient les informations de correctif relatives à la version actuelle de votre moteur. Lorsque vous effectuez une mise à niveau mineure ou majeure, Amazon RDS met à jour `lsinventory-dbv.txt` dans l'heure suivant l'application du correctif. Pour vérifier les correctifs appliqués, consultez `lsinventory-dbv.txt`. Cette action revient à exécuter la commande `opatch lsinventory`.
**Note**
Les exemples de cette section supposent que le répertoire BDUMP est nommé `BDUMP`. Sur un réplica en lecture, le nom du répertoire BDUMP est différent. Pour savoir comment obtenir le nom BDUMP en interrogeant `V$DATABASE.DB_UNIQUE_NAME` sur un réplica en lecture, consultez [Liste de fichiers](USER_LogAccess.Concepts.Oracle.md#USER_LogAccess.Concepts.Oracle.WorkingWithTracefiles.ViewingBackgroundDumpDest).
Les fichiers d'inventaire utilisent la convention de dénomination Amazon RDS `lsinventory-dbv.txt` et `lsinventory_detail-dbv.txt` indiquent où se *dbv* trouve le nom complet de votre version de base de données. Le fichier `lsinventory-dbv.txt` est disponible sur toutes les versions de base de données. La `lsinventory_detail-dbv.txt` correspondante est disponible sur 19.0.0.0, ru-2020-01.rur-2020-01.r1 ou version ultérieure.
Par exemple, si votre version de base de données est 19.0.0.0.ru-2021-07.rur-2021-07.r1, vos fichiers d'inventaire portent les noms suivants.
```
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
```
Assurez-vous de télécharger les fichiers qui correspondent à la version actuelle de votre moteur de base de données.
### Console
**Pour télécharger un fichier d'inventaire à l'aide de la console**
1. Ouvrez la console Amazon RDS à l'adresse [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Dans la panneau de navigation, choisissez **Databases (Bases de données)**.
1. Choisissez le nom de l’instance de base de données qui contient le fichier journal que vous voulez consulter.
1. Choisissez l’onglet **Logs & events** (Journaux et événements).
1. Faites défiler jusqu'à la section **Journaux**.
1. Dans la section **Logs (Journaux)** recherchez `lsinventory`.
1. Sélectionnez le fichier auquel vous souhaitez accéder, puis choisissez **Download (Télécharger)**.
### SQL
Pour lire le fichier `lsinventory-dbv.txt` dans un client SQL, vous pouvez utiliser une instruction `SELECT`. Pour cette technique, utilisez l'une des fonctions `rdsadmin` suivantes : `rdsadmin.rds_file_util.read_text_file` ou `rdsadmin.tracefile_listing`.
Dans l'exemple de requête suivant, remplacez-le *dbv* par votre version de base de données Oracle. Par exemple, la version de votre base de données peut être 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
Pour lire le `lsinventory-dbv.txt` dans un client SQL, vous pouvez écrire un PL/SQL programme. Ce programme utilise `utl_file` pour lire le fichier et `dbms_output` pour l'imprimer. Ce sont des packages fournis par Oracle.
Dans l'exemple de programme suivant, remplacez-le *dbv* par votre version de base de données Oracle. Par exemple, la version de votre base de données peut être 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 interrogez `rdsadmin.tracefile_listing` et spoulez la sortie vers un fichier. L'exemple suivant spoule la sortie vers `/tmp/tracefile.txt`.
```
SPOOL /tmp/tracefile.txt
SELECT *
FROM rdsadmin.tracefile_listing
WHERE FILENAME LIKE 'lsinventory%';
SPOOL OFF;
```
## Gestion des tâches de conseiller
Oracle Database comprend un nombre de conseillers. Chaque conseiller prend en charge des tâches automatisées et manuelles. Vous pouvez utiliser des procédures dans le package `rdsadmin.rdsadmin_util` pour gérer certaines tâches de conseiller.
Les procédures de tâches de conseiller sont disponibles dans les versions suivantes du moteur :
+ Oracle Database 21c (21.0.0)
+ Version 19.0.0.0.ru-2021-01.rur-2021-01.r1 et versions ultérieures de Oracle Database 19c
Pour plus d’informations, consultez [Version 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) dans *Notes de mise à jour d’Amazon RDS for Oracle*.
**Topics**
+ [Définition des paramètres des tâches de conseiller](#Appendix.Oracle.CommonDBATasks.setting-task-parameters)
+ [Désactivation de AUTO\$1STATS\$1ADVISOR\$1TASK](#Appendix.Oracle.CommonDBATasks.dropping-advisor-task)
+ [Réactivation de AUTO\$1STATS\$1ADVISOR\$1TASK](#Appendix.Oracle.CommonDBATasks.recreating-advisor-task)
### Définition des paramètres des tâches de conseiller
Pour définir les paramètres de certaines tâches de conseiller, utilisez la procédure Amazon RDS `rdsadmin.rdsadmin_util.advisor_task_set_parameter`. La procédure `advisor_task_set_parameter` possède les paramètres suivants.
****
| Nom du paramètre | Type de données | Par défaut | Obligatoire | Description |
| --- | --- | --- | --- | --- |
| `p_task_name` | varchar2 | — | Oui | Nom de la tâche de conseiller dont vous voulez modifier les paramètres. Les valeurs suivantes sont valides : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.Misc.html) |
| `p_parameter` | varchar2 | — | Oui | Nom du paramètre de la tâche. Pour rechercher des paramètres valides d'une tâche de conseiller, exécutez la requête suivante. Remplacez *p\$1task\$1name* par une valeur valide `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 | — | Oui | Valeur d'un paramètre de la tâche. Pour rechercher des valeurs valides pour des paramètres de la tâche, exécutez la requête suivante. Remplacez *p\$1task\$1name* par une valeur valide `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;
|
Le PL/SQL programme suivant est défini `ACCEPT_PLANS` sur `FALSE` for`SYS_AUTO_SPM_EVOLVE_TASK`. La tâche automatisée SQL Plan Management vérifie les plans et génère un rapport de résultats, mais ne fait pas évoluer les plans automatiquement. Vous pouvez utiliser un rapport pour identifier de nouvelles lignes de base de SQL Plan et les accepter manuellement.
```
BEGIN
rdsadmin.rdsadmin_util.advisor_task_set_parameter(
p_task_name => 'SYS_AUTO_SPM_EVOLVE_TASK',
p_parameter => 'ACCEPT_PLANS',
p_value => 'FALSE');
END;
```
Le PL/SQL programme suivant est défini `EXECUTION_DAYS_TO_EXPIRE` sur `10` for`AUTO_STATS_ADVISOR_TASK`. La tâche prédéfinie `AUTO_STATS_ADVISOR_TASK` s'exécute dans la fenêtre de maintenance une fois par jour automatiquement. Dans l'exemple, la période de rétention pour l'exécution de la tâche est définie à 10 jours.
```
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;
```
### Désactivation de AUTO\$1STATS\$1ADVISOR\$1TASK
Pour désactiver `AUTO_STATS_ADVISOR_TASK`, utilisez la procédure Amazon RDS `rdsadmin.rdsadmin_util.advisor_task_drop`. La procédure `advisor_task_drop` accepte les paramètres suivants.
****
| Nom du paramètre | Type de données | Par défaut | Obligatoire | Description |
| --- | --- | --- | --- | --- |
| `p_task_name` | varchar2 | — | Oui | Nom de la tâche de conseiller qui doit être désactivée. La seule valeur valide est `AUTO_STATS_ADVISOR_TASK`. |
La commande suivante désactive `AUTO_STATS_ADVISOR_TASK`.
```
EXEC rdsadmin.rdsadmin_util.advisor_task_drop('AUTO_STATS_ADVISOR_TASK')
```
Vous pouvez réactiver `AUTO_STATS_ADVISOR_TASK` en utilisant `rdsadmin.rdsadmin_util.dbms_stats_init`.
### Réactivation de AUTO\$1STATS\$1ADVISOR\$1TASK
Pour réactiver `AUTO_STATS_ADVISOR_TASK`, utilisez la procédure Amazon RDS `rdsadmin.rdsadmin_util.dbms_stats_init`. La procédure `dbms_stats_init` n'accepte aucun paramètre.
La commande suivante réactive `AUTO_STATS_ADVISOR_TASK`.
```
EXEC rdsadmin.rdsadmin_util.dbms_stats_init()
```
# Transport des espaces de table
Utilisez le package Amazon RDS `rdsadmin.rdsadmin_transport_util` pour copier un ensemble d'espaces de table d'une base de données Oracle sur site vers une instance de base de données RDS for Oracle. Au niveau physique, la fonctionnalité d'espace de table transportable copie de manière incrémentielle les fichiers de données et de métadonnées sources vers votre instance cible. Vous pouvez transférer les fichiers à l'aide d'Amazon EFS ou d'Amazon S3. Pour de plus amples informations, consultez [Migration à l'aide des espaces de table transportables Oracle](oracle-migrating-tts.md).
**Topics**
+ [Importation des espaces de table transportés dans votre instance de base de données](rdsadmin_transport_util_import_xtts_tablespaces.md)
+ [Importation des métadonnées d'espaces de table transportables dans votre instance de base de données](rdsadmin_transport_util_import_xtts_metadata.md)
+ [Établissement de la liste des fichiers orphelins après une importation d'espace de table](rdsadmin_transport_util_list_xtts_orphan_files.md)
+ [Suppression des fichiers de données devenus orphelins après une importation d'espace de table](rdsadmin_transport_util_cleanup_incomplete_xtts_import.md)
# Importation des espaces de table transportés dans votre instance de base de données
Utilisez la procédure `rdsadmin.rdsadmin_transport_util.import_xtts_tablespaces` pour restaurer les espaces de table que vous avez précédemment exportés depuis une instance de base de données source. Dans la phase de transport, vous sauvegardez vos espaces de table en lecture seule, exportez les métadonnées Data Pump, transférez ces fichiers vers votre instance de base de données cible, puis importez les espaces de table. Pour de plus amples informations, veuillez consulter [Phase 4 : Transport des espaces de table](oracle-migrating-tts.md#oracle-migrating-tts.final-br-phase).
## Syntaxe
```
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;
```
## Parameters
****
| Nom du paramètre | Type de données | Par défaut | Obligatoire | Description |
| --- | --- | --- | --- | --- |
| `p_tablespace_list` | `CLOB` | — | Oui | Liste des espaces de table à importer. |
| `p_directory_name` | `VARCHAR2` | — | Oui | Répertoire qui contient les sauvegardes d'espaces de table. |
| `p_platform_id` | `NUMBER` | `13` | Non | Fournissez un ID de plateforme qui correspond à celui spécifié durant la phase de sauvegarde. Pour obtenir la liste des plateformes, interrogez `V$TRANSPORTABLE_PLATFORM`. La plateforme par défaut est Linux x86 64 bits, qui est au format Little Endian. |
| `p_parallel` | `INTEGER` | `0` | Non | Degré de parallélisme. Par défaut, le parallélisme est désactivé. |
## Exemples
L'exemple suivant importe les tablespaces *TBS1**TBS2*, et *TBS3* depuis le répertoire. *DATA\$1PUMP\$1DIR* La plateforme source est AIX-Based Systems (64 bits), dont l’ID de plateforme est `6`. Vous pouvez trouver la plateforme IDs en `V$TRANSPORTABLE_PLATFORM` interrogeant.
```
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
```
# Importation des métadonnées d'espaces de table transportables dans votre instance de base de données
Utilisez la procédure `rdsadmin.rdsadmin_transport_util.import_xtts_metadata` pour importer les métadonnées d'espaces de table transportables dans votre instance de base de données RDS for Oracle. Pendant l'opération, le statut de l'importation des métadonnées est indiqué dans la table `rdsadmin.rds_xtts_operation_info`. Pour de plus amples informations, veuillez consulter [Étape 5 : Importer les métadonnées d'espace de table dans votre instance de base de données cible](oracle-migrating-tts.md#oracle-migrating-tts.transport.import-dmp).
## Syntaxe
```
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);
```
## Parameters
****
| Nom du paramètre | Type de données | Par défaut | Obligatoire | Description |
| --- | --- | --- | --- | --- |
| `p_datapump_metadata_file` | `SYS.DBA_DATA_FILES.FILE_NAME%TYPE` | — | Oui | Nom du fichier Data Pump d'Oracle qui contient les métadonnées de vos espaces de table transportables. |
| `p_directory_name` | `VARCHAR2` | — | Oui | Répertoire qui contient le fichier Data Pump. |
| `p_exclude_stats` | `BOOLEAN` | `FALSE` | Non | Indicateur qui indique s'il convient d'exclure les statistiques. |
| `p_remap_tablespace_list` | `CLOB` | NULL | Non | Liste des espaces de table à remapper lors de l'importation des métadonnées. Utilisez le format `from_tbs:to_tbs`. Par exemple, spécifiez `users:user_data`. |
| `p_remap_user_list` | `CLOB` | NULL | Non | Liste des schémas utilisateur à remapper lors de l'importation des métadonnées. Utilisez le format `from_schema_name:to_schema_name`. Par exemple, spécifiez `hr:human_resources`. |
## Exemples
L'exemple importe les métadonnées de l'espace disque logique à partir du fichier*xttdump.dmp*, qui se trouve dans le répertoire. *DATA\$1PUMP\$1DIR*
```
BEGIN
rdsadmin.rdsadmin_transport_util.import_xtts_metadata('xttdump.dmp','DATA_PUMP_DIR');
END;
/
```
# Établissement de la liste des fichiers orphelins après une importation d'espace de table
Utilisez la procédure `rdsadmin.rdsadmin_transport_util.list_xtts_orphan_files` pour répertorier les fichiers de données devenus orphelins après une importation d'espace de table. Après avoir identifié les fichiers de données, vous pouvez les supprimer en appelant `rdsadmin.rdsadmin_transport_util.cleanup_incomplete_xtts_import`.
## Syntaxe
```
FUNCTION list_xtts_orphan_files RETURN xtts_orphan_files_list_t PIPELINED;
```
## Exemples
L'exemple suivant exécute la procédure `rdsadmin.rdsadmin_transport_util.list_xtts_orphan_files`. La sortie montre deux fichiers de données devenus orphelins.
```
SQL> SELECT * FROM TABLE(rdsadmin.rdsadmin_transport_util.list_xtts_orphan_files);
FILENAME FILESIZE
-------------- ---------
datafile_7.dbf 104865792
datafile_8.dbf 104865792
```
# Suppression des fichiers de données devenus orphelins après une importation d'espace de table
Utilisez la procédure `rdsadmin.rdsadmin_transport_util.list_xtts_orphan_files` pour supprimer les fichiers de données devenus orphelins après une importation d'espace de table. L'exécution de cette commande génère un fichier journal qui utilise le format de noms `rds-xtts-delete_xtts_orphaned_files-YYYY-MM-DD.HH24-MI-SS.FF.log` dans le répertoire `BDUMP`. Utilisez la procédure `rdsadmin.rdsadmin_transport_util.cleanup_incomplete_xtts_import` pour trouver les fichiers orphelins. Vous pouvez lire le fichier journal en appelant la procédure `rdsadmin.rds_file_util.read_text_file`. Pour de plus amples informations, veuillez consulter [Phase 6 : Nettoyage des fichiers restants](oracle-migrating-tts.md#oracle-migrating-tts.cleanup).
## Syntaxe
```
PROCEDURE cleanup_incomplete_xtts_import(
p_directory_name IN VARCHAR2);
```
## Parameters
****
| Nom du paramètre | Type de données | Par défaut | Obligatoire | Description |
| --- | --- | --- | --- | --- |
| `p_directory_name` | `VARCHAR2` | — | Oui | Répertoire qui contient les fichiers de données orphelins. |
## Exemples
L'exemple suivant supprime les fichiers de données orphelins dans. *DATA\$1PUMP\$1DIR*
```
BEGIN
rdsadmin.rdsadmin_transport_util.cleanup_incomplete_xtts_import('DATA_PUMP_DIR');
END;
/
```
L'exemple suivant lit le fichier journal généré par la commande précédente.
```
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.
```