Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Verwaltung Ihrer DB-Instance von RDS für Oracle
Nachfolgend finden Sie die üblichen Verwaltungsaufgaben, die Sie mit einer DB-Instance von RDS für Oracle ausführen. Einige Aufgaben sind für alle RDS-DB-Instances gleich. Andere Aufgaben sind spezifisch für RDS für Oracle.
Die folgenden Aufgaben sind allen RDS-Datenbanken gemeinsam, Oracle Database hat jedoch spezielle Aspekte. Sie stellen beispielsweise eine Verbindung mit einer Oracle-Datenbank über die Oracle-Clients SQL\$1Plus und SQL Developer her.
****
| Aufgabenbereich | Relevante Dokumentation |
| --- | --- |
| **Instance-Klassen, Speicher und PIOPS** Wenn Sie eine Produktionsinstance erstellen, erfahren Sie, wie Instance-Klassen, Speichertypen und bereitgestellte IOPS in Amazon RDS funktionieren. | [DB-Instance-Klassen von RDS für Oracle](Oracle.Concepts.InstanceClasses.md) [Amazon-RDS-Speichertypen](CHAP_Storage.md#Concepts.Storage) |
| **Multi-AZ-Bereitstellungen** Bei einer DB-Instance für die Produktion sollten Multi-AZ-Bereitstellungen eingesetzt werden. Multi-AZ-Bereitstellungen bieten eine erhöhte Verfügbarkeit, eine längere Lebensdauer von Daten sowie eine höhere Fehlertoleranz für DB-Instances. | [Konfigurieren und Verwalten einer Multi-AZ-Bereitstellung für Amazon RDS](Concepts.MultiAZ.md) |
| **Amazon VPC** Wenn Ihr AWS Konto über eine standardmäßige Virtual Private Cloud (VPC) verfügt, wird Ihre DB-Instance automatisch in der Standard-VPC erstellt. Wenn Ihr Konto über keine Standard-VPC verfügt und Sie die DB-Instance in einer VPC erstellen möchten, müssen Sie zunächst die VPC und Subnetz-Gruppen erstellen, bevor Sie die Instance erstellen können. | [Arbeiten mit einer DB-Instance in einer VPC](USER_VPC.WorkingWithRDSInstanceinaVPC.md) |
| **Sicherheitsgruppen** Standardmäßig verwenden DB-Instances eine Firewall, die den Zugriff verhindert. Stellen Sie sicher, dass Sie eine Sicherheitsgruppe mit den korrekten IP-Adressen und Netzwerkkonfigurationen erstellen, um auf die DB-Instance zugreifen zu können. | [Zugriffskontrolle mit Sicherheitsgruppen](Overview.RDSSecurityGroups.md) |
| **Parametergruppen** Wenn Ihre DB-Instance spezifische Datenbankparameter erfordert, erstellen Sie vor der DB-Instance eine Parametergruppe. | [Parametergruppen für Amazon RDS](USER_WorkingWithParamGroups.md) |
| **Optionsgruppen** Wenn Ihre DB-Instance bestimmte Datenbankoptionen erfordert, erstellen Sie eine Optionsgruppe, bevor Sie die DB-Instance erstellen. | [Hinzufügen von Optionen zu Oracle DB-Instances](Appendix.Oracle.Options.md) |
| **Herstellen einer Verbindung mit einer DB-Instance** Nachdem Sie eine Sicherheitsgruppe erstellt und diese einer DB-Instance zugeordnet haben, können Sie mithilfe einer beliebigen Standard-SQL-Client-Anwendung, zum Beispiel Oracle SQL\$1Plus, eine Verbindung mit dieser DB-Instance herstellen. | [Herstellen der Verbindung zu Ihrer Oracle-DB-Instance](USER_ConnectToOracleInstance.md) |
| **Backup und Wiederherstellung** Sie können Ihre DB-Instance so konfigurieren, dass sie automatische Backups oder manuelle Snapshots vornimmt. Aus diesen Backups oder Snapshots können Sie dann Instances wiederherstellen. | [Sichern, Wiederherstellen und Exportieren von Daten](CHAP_CommonTasks.BackupRestore.md) |
| **Überwachung** Sie können eine Oracle-DB-Instance mithilfe von CloudWatch Amazon RDS-Metriken, Ereignissen und erweiterter Überwachung überwachen. | [Anzeigen von Metriken in der Amazon-RDS-Konsole](USER_Monitoring.md) [Anzeigen von Amazon-RDS-Ereignissen](USER_ListEvents.md) |
| **Protokolldateien** Sie können auf die Protokolldateien für Ihre Orale-DB-Instance zugreifen. | [Überwachen von Amazon RDS-Protokolldateien](USER_LogAccess.md) |
Nachfolgend finden Sie eine Beschreibung für Amazon-RDS-spezifische Implementierungen von häufigen DBA-Aufgaben für RDS Oracle. Um eine verwaltete Service-Erfahrung zu bieten, ermöglicht Amazon RDS keinen Shell-Zugriff auf DB-Instances. Außerdem schränkt RDS den Zugriff auf bestimmte Systemprozeduren und -tabellen ein, die erweiterte Berechtigungen erfordern. Bei vielen Aufgaben führen Sie das `rdsadmin`-Paket aus, das ist ein Amazon-RDS-spezifisches Tool ist, mit dem Sie Ihre Datenbank verwalten können.
Nachfolgend sehen Sie häufige DBA-Aufgaben für DB-Instances, in denen Oracle ausgeführt wird:
+ [Systemaufgaben](Appendix.Oracle.CommonDBATasks.System.md)
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.html)
+ [Datenbankaufgaben](Appendix.Oracle.CommonDBATasks.Database.md)
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.html)
+ [Protokollaufgaben](Appendix.Oracle.CommonDBATasks.Log.md)
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.html)
+ [RMAN-Aufgaben](Appendix.Oracle.CommonDBATasks.RMAN.md)
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.html)
+ [Oracle-Scheduler-Aufgaben](Appendix.Oracle.CommonDBATasks.Scheduler.md)
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.html)
+ [Diagnose von Problemen](Appendix.Oracle.CommonDBATasks.Diagnostics.md)
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.html)
+ [Weitere Aufgaben](Appendix.Oracle.CommonDBATasks.Misc.md)
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.html)
Sie können auch Amazon-RDS-Verfahren für die Amazon S3-Integration mit Oracle und für die Ausführung von OEM Management-Agent-Datenbankaufgaben verwenden. Weitere Informationen erhalten Sie unter [Amazon S3-Integration](oracle-s3-integration.md) und [Ausführen von Datenbankaufgaben mit dem Management Agent](Oracle.Options.OEMAgent.md#Oracle.Options.OEMAgent.DBTasks).
# Durchführen allgemeiner Systemaufgaben für Oracle DB-Instances
Im Folgenden erfahren Sie, wie Sie bestimmte allgemeine DBA-Aufgaben durchführen können, die mit dem System Ihrer Amazon-RDS-DB-Instances in Oracle zusammenhängen. Um eine verwaltete Service-Erfahrung zu bieten, stellt Amazon RDS keinen Shell-Zugriff zu DB-Instances bereit und beschränkt den Zugriff auf bestimmte Systemprozeduren und -tabellen, die erweiterte Sonderrechte erfordern.
**Topics**
+ [
# Trennen einer Sitzung
](Appendix.Oracle.CommonDBATasks.DisconnectingSession.md)
+ [
# Beenden einer Sitzung
](Appendix.Oracle.CommonDBATasks.KillingSession.md)
+ [
# Abbrechen einer SQL-Anweisung in einer Sitzung
](Appendix.Oracle.CommonDBATasks.CancellingSQL.md)
+ [
# Aktivieren und Deaktivieren von beschränkten Sitzungen
](Appendix.Oracle.CommonDBATasks.RestrictedSession.md)
+ [
# Bereinigen des freigegebenen Pools
](Appendix.Oracle.CommonDBATasks.FlushingSharedPool.md)
+ [
# Erteilen von SELECT- oder EXECUTE-Berechtigungen für SYS-Objekte
](Appendix.Oracle.CommonDBATasks.TransferPrivileges.md)
+ [
# Widerrufen von SELECT- oder EXECUTE-Berechtigungen für SYS-Objekte
](Appendix.Oracle.CommonDBATasks.RevokePrivileges.md)
+ [
# Verwalten von RDS\$1X\$1-Ansichten für Oracle-DB-Instances
](Appendix.Oracle.CommonDBATasks.X-dollar.md)
+ [
# Erteilen von Berechtigungen an Nicht-Hauptbenutzer
](Appendix.Oracle.CommonDBATasks.PermissionsNonMasters.md)
+ [
# Erstellen von benutzerdefinierten Funktionen für das Überprüfen von Passwörtern
](Appendix.Oracle.CommonDBATasks.CustomPassword.md)
+ [
## Einrichten eines benutzerdefinierten DNS-Servers
](#Appendix.Oracle.CommonDBATasks.CustomDNS)
+ [
# Festlegen und Aufheben von Systemdiagnoseereignissen
](Appendix.Oracle.CommonDBATasks.SystemEvents.md)
# Trennen einer Sitzung
Um die aktuelle Sitzung zu trennen, indem Sie den dedizierten Serverprozess beenden, verwenden Sie die Amazon RDS-Prozedur `rdsadmin.rdsadmin_util.disconnect`. Die Prozedur `disconnect` hat die folgenden Parameter.
****
| Parametername | Datentyp | Standard | Erforderlich | Beschreibung |
| --- | --- | --- | --- | --- |
| `sid` | Zahl | — | Ja | Die Sitzungskennung |
| `serial` | Zahl | — | Ja | Die Seriennummer der Sitzung |
| `method` | varchar | 'IMMEDIATE' | Nein | Gültige Werte sind `'IMMEDIATE'` oder `'POST_TRANSACTION'`. |
Im folgenden Beispiel wird die Verbindung mit einer Sitzung getrennt.
```
begin
rdsadmin.rdsadmin_util.disconnect(
sid => sid,
serial => serial_number);
end;
/
```
Stellen Sie an die Ansicht `V$SESSION` eine Abfrage, um die Sitzungskennung und die -seriennummer zu erhalten. Im folgenden Beispiel werden alle Sitzungen für den Benutzer abgerufen `AWSUSER`.
```
SELECT SID, SERIAL#, STATUS FROM V$SESSION WHERE USERNAME = 'AWSUSER';
```
Die Datenbank muss offen sein, um diese Methode zu verwenden. Weitere Informationen über das Trennen der Verbindung zu einer Sitzung finden Sie unter [ALTER SYSTEM](http://docs.oracle.com/cd/E11882_01/server.112/e41084/statements_2014.htm#SQLRF53166) in der Oracle-Dokumentation.
# Beenden einer Sitzung
Um eine Sitzung zu beenden, verwenden Sie die Amazon RDS-Prozedur `rdsadmin.rdsadmin_util.kill`. Die Prozedur `kill` hat die folgenden Parameter.
****
| Parametername | Datentyp | Standard | Erforderlich | Beschreibung |
| --- | --- | --- | --- | --- |
| `sid` | Zahl | — | Ja | Die Sitzungskennung |
| `serial` | Zahl | — | Ja | Die Seriennummer der Sitzung |
| `method` | varchar | Null | Nein | Gültige Werte sind `'IMMEDIATE'` oder `'PROCESS'`. Wenn Sie `IMMEDIATE` angeben, hat dies den gleichen Effekt wie das Ausführen der folgenden Anweisung: ALTER SYSTEM KILL SESSION 'sid,serial#' IMMEDIATE
Wenn Sie `PROCESS` angeben, beenden Sie die mit einer Sitzung verbundenen Prozesse. Geben Sie `PROCESS` nur an, wenn Sie die Sitzung mit `IMMEDIATE` nicht beenden konnten. |
Stellen Sie an die Ansicht `V$SESSION` eine Abfrage, um die Sitzungskennung und die -seriennummer zu erhalten. Im folgenden Beispiel werden alle Sitzungen für den Benutzer abgerufen *AWSUSER*.
```
SELECT SID, SERIAL#, STATUS FROM V$SESSION WHERE USERNAME = 'AWSUSER';
```
Im folgenden Beispiel wird eine Sitzung beendet.
```
BEGIN
rdsadmin.rdsadmin_util.kill(
sid => sid,
serial => serial_number,
method => 'IMMEDIATE');
END;
/
```
Im folgenden Beispiel werden die mit einer Sitzung verbundenen Prozesse beendet.
```
BEGIN
rdsadmin.rdsadmin_util.kill(
sid => sid,
serial => serial_number,
method => 'PROCESS');
END;
/
```
# Abbrechen einer SQL-Anweisung in einer Sitzung
Um eine SQL-Anweisung in einer Sitzung abzubrechen, verwenden Sie die Amazon RDS-Prozedur `rdsadmin.rdsadmin_util.cancel`.
**Anmerkung**
Dieses Verfahren wird für Oracle Database 19c (19.0.0) und alle höheren Haupt- und Nebenversionen von RDS for Oracle unterstützt.
Die Prozedur `cancel` hat die folgenden Parameter.
****
| Parametername | Datentyp | Standard | Erforderlich | Beschreibung |
| --- | --- | --- | --- | --- |
| `sid` | Zahl | — | Ja | Die Sitzungskennung |
| `serial` | Zahl | — | Ja | Die Seriennummer der Sitzung |
| `sql_id` | varchar2 | Null | Nein | Die SQL-ID der SQL-Anweisung. |
Das folgende Beispiel bricht eine SQL-Anweisung in einer Sitzung ab.
```
begin
rdsadmin.rdsadmin_util.cancel(
sid => sid,
serial => serial_number,
sql_id => sql_id);
end;
/
```
Um die Sitzungs-ID, die Sitzungsseriennummer und die SQL-ID einer SQL-Anweisung abzurufen, rufen Sie die `V$SESSION`-Ansicht ab. Das folgende Beispiel ruft alle Sitzungen und SQL-IDs für den Benutzer a `AWSUSER`.
```
select SID, SERIAL#, SQL_ID, STATUS from V$SESSION where USERNAME = 'AWSUSER';
```
# Aktivieren und Deaktivieren von beschränkten Sitzungen
Um eine SQL-Anweisung in einer Sitzung abzubrechen, verwenden Sie die Amazon RDS-Prozedur `rdsadmin.rdsadmin_util.restricted_session`. Die Prozedur `restricted_session` hat die folgenden Parameter.
****
| Parametername | Datentyp | Standard | Ja | Beschreibung |
| --- | --- | --- | --- | --- |
| `p_enable` | Boolean | true | Nein | Setzen Sie diesen Parameter auf `true`, um beschränkte Sitzungen zu aktivieren, oder auf `false`, um beschränkte Sitzungen zu deaktivieren. |
Im folgenden Beispiel wird gezeigt, wie beschränkte Sitzungen aktiviert und deaktiviert werden können.
```
/* 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
```
# Bereinigen des freigegebenen Pools
Um den freigegebenen Pool zu bereinigen, verwenden Sie die Amazon-RDS-Prozedur `rdsadmin.rdsadmin_util.flush_shared_pool`. Die Prozedur `flush_shared_pool` hat keine Parameter.
Im folgenden Beispiel wird der geteilte Pool bereinigt.
```
EXEC rdsadmin.rdsadmin_util.flush_shared_pool;
```
## Bereinigen des Buffer-Cache
Um den gemeinsamen Pool zu leeren, verwenden Sie die Amazon RDS-Prozedur `rdsadmin.rdsadmin_util.flush_buffer_cache`. Die Prozedur `flush_buffer_cache` hat keine Parameter.
Im folgenden Beispiel wird der Buffer-Cache bereinigt.
```
EXEC rdsadmin.rdsadmin_util.flush_buffer_cache;
```
## Leeren des Smart-Flash-Caches der Datenbank
Wenn Sie den Smart-Flash-Cache der Datenbank leeren möchten, verwenden Sie das Amazon-RDS-Verfahren `rdsadmin.rdsadmin_util.flush_flash_cache`. Die Prozedur `flush_flash_cache` hat keine Parameter. Im folgenden Beispiel wird der Smart-Flash-Cache der Datenbank geleert.
```
EXEC rdsadmin.rdsadmin_util.flush_flash_cache;
```
Weitere Informationen zur Verwendung des Smart-Flash-Caches der Datenbank mit RDS für Oracle finden Sie unter [Speichern temporärer Daten in einem Instance-Speicher von RDS für Oracle](CHAP_Oracle.advanced-features.instance-store.md).
# Erteilen von SELECT- oder EXECUTE-Berechtigungen für SYS-Objekte
Im Normalfall werden Sonderrechte mithilfe von Rollen übertragen, die viele Objekte beinhalten können. Um den Puffer-Cache zu leeren, verwenden Sie die Amazon RDS-Prozedur `rdsadmin.rdsadmin_util.grant_sys_object`. Die Prozedur gewährt nur Berechtigungen, die dem Masterbenutzer bereits über eine Rolle oder direkte Erteilung gewährt wurden.
Die Prozedur `grant_sys_object` hat die folgenden Parameter.
**Wichtig**
Verwenden Sie für alle Parameterwerte Großbuchstaben, es sei denn, Sie haben den Benutzer mit einer Kennung mit bedeutsamer Groß- und Kleinschreibung erstellt. Wenn Sie z. B. `CREATE USER myuser` oder `CREATE USER MYUSER` ausführen , wird im Datenwörterbuch `MYUSER` gespeichert. Wenn Sie jedoch doppelte Anführungszeichen in `CREATE USER "MyUser"` verwenden, speichert das Datenwörterbuch `MyUser`.
****
| Parametername | Datentyp | Standard | Erforderlich | Beschreibung |
| --- | --- | --- | --- | --- |
| `p_obj_name` | varchar2 | — | Ja | Der Name des Objekts dem die Sonderrechte erteilt werden sollen. Das Objekt kann ein Verzeichnis, eine Funktion, ein Paket, eine Prozedur, eine Sequenz, eine Tabelle oder eine Ansicht sein. Objektnamen müssen genauso angegeben werden, wie sie in sin `DBA_OBJECTS`. Die meisten Systemobjekte sind in Großbuchstaben definiert. Daher empfehlen wir Ihnen, zuerst diese Schreibweise zu verwenden. |
| `p_grantee` | varchar2 | — | Ja | Der Name des Objekts, dem die Sonderrechte erteilt werden sollen. Das Objekt kann ein Schema oder eine Rolle sein. |
| `p_privilege` | varchar2 | Null | Ja | — |
| `p_grant_option` | Boolean | false | Nein | Setzen Sie diesen Wert auf `true`, um ihn mit der Genehmigungsoption zu verwenden. |
Im folgenden Beispiel werden einem Objekt mit dem Namen `V_$SESSION` für einen Benutzer mit dem Namen `USER1` ausgewählte Berechtigungen erteilt.
```
begin
rdsadmin.rdsadmin_util.grant_sys_object(
p_obj_name => 'V_$SESSION',
p_grantee => 'USER1',
p_privilege => 'SELECT');
end;
/
```
Im folgenden Beispiel werden einem Objekt mit dem Namen `V_$SESSION` für einen Benutzer mit dem Namen `USER1` mit der Erteilungsoption ausgewählte Berechtigungen erteilt.
```
begin
rdsadmin.rdsadmin_util.grant_sys_object(
p_obj_name => 'V_$SESSION',
p_grantee => 'USER1',
p_privilege => 'SELECT',
p_grant_option => true);
end;
/
```
Um Sonderrechte für ein Objekt erteilen zu können, muss Ihr Konto über diese Sonderrechte verfügen, die ihm entweder direkt, mithilfe der Genehmigungsoption oder einer Rolle mithilfe von erteilt wurde `with admin option`. Im häufigsten Fall wird das Sonderrecht `SELECT` an eine DBA-Ansicht erteilt, das an die Rolle `SELECT_CATALOG_ROLE` erteilt wurde. Wenn diese Rolle Ihrem Benutzer nicht bereits direkt mithilfe von `with admin option` erteilt wurde, können Sie die Berechtigung nicht übertragen. Wenn Sie über das DBA-Sonderrecht verfügen, können Sie die Rolle direkt an einen anderen Benutzer übertragen.
Im folgenden Beispiel wird die `SELECT_CATALOG_ROLE` und `EXECUTE_CATALOG_ROLE` an `USER1` übertragen. Da `with admin option` verwendet wird, kann `USER1` jetzt Zugriffsrechte auf SYS-Objekte erteilen, die an `SELECT_CATALOG_ROLE` erteilt wurden.
```
GRANT SELECT_CATALOG_ROLE TO USER1 WITH ADMIN OPTION;
GRANT EXECUTE_CATALOG_ROLE to USER1 WITH ADMIN OPTION;
```
Objekte, die bereits an `PUBLIC` erteilt wurden, müssen nicht erneut erteilt werden. Wenn Sie die Prozedur `grant_sys_object` verwenden, um erneut Zugriffsrechte zu erteilen, ist der Prozeduraufruf erfolgreich.
# Widerrufen von SELECT- oder EXECUTE-Berechtigungen für SYS-Objekte
Um Berechtigungen für ein einzelnes Objekt zu entziehen, verwenden Sie die Amazon RDS-Prozedur `rdsadmin.rdsadmin_util.revoke_sys_object`. Das Verfahren widerruft nur Privilegien, die dem Masterkonto bereits über eine Rolle oder direkte Erteilung gewährt wurden.
Die Prozedur `revoke_sys_object` hat die folgenden Parameter.
****
| Parametername | Datentyp | Standard | Erforderlich | Beschreibung |
| --- | --- | --- | --- | --- |
| `p_obj_name` | varchar2 | — | Ja | Der Name des Objekts, für das Berechtigungen widerrufen werden sollen. Das Objekt kann ein Verzeichnis, eine Funktion, ein Paket, eine Prozedur, eine Sequenz, eine Tabelle oder eine Ansicht sein. Objektnamen müssen genauso angegeben werden, wie sie in sin `DBA_OBJECTS`. Die meisten Systemobjekte sind in Großbuchstaben definiert, von daher empfehlen wir Ihnen, diese Schreibweise zuerst auszuprobieren. |
| `p_revokee` | varchar2 | — | Ja | Der Name des Objekts, für das Berechtigungen widerrufen werden sollen. Das Objekt kann ein Schema oder eine Rolle sein. |
| `p_privilege` | varchar2 | Null | Ja | — |
Im folgenden Beispiel werden ausgewählte Berechtigungen für ein Objekt mit dem Namen `V_$SESSION` von einem Benutzer mit dem Namen `USER1` widerrufen.
```
begin
rdsadmin.rdsadmin_util.revoke_sys_object(
p_obj_name => 'V_$SESSION',
p_revokee => 'USER1',
p_privilege => 'SELECT');
end;
/
```
# Verwalten von RDS\$1X\$1-Ansichten für Oracle-DB-Instances
Möglicherweise müssen Sie auf feste `SYS.X$`-Tabellen zugreifen, die nur über`SYS` aufgerufen werden können. Verwenden Sie die im `rdsadmin.rdsadmin_util`-Paket enthaltenen Verfahren, um `SYS.RDS_X$`-Ansichten für berechtigte `X$`-Tabellen zu erstellen. Ihrem Masterbenutzer wird automatisch die Berechtigung `SELECT … WITH GRANT OPTION` für die `RDS_X$`-Ansichten erteilt.
Die `rdsadmin.rdsadmin_util`-Verfahren sind in den folgenden Fällen verfügbar:
+ Vorhandene DB-Instances, die noch nie aktualisiert wurden und die folgenden Versionen verwenden:
+ `21.0.0.0.ru-2023-10.rur-2023-10.r1` und höhere 21c-Versionen
+ `19.0.0.0.ru-2023-10.rur-2023-10.r1` und höhere 19c-Versionen
+ Jede neue DB-Instance, die Sie erstellen
+ Jede vorhandene DB-Instance, die Sie aktualisiert haben
**Wichtig**
Intern erstellt das `rdsadmin.rdsadmin_util`-Paket Ansichten für `X$`-Tabellen. Die `X$`-Tabellen sind interne Systemobjekte, die in der Dokumentation zu Oracle Database nicht beschrieben werden. Wir empfehlen, dass Sie bestimmte Ansichten in Ihrer Nicht-Produktionsdatenbank testen und Ansichten in Ihrer Produktionsdatenbank nur unter der Anleitung von Oracle Support festlegen.
## Listet feste X\$1-Tabellen auf, die für die Verwendung in RDS\$1X\$1-Ansichten berechtigt sind
Verwenden Sie das RDS-Verfahren `rdsadmin.rdsadmin_util.list_allowed_sys_x$_views`, um X\$1-Tabellen aufzulisten, die für die Verwendung in `RDS_X$` Ansichten berechtigt sind. Dieses Verfahren akzeptiert keine Parameter. In den folgenden Anweisungen werden alle berechtigten `X$`-Tabellen aufgeführt (einschließlich Beispielausgabe).
```
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'
```
Die Liste der berechtigten `X$`-Tabellen kann sich im Laufe der Zeit ändern. Um sicherzustellen, dass Ihre Liste der berechtigten festen `X$`-Tabellen aktuell ist, sollten Sie `list_allowed_sys_x$_views` regelmäßig erneut ausführen.
## Erstellen von SYS.RDS\$1X\$1-Ansichten
Verwenden Sie das RDS-Verfahren `rdsadmin.rdsadmin_util.create_sys_x$_view`, um eine `RDS_X$`-Ansicht für eine berechtigte `X$`-Tabelle zu erstellen. Sie können nur Ansichten für die in der Ausgabe von `rdsadmin.rdsadmin_util.list_allowed_sys_x$_views` aufgelisteten Tabellen erstellen. Das `create_sys_x$_view`-Verfahren akzeptiert die folgenden Parameter.
****
| Parametername | Datentyp | Standard | Erforderlich | Beschreibung |
| --- | --- | --- | --- | --- |
| `p_x$_tbl` | varchar2 | Null | Ja | Ein gültiger `X$`-Tabellenname. Der Wert muss eine der von `list_allowed_sys_x$_views` gemeldeten `X$`-Tabellen sein. |
| `p_force_creation` | Boolesch | FALSE | Nein | Ein Wert, der angibt, ob die Erstellung einer `RDS_X$`-Ansicht erzwungen werden soll, die bereits für eine `X$`-Tabelle vorhanden ist. Standardmäßig erstellt RDS keine Ansicht, wenn sie bereits vorhanden ist. Um die Erstellung zu erzwingen, legen Sie diesen Parameter auf `TRUE` fest. |
Das folgende Beispiel erstellt die `SYS.RDS_X$KGLOB`-Ansicht aus der Tabelle `X$KGLOB`. Das Format für den Ansichtsnamen ist `RDS_X$tablename`.
```
SQL> SET SERVEROUTPUT ON
SQL> EXEC rdsadmin.rdsadmin_util.create_sys_x$_view('X$KGLOB');
PL/SQL procedure successfully completed.
```
In der folgenden Datenwörterbuchabfrage werden die Ansicht `SYS.RDS_X$KGLOB` und ihr Status aufgeführt. Ihrem Masterbenutzer wird automatisch die Berechtigung `SELECT ... WITH GRANT OPTION` für diese Ansicht erteilt.
```
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
```
**Wichtig**
Es kann nicht garantiert werden, dass `X$`-Tabellen vor und nach einem Upgrade unverändert bleiben. RDS für Oracle löscht die `RDS_X$`-Ansichten der `X$`-Tabellen während eines Engine-Upgrades und erstellt sie neu. Anschließend wird dem Masterbenutzer die `SELECT ... WITH GRANT OPTION`-Berechtigung gewährt. Erteilen Sie Datenbankbenutzern nach einem Upgrade nach Bedarf Berechtigungen für die entsprechenden `RDS_X$`-Ansichten.
## Erstellen von SYS.RDS\$1X\$1-Ansichten
Verwenden Sie das RDS-Verfahren `RDS_X$`, um vorhandene `rdsadmin.rdsadmin_util.list_created_sys_x$_views`-Ansichten aufzulisten. Das Verfahren listet nur Ansichten auf, die mit dem Verfahren `create_sys_x$_view` erstellt wurden. Das folgende Beispiel listet `X$`-Tabellen mit entsprechenden `RDS_X$`-Ansichten auf (einschließlich Beispielausgabe).
```
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.
```
## Löschen von RDS\$1X\$1-Ansichten
Verwenden Sie das RDS-Verfahren `rdsadmin.rdsadmin_util.drop_sys_x$_view`, um eine `SYS.RDS_X$`-Ansicht zu löschen. Sie können nur Ansichten festlegen, die in der Ausgabe von `rdsadmin.rdsadmin_util.list_allowed_sys_x$_views` aufgeführt sind. Das `drop_sys_x$_view`-Verfahren akzeptiert den folgenden Parameter.
****
| Parametername | Datentyp | Standard | Erforderlich | Beschreibung |
| --- | --- | --- | --- | --- |
| `p_x$_tbl` | varchar2 | Null | Ja | Ein gültiger fester `X$`-Tabellenname. Der Wert muss eine der von `list_created_sys_x$_views` gemeldeten festen `X$`-Tabellen sein. |
Das folgende Beispiel löscht die `RDS_X$KGLOB`-Ansicht, die in der Tabelle `X$KGLOB` erstellt wurde.
```
SQL> SET SERVEROUTPUT ON
SQL> EXEC rdsadmin.rdsadmin_util.drop_sys_x$_view('X$KGLOB');
PL/SQL procedure successfully completed.
```
Das folgende Beispiel zeigt, dass die Ansicht `SYS.RDS_X$KGLOB` gelöscht wurde (einschließlich Beispielausgabe).
```
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
```
# Erteilen von Berechtigungen an Nicht-Hauptbenutzer
Sie können Auswahl-Sonderrechte für viele Objekte im `SYS`-Schema mithilfe der `SELECT_CATALOG_ROLE`-Rolle erteilen. Die Rolle `SELECT_CATALOG_ROLE` gibt Benutzern `SELECT`-Sonderrechte für Datenverzeichnisansichten. Im folgenden Beispiel wird die Rolle `SELECT_CATALOG_ROLE` einem Benutzer mit dem Namen `user1` erteilt.
```
GRANT SELECT_CATALOG_ROLE TO user1;
```
Sie können `EXECUTE`-Sonderrechte für viele Objekte im `SYS`-Schema mithilfe der `EXECUTE_CATALOG_ROLE`-Rolle erteilen. Die Rolle `EXECUTE_CATALOG_ROLE` gibt Benutzern `EXECUTE`-Sonderrechte für Pakete und Prozeduren im Datenverzeichnis. Im folgenden Beispiel wird die Rolle `EXECUTE_CATALOG_ROLE` einem Benutzer mit dem Namen *user1* erteilt.
```
GRANT EXECUTE_CATALOG_ROLE TO user1;
```
Im folgenden Beispiel werden die Berechtigungen abgerufen, die durch die Rollen `SELECT_CATALOG_ROLE` und `EXECUTE_CATALOG_ROLE` gewährt werden.
```
SELECT *
FROM ROLE_TAB_PRIVS
WHERE ROLE IN ('SELECT_CATALOG_ROLE','EXECUTE_CATALOG_ROLE')
ORDER BY ROLE, TABLE_NAME ASC;
```
Im folgenden Beispiel wird ein Nicht-Masterbenutzer mit dem Namen `user1` erstellt, die Berechtigung `CREATE SESSION` gewährt und die Berechtigung `SELECT` für eine Datenbank mit dem Namen *sh.sales* erteilt.
```
CREATE USER user1 IDENTIFIED BY PASSWORD;
GRANT CREATE SESSION TO user1;
GRANT SELECT ON sh.sales TO user1;
```
# Erstellen von benutzerdefinierten Funktionen für das Überprüfen von Passwörtern
Es gibt verschiedene Möglichkeiten, eine benutzerdefinierte Funktion für die Passwortüberprüfung zu erstellen:
+ Um die Standardüberprüfungslogik zu verwenden und Ihre Funktion im `SYS`-Schema zu speichern, verwenden Sie die Prozedur `create_verify_function`.
+ Um eine benutzerdefinierte Überprüfungslogik zu verwenden und Ihre Funktion nicht im `SYS`-Schema zu speichern, verwenden Sie die Prozedur `create_passthrough_verify_fcn`.
# Die Prozedur create\$1verify\$1function
Sie können eine benutzerdefinierte Funktion erstellen, um Passwörter mithilfe der Amazon-RDS-Prozedur `rdsadmin.rdsadmin_password_verify.create_verify_function` zu überprüfen. Das Verfahren `create_verify_function` wird für alle Versionen von RDS für Oracle unterstützt.
Die Prozedur `create_verify_function` hat die folgenden Parameter.
****
| Parametername | Datentyp | Standard | Erforderlich | Beschreibung |
| --- | --- | --- | --- | --- |
| `p_verify_function_name` | varchar2 | — | Ja | Der Name für Ihre benutzerdefinierte Funktion. Diese Funktion wird für Sie im SYS-Schema erstellt. Sie teilen diese Funktion den Benutzerprofilen zu. |
| `p_min_length` | Zahl | 8 | Nein | Die erforderliche Mindestzeichenanzahl. |
| `p_max_length` | Zahl | 256 | Nein | Die maximale Anzahl der erlaubten Zeichen |
| `p_min_letters` | Zahl | 1 | Nein | Die Mindestanzahl der erforderlichen Buchstaben |
| `p_min_uppercase` | Zahl | 0 | Nein | Die Mindestanzahl der erforderlichen Großbuchstaben |
| `p_min_lowercase` | Zahl | 0 | Nein | Die Mindestanzahl der erforderlichen Kleinbuchstaben |
| `p_min_digits` | Zahl | 1 | Nein | Die Mindestanzahl der erforderlichen Zahlen |
| `p_min_special` | Zahl | 0 | Nein | Die Mindestanzahl der erforderlichen Sonderzeichen |
| `p_min_different_chars` | Zahl | 3 | Nein | Die Mindestanzahl der zwischen dem alten und dem neuen Passwort erforderlichen unterschiedlichen Zeichen. |
| `p_disallow_username` | Boolean | true | Nein | Setzen Sie diesen Wert auf `true`, um den Benutzernamen im Passwort nicht zu erlauben. |
| `p_disallow_reverse` | Boolean | true | Nein | Auf `true` festlegen, um die Umkehrung des Benutzernamens im Passwort zu verbieten. |
| `p_disallow_db_name` | Boolean | true | Nein | Setzen Sie diesen Wert auf `true`, um den Datenbank- oder Servernamen im Passwort nicht zu erlauben. |
| `p_disallow_simple_strings` | Boolean | true | Nein | Setzen Sie diesen Wert auf `true`, um einfache Zeichenfolgen im Passwort nicht zu erlauben. |
| `p_disallow_whitespace` | Boolean | false | Nein | Setzen Sie diesen Wert auf `true`, um Leerzeichen im Passwort nicht zu erlauben. |
| `p_disallow_at_sign` | Boolean | false | Nein | Setzen Sie diesen Wert auf `true`, um das @-Zeichen im Passwort nicht zu erlauben. |
Sie können mehrere benutzerdefinierte Funktionen für die Passwortüberprüfung erstellen.
Es gibt Einschränkungen im Hinblick auf den Namen für Ihre benutzerdefinierte Funktion. Der Name Ihrer benutzerdefinierten Funktion darf nicht mit dem Namen eines vorhandenen Systemobjekts identisch sein. Der Name darf nicht mehr als 30 Zeichen lang sein. Der Name muss außerdem eine der folgenden Zeichenfolgen enthalten: `PASSWORD`, `VERIFY`, `COMPLEXITY`, `ENFORCE` oder `STRENGTH`.
Im folgenden Beispiel wird die Funktion mit dem Namen erstell `CUSTOM_PASSWORD_FUNCTION`. Die Funktion erfordert ein Passwort mit mindestens 12 Zeichen, 2 Großbuchstaben, 1 Zahl und 1 Sonderzeichen. Außerdem ist das @-Zeichen im Passwort nicht erlaubt.
```
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;
/
```
Tätigen Sie die Abfrage `DBA_SOURCE`, um den Text Ihrer Überprüfungsfunktion anzusehen. Im folgenden Beispiel wird der Text einer benutzerdefinierten Passwortfunktion mit dem Namen erhalte `CUSTOM_PASSWORD_FUNCTION`.
```
COL TEXT FORMAT a150
SELECT TEXT
FROM DBA_SOURCE
WHERE OWNER = 'SYS'
AND NAME = 'CUSTOM_PASSWORD_FUNCTION'
ORDER BY LINE;
```
Verwenden Sie `ALTER PROFILE`, um Ihre Überprüfungsfunktion einem Benutzerprofil zuzuordnen. Im folgenden Beispiel wird eine PL/SQL Bestätigungsfunktion `CUSTOM_PASSWORD_FUNCTION` mit dem Namen des `DEFAULT` Benutzerprofils verknüpft. `PASSWORD_VERIFY_FUNCTION`ist der Ressourcenname des Oracle-Profils.
```
ALTER PROFILE DEFAULT LIMIT PASSWORD_VERIFY_FUNCTION CUSTOM_PASSWORD_FUNCTION;
```
Um zu sehen, welche Benutzerprofile mit welchen Überprüfungsfunktionen verknüpft sind, fragen Sie ab`DBA_PROFILES`. Im folgenden Beispiel wird das Profil erhalten, dem die benutzerdefinierte Überprüfungsfunktion mit dem Namen zugehörig is `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
```
Im folgenden Beispiel werden alle Profile und Passwortüberprüfungsfunktionen erhalten, die miteinander verknüpft sind.
```
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
```
# Die Prozedur create\$1passthrough\$1verify\$1fcn
Das Verfahren `create_passthrough_verify_fcn` wird für alle Versionen von RDS für Oracle unterstützt.
Sie können eine benutzerdefinierte Funktion erstellen, um Passwörter mithilfe der Amazon-RDS-Prozedur `rdsadmin.rdsadmin_password_verify.create_passthrough_verify_fcn` zu überprüfen. Die Prozedur `create_passthrough_verify_fcn` hat die folgenden Parameter.
****
| Parametername | Datentyp | Standard | Erforderlich | Beschreibung |
| --- | --- | --- | --- | --- |
| `p_verify_function_name` | varchar2 | — | Ja | Der Name für Ihre benutzerdefinierte Überprüfungsfunktion. Dies ist eine Wrapper-Funktion, die für Sie im SYS-Schema erstellt wird und keine Überprüfungslogik beinhaltet. Sie teilen diese Funktion den Benutzerprofilen zu. |
| `p_target_owner` | varchar2 | — | Ja | Der Schemabesitzer für Ihre benutzerdefinierte Überprüfungsfunktion |
| `p_target_function_name` | varchar2 | — | Ja | Der Name für Ihre bestehende benutzerdefinierte Funktion, der die Überprüfungslogik beinhaltet. Ihre benutzerdefinierte Funktion muss einen Booleschen Wert zurückgeben. Ihre Funktion sollte `true`zurückgeben, wenn das Passwort gültig ist, und `false`, wenn das Passwort ungültig ist. |
Im folgenden Beispiel wird eine Passwortüberprüfungsfunktion erstellt, die die Logik aus der Funktion mit dem Namen verwende `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;
/
```
Verwenden Sie , um die Überprüfungsfunktion Ihrem Benutzerprofil zuzuordne `alter profile`. Im folgenden Beispiel wird die Überprüfungsfunktion mit dem `DEFAULT`-Benutzerprofil verknüpft.
```
ALTER PROFILE DEFAULT LIMIT PASSWORD_VERIFY_FUNCTION CUSTOM_PASSWORD_FUNCTION;
```
## Einrichten eines benutzerdefinierten DNS-Servers
Amazon RDS unterstützt ausgehenden Netzwerkzugriff auf Ihre DB-Instance, auf der Oracle ausgeführt wird. Weitere Informationen zu ausgehendem Netzwerkzugriff, einschließlich Voraussetzungen, finden Sie unter [Konfigurieren des UTL\$1HTTP-Zugriffs mit Zertifikaten und einer Oracle Wallet](Oracle.Concepts.ONA.md).
Amazon-RDS-Oracle erlaubt Domain Name Service (DNS)-Auflösung aus einem benutzerdefinierten DNS-Server, der im Besitz des Kunden ist. Sie können nur vollständig geeignete Domänenamen aus Ihrer Amazon-RDS-DB-Instance über Ihren benutzerdefinierten DNS-Server auflösen.
Nachdem Sie Ihren benutzerdefinierten DNS-Namensserver eingerichtet haben, dauert es bis zu 30 Minuten, um die Änderungen an Ihre DB-Instance zu übertragen. Nachdem die Änderungen an Ihre DB-Instance übertragen wurden, wird ausgehender Datenverkehr, der eine DNS-Abfrage tätigen muss, Ihren DNS-Server über Port 53 abrufen.
Führen Sie folgende Schritte aus, um einen benutzerdefinierten DNS-Server für Ihre Amazon RDS für Oracle-DB-Instance einzurichten:
+ Legen Sie in dem Ihrer Virtual Private Cloud (VPC) beigefügten DHCP-Optionsset die Option `domain-name-servers` für die IP-Adresse Ihres DNS-Namensservers fest. Weitere Informationen finden Sie unter [DHCP-Optionssets](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_DHCP_Options.html).
**Anmerkung**
Die Option `domain-name-servers` akzeptiert bis zu vier Werte, Ihre Amazon-RDS-DB-Instance verwendet jedoch nur den ersten Wert.
+ Stellen Sie sicher, dass Ihr DNS-Server die Suchabfragen auflösen kann, einschließlich DNS-Namen, Amazon EC2-private-DNS-Namen und benutzerspezifischen DNS-Namen. Wenn der ausgehende Datenverkehr DNS-Abfragen beinhaltet, die Ihr DNS-Server nicht handhaben kann, müssen für Ihren DNS-Server angemessene DNS-Provider für einen Upstream konfiguriert sein.
+ Konfigurieren Sie Ihren DNS-Server, um User Datagram Protocol (UDP)-Antworten in der Größenordnung von 512 Bytes oder weniger zu erhalten.
+ Konfigurieren Sie Ihren DNS-Server, um Transmission Control Protocol (TCP)-Antworten in der Größenordnung von 1 024 Bytes oder weniger zu erhalten.
+ Konfigurieren Sie Ihren DNS-Server, um eingehenden Datenverkehr aus Ihrer Amazon-RDS-DB-Instance über Port 53 zu erlauben. Wenn sich Ihr DNS-Server in einer Amazon VPC befindet, muss die VPC über eine Sicherheitsgruppe verfügen, die eingehende Regeln für das Erlauben von UDP und TCP über Port 53 beinhaltet. Wenn sich Ihr DNS-Server nicht in einer Amazon VPC befindet, muss er über eine angemessene Firewall-Whitelist verfügen, die UDP- und TCP-Übertragungen über Port 53 zulassen.
Weitere Informationen finden Sie unter [Sicherheitsgruppen für Ihre VPC](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html) und unter [Hinzufügen und Entfernen von Regeln](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html#AddRemoveRules).
+ Konfigurieren Sie die VPC Ihrer Amazon-RDS-DB-Instance, um ausgehenden Datenverkehr über Port 53 zu erlauben. Ihre VPC muss über eine Sicherheitsgruppe mit ausgehenden Regeln verfügen, die UDP- und TCP-Übertragungen über Port 53 erlauben.
Weitere Informationen finden Sie unter [Sicherheitsgruppen für Ihre VPC](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html) und unter [Hinzufügen und Entfernen von Regeln](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html#AddRemoveRules).
+ Der Routing-Pfad zwischen der Amazon-RDS-DB-Instance und dem DNS-Server muss korrekt konfiguriert werden, um DNS-Datenverkehr zu erlauben.
+ Wenn sich die Amazon-RDS-DB-Instance und der DNS-Server nicht in der selben VPC befinden, muss zwischen ihnen eine Peer-to-Peer-Verbindung eingerichtet werden. Weitere Informationen finden Sie unter [Was ist VPC Peering?](https://docs.aws.amazon.com/vpc/latest/peering/Welcome.html)
# Festlegen und Aufheben von Systemdiagnoseereignissen
Um Diagnoseereignisse auf Sitzungsebene festzulegen und aufzuheben, können Sie die Oracle SQL-Anweisung verwende `ALTER SESSION SET EVENTS`. Um Ereignisse auf Systemebene festzulegen, können Sie Oracle SQL jedoch nicht verwenden. Verwenden Sie stattdessen die Systemereignisprozesse im `rdsadmin.rdsadmin_util`-Paket. Die Systemereignisprozesse sind in den folgenden Engine-Versionen verfügbar:
+ Alle Versionen von Oracle Database 21c
+ 19.0.0.0.ru-2020-10.rur-2020-10.r1 oder höhere Versionen von Oracle Database 19c
Weitere Informationen finden Sie unter [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) in den *Versionshinweisen zu Amazon RDS für Oracle*.
**Wichtig**
Intern legt das `rdsadmin.rdsadmin_util`-Paket Ereignisse mithilfe der `ALTER SYSTEM SET EVENTS`-Anweisung fest. Diese `ALTER SYSTEM`-Aussage ist nicht in der Oracle Database-Dokumentation dokumentiert. Einige Systemdiagnoseereignisse können große Mengen an Rückverfolgungsinformationen generieren, Konflikte verursachen oder die Datenbankverfügbarkeit beeinträchtigen. Wir empfehlen, dass Sie bestimmte Diagnoseereignisse in Ihrer Nicht-Produktionsdatenbank testen und Ereignisse in Ihrer Produktionsdatenbank nur unter Anleitung von Oracle Support festlegen.
## Auflisten zulässiger Systemdiagnoseereignisse
Verwenden Sie das Amazon-RDS-Verfahren , um die Systemereignisse aufzulisten, die Sie festlegen könne `rdsadmin.rdsadmin_util.list_allowed_system_events`. Dieses Verfahren akzeptiert keine Parameter.
Im folgenden Beispiel werden alle Systemereignisse aufgeführt, die Sie festlegen können.
```
SET SERVEROUTPUT ON
EXEC rdsadmin.rdsadmin_util.list_allowed_system_events;
```
Die folgende Beispielausgabe listet Ereignisnummern und ihre Beschreibungen auf. Verwenden Sie die Amazon-RDS-Verfahren `set_system_event`, um diese Ereignisse festzulegen und `unset_system_event`, um sie aufzuheben.
```
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:
```
**Anmerkung**
Die Liste der erlaubten Systemereignisse kann sich im Laufe der Zeit ändern. Um sicherzustellen, dass Sie die aktuellste Liste der berechtigten Ereignisse haben, verwenden Sie `rdsadmin.rdsadmin_util.list_allowed_system_events`.
## Festlegen von Systemdiagnoseereignissen
Verwenden Sie das Amazon-RDS-Verfahren , um ein Systemereignis festzulege `rdsadmin.rdsadmin_util.set_system_event`. Sie können nur Ereignisse festlegen, die in der Ausgabe von aufgeführt sin `rdsadmin.rdsadmin_util.list_allowed_system_events`. Das `set_system_event`-Verfahren akzeptiert die folgenden Parameter.
****
| Parametername | Datentyp | Standard | Erforderlich | Beschreibung |
| --- | --- | --- | --- | --- |
| `p_event` | Zahl | — | Ja | Die Systemereignisnummer. Der Wert muss eine der von gemeldeten Ereignisnummern sei `list_allowed_system_events`. |
| `p_level` | Zahl | — | Ja | Das Event-Level. In der Oracle Database-Dokumentation oder bei Oracle Support finden Sie Beschreibungen von Werten verschiedener Ebenen. |
Das Verfahren `set_system_event` konstruiert und führt die erforderlichen `ALTER SYSTEM SET EVENTS`-Aussagen nach folgenden Grundsätzen aus:
+ Der Ereignistyp (`context` oder `errorstack`) wird automatisch bestimmt.
+ Eine Anweisung im Formular `ALTER SYSTEM SET EVENTS 'event LEVEL event_level'` legt die Kontextereignisse fest. Diese Notation entspricht `ALTER SYSTEM SET EVENTS 'event TRACE NAME CONTEXT FOREVER, LEVEL event_level'`.
+ Eine Anweisung im Formular `ALTER SYSTEM SET EVENTS 'event ERRORSTACK (event_level)'` legt die Fehler-Stack-Ereignisse fest. Diese Notation entspricht `ALTER SYSTEM SET EVENTS 'event TRACE NAME ERRORSTACK LEVEL event_level'`.
Im folgenden Beispiel werden Ereignis 942 auf Ebene 3 und Ereignis 10 442 auf Ebene 10 festgelegt. Die Beispielausgabe ist enthalten.
```
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.
```
## Auflisten der festgesetzten Systemdiagnoseereignisse
Verwenden Sie das Amazon-RDS-Verfahren , um die derzeit festgelegten Systemereignisse aufzuliste `rdsadmin.rdsadmin_util.list_set_system_events`. Dieses Verfahren meldet nur Ereignisse, die auf Systemebene von festgelegt wurde `set_system_event`.
Im folgenden Beispiel werden die aktiven Systemereignisse aufgeführt.
```
SET SERVEROUTPUT ON
EXEC rdsadmin.rdsadmin_util.list_set_system_events;
```
Die folgende Beispielausgabe zeigt die Liste der Ereignisse, den Ereignistyp, die Ebene, auf der die Ereignisse derzeit festgelegt sind, und den Zeitpunkt, zu dem das Ereignis festgelegt wurde.
```
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.
```
## Aufheben von Systemdiagnoseereignissen
Verwenden Sie das Amazon-RDS-Verfahren , um ein Systemereignis aufzuhebe `rdsadmin.rdsadmin_util.unset_system_event`. Sie können nur die in der Ausgabe von aufgelisteten Ereignisse aufhebe `rdsadmin.rdsadmin_util.list_allowed_system_events`. Das `unset_system_event`-Verfahren akzeptiert den folgenden Parameter.
****
| Parametername | Datentyp | Standard | Erforderlich | Beschreibung |
| --- | --- | --- | --- | --- |
| `p_event` | Zahl | — | Ja | Die Systemereignisnummer. Der Wert muss eine der von gemeldeten Ereignisnummern sei `list_allowed_system_events`. |
Im folgenden Beispiel werden die Ereignisse 942 und 10 442 aufgezeichnet. Die Beispielausgabe ist enthalten.
```
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.
```
# Ausführen allgemeiner Datenbank-Aufgaben für Oracle DB-Instances
Im Folgenden erfahren Sie, wie Sie bestimmte allgemeine DBA-Aufgaben durchführen können, die mit den Datenbanken Ihrer Amazon RDS-DB-Instances in Oracle zusammenhängen. Um eine verwaltete Service-Erfahrung zu bieten, ermöglicht Amazon RDS keinen Shell-Zugriff auf DB-Instances. Amazon RDS schränkt auch den Zugriff auf einige Systemverfahren und Tabellen ein, die erweiterte Berechtigungen erfordern.
**Topics**
+ [
# Ändern des globalen Namens einer Datenbank
](Appendix.Oracle.CommonDBATasks.RenamingGlobalName.md)
+ [
# Arbeiten mit Tablespaces in RDS für Oracle
](Appendix.Oracle.CommonDBATasks.TablespacesAndDatafiles.md)
+ [
# Arbeiten mit Tempfiles in RDS für Oracle
](Appendix.Oracle.CommonDBATasks.using-tempfiles.md)
+ [
# Ändern der Größe von Tablespaces, Datendateien und Tempfiles in RDS for Oracle
](Appendix.Oracle.CommonDBATasks.ResizeTempSpaceReadReplica.md)
+ [
# Verschieben von Daten zwischen Speichervolumes in RDS für Oracle
](Appendix.Oracle.CommonDBATasks.MovingDataBetweenVolumes.md)
+ [
# Arbeiten mit externen Tabellen in RDS for Oracle
](Appendix.Oracle.CommonDBATasks.External_Tables.md)
# Ändern des globalen Namens einer Datenbank
Um den globalen Namen einer Datenbank zu ändern, verwenden Sie die Amazon RDS-Prozedur `rdsadmin.rdsadmin_util.rename_global_name`. Die Prozedur `rename_global_name` hat die folgenden Parameter.
****
| Parametername | Datentyp | Standard | Erforderlich | Beschreibung |
| --- | --- | --- | --- | --- |
| `p_new_global_name` | varchar2 | — | Ja | Der neue globale Name für die Datenbank |
Die Datenbank muss geöffnet sein, damit die Änderungen übernommen werden. Weitere Informationen über das Ändern des globalen Namens einer Datenbank finden Sie unter [ALTER DATABASE](http://docs.oracle.com/cd/E11882_01/server.112/e41084/statements_1004.htm#SQLRF52547) in der Oracle-Dokumentation.
Im folgenden Beispiel wird der globale Name einer Datenbank geänder `new_global_name`.
```
EXEC rdsadmin.rdsadmin_util.rename_global_name(p_new_global_name => 'new_global_name');
```
# Arbeiten mit Tablespaces in RDS für Oracle
Sie können Tablespaces mit RDS for Oracle verwenden, einer logischen Speichereinheit, die die Daten der Datenbank speichert.
**Wichtig**
Wenn Ihre DB-Instance über Replikate verfügt, empfehlen wir die Verwendung von Parametergruppeneinstellungen anstelle von Änderungen auf Sitzungsebene, um die Standard-Dateispeicherorte zu verwalten. Änderungen auf Sitzungsebene an den Standard-Dateispeicherorten in der primären Instance werden nicht automatisch in den Replikaten widergespiegelt. Die Verwendung von Parametergruppeneinstellungen gewährleistet konsistente Dateispeicherorte in Ihren Primär- und Replikatinstanzen.
**Topics**
+ [
## Angabe von Speicherorten für Datenbankdateien in RDS für Oracle
](#Appendix.Oracle.CommonDBATasks.DatabaseFileLocations)
+ [
## Tablespaces in RDS für Oracle erstellen und deren Größe anpassen
](#Appendix.Oracle.CommonDBATasks.CreatingTablespacesAndDatafiles)
+ [
## Tablespaces auf zusätzlichen Speichervolumes in RDS für Oracle erstellen
](#Appendix.Oracle.CommonDBATasks.CreatingTablespacesWithFileLocations)
+ [
## Den Standard-Tablespace in RDS für Oracle einrichten
](#Appendix.Oracle.CommonDBATasks.SettingDefaultTablespace)
+ [
## Einstellung des standardmäßigen temporären Tablespace in RDS für Oracle
](#Appendix.Oracle.CommonDBATasks.SettingDefTempTablespace)
+ [
## Erstellen eines temporären Tabellenraums im Instance-Speicher
](#Appendix.Oracle.CommonDBATasks.creating-tts-instance-store)
## Angabe von Speicherorten für Datenbankdateien in RDS für Oracle
RDS for Oracle verwendet Oracle Managed Files (OMF) zur Benennung von Datenbankdateien. Wenn Sie Datenbankdateien erstellen, leitet die Datenbank die Einstellung auf der Grundlage der aktuellen Einstellung des `DB_CREATE_FILE_DEST` Initialisierungsparameters ab.
Der Standardwert des `DB_CREATE_FILE_DEST` Initialisierungsparameters gilt `/rdsdbdata/db` für eigenständige Datenbanken und `/rdsdbdata/db/pdb` für containerisierte (CDB/MT) Architekturen. Wenn Ihre DB-Instance über zusätzliche Speichervolumes verfügt, können Sie diese auf die Speicherorte Ihrer Volumes festlegen. `DB_CREATE_FILE_DEST` Wenn auf Ihrer Instance beispielsweise ein Volume installiert ist`/rdsdbdata/db`, können `DB_CREATE_FILE_DEST` Sie diesen Wert festlegen.
Sie können den `DB_CREATE_FILE_DEST` Parameter entweder auf Sitzungsebene oder auf Ebene der Oracle-Datenbankinstanz ändern.
### Ändern von DB\$1CREATE\$1FILE\$1SET auf Instanzebene
Um den Parameter auf Instanzebene zu ändern, aktualisieren Sie den Parameter in der Parametergruppe, die Ihrer DB-Instance zugewiesen ist, und wenden Sie ihn an. Weitere Informationen erhalten Sie unter [Initialisierungsparameter für RDS für Oracle](Oracle.Concepts.FeatureSupport.Parameters.md) und [Ändern von Parametern in einer DB-Parametergruppe in Amazon RDS](USER_WorkingWithParamGroups.Modifying.md).
### Ändern von DB\$1CREATE\$1FILE\$1DEST auf Sitzungsebene
Sie können den Parameter auf Sitzungsebene ändern, indem Sie eine `ALTER SESSION` Anweisung ausführen. Dieser Ansatz ist nützlich, wenn Sie Datenbankdateien an einem bestimmten Ort für eine bestimmte Sitzung erstellen möchten, ohne dass sich dies auf die gesamte Instanz auswirkt.
Das folgende Beispiel zeigt, wie Sie den aktuellen Parameterwert überprüfen und für die Sitzung ändern können:
```
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
```
## Tablespaces in RDS für Oracle erstellen und deren Größe anpassen
Wenn Sie Tablespaces erstellen, erstellt die Datenbank die Datendateien auf dem Speichervolume, das durch den `DB_CREATE_FILE_DEST` Initialisierungsparameter zum Zeitpunkt der Erstellung angegeben wurde. Wenn Sie keine Datendateigröße angeben, werden Tabellenbereiche standardmäßig mit der Standardeinstellung `AUTOEXTEND ON` und ohne maximal zulässige Größe erstellt. Im folgenden Beispiel ist der Tablespace *users1* automatisch erweiterbar.
```
CREATE TABLESPACE users1;
```
Durch diese Standardeinstellungen können Tabellenräume so sehr anwachsen, dass sie den gesamten zugewiesenen Speicherplatz verwenden. Wir empfehlen, dass Sie eine angemessene Maximalgröße für permanente und temporäre Tabellenräume festlegen, und dass Sie die Speicherverwendung sorgfältig überwachen.
Im folgenden Beispiel wird ein Tablespace mit einem Namen *users2* mit einer Startgröße von 1 Gigabyte erstellt. Da zwar die Datendateigröße, nicht aber `AUTOEXTEND ON` angegeben ist, ist der Tabellenbereich nicht automatisch erweiterbar.
```
CREATE TABLESPACE users2 DATAFILE SIZE 1G;
```
Im folgenden Beispiel wird ein Tablespace *users3* mit einer Startgröße von 1 Gigabyte, aktivierter automatischer Erweiterung und einer maximalen Größe von 10 Gigabyte erstellt.
```
CREATE TABLESPACE users3 DATAFILE SIZE 1G AUTOEXTEND ON MAXSIZE 10G;
```
Im folgenden Beispiel wird ein temporärer Tablespace mit dem Namen erstellt. *temp01*
```
CREATE TEMPORARY TABLESPACE temp01;
```
Sie können die Größe eines Tabellenraums mit großen Dateien mithilfe von änder `ALTER TABLESPACE`. Sie können die Größe in Kilobytes (KB), Megabytes (MB), Gigabytes (GB) oder Terabytes (TB) festlegen. Im folgenden Beispiel wird ein Tabellenraum mit dem Namen *users\$1bf* für große Dateien bis 200 MB erstellt.
```
ALTER TABLESPACE users_bf RESIZE 200M;
```
Das folgende Beispiel fügt eine zusätzliche Datendatei zu einem kleinen Datei-Tablespace mit dem Namen hinzu. *users\$1sf*
```
ALTER TABLESPACE users_sf ADD DATAFILE SIZE 100000M AUTOEXTEND ON NEXT 250m MAXSIZE UNLIMITED;
```
## Tablespaces auf zusätzlichen Speichervolumes in RDS für Oracle erstellen
Um einen Tablespace auf einem zusätzlichen Speichervolume zu erstellen, ändern Sie den `DB_CREATE_FILE_DEST` Parameter auf den Speicherort des Volumes. Im folgenden Beispiel wird der Dateispeicherort auf `/rdsdbdata2/db` festgelegt.
```
ALTER SESSION SET db_create_file_dest = '/rdsdbdata2/db';
Session altered.
```
Im folgenden Beispiel erstellen Sie einen Tablespace auf dem zusätzlichen Volume`/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
```
Um einen Tablespace für kleine Dateien zu erstellen und seine Datendateien auf verschiedene Speichervolumes zu verteilen, fügen Sie dem Tablespace nach der Erstellung Datendateien hinzu. Im folgenden Beispiel erstellen Sie einen Tablespace mit den Datendateien am Standardspeicherort von. `/rdsdbdata/db` Dann setzen Sie das Standardziel auf`/rdsdbdata/db2`. Wenn Sie Ihrem neu erstellten Tablespace eine Datendatei hinzufügen, speichert die Datenbank die Datei in`/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
```
## Den Standard-Tablespace in RDS für Oracle einrichten
Um den Standard-Tablespace festzulegen, verwenden Sie die Amazon-RDS-Prozedur `rdsadmin.rdsadmin_util.alter_default_tablespace`. Die Prozedur `alter_default_tablespace` hat die folgenden Parameter.
****
| Parametername | Datentyp | Standard | Erforderlich | Beschreibung |
| --- | --- | --- | --- | --- |
| `tablespace_name` | varchar | — | Ja | Der Name des Standard-Tabellenraums |
Im folgenden Beispiel wird der Standard-Tablespace wie folgt festgelegt: *users2*
```
EXEC rdsadmin.rdsadmin_util.alter_default_tablespace(tablespace_name => 'users2');
```
## Einstellung des standardmäßigen temporären Tablespace in RDS für Oracle
Um den temporären Standard-Tablespace festzulegen, verwenden Sie die Amazon-RDS-Prozedur `rdsadmin.rdsadmin_util.alter_default_temp_tablespace`. Die Prozedur `alter_default_temp_tablespace` hat die folgenden Parameter.
****
| Parametername | Datentyp | Standard | Erforderlich | Beschreibung |
| --- | --- | --- | --- | --- |
| `tablespace_name` | varchar | — | Ja | Der Name des temporären Standard-Tabellenraums |
Im folgenden Beispiel wird der standardmäßige temporäre Tablespace auf festgelegt. *temp01*
```
EXEC rdsadmin.rdsadmin_util.alter_default_temp_tablespace(tablespace_name => 'temp01');
```
## Erstellen eines temporären Tabellenraums im Instance-Speicher
Wenn Sie einen temporären Tabellenraum im Instance-Speicher erstellen möchten, verwenden Sie das Amazon-RDS-Verfahren `rdsadmin.rdsadmin_util.create_inst_store_tmp_tblspace`. Die Prozedur `create_inst_store_tmp_tblspace` hat die folgenden Parameter.
****
| Parametername | Datentyp | Standard | Erforderlich | Beschreibung |
| --- | --- | --- | --- | --- |
| `p_tablespace_name` | varchar | — | Ja | Der Name des temporären Tabellenraums. |
Im folgenden Beispiel wird der temporäre Tablespace *temp01* im Instanzspeicher erstellt.
```
EXEC rdsadmin.rdsadmin_util.create_inst_store_tmp_tblspace(p_tablespace_name => 'temp01');
```
**Wichtig**
Beim Ausführen von `rdsadmin_util.create_inst_store_tmp_tblspace` wird der neu erstellte temporäre Tabellenraum nicht automatisch als temporärer Standardtabellenraum festgelegt. Informationen zum Festlegen als Standard finden Sie unter [Einstellung des standardmäßigen temporären Tablespace in RDS für Oracle](#Appendix.Oracle.CommonDBATasks.SettingDefTempTablespace).
Weitere Informationen finden Sie unter [Speichern temporärer Daten in einem Instance-Speicher von RDS für Oracle](CHAP_Oracle.advanced-features.instance-store.md).
# Arbeiten mit Tempfiles in RDS für Oracle
## Hinzufügen einer temporären Datei zum Instance-Speicher auf einer Read Replica
Wenn Sie einen temporären Tabellenraum auf einer primären DB-Instance erstellen, werden von der Read Replica keine temporären Dateien erstellt. Nehmen Sie an, dass aus einem der folgenden Gründe ein leerer temporärer Tabellenraum in Ihrer Read Replica vorhanden ist:
+ Sie haben eine temporäre Datei aus dem Tabellenraum Ihrer Read Replica gelöscht. Weitere Informationen finden Sie unter [Löschen von temporären Dateien auf einer Read Replica](Appendix.Oracle.CommonDBATasks.dropping-tempfiles-replica.md).
+ Sie haben einen neuen temporären Tabellenraum auf der primären DB-Instance erstellt. In diesem Fall synchronisiert RDS für Oracle die Metadaten mit der Read Replica.
Sie können ein temporäre Datei dem leeren temporären Tabellenraum hinzufügen und die temporäre Dateie im Instance-Speicher ablegen. Wenn Sie eine temporäre Datei im Instance-Speicher erstellen möchten, verwenden Sie das Amazon-RDS-Verfahren `rdsadmin.rdsadmin_util.add_inst_store_tempfile`. Sie können dieses Verfahren nur für eine Read Replica verwenden. Die Prozedur hat die folgenden Parameter.
****
| Parametername | Datentyp | Standard | Erforderlich | Beschreibung |
| --- | --- | --- | --- | --- |
| `p_tablespace_name` | varchar | — | Ja | Der Name des temporären Tabellenraums auf Ihrer Read Replica. |
Im folgenden Beispiel ist der leere temporäre Tablespace in Ihrer Read Replica *temp01* vorhanden. Führen Sie den folgenden Befehl aus, um eine temporäre Datei für diesen Tabellenraum zu erstellen und sie im Instance-Speicher abzulegen.
```
EXEC rdsadmin.rdsadmin_util.add_inst_store_tempfile(p_tablespace_name => 'temp01');
```
Weitere Informationen finden Sie unter [Speichern temporärer Daten in einem Instance-Speicher von RDS für Oracle](CHAP_Oracle.advanced-features.instance-store.md).
# Löschen von temporären Dateien auf einer Read Replica
Sie können einen vorhandenen temporären Tabellenraum auf einer Read Replica nicht löschen. Sie können den Speicher der temporären Datei auf einer Read Replica von Amazon EBS in den Instance-Speicher oder vom Instance-Speicher in Amazon EBS ändern. Gehen Sie wie folgt vor, um diese Ziele zu erreichen:
1. Löschen Sie die aktuellen temporären Dateien im temporären Tabellenraum auf der Read Replica.
1. Erstellen Sie neue temporäre Dateien in einem anderen Speicher.
Wenn Sie die temporären Dateien löschen möchten, verwenden Sie das Amazon-RDS-Verfahren `rdsadmin.rdsadmin_util. drop_replica_tempfiles`. Sie können dieses Verfahren nur für Read Replicas verwenden. Die Prozedur `drop_replica_tempfiles` hat die folgenden Parameter.
****
| Parametername | Datentyp | Standard | Erforderlich | Beschreibung |
| --- | --- | --- | --- | --- |
| `p_tablespace_name` | varchar | — | Ja | Der Name des temporären Tabellenraums auf Ihrer Read Replica. |
Gehen Sie davon aus, dass sich ein temporärer Tablespace mit dem *temp01* Namen im Instanzspeicher Ihrer Read Replica befindet. Löschen Sie alle temporären Dateien in diesem Tabellenraum, indem Sie den folgenden Befehl ausführen.
```
EXEC rdsadmin.rdsadmin_util.drop_replica_tempfiles(p_tablespace_name => 'temp01');
```
Weitere Informationen finden Sie unter [Speichern temporärer Daten in einem Instance-Speicher von RDS für Oracle](CHAP_Oracle.advanced-features.instance-store.md).
# Ändern der Größe von Tablespaces, Datendateien und Tempfiles in RDS for Oracle
Standardmäßig werden Oracle-Tabellenbereiche mit aktivierter automatischen Erweiterbarkeit und ohne Obergrenze für die Größe erstellt. Durch diese Standardeinstellungen können Tabellenbereiche bisweilen zu groß werden. Wir empfehlen, dass Sie eine angemessene Maximalgröße für permanente und temporäre Tabellenräume festlegen, und dass Sie die Speicherverwendung sorgfältig überwachen.
## Ändern der Größe von permanenten Tabellenbereichen
Verwenden Sie eines der folgenden Amazon-RDS-Verfahren, um die Größe eines permanenten Tabellenbereichs in einer DB-Instance von RDS für Oracle zu ändern:
+ `rdsadmin.rdsadmin_util.resize_datafile`
+ `rdsadmin.rdsadmin_util.autoextend_datafile`
Die Prozedur `resize_datafile` hat die folgenden Parameter.
****
| Parametername | Datentyp | Standard | Erforderlich | Beschreibung |
| --- | --- | --- | --- | --- |
| `p_data_file_id` | Zahl | — | Ja | Der Bezeichner der Datendatei, deren Größe geändert werden soll. |
| `p_size` | varchar2 | — | Ja | Die Größe der Datendatei. Geben Sie die Größe in Byte (Standard), Kilobyte (KB), Megabyte (MB) oder Gigabyte (GB) an. |
Die Prozedur `autoextend_datafile` hat die folgenden Parameter.
****
| Parametername | Datentyp | Standard | Erforderlich | Beschreibung |
| --- | --- | --- | --- | --- |
| `p_data_file_id` | Zahl | — | Ja | Der Bezeichner der Datendatei, deren Größe geändert werden soll. |
| `p_autoextend_state` | varchar2 | — | Ja | Der Status der automatischen Erweiterungsfunktion. Geben Sie `ON` an, um die Datendatei automatisch erweitern zu lassen, und `OFF`, wenn die automatische Erweiterung deaktiviert werden soll. |
| `p_next` | varchar2 | — | Nein | Die Größe des nächsten Datendateiinkrements. Geben Sie die Größe in Byte (Standard), Kilobyte (KB), Megabyte (MB) oder Gigabyte (GB) an. |
| `p_maxsize` | varchar2 | — | Nein | Der maximale Festplattenspeicher, der für die automatische Erweiterung zulässig ist. Geben Sie die Größe in Byte (Standard), Kilobyte (KB), Megabyte (MB) oder Gigabyte (GB) an. Sie können `UNLIMITED` angeben, um die Dateigrößenbeschränkung aufzuheben. |
Im folgenden Beispiel wird die Größe der Datendatei 4 auf 500 MB geändert.
```
EXEC rdsadmin.rdsadmin_util.resize_datafile(4,'500M');
```
Im folgenden Beispiel wird die automatische Erweiterung für die Datendatei 4 deaktiviert. Außerdem wird die automatische Erweiterung für die Datendatei 5 mit einem Inkrement von 128 MB und ohne maximal zulässige Größe aktiviert.
```
EXEC rdsadmin.rdsadmin_util.autoextend_datafile(4,'OFF');
EXEC rdsadmin.rdsadmin_util.autoextend_datafile(5,'ON','128M','UNLIMITED');
```
## Ändern der Größe temporärer Tabellenbereiche
Verwenden Sie eines der folgenden Amazon-RDS-Verfahren, um die Größe eines temporären Tabellenbereichs in einer DB-Instance von RDS für Oracle, einschließlich eines Lesereplikats, zu ändern:
+ `rdsadmin.rdsadmin_util.resize_temp_tablespace`
+ `rdsadmin.rdsadmin_util.resize_tempfile`
+ `rdsadmin.rdsadmin_util.autoextend_tempfile`
Die Prozedur `resize_temp_tablespace` hat die folgenden Parameter.
****
| Parametername | Datentyp | Standard | Erforderlich | Beschreibung |
| --- | --- | --- | --- | --- |
| `p_temp_tablespace_name` | varchar2 | — | Ja | Der Name des temporären Tabellenraums für die Größenanpassung. |
| `p_size` | varchar2 | — | Ja | Die Größe des Tabellenbereichs. Geben Sie die Größe in Byte (Standard), Kilobyte (KB), Megabyte (MB) oder Gigabyte (GB) an. |
Die Prozedur `resize_tempfile` hat die folgenden Parameter.
****
| Parametername | Datentyp | Standard | Erforderlich | Beschreibung |
| --- | --- | --- | --- | --- |
| `p_temp_file_id` | Zahl | — | Ja | Die Kennung der temporären Datei, deren Größe geändert werden soll. |
| `p_size` | varchar2 | — | Ja | Die Größe der temporären Datei. Geben Sie die Größe in Byte (Standard), Kilobyte (KB), Megabyte (MB) oder Gigabyte (GB) an. |
Die Prozedur `autoextend_tempfile` hat die folgenden Parameter.
****
| Parametername | Datentyp | Standard | Erforderlich | Beschreibung |
| --- | --- | --- | --- | --- |
| `p_temp_file_id` | Zahl | — | Ja | Die Kennung der temporären Datei, deren Größe geändert werden soll. |
| `p_autoextend_state` | varchar2 | — | Ja | Der Status der automatischen Erweiterungsfunktion. Geben Sie `ON` an, um die temporäre Datei automatisch erweitern zu lassen, und `OFF`, wenn die automatische Erweiterung deaktiviert werden soll. |
| `p_next` | varchar2 | — | Nein | Die Größe des nächsten temporären Dateiinkrements. Geben Sie die Größe in Byte (Standard), Kilobyte (KB), Megabyte (MB) oder Gigabyte (GB) an. |
| `p_maxsize` | varchar2 | — | Nein | Der maximale Festplattenspeicher, der für die automatische Erweiterung zulässig ist. Geben Sie die Größe in Byte (Standard), Kilobyte (KB), Megabyte (MB) oder Gigabyte (GB) an. Sie können `UNLIMITED` angeben, um die Dateigrößenbeschränkung aufzuheben. |
In den folgenden Beispielen wird die Größe eines temporären Tabellenbereichs mit dem Namen `TEMP` auf 4 GB geändert.
```
EXEC rdsadmin.rdsadmin_util.resize_temp_tablespace('TEMP','4G');
```
```
EXEC rdsadmin.rdsadmin_util.resize_temp_tablespace('TEMP','4096000000');
```
Im folgenden Beispiel wird die Größe eines temporären Tabellenbereichs auf der Grundlage der temporären Datei mit der Datei-ID `1` auf 2 MB geändert.
```
EXEC rdsadmin.rdsadmin_util.resize_tempfile(1,'2M');
```
Im folgenden Beispiel wird die automatische Erweiterung für die temporäre Datei 1 deaktiviert. Außerdem wird die maximale Größe der automatischen Erweiterung der temporären Datei 2 auf 10 GB mit einem Inkrement von 100 MB festgelegt.
```
EXEC rdsadmin.rdsadmin_util.autoextend_tempfile(1,'OFF');
EXEC rdsadmin.rdsadmin_util.autoextend_tempfile(2,'ON','100M','10G');
```
Weitere Informationen zu Lesereplikaten für Oracle-DB-Instances finden Sie unter [Arbeiten mit Lese-Replikaten für Amazon RDS für Oracle](oracle-read-replicas.md).
# Verschieben von Daten zwischen Speichervolumes in RDS für Oracle
Sie können Datendateien und Datenbankobjekte zwischen Ihren primären und zusätzlichen Speichervolumes verschieben. Bevor Sie Daten verschieben, sollten Sie die folgenden Punkte berücksichtigen:
+ Das Quell- und das Zielvolume müssen über ausreichend freien Speicherplatz verfügen.
+ Datenverschiebungen I/O beanspruchen beide Volumes.
+ Große Datenbewegungen können sich auf die Datenbankleistung auswirken.
+ Wenn Sie einen Snapshot wiederherstellen, kann das Verschieben von Daten zwischen Speichervolumes langsam sein, wenn dies durch verzögertes EBS-Laden beeinträchtigt wird.
**Topics**
+ [
## Verschieben von Datendateien zwischen Volumes in RDS für Oracle
](#Appendix.Oracle.CommonDBATasks.MovingDatafiles)
+ [
## Verschieben von Tabellendaten und Indizes zwischen Volumes in RDS for Oracle
](#Appendix.Oracle.CommonDBATasks.MovingTableData)
+ [
## Verwaltung von LOB-Speicher mithilfe zusätzlicher Volumes
](#Appendix.Oracle.CommonDBATasks.ManagingLargeLOBStorage)
## Verschieben von Datendateien zwischen Volumes in RDS für Oracle
Verwenden Sie das Amazon RDS-Verfahren, um Datendateien zwischen Speichervolumes zu verschieben`rdsadmin.rdsadmin_util.move_datafile`. Beachten Sie die folgenden Voraussetzungen:
+ Sie müssen Oracle Enterprise Edition verwenden, um das `move_datafile` Verfahren auszuführen.
+ Sie können Tablespace `SYSTEM` und `RDSADMIN` nicht verschieben.
Die Prozedur `move_datafile` hat die folgenden Parameter.
****
| Parametername | Datentyp | Erforderlich | Beschreibung |
| --- | --- | --- | --- |
| `p_data_file_id` | Zahl | Ja | Die ID der Datendatei, die verschoben werden soll. |
| `p_location` | varchar2 | Ja | Das Speichervolume, auf das Sie die Datendatei verschieben möchten. |
Im folgenden Beispiel wird ein Tablespace vom Standardvolume `rdsdbdata` auf das zusätzliche Volume `rdsdbdata2` verschoben.
```
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
```
## Verschieben von Tabellendaten und Indizes zwischen Volumes in RDS for Oracle
Sie können den Datenbankspeicher optimieren, indem Sie Tablespaces auf zusätzlichen Speichervolumes erstellen. Anschließend können Sie Objekte wie Tabellen, Indizes und Partitionen mithilfe von Oracle-Standard-SQL in diese Tablespaces verschieben. Dieser Ansatz ist nützlich für die Leistungsoptimierung, wenn Ihre Datenbank Daten mit unterschiedlichen Zugriffsmustern enthält. Sie könnten beispielsweise häufig abgerufene Betriebsdaten auf Hochleistungsspeichervolumes speichern und gleichzeitig historische Daten, auf die selten zugegriffen wird, auf kostengünstigere Speichervolumes verschieben.
Im folgenden Beispiel erstellen Sie einen neuen Tablespace auf einem Hochleistungsvolume. `rdsdbdata2` Anschließend verschieben Sie eine Tabelle auf Ihr zusätzliches Speichervolume, solange die Tabelle online ist. Außerdem verschieben Sie den Index auf dasselbe Volume. Für das Verschieben von Tabellen und das Neuerstellen von Indizes, während Sie online sind, ist Oracle Enterprise Edition erforderlich.
```
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;
```
Im folgenden Beispiel erstellen Sie einen Tablespace auf einem kostengünstigen Volume. Anschließend verschieben Sie mithilfe eines Online-Vorgangs eine Tabellenpartition auf Ihr kostengünstiges Speichervolume.
```
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;
```
Im folgenden Beispiel fragen Sie aktive Sitzungen und lange Operationen ab.
```
SELECT sid,opname,sofar,totalwork,time_remaining,elapsed_seconds
FROM v$session_longops
WHERE time_remaining > 0;
```
Sie können die Nutzung Ihrer Tablespaces mit der folgenden Abfrage überprüfen.
```
SELECT tablespace_name, used_percent
FROM dba_tablespace_usage_metrics
ORDER BY used_percent DESC;
```
## Verwaltung von LOB-Speicher mithilfe zusätzlicher Volumes
Ihre Datenbank enthält möglicherweise Tabellen mit BLOB- oder CLOB-Objekten, die viel Speicherplatz beanspruchen, auf die jedoch selten zugegriffen wird. Um den Speicher zu optimieren, können Sie diese LOB-Segmente in einen Tablespace auf einem zusätzlichen Speichervolume verlagern.
Im folgenden Beispiel erstellen Sie einen Tablespace für LOB-Daten auf einem kostengünstigen Volume, das für Daten mit geringem Zugriff vorgesehen ist. Anschließend erstellen Sie eine Tabelle, in der Daten auf diesem Volume gespeichert werden.
```
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);
```
# Arbeiten mit externen Tabellen in RDS for Oracle
*Externe Oracle-Tabellen *sind Tabellen mit Daten, die sich nicht in der Datenbank befinden. Stattdessen befinden sich die Daten in externen Dateien, auf die die Datenbank zugreifen kann. Durch die Verwendung externer Tabellen können Sie auf die Daten zugreifen, ohne sie in die Datenbank zu laden. Weitere Informationen zu externen Tabellen finden Sie unter [Managing External Tables](http://docs.oracle.com/database/121/ADMIN/tables.htm#ADMIN01507) in der Oracle-Dokumentation.
Mit Amazon RDS können Sie externe Tabellendateien in Verzeichnisobjekten speichern. Sie können ein Verzeichnisobjekt erstellen oder eines verwenden, das in der Oracle-Datenbank vordefiniert ist, z. B. das Verzeichnis DATA\$1PUMP\$1DIR. Weitere Informationen zum Erstellen von Verzeichnisobjekten finden Sie unter [Erstellen und Löschen von Verzeichnissen im Hauptdatenspeicherbereich](Appendix.Oracle.CommonDBATasks.Misc.md#Appendix.Oracle.CommonDBATasks.NewDirectories). Sie können die Ansicht ALL\$1DIRECTORIES abfragen, um die Verzeichnisobjekte für Ihre Amazon RDS Oracle DB-Instance aufzulisten.
**Anmerkung**
Verzeichnisobjekte zeigen auf den von Ihrer Instance verwendeten Datenspeicherplatz (Amazon EBS-Volume). Der belegte Speicherplatz – mit Datendateien, Redo-Logs, Audit- und Nachverfolgungsdateien sowie anderen Dateien – wird auf den zugewiesenen Speicherplatz angerechnet.
Sie verschieben eine externe Datendatei von einer Oracle-Datenbank in eine andere Datenbank, indem Sie das Paket [ DBMS\$1FILE\$1TRANSFER](https://docs.oracle.com/database/121/ARPLS/d_ftran.htm#ARPLS095) oder das Paket [UTL\$1FILE](https://docs.oracle.com/database/121/ARPLS/u_file.htm#ARPLS069) verwenden. Die externe Datendatei wird von einem Verzeichnis auf der Quelldatenbank in das angegebene Verzeichnis auf der Zieldatenbank verschoben. Für weitere Informationen zur Nutzung von `DBMS_FILE_TRANSFER` siehe [Importieren mit Oracle Data Pump](Oracle.Procedural.Importing.DataPump.md).
Nachdem Sie die externe Datendatei verschoben haben, können Sie damit eine externe Tabelle anlegen. Im folgenden Beispiel wird eine externe Tabelle erstellt, die die `emp_xt_file1.txt` Datei im DIR1 Verzeichnis USER\$1 verwendet.
```
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;
```
Angenommen, Sie möchten Daten, die sich in einer Amazon RDS Oracle DB-Instance befinden, in eine externe Datendatei verschieben. In diesem Fall können Sie die externe Datendatei füllen, indem Sie eine externe Tabelle anlegen und die Daten aus der Tabelle in der Datenbank auswählen. Die folgende SQL-Anweisung erzeugt z. B. die externe Tabelle `orders_xt` durch Abfrage der Tabelle `orders` in der Datenbank.
```
CREATE TABLE orders_xt
ORGANIZATION EXTERNAL
(
TYPE ORACLE_DATAPUMP
DEFAULT DIRECTORY DATA_PUMP_DIR
LOCATION ('orders_xt.dmp')
)
AS SELECT * FROM orders;
```
In diesem Beispiel werden die Daten in der Datei `orders_xt.dmp` im Verzeichnis DATA\$1PUMP\$1DIR gefüllt.
# Überprüfung einer Datenbank
Um die Datenbank zu überprüfen, verwenden Sie die Amazon RDS-Prozedur `rdsadmin.rdsadmin_util.checkpoint`. Die Prozedur `checkpoint` hat keine Parameter.
Im folgenden Beispiel wird die Datenbank stichprobenartig kontrolliert.
```
EXEC rdsadmin.rdsadmin_util.checkpoint;
```
# Einstellen der verteilten Wiederherstellung
Um die verteilte Wiederherstellung festzulegen, verwenden Sie die Amazon-RDS-Prozeduren `rdsadmin.rdsadmin_util.enable_distr_recovery` und `disable_distr_recovery`. Die Prozeduren haben keine Parameter.
Im folgenden Beispiel wird die verteilte Wiederherstellung aktiviert.
```
EXEC rdsadmin.rdsadmin_util.enable_distr_recovery;
```
Im folgenden Beispiel wird die verteilte Wiederherstellung deaktiviert.
```
EXEC rdsadmin.rdsadmin_util.disable_distr_recovery;
```
# Einstellen der Datenbank-Zeitzone
Sie können die Zeitzone Ihrer Amazon RDS Oracle-Datenbank auf folgende Weise festlegen:
+ Die Option `Timezone`
Die Option `Timezone` ändert die Zeitzone auf Host-Ebene und wirkt sich auf alle Datumsspalten und -Werte aus, wie zum Beispiel auf `SYSDATE`. Weitere Informationen finden Sie unter [Oracle-Zeitzone](Appendix.Oracle.Options.Timezone.md).
+ Das Amazon RDS-Verfahren `rdsadmin.rdsadmin_util.alter_db_time_zone`
Die Prozedur `alter_db_time_zone` ändert die Zeitzone nur für bestimmte Datentypen und ändert nicht `SYSDATE`. Beim Einstellen der Zeitzone bestehen weitere Beschränkungen, die Sie in der [Oracle-Dokumentation](http://docs.oracle.com/cd/B19306_01/server.102/b14225/ch4datetime.htm#i1006705) nachlesen.
**Anmerkung**
Sie können auch die Standardzeitzone für Oracle Scheduler festlegen. Weitere Informationen finden Sie unter [Festlegen der Zeitzone für Oracle Scheduler-Aufgaben](Appendix.Oracle.CommonDBATasks.Scheduler.md#Appendix.Oracle.CommonDBATasks.Scheduler.TimeZone).
Die Prozedur `alter_db_time_zone` hat die folgenden Parameter.
****
| Parametername | Datentyp | Standard | Erforderlich | Beschreibung |
| --- | --- | --- | --- | --- |
| `p_new_tz` | varchar2 | — | Ja | Die neue Zeitzone als benannte Region oder ein absoluter Versatz von der koordinierten Weltzeit (UTC). Gültige Offsets liegen im Bereich von -12:00 bis \$114:00. |
Im folgenden Beispiel wird die Zeitzone auf UTC plus drei Stunden geändert.
```
EXEC rdsadmin.rdsadmin_util.alter_db_time_zone(p_new_tz => '+3:00');
```
Im folgenden Beispiel wird die Zeitzone in die Africa/Algiers Zeitzone geändert.
```
EXEC rdsadmin.rdsadmin_util.alter_db_time_zone(p_new_tz => 'Africa/Algiers');
```
Nachdem Sie die Zeitzone mithilfe der Prozedur `alter_db_time_zone` geändert haben, starten Sie Ihre DB-Instance neu, damit die Änderung übernommen wird. Weitere Informationen finden Sie unter [Eine DB-Instance DB-Cluster neu starten](USER_RebootInstance.md). Weitere Informationen zum Aktualisieren von Zeitzonen finden Sie unter [Überlegungen zur Zeitzone](USER_UpgradeDBInstance.Oracle.OGPG.md#USER_UpgradeDBInstance.Oracle.OGPG.DST).
# Generieren von Leistungsberichten mit Automatic Workload Repository (AWR)
Um Leistungsdaten zu sammeln und Berichte zu generieren, empfiehlt Oracle Automatic Workload Repository (AWR). AWR erfordert Oracle Database Enterprise Edition und eine Lizenz für die Diagnostics and Tuning Packs. Um AWR zu aktivieren, legen Sie den `CONTROL_MANAGEMENT_PACK_ACCESS`-Initialisierungsparameter entweder auf `DIAGNOSTIC` oder `DIAGNOSTIC+TUNING` fest.
## Arbeiten mit AWR-Berichten in RDS
Um AWR-Berichte zu generieren, können Sie Skripte wie ausführe `awrrpt.sql`. Diese Skripte werden auf dem Datenbankhostserver installiert. In Amazon RDS haben Sie keinen direkten Zugriff auf den Host. Sie können jedoch Kopien von SQL-Skripten von einer anderen Installation von Oracle Database abrufen.
Sie können AWR auch verwenden, indem Sie Prozeduren im `SYS.DBMS_WORKLOAD_REPOSITORY` PL/SQL Paket ausführen. Sie können dieses Paket verwenden, um Baselines und Snapshots zu verwalten und auch ASH- und AWR-Berichte anzuzeigen. Um beispielsweise einen AWR-Bericht im Textformat zu generieren, führen Sie das `DBMS_WORKLOAD_REPOSITORY.AWR_REPORT_TEXT`-Verfahren aus. Sie können diese AWR-Berichte jedoch nicht über die erreich AWS-Managementkonsole.
Bei der Arbeit mit AWR empfehlen wir, die `rdsadmin.rdsadmin_diagnostic_util`-Verfahren zu verwenden. Sie können diese Verfahren verwenden, um Folgendes zu generieren:
+ AWR-Berichte
+ ASH-Berichte (Active Session History)
+ ADDM-Berichte (Automatic Database Diagnostic Monitor)
+ Oracle Data Pump Export-Dump-Dateien von AWR-Daten
Die `rdsadmin_diagnostic_util`-Verfahren speichern die Berichte im DB-Instance-Dateisystem. Sie können über die Konsole auf diese Berichte zugreifen. Sie können auch mithilfe der `rdsadmin.rds_file_util`-Verfahren auf Berichte zugreifen, und Sie können auf Berichte zugreifen, die mit der Option „S3-Integration“ in Amazon S3 kopiert werden. Weitere Informationen erhalten Sie unter [Lesen von Dateien in einem DB-Instance-Verzeichnis](Appendix.Oracle.CommonDBATasks.Misc.md#Appendix.Oracle.CommonDBATasks.ReadingFiles) und [Amazon S3-Integration](oracle-s3-integration.md).
Sie können die `rdsadmin_diagnostic_util`-Verfahren in den folgenden Amazon RDS for Oracle-DB-Engine-Versionen verwenden:
+ Alle Versionen von Oracle Database 21c
+ 19.0.0.0.ru-2020-04.rur-2020-04.r1 und höhere Versionen von Oracle Database 19c
Einen Blog mit Erläuterungen zum Arbeiten mit Diagnoseberichten in einem Replikationsszenario finden Sie unter [Generieren von AWR-Berichten für Amazon-RDS-für-Oracle-Lesereplikate](https://aws.amazon.com/blogs/database/generate-awr-reports-for-amazon-rds-for-oracle-read-replicas/).
## Geläufige Parameter für das Diagnose-Utility-Paket
Normalerweise verwenden Sie die folgenden Parameter, wenn AWR und ADDM mit dem `rdsadmin_diagnostic_util`-Paket verwaltet werden.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.AWR.html)
Normalerweise verwenden Sie die folgenden Parameter, wenn Sie ASH mit dem rdsadmin\$1diagnostic\$1util-Paket verwalten.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.AWR.html)
## Generieren eines AWR-Berichts
Verwenden Sie das `rdsadmin.rdsadmin_diagnostic_util.awr_report`-Verfahren, um einen AWR-Bericht zu generieren.
Im folgenden Beispiel wird ein AWR-Bericht für den Snapshot-Bereich 101–106 generiert. Die Ausgabetextdatei heißt `awrrpt_101_106.txt`. Sie können auf diesen Bericht in der zugreife AWS-Managementkonsole.
```
EXEC rdsadmin.rdsadmin_diagnostic_util.awr_report(101,106,'TEXT');
```
Im folgenden Beispiel wird ein HTML-Bericht für den Snapshot-Bereich 63–65 generiert. Die Ausgabe-HTML-Datei heißt `awrrpt_63_65.html`. Das Verfahren schreibt den Bericht in das nicht standardmäßige Datenbankverzeichnis namens `AWR_RPT_DUMP`.
```
EXEC rdsadmin.rdsadmin_diagnostic_util.awr_report(63,65,'HTML','AWR_RPT_DUMP');
```
## Extrahieren von AWR-Daten in eine Dump-Datei
Verwenden Sie das `rdsadmin.rdsadmin_diagnostic_util.awr_extract`-Verfahren, um AWR-Daten in eine Dump-Datei zu extrahieren. Sie können diese Funktion nur auf PDB-Ebene verwenden.
Im folgenden Beispiel wird der Snapshot-Bereich 101–106 extrahiert. Die Ausgabe-Dump-Datei heißt `awrextract_101_106.dmp`. Sie können über die Konsole auf diese Datei zugreifen.
```
EXEC rdsadmin.rdsadmin_diagnostic_util.awr_extract(101,106);
```
Im folgenden Beispiel wird der Snapshot-Bereich 63–65 extrahiert. Die Ausgabe-Dump-Datei heißt `awrextract_63_65.dmp`. Die Datei wird im nicht standardmäßigen Datenbankverzeichnis namens gespeicher `AWR_RPT_DUMP`.
```
EXEC rdsadmin.rdsadmin_diagnostic_util.awr_extract(63,65,'AWR_RPT_DUMP');
```
## Generieren eines ADDM-Berichts
Verwenden Sie das `rdsadmin.rdsadmin_diagnostic_util.addm_report`-Verfahren, um einen ADDM-Bericht zu generieren.
Im folgenden Beispiel wird ein ADDM-Bericht für den Snapshot-Bereich 101–106 generiert. Die Ausgabetextdatei heißt `addmrpt_101_106.txt`. Sie können über die Konsole auf den Bericht zugreifen.
```
EXEC rdsadmin.rdsadmin_diagnostic_util.addm_report(101,106);
```
Im folgenden Beispiel wird ein ADDM-Bericht für den Snapshot-Bereich 63–65 generiert. Die Ausgabetextdatei heißt `addmrpt_63_65.txt`. Die Datei wird im nicht standardmäßigen Datenbankverzeichnis namens gespeicher `ADDM_RPT_DUMP`.
```
EXEC rdsadmin.rdsadmin_diagnostic_util.addm_report(63,65,'ADDM_RPT_DUMP');
```
## Generieren eines ASH-Berichts
Verwenden Sie das `rdsadmin.rdsadmin_diagnostic_util.ash_report`-Verfahren, um einen ASH-Bericht zu generieren.
Im folgenden Beispiel wird ein ASH-Bericht generiert, der die Daten von vor 14 Minuten bis zur aktuellen Zeit enthält. Der Name der Ausgabedatei verwendet das Format `ashrptbegin_timeend_time.txt`, wobei `begin_time` und `end_time` das Format `YYYYMMDDHH24MISS` verwenden. Sie können über die Konsole auf die Datei zugreifen.
```
BEGIN
rdsadmin.rdsadmin_diagnostic_util.ash_report(
begin_time => SYSDATE-14/1440,
end_time => SYSDATE,
report_type => 'TEXT');
END;
/
```
Im folgenden Beispiel wird ein ASH-Bericht generiert, der die Daten vom 18. November 2019 um 18:07 Uhr bis zum 18. November 2019 um 18:15 Uhr enthält. Der Name des HTML-Ausgabeberichts lautet `ashrpt_20190918180700_20190918181500.html`. Der Bericht wird im nicht standardmäßigen Datenbankverzeichnis mit dem Namen gespeicher `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;
/
```
## Zugriff auf AWR-Berichte über die Konsole oder CLI
Um auf AWR-Berichte zuzugreifen oder Dumpdateien zu exportieren, können Sie das oder verwenden. AWS-Managementkonsole AWS CLI Weitere Informationen finden Sie unter [Herunterladen einer Datenbank-Protokolldatei](USER_LogAccess.Procedural.Downloading.md).
# Anpassen von Datenbank-Links für die Verwendung mit DB-Instances in einer VPC
Um Oracle-Datenbanklinks mit Amazon RDS-DB-Instances innerhalb derselben Virtual Private Cloud (VPC) oder Peered zu verwenden VPCs, sollten die beiden DB-Instances über eine gültige Route zwischen ihnen verfügen. Überprüfen Sie die gültige Route zwischen den DB-Instances mithilfe Ihrer VPC-Routing-Tabellen und Netzwerk-Zugriffskontrolllisten (ACL).
Die Sicherheitsgruppe jeder DB-Instance muss den Eintritt und den Austritt von einer zur anderen DB-Instance erlauben. Die eingehenden und ausgehenden Regeln können sich auf Sicherheitsgruppen in der selben VPC oder in gleichrangingen VPCs beziehen. Weitere Informationen finden Sie unter [Aktualisieren der Sicherheitsgruppen, um auf Peer-VPC-Gruppen zu verweisen](https://docs.aws.amazon.com/vpc/latest/peering/working-with-vpc-peering.html#vpc-peering-security-groups).
Wenn Sie einen benutzerdefinierten DNS-Server mithilfe des DHCP-Options-Sets in Ihrer VPC konfiguriert haben, muss Ihr DNS-Server fähig sein, den Namen des Datenbank-Link-Ziels aufzulösen. Weitere Informationen finden Sie unter [Einrichten eines benutzerdefinierten DNS-Servers](Appendix.Oracle.CommonDBATasks.System.md#Appendix.Oracle.CommonDBATasks.CustomDNS).
Weitere Informationen über die Verwendung von Datenbank-Links mit Oracle Data Pump finden Sie unter [Importieren mit Oracle Data Pump](Oracle.Procedural.Importing.DataPump.md).
# Einrichten der Standardversion für eine DB-Instance
Sie können Datenbankobjekte in einer privaten Umgebung neu definieren, einer so genannten Version. Mit der versionsbasierten Neudefinition können Sie die Datenbankobjekte einer Anwendung mit minimalen Ausfallzeiten aktualisieren.
Sie legen die Standardversion einer Amazon RDS-Oracle-DB-Instance mit der Amazon RDS-Prozedur fes `rdsadmin.rdsadmin_util.alter_default_edition`.
Das folgende Beispiel setzt die Standardversion für die Amazon RDS-Oracle-DB-Instance auf `RELEASE_V1`.
```
EXEC rdsadmin.rdsadmin_util.alter_default_edition('RELEASE_V1');
```
Das folgende Beispiel setzt die Standardversion für die Amazon RDS Oracle DB-Instance zurück auf die Oracle Standardeinstellung.
```
EXEC rdsadmin.rdsadmin_util.alter_default_edition('ORA$BASE');
```
Weitere Informationen über die versionsbasierte Neudefinition von Oracle finden Sie unter [About Editions and Edition-Based Redefinition](https://docs.oracle.com/database/121/ADMIN/general.htm#ADMIN13167) in der Oracle-Dokumentation.
# Aktivieren der Prüfung für die SYS.AUD\$1-Tabelle
Um das Auditing in der Datenbank-Audit-Trail-Tabelle `SYS.AUD$` zu aktivieren, verwenden Sie die Amazon RDS-Prozedur `rdsadmin.rdsadmin_master_util.audit_all_sys_aud_table`. Die einzige unterstützte Audit-Eigenschaft ist `ALL`. Sie können einzelne Anweisungen und Operationen (nicht) prüfen.
Die Aktivierung der Prüfung wird für Oracle DB-Instances unterstützt, die die folgenden Versionen ausführen:
+ Oracle Database 21c (21.0.0)
+ Oracle Database 19c (19.0.0)
Die Prozedur `audit_all_sys_aud_table` hat die folgenden Parameter.
****
| Parametername | Datentyp | Standard | Erforderlich | Beschreibung |
| --- | --- | --- | --- | --- |
| `p_by_access` | Boolean | true | Nein | Auf `true` festlegen, um `BY ACCESS` zu prüfen. Auf `false` festlegen, um `BY SESSION` zu prüfen. |
Die folgende Abfrage gibt die aktuelle Audit-Konfiguration für `SYS.AUD$` für eine Datenbank zurück.
```
SELECT * FROM DBA_OBJ_AUDIT_OPTS WHERE OWNER='SYS' AND OBJECT_NAME='AUD$';
```
Die folgenden Befehle aktivieren die Prüfung von `ALL` auf `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);
```
Der folgende Befehl aktiviert die Prüfung von `ALL` auf `SYS.AUD$` `BY SESSION`.
```
EXEC rdsadmin.rdsadmin_master_util.audit_all_sys_aud_table(p_by_access => false);
```
Weitere Informationen finden Sie unter [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) in der Oracle-Dokumentation.
# Deaktivieren der Prüfung für die SYS.AUD\$1-Tabelle
Um das Auditing in der Datenbank-Audit-Trail-Tabelle `SYS.AUD$` zu deaktivieren, verwenden Sie die Amazon RDS-Prozedur `rdsadmin.rdsadmin_master_util.noaudit_all_sys_aud_table`. Diese Prozedur verwendet keine Parameter.
Die folgende Abfrage gibt die aktuelle Audit-Konfiguration für `SYS.AUD$` für eine Datenbank zurück:
```
SELECT * FROM DBA_OBJ_AUDIT_OPTS WHERE OWNER='SYS' AND OBJECT_NAME='AUD$';
```
Der folgende Befehl deaktiviert die Prüfung von `ALL` auf `SYS.AUD$`.
```
EXEC rdsadmin.rdsadmin_master_util.noaudit_all_sys_aud_table;
```
Weitere Informationen finden Sie unter [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) in der Oracle-Dokumentation.
# Bereinigen unterbrochener Online-Index-Builds
Zum Bereinigen fehlgeschlagener Online-Index-Builds verwenden Sie das Amazon RDS-Verfahren `rdsadmin.rdsadmin_dbms_repair.online_index_clean`.
Die Prozedur `online_index_clean` hat die folgenden Parameter.
****
| Parametername | Datentyp | Standard | Erforderlich | Beschreibung |
| --- | --- | --- | --- | --- |
| `object_id` | binary\$1integer | `ALL_INDEX_ID` | Nein | Die Objekt-ID des Index. In der Regel können Sie die Objekt-ID aus dem ORA-08104-Fehlertext verwenden. |
| `wait_for_lock` | binary\$1integer | `rdsadmin.rdsadmin_dbms_repair.lock_wait` | Nein | Geben Sie `rdsadmin.rdsadmin_dbms_repair.lock_wait` an (Standardeinstellung), um zu versuchen, eine Sperre für das zugrunde liegende Objekt zu erhalten und den Vorgang zu wiederholen, bis ein interner Grenzwert erreicht ist, wenn die Sperre fehlschlägt. Geben Sie `rdsadmin.rdsadmin_dbms_repair.lock_nowait` an, um zu versuchen, eine Sperre für das zugrunde liegende Objekt zu erhalten, den Vorgang jedoch nicht zu wiederholen, wenn die Sperre fehlschlägt. |
Das folgende Beispiel bereinigt einen fehlgeschlagenen Online-Index-Build:
```
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;
/
```
Weitere Informationen finden Sie unter [ONLINE\$1INDEX\$1CLEAN Function](https://docs.oracle.com/database/121/ARPLS/d_repair.htm#ARPLS67555) in der Oracle-Dokumentation.
# Überspringen von beschädigten Blöcken
Zum Überspringen von beschädigten Blöcken während Index- und Tabellenscans verwenden Sie das `rdsadmin.rdsadmin_dbms_repair`-Paket.
Die folgenden Verfahren umschließen die Funktionalität der `sys.dbms_repair.admin_table`-Prozedur und verwenden keine Parameter:
+ `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`
Die folgenden Verfahren verwenden dieselben Parameter wie ihre Gegenstücke im `DBMS_REPAIR`-Paket für Oracle-Datenbanken:
+ `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`
Weitere Informationen zum Umgang mit Datenbankbeschädigungen finden Sie unter [DBMS\$1REPAIR](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/DBMS_REPAIR.html#GUID-B8EC4AB3-4D6A-46C9-857F-4ED53CD9C948) in der Oracle-Dokumentation.
**Example Reaktion auf beschädigte Blöcke**
Dieses Beispiel zeigt den grundlegenden Workflow für die Reaktion auf beschädigte Blöcke. Ihre Schritte hängen vom Ort und der Art Ihrer Blockbeschädigung ab.
Bevor Sie versuchen, beschädigte Blöcke zu reparieren, überprüfen Sie sorgfältig die [DBMS\$1REPAIR](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/DBMS_REPAIR.html#GUID-B8EC4AB3-4D6A-46C9-857F-4ED53CD9C948)-Dokumentation.
**So überspringen Sie beschädigte Blöcke bei Index- und Tabellenscans**
1. Führen Sie die folgenden Verfahren aus, um Reparaturtabellen zu erstellen, wenn sie noch nicht vorhanden sind.
```
EXEC rdsadmin.rdsadmin_dbms_repair.create_repair_table;
EXEC rdsadmin.rdsadmin_dbms_repair.create_orphan_keys_table;
```
1. Führen Sie die folgenden Verfahren aus, um nach vorhandenen Datensätzen zu suchen und diese ggf. zu löschen.
```
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. Führen Sie das folgende Verfahren aus, um nach beschädigten Blöcken zu suchen.
```
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. Führen Sie das Verfahren `skip_corrupt_blocks` aus, um das Überspringen von Beschädigungen für betroffene Tabellen zu aktivieren oder zu deaktivieren. Abhängig von der Situation müssen Sie möglicherweise auch Daten in eine neue Tabelle extrahieren und dann die Tabelle löschen, die den beschädigten Block enthält.
Führen Sie das folgende Verfahren aus, um das Überspringen von Beschädigungen für betroffene Tabellen zu aktivieren.
```
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';
```
Führen Sie das folgende Verfahren aus, um das Überspringen von Beschädigungen zu deaktivieren.
```
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. Wenn Sie alle Reparaturarbeiten abgeschlossen haben, führen Sie die folgenden Verfahren aus, um die Reparaturtabellen zu löschen.
```
EXEC rdsadmin.rdsadmin_dbms_repair.drop_repair_table;
EXEC rdsadmin.rdsadmin_dbms_repair.drop_orphan_keys_table;
```
## Bereinigen des Papierkorbs
Wenn Sie eine Tabelle löschen, entfernt Ihre Oracle-Datenbank nicht sofort ihren Speicherplatz. Die Datenbank benennt die Tabelle um und platziert sie und alle zugehörigen Objekte in einem Papierkorb. Durch das Bereinigen des Papierkorbs werden diese Elemente entfernt und der Speicherplatz freigegeben.
Verwenden Sie das Amazon RDS-Verfahren , um den gesamten Papierkorb zu bereinige `rdsadmin.rdsadmin_util.purge_dba_recyclebin`. Dieser Vorgang kann jedoch den Papierkorb von `SYS`- und `RDSADMIN`-Objekten nicht bereinigen. Wenn Sie diese Objekte löschen müssen, wenden Sie sich an den AWS Support.
Im folgenden Beispiel wird der gesamte Papierkorb bereinigt.
```
EXEC rdsadmin.rdsadmin_util.purge_dba_recyclebin;
```
# Festlegen der angezeigten Standardwerte für vollständige Redaktion
Verwenden Sie das Amazon-RDS-Verfahren `rdsadmin.rdsadmin_util.dbms_redact_upd_full_rdct_val`, um die angezeigten Standardwerte für eine für vollständige Redaktion auf Ihrer Amazon-RDS-Oracle-Instance zu ändern. Beachten Sie, dass Sie mit dem `DBMS_REDACT` PL/SQL Paket eine Schwärzungsrichtlinie erstellen, wie in der Oracle Database-Dokumentation erklärt. Das Verfahren `dbms_redact_upd_full_rdct_val` gibt die Zeichen an, die für verschiedene Datentypen angezeigt werden sollen, auf die sich eine bestehende Richtlinie auswirkt.
Die Prozedur `dbms_redact_upd_full_rdct_val` hat die folgenden Parameter.
****
| Parametername | Datentyp | Standard | Erforderlich | Beschreibung |
| --- | --- | --- | --- | --- |
| `p_number_val` | number | Null | Nein | Ändert den Standardwert für Spalten des Datentyps `NUMBER`. |
| `p_binfloat_val` | binary\$1float | Null | Nein | Ändert den Standardwert für Spalten des Datentyps `BINARY_FLOAT`. |
| `p_bindouble_val` | binary\$1double | Null | Nein | Ändert den Standardwert für Spalten des Datentyps `BINARY_DOUBLE`. |
| `p_char_val` | char | Null | Nein | Ändert den Standardwert für Spalten des Datentyps `CHAR`. |
| `p_varchar_val` | varchar2 | Null | Nein | Ändert den Standardwert für Spalten des Datentyps `VARCHAR2`. |
| `p_nchar_val` | nchar | Null | Nein | Ändert den Standardwert für Spalten des Datentyps `NCHAR`. |
| `p_nvarchar_val` | nvarchar2 | Null | Nein | Ändert den Standardwert für Spalten des Datentyps `NVARCHAR2`. |
| `p_date_val` | date | Null | Nein | Ändert den Standardwert für Spalten des Datentyps `DATE`. |
| `p_ts_val` | Zeitstempel | Null | Nein | Ändert den Standardwert für Spalten des Datentyps `TIMESTAMP`. |
| `p_tswtz_val` | timestamp with time zone | Null | Nein | Ändert den Standardwert für Spalten des Datentyps `TIMESTAMP WITH TIME ZONE`. |
| `p_blob_val` | blob | Null | Nein | Ändert den Standardwert für Spalten des Datentyps `BLOB`. |
| `p_clob_val` | clob | Null | Nein | Ändert den Standardwert für Spalten des Datentyps `CLOB`. |
| `p_nclob_val` | nclob | Null | Nein | Ändert den Standardwert für Spalten des Datentyps `NCLOB`. |
Im folgenden Beispiel wird der standardmäßige redigierte Wert für den Datentyp `CHAR` auf \$1 geändert:
```
EXEC rdsadmin.rdsadmin_util.dbms_redact_upd_full_rdct_val(p_char_val => '*');
```
Im folgenden Beispiel wird der standardmäßige redigierte Wert für die Datentypen `NUMBER`, `DATE` und `CHAR` geändert:
```
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;
/
```
Nachdem Sie die Standardwerte für vollständige Redaktion mit dem Prozess `dbms_redact_upd_full_rdct_val` geändert haben, starten Sie Ihre DB-Instance neu, damit die Änderung übernommen wird. Weitere Informationen finden Sie unter [Eine DB-Instance DB-Cluster neu starten](USER_RebootInstance.md).
# Ausführen allgemeiner Protokoll-bezogener Aufgaben für Oracle DB-Instances
Im Folgenden erfahren Sie, wie Sie bestimmte allgemeine DBA-Aufgaben durchführen können, die mit der Protokollierung Ihrer Amazon-RDS-DB-Instances in Oracle zusammenhängen. Um eine verwaltete Service-Erfahrung zu bieten, stellt Amazon RDS keinen Shell-Zugriff zu DB-Instances bereit und beschränkt den Zugriff auf bestimmte Systemprozeduren und -tabellen, die erweiterte Sonderrechte erfordern.
Weitere Informationen finden Sie unter [Datenbankprotokolldateien von Amazon RDS für Oracle](USER_LogAccess.Concepts.Oracle.md).
**Topics**
+ [
## Einstellen der erzwungenen Protokollierung
](#Appendix.Oracle.CommonDBATasks.SettingForceLogging)
+ [
## Einstellen der ergänzenden Protokollierung
](#Appendix.Oracle.CommonDBATasks.AddingSupplementalLogging)
+ [
## Wechseln zwischen Online-Protokolldateien
](#Appendix.Oracle.CommonDBATasks.SwitchingLogfiles)
+ [
## Hinzufügen von Online-Redo-Log-Dateien
](#Appendix.Oracle.CommonDBATasks.RedoLogs)
+ [
## Löschen von Online-Redo-Log-Dateien
](#Appendix.Oracle.CommonDBATasks.DroppingRedoLogs)
+ [
# Anpassen der Größe von Online-Redo-Log-Dateien
](Appendix.Oracle.CommonDBATasks.ResizingRedoLogs.md)
+ [
# Beibehaltung von archivierten Redo-Log-Dateien
](Appendix.Oracle.CommonDBATasks.RetainRedoLogs.md)
+ [
# Zugriff auf Online- oder archivierte Redo-Protokolle
](Appendix.Oracle.CommonDBATasks.Log.Download.md)
+ [
# Herunterladen von archivierten Redo-Protokolle aus Amazon S3
](Appendix.Oracle.CommonDBATasks.download-redo-logs.md)
## Einstellen der erzwungenen Protokollierung
Im Modus für erzwungene Protokollierung protokolliert Oracle alle Änderungen in einer Datenbank, außer Änderung in temporären Tabellenräumen und temporären Segmenten (`NOLOGGING` Klauseln werden ignoriert). Weitere Informationen finden Sie unter [Specifying FORCE LOGGING Mode](https://docs.oracle.com/cd/E11882_01/server.112/e25494/create.htm#ADMIN11096) in der Oracle-Dokumentation.
Um die erzwungene Protokollierung festzulegen, verwenden Sie die Amazon-RDS-Prozedur `rdsadmin.rdsadmin_util.force_logging`. Die Prozedur `force_logging` hat die folgenden Parameter.
****
| Parametername | Datentyp | Standard | Ja | Beschreibung |
| --- | --- | --- | --- | --- |
| `p_enable` | Boolean | true | Nein | Setzen Sie diesen Wert auf `true`, um die Datenbank in den Modus für erzwungene Protokollierung zu setzen, oder auf `false`, um Datenbanken aus diesem Modus zu entfernen. |
Im folgenden Beispiel wird eine Datenbank in den Modus für erzwungene Protokollierung gesetzt.
```
EXEC rdsadmin.rdsadmin_util.force_logging(p_enable => true);
```
## Einstellen der ergänzenden Protokollierung
Wenn Sie die zusätzliche Protokollierung aktivieren, LogMiner verfügt es über die erforderlichen Informationen, um verkettete Zeilen und geclusterte Tabellen zu unterstützen. Weitere Informationen finden Sie unter [Supplemental Logging](https://docs.oracle.com/cd/E11882_01/server.112/e22490/logminer.htm#SUTIL1582) in der Oracle-Dokumentation.
In Oracle Database ist die ergänzende Protokollierung standardmäßig deaktiviert. Um die erzwungene Protokollierung festzulegen, verwenden Sie die Amazon-RDS-Prozedur `rdsadmin.rdsadmin_util.alter_supplemental_logging`. Weitere Informationen über die Verwaltung der Aufbewahrung von archivierten Redo-Log-Dateien für Oracle-DB-Instances in Amazon RDS finden Sie unter [Beibehaltung von archivierten Redo-Log-Dateien](Appendix.Oracle.CommonDBATasks.RetainRedoLogs.md).
Die Prozedur `alter_supplemental_logging` hat die folgenden Parameter.
****
| Parametername | Datentyp | Standard | Erforderlich | Beschreibung |
| --- | --- | --- | --- | --- |
| `p_action` | varchar2 | — | Ja | `'ADD'`, um ergänzende Protokollierung hinzuzufügen, `'DROP'` um ergänzende Protokollierung zu verwerfen. |
| `p_type` | varchar2 | Null | Nein | Der Typ der ergänzenden Protokollierung. Gültige Werte sind `'ALL'`, `'FOREIGN KEY'`, `'PRIMARY KEY'`, `'UNIQUE'` oder `PROCEDURAL`. |
Im folgenden Beispiel wird die ergänzende Protokollierung aktiviert.
```
begin
rdsadmin.rdsadmin_util.alter_supplemental_logging(
p_action => 'ADD');
end;
/
```
Im folgenden Beispiel wird die ergänzende Protokollierung für alle Spalten mit fester Länge für Maximalgröße aktiviert.
```
begin
rdsadmin.rdsadmin_util.alter_supplemental_logging(
p_action => 'ADD',
p_type => 'ALL');
end;
/
```
Im folgenden Beispiel wird die ergänzende Protokollierung für primäre Schlüsselspalten aktiviert.
```
begin
rdsadmin.rdsadmin_util.alter_supplemental_logging(
p_action => 'ADD',
p_type => 'PRIMARY KEY');
end;
/
```
## Wechseln zwischen Online-Protokolldateien
Um die Protokolldateien zu wechseln, verwenden Sie die Amazon-RDS-Prozedur `rdsadmin.rdsadmin_util.switch_logfile`. Die Prozedur `switch_logfile` hat keine Parameter.
Im folgenden Beispiel wird zwischen Protokolldateien gewechselt.
```
EXEC rdsadmin.rdsadmin_util.switch_logfile;
```
## Hinzufügen von Online-Redo-Log-Dateien
Eine Amazon-RDS-DB-Instance, die Oracle ausführt, beginnt mit vier Online-Redo-Log-Dateien, jede 128 MB groß. Um weitere Wiederherstellungsprotokolle hinzuzufügen, verwenden Sie die Amazon-RDS-Prozedur `rdsadmin.rdsadmin_util.add_logfile`.
Die Prozedur `add_logfile` hat die folgenden Parameter.
**Anmerkung**
Die Parameter schließen sich gegenseitig aus.
****
| Parametername | Datentyp | Standard | Erforderlich | Beschreibung |
| --- | --- | --- | --- | --- |
| `bytes` | positiv | Null | Nein | Die Größe der Protokolldatei in Bytes Verwenden Sie diesen Parameter nur, wenn die Größe des Protokolls unter 2147483648 Byte (2 GiB) liegt. Andernfalls gibt RDS einen Fehler aus. Verwenden Sie für Protokollgrößen, die über diesem Bytewert liegen, stattdessen den Parameter `p_size`. |
| `p_size` | varchar2 | — | Ja | Die Größe der Protokolldatei in Kilobyte (KB), Megabyte (MB) oder Gigabyte (GB). |
Mit dem folgenden Befehl wird eine Protokolldatei der Größe 100 MB hinzugefügt.
```
EXEC rdsadmin.rdsadmin_util.add_logfile(p_size => '100M');
```
## Löschen von Online-Redo-Log-Dateien
Um Wiederherstellungsprotokolle zu löschen, verwenden Sie die Amazon-RDS-Prozedur `rdsadmin.rdsadmin_util.drop_logfile`. Die Prozedur `drop_logfile` hat die folgenden Parameter.
****
| Parametername | Datentyp | Standard | Erforderlich | Beschreibung |
| --- | --- | --- | --- | --- |
| `grp` | positiv | — | Ja | Die Gruppennummer des Protokolls |
Im folgenden Beispiel wird das Protokoll mit der Gruppennummer 3 verworfen.
```
EXEC rdsadmin.rdsadmin_util.drop_logfile(grp => 3);
```
Sie können nur Protokolle verwerfen, die den Status "unbenutzt" oder "inaktiv" haben. Im folgenden Beispiel werden die Stati der Protokolle abgerufen.
```
SELECT GROUP#, STATUS FROM V$LOG;
GROUP# STATUS
---------- ----------------
1 CURRENT
2 INACTIVE
3 INACTIVE
4 UNUSED
```
# Anpassen der Größe von Online-Redo-Log-Dateien
Eine Amazon RDS-DB-Instance, die Oracle ausführt, beginnt mit vier Online-Redo-Log-Dateien, jede 128 MB groß. Im folgenden Beispiel wird gezeigt, wie Sie Amazon RDS-Prozeduren verwenden können, um die Größe für jedes Ihrer Protokolle von 128 MB auf 512 MB anzupassen.
```
/* 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
```
# Beibehaltung von archivierten Redo-Log-Dateien
Sie können archivierte Redo-Logs lokal auf Ihrer DB-Instance speichern, um sie mit Produkten wie Oracle LogMiner (`DBMS_LOGMNR`) zu verwenden. Nachdem Sie die Redo-Logs aufbewahrt haben, können Sie sie LogMiner zur Analyse der Logs verwenden. Weitere Informationen finden Sie in der [ LogMiner Oracle-Dokumentation unter Verwendung zur Analyse von Redo-Log-Dateien](http://docs.oracle.com/cd/E11882_01/server.112/e22490/logminer.htm).
Um archivierte Wiederherstellungsprotokolle zu erhalten, verwenden Sie das Amazon-RDS-Verfahren `rdsadmin.rdsadmin_util.set_configuration`. Wenn Sie dieses Verfahren auf einer primären Instance in Oracle Data Guard anwenden, ändert RDS die Aufbewahrungseinstellung für Archivprotokolle auf der primären Instance und öffnet Lesereplikate, aber nicht auf aufgespielten Replikaten. RDS speichert die neuesten Archiv-Redo-Protokolle auf aufgespielten Replikaten für einen kurzen Zeitraum. RDS löscht automatisch ältere Protokolle, die auf gemountete Replikate heruntergeladen wurden.
Die Prozedur `set_configuration` hat die folgenden Parameter.
****
| Parametername | Datentyp | Standard | Erforderlich | Beschreibung |
| --- | --- | --- | --- | --- |
| `name` | varchar | — | Ja | Der Name für die zu aktualisierende Konfiguration Um die Aufbewahrungszeiten für archivierte Redo-Protokolle zu ändern, legen Sie den Namen auf `archivelog retention hours` fest. |
| `value` | varchar | — | Ja | Der Wert für die Konfiguration Geben Sie als Wert die Anzahl der Stunden an, für die die Protokolle aufbewahrt werden sollen. |
Im folgenden Beispiel werden 24 Stunden an Redo-Logs aufbewahrt.
```
begin
rdsadmin.rdsadmin_util.set_configuration(
name => 'archivelog retention hours',
value => '24');
end;
/
commit;
```
**Anmerkung**
Das Commit muss durchgeführt werden, damit die Änderungen wirksam werden.
Um zu sehen, wie lange archivierte Wiederherstellungsprotokolle für Ihre DB-Instance aufbewahrt werden, verwenden Sie die Amazon-RDS-Prozedur `rdsadmin.rdsadmin_util.show_configuration`.
Im folgenden Beispiel wird die Protokoll-Aufbewahrungszeit angezeigt.
```
set serveroutput on
EXEC rdsadmin.rdsadmin_util.show_configuration;
```
Der Ausgang zeigt die aktuelle Einstellung für `archivelog retention hours`. Die folgende Ausgabe zeigt, dass archivierte Wiederherstellungsprotokolle 48 Stunden lang aufbewahrt werden.
```
NAME:archivelog retention hours
VALUE:48
DESCRIPTION:ArchiveLog expiration specifies the duration in hours before archive/redo log files are automatically deleted.
```
Da die archivierten Redo-Log-Dateien in Ihrer DB-Instance aufbewahrt werden, stellen Sie sicher, dass Ihre DB-Instance genügend zugewiesenen Speicherplatz für die aufbewahrten Protokolle bietet. Um festzustellen, wie viel Speicherplatz Ihre DB-Instance in den letzten X Stunden belegt hat, können Sie die folgende Abfrage ausführen. Dabei ersetzen Sie X durch die Anzahl von Stunden.
```
SELECT SUM(BLOCKS * BLOCK_SIZE) bytes
FROM V$ARCHIVED_LOG
WHERE FIRST_TIME >= SYSDATE-(X/24) AND DEST_ID=1;
```
RDS für Oracle generiert nur dann archivierte Redo-Protokolle, wenn die Backup-Aufbewahrungsdauer Ihrer DB-Instance größer als null ist. Standardmäßig ist der Aufbewahrungszeitraum für Backups größer als null.
Wenn der Aufbewahrungszeitraum für archivierte Protokolle abläuft, entfernt RDS für Oracle die archivierten Redo-Protokolle aus Ihrer DB-Instance. Um die Backup Ihrer DB-Instance zu einem bestimmten Zeitpunkt zu unterstützen, bewahrt Amazon RDS die archivierten Redo-Protokolle außerhalb Ihrer DB-Instance basierend auf dem Aufbewahrungszeitraum für Backups auf. Informationen zum Ändern des Aufbewahrungszeitraums für Backups finden Sie unter [Ändern einer Amazon-RDS-DB-Instance](Overview.DBInstance.Modifying.md).
**Anmerkung**
In einigen Fällen kann es vorkommen, das beim Verwenden von JDBC unter Linux zum Herunterladen von Redo-Logs lange Latenzzeiten auftreten und Verbindungen zurückgesetzt werden. Das Problem wird in solchen Fällen vielleicht durch die Standardeinstellung des Zufallszahlengenerators in Ihrem Java-Client verursacht. Wir empfehlen, dass Sie für die JDBC-Treiber die Verwendung eines blockierungsfreien Zufallszahlengenerators festlegen.
# Zugriff auf Online- oder archivierte Redo-Protokolle
Möglicherweise möchten Sie mit externen Tools wie Attunity, Informatica und anderen auf Ihre Online- und archivierten Redo-Log-Dateien für das Mining zugreifen. GoldenGate Gehen Sie folgendermaßen vor, um auf diese Dateien zuzugreifen:
1. Erstellen Sie Verzeichnisobjekte, die schreibgeschützten Zugriff auf die physischen Dateipfade bieten.
Verwendung von `rdsadmin.rdsadmin_master_util.create_archivelog_dir` und `rdsadmin.rdsadmin_master_util.create_onlinelog_dir`.
1. Lesen Sie die Dateien mit PL/SQL.
Sie können die Dateien mit PL/SQL lesen. Weitere Informationen über das Lesen von Dateien in Verzeichnisobjekten finden Sie unter [Auflisten von Dateien in einem DB-Instance-Verzeichnis](Appendix.Oracle.CommonDBATasks.Misc.md#Appendix.Oracle.CommonDBATasks.ListDirectories) und [Lesen von Dateien in einem DB-Instance-Verzeichnis](Appendix.Oracle.CommonDBATasks.Misc.md#Appendix.Oracle.CommonDBATasks.ReadingFiles).
Der Zugriff auf Transaktionsprotokolle wird für die folgenden Versionen unterstützt:
+ Oracle Database 21c
+ Oracle Database 19c
Der folgende Code erstellt Verzeichnisse, die schreibgeschützten Zugriff auf Ihre Online- und archivierte Redo-Log-Dateien bieten:
**Wichtig**
Dieser Code widerruft das Sonderrecht `DROP ANY DIRECTORY`.
```
EXEC rdsadmin.rdsadmin_master_util.create_archivelog_dir;
EXEC rdsadmin.rdsadmin_master_util.create_onlinelog_dir;
```
Der folgende Code verwirft die Verzeichnisse für Ihre Online- und archivierten Redo-Log-Dateien.
```
EXEC rdsadmin.rdsadmin_master_util.drop_archivelog_dir;
EXEC rdsadmin.rdsadmin_master_util.drop_onlinelog_dir;
```
Der folgende Code erteilt oder widerruft die Berechtigung `DROP ANY DIRECTORY`.
```
EXEC rdsadmin.rdsadmin_master_util.revoke_drop_any_directory;
EXEC rdsadmin.rdsadmin_master_util.grant_drop_any_directory;
```
# Herunterladen von archivierten Redo-Protokolle aus Amazon S3
Sie können archivierte Redo-Protokolle auf Ihrer DB-Instance mit dem `rdsadmin.rdsadmin_archive_log_download`-Paket. Wenn sich archivierte Redo-Protkolle nicht mehr auf Ihrer DB-Instance befinden, sollten Sie sie möglicherweise erneut von Amazon S3 herunterladen. Dann können Sie die Protokolle durchsuchen oder sie verwenden, um Ihre Datenbank wiederherzustellen oder zu replizieren.
**Anmerkung**
Sie können keine archivierten Redo-Logs auf Read Replica-Instanzen herunterladen.
## Archivierte Redo-Protokolle herunterladen: Grundlegende Schritte
Die Verfügbarkeit Ihrer archivierten Redo-Protokolle hängt von den folgenden Aufbewahrungsrichtlinien ab:
+ Backup-Aufbewahrungsrichtlinie – Protokolle innerhalb dieser Richtlinie sind in Amazon S3 verfügbar. Protokolle außerhalb dieser Richtlinie werden entfernt.
+ Aufbewahrungsrichtlinie für archivierte Protokolle – Protokolle innerhalb dieser Richtlinie sind auf Ihrer DB-Instance verfügbar. Protokolle außerhalb dieser Richtlinie werden entfernt.
Wenn sich Protokolle nicht auf Ihrer Instance befinden, aber durch Ihre Backup-Aufbewahrungsdauer geschützt sind, verwenden Sie `rdsadmin.rdsadmin_archive_log_download`, um sie erneut herunterzuladen. RDS for Oracle speichert die Protokolle im `/rdsdbdata/log/arch`-Verzeichnis auf Ihrer DB-Instance.
**Herunterladen von archivierten Redo-Protokolle aus Amazon S3**
1. Konfigurieren Sie Ihren Aufbewahrungszeitraum, um sicherzustellen, dass Ihre heruntergeladenen archivierten Redo-Protokolle so lange aufbewahrt werden, wie Sie sie benötigen. Stellen Sie sicher, dass Sie die Änderungen `COMMIT`
RDS speichert Ihre heruntergeladenen Protokolle gemäß der Aufbewahrungsrichtlinie für archivierte Protokolle, und zwar ab dem Zeitpunkt, zu dem die Protokolle heruntergeladen wurden. Informationen zum Festlegen der Aufbewahrungsrichtlinie finden Sie unter [Beibehaltung von archivierten Redo-Log-Dateien](Appendix.Oracle.CommonDBATasks.RetainRedoLogs.md).
1. Warten Sie bis zu 5 Minuten, bis die Änderung der Aufbewahrungsrichtlinie für archivierte Protokolle wirksam wird.
1. Laden Sie die archivierten Redo-Protokolle von Amazon S3 mit`rdsadmin.rdsadmin_archive_log_download` herunter.
Weitere Informationen erhalten Sie unter [Herunterladen eines einzelnen archivierten Redo-Protokoll](#Appendix.Oracle.CommonDBATasks.download-redo-logs.single-log) und [Herunterladen einer Reihe archivierter Redo-Protokolle](#Appendix.Oracle.CommonDBATasks.download-redo-logs.series).
**Anmerkung**
RDS überprüft automatisch den verfügbaren Speicher vor dem Herunterladen. Wenn die angeforderten Protokolle einen hohen Anteil an Speicherplatz verbrauchen, erhalten Sie eine Warnung.
1. Bestätigen Sie, dass die Protokolle erfolgreich von Amazon S3 heruntergeladen wurden.
Sie können den Status Ihrer Download-Aufgabe in einer bdump-Datei anzeigen. Die bdump-Dateien haben den Pfadnamen `/rdsdbdata/log/trace/dbtask-task-id.log`. Im vorherigen Download-Schritt führen Sie eine `SELECT`-Anweisung aus, die die Aufgaben-ID im Datentyp `VARCHAR2` zurückgibt. Weitere Informationen finden Sie in ähnlichen Beispielen in [Überwachen des Status einer Dateiübertragung](oracle-s3-integration.using.md#oracle-s3-integration.using.task-status).
## Herunterladen eines einzelnen archivierten Redo-Protokoll
Um ein einzelnes archiviertes Redo-Protkoll in das `/rdsdbdata/log/arch`-Verzeichnis herunterzuladen, verwenden Sie `rdsadmin.rdsadmin_archive_log_download.download_log_with_seqnum`. Dieses Verfahren hat die folgenden Parameter.
****
| Parametername | Datentyp | Standard | Erforderlich | Beschreibung |
| --- | --- | --- | --- | --- |
| `seqnum` | Zahl | — | Ja | Die Sequenznummer des archivierten Redo-Protokolls. |
Im folgenden Beispiel wird das Protokoll mit der Sequenznummer 20 heruntergeladen.
```
SELECT rdsadmin.rdsadmin_archive_log_download.download_log_with_seqnum(seqnum => 20)
AS TASK_ID
FROM DUAL;
```
## Herunterladen einer Reihe archivierter Redo-Protokolle
Um eine Reihe archivierter Redo-Protokolle in das `/rdsdbdata/log/arch`-Verzeichnis herunterzuladen, verwenden Sie `download_logs_in_seqnum_range`. Ihr Download ist auf 300 Protokolle pro Anfrage beschränkt. Die Prozedur `download_logs_in_seqnum_range` hat die folgenden Parameter.
****
| Parametername | Datentyp | Standard | Erforderlich | Beschreibung |
| --- | --- | --- | --- | --- |
| `start_seq` | Zahl | — | Ja | Die Anfangssequenznummer für die Reihe. |
| `end_seq` | Zahl | — | Ja | Die Endsequenznummer für die Reihe. |
Im folgenden Beispiel werden die Protokolle von Sequenz 50 auf 100 heruntergeladen.
```
SELECT rdsadmin.rdsadmin_archive_log_download.download_logs_in_seqnum_range(start_seq => 50, end_seq => 100)
AS TASK_ID
FROM DUAL;
```
# Ausführen allgemeiner RMAN-Aufgaben für Oracle DB-Instances
In diesem Abschnitt wird beschrieben, wie Sie Oracle Recovery Manager (RMAN)-DBA-Aufgaben auf Ihren Amazon RDS-DB-Instances unter Oracle ausführen. Um eine verwaltete Service-Erfahrung zu bieten, ermöglicht Amazon RDS keinen Shell-Zugriff auf DB-Instances. Eingeschränkt wird auch der Zugriff auf bestimmte Systemprozeduren und Tabellen, für die erweiterte Berechtigungen erforderlich sind.
Nehmen Sie mit dem Amazon RDS-Paket `rdsadmin.rdsadmin_rman_util` RMAN-Backups Ihrer Amazon RDS für Oracle Database auf der Festplatte vor. Das `rdsadmin.rdsadmin_rman_util`-Paket unterstützt vollständige und inkrementelle Sicherungen von Datenbankdateien, Tabellenräumen und archivierten Redo-Protokollen.
Nachdem ein RMAN-Backup abgeschlossen wurde, können Sie die Sicherungsdateien vom Host der Amazon RDS for Oracle-DB-Instance kopieren. Grund hierfür kann die Backup auf einem Nicht-RDS-Host oder die langfristige Speicherung von Backups sein. Sie können die Sicherungsdateien beispielsweise in einen Amazon S3-Bucket kopieren. Weitere Informationen finden Sie unter "Verwendung von [Amazon S3-Integration](oracle-s3-integration.md).
Die Sicherungsdateien für RMAN-Backups verbleiben auf dem Host der Amazon RDS-DB-Instance, bis Sie sie manuell entfernen. Sie können mithilfe des Oracle-Verfahrens `UTL_FILE.FREMOVE` Dateien aus einem Verzeichnis entfernen. Weitere Informationen finden Sie unter [FREMOVE Procedure](https://docs.oracle.com/database/121/ARPLS/u_file.htm#ARPLS70924) in der Oracle Database-Dokumentation.
Sie können dRMAN nicht verwenden, um DB-Instances von RDS für Oracle wiederherzustellen. Sie können RMAN jedoch verwenden, um ein Backup auf einer On-Premises- oder Amazon-EC2-Instance wiederherzustellen. Weitere Informationen finden Sie im Blogartikel [Restore an Amazon RDS for Oracle instance to a self-managed instance](https://aws.amazon.com/blogs/database/restore-an-amazon-rds-for-oracle-instance-to-a-self-managed-instance/) (Wiederherstellen einer Instance von Amazon RDS für Oracle auf einer selbstverwalteten Instance).
**Anmerkung**
Wenn Sie eine weitere Amazon RDS for Oracle-DB-Instance sichern und wiederherstellen möchten, können Sie dazu ebenfalls die Amazon RDS-Sicherungs- und -Wiederherstellungsfunktionen verwenden. Weitere Informationen finden Sie unter [Sichern, Wiederherstellen und Exportieren von Daten](CHAP_CommonTasks.BackupRestore.md).
**Topics**
+ [
# Voraussetzungen für RMAN-Backups
](Appendix.Oracle.CommonDBATasks.RMAN-requirements.md)
+ [
# Geläufige Parameter für RMAN-Verfahren
](Appendix.Oracle.CommonDBATasks.CommonParameters.md)
+ [
# Validieren von Datenbankdateien von RDS für Oracle
](Appendix.Oracle.CommonDBATasks.ValidateDBFiles.md)
+ [
# Aktivieren und Deaktivieren der Nachverfolgung von Blockänderungen
](Appendix.Oracle.CommonDBATasks.BlockChangeTracking.md)
+ [
# Gegenprüfen archivierter Redo-Logs
](Appendix.Oracle.CommonDBATasks.Crosscheck.md)
+ [
# Sichern archivierter Redo-Protokolldateien
](Appendix.Oracle.CommonDBATasks.BackupArchivedLogs.md)
+ [
# Durchführen einer vollständigen Datenbanksicherung
](Appendix.Oracle.CommonDBATasks.BackupDatabaseFull.md)
+ [
# Durchführen einer vollständigen Sicherung einer Tenant-Datenbank
](Appendix.Oracle.CommonDBATasks.BackupTenantDatabaseFull.md)
+ [
# Durchführen einer inkrementellen Datenbanksicherung
](Appendix.Oracle.CommonDBATasks.BackupDatabaseIncremental.md)
+ [
# Durchführen einer inkrementellen Sicherung einer Tenant-Datenbank
](Appendix.Oracle.CommonDBATasks.BackupTenantDatabaseIncremental.md)
+ [
# Sichern eines Tablespace
](Appendix.Oracle.CommonDBATasks.BackupTablespace.md)
+ [
# Sichern einer Steuerdatei
](Appendix.Oracle.CommonDBATasks.backup-control-file.md)
+ [
# Durchführen von Blockmedienwiederherstellungen
](Appendix.Oracle.CommonDBATasks.block-media-recovery.md)
# Voraussetzungen für RMAN-Backups
Bevor Sie Ihre Datenbank mit dem `rdsadmin.rdsadmin_rman_util`-Paket sichern, stellen Sie sicher, dass Sie die folgenden Voraussetzungen erfüllen:
+ Stellen Sie sicher, dass sich Ihre Datenbank von RDS für Oracle im Modus `ARCHIVELOG` befindet. Um diesen Modus zu aktivieren, legen Sie den Aufbewahrungszeitraum für Backups auf einen Wert ungleich Null fest.
+ Wenn Sie archivierte Redo-Protokolle sichern oder ein vollständiges oder inkrementelles Backup durchführen, das archivierte Redo-Protokolle umfasst, muss für die Beibehaltung von Redo-Logs ein Wert ungleich Null festgelegt werden. Archivierte Redo-Protokolle sind erforderlich, um die Datenbankdateien während der Wiederherstellung konsistent zu halten. Weitere Informationen finden Sie unter [Beibehaltung von archivierten Redo-Log-Dateien](Appendix.Oracle.CommonDBATasks.RetainRedoLogs.md).
+ Stellen Sie sicher, dass Ihre DB-Instance über ausreichend freien Speicherplatz für die Backups verfügt. Wenn Sie ein Backup für Ihre Datenbank durchführen, geben Sie als Parameter im Prozeduraufruf ein Oracle-Verzeichnisobjekt an. RMAN speichert die Dateien im angegebenen Verzeichnis. Sie können Standardverzeichnisse, wie z. B. `DATA_PUMP_DIR`, verwenden oder ein neues Verzeichnis erstellen. Weitere Informationen finden Sie unter [Erstellen und Löschen von Verzeichnissen im Hauptdatenspeicherbereich](Appendix.Oracle.CommonDBATasks.Misc.md#Appendix.Oracle.CommonDBATasks.NewDirectories).
Mithilfe der CloudWatch Metrik können Sie den aktuellen freien Speicherplatz in einer RDS for Oracle-Instance überwachen`FreeStorageSpace`. Wir empfehlen, dass Ihr freier Speicherplatz die aktuelle Größe der Datenbank übersteigt, obwohl RMAN nur formatierte Blöcke sichert und die Komprimierung unterstützt.
# Geläufige Parameter für RMAN-Verfahren
Sie können mit den Verfahren im Amazon RDS-Paket `rdsadmin.rdsadmin_rman_util` Aufgaben mit RMAN durchführen. Den Verfahren im Paket sind mehrere Parameter gemeinsam. Das Paket besitzt die folgenden geläufigen Parameter.
****
| Parametername | Datentyp | Zulässige Werte | Standard | Erforderlich | Beschreibung |
| --- | --- | --- | --- | --- | --- |
| `p_directory_name` | varchar2 | Ein gültiger Datenbankverzeichnisname. | — | Ja | Der Name des Verzeichnisses, das die Sicherungsdateien enthalten soll. |
| `p_label` | varchar2 | `a-z`, `A-Z`, `0-9`, `'_'`, `'-'`, `'.'` | — | Nein | Eine eindeutige Zeichenfolge, die in die Sicherungsdateinamen eingeschlossen wird. Das Limit ist 30 Zeichen. |
| `p_owner` | varchar2 | Ein gültiger Eigentümer des in angegebenen Verzeichnisse `p_directory_name`. | — | Ja | Der Eigentümer des Verzeichnisses, das die Sicherungsdateien enthalten soll. |
| `p_tag` | varchar2 | `a-z`, `A-Z`, `0-9`, `'_'`, `'-'`, `'.'` | NULL | Nein | Eine Zeichenfolge, die verwendet werden kann, um zwischen Backups zu unterscheiden, um den Zweck oder die Verwendung von Backups anzugeben, wie beispielsweise tägliche, wöchentliche oder inkrementelle Backups. Das Limit ist 30 Zeichen. Bei einem Tag wird die Groß- und Kleinschreibung nicht beachtet. Tags werden immer in Großbuchstaben gespeichert, unabhängig davon, ob bei der Eingabe Groß- oder Kleinschreibung verwendet wird. Tags müssen nicht eindeutig sein, daher können mehrere Backups das gleiche Tag haben. Wenn Sie kein Tag angeben, weist RMAN automatisch ein Standard-Tag zu, wobei das Format verwendet *YYYY* wird`TAGYYYYMMDDTHHMMSS`, wobei das Jahr, *MM* der Monat, *DD* der Tag, *HH* die Stunde (im 24-Stunden-Format), *MM* die Minuten und die Sekunden *SS* sind. Datum und Uhrzeit verweisen darauf, wann RMAN das Backup gestartet hat. Beispielsweise könnte ein Backup das Tag `TAG20190927T214517` für ein Backup erhalten, das am 27.09.2019 um 21:45:17 Uhr gestartet wurde. Der Parameter `p_tag` wird für die folgenden Amazon-RDS-for-Oracle-DB-Engine-Versionen unterstützt: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.CommonParameters.html) |
| `p_compress` | boolesch | `TRUE`, `FALSE` | `FALSE` | Nein | Geben Sie `TRUE` an, um die BASIC-Sicherungskomprimierung zu aktivieren. Geben Sie `FALSE` an, um die BASIC-Sicherungskomprimierung zu deaktivieren. |
| `p_include_archive_logs` | Boolean | `TRUE`, `FALSE` | `FALSE` | Nein | Geben Sie `TRUE` an, um archivierte Redo-Logs in das Backup einzuschließen. Geben Sie `FALSE` an, um archivierte Redo-Logs aus dem Backup auszuschließen. Wenn Sie archivierte Redo-Logs in das Backup einschließen, legen Sie mit dem Verfahren `rdsadmin.rdsadmin_util.set_configuration` als Aufbewahrungszeitraum eine Stunde oder länger fest. Rufen Sie zudem das Verfahren `rdsadmin.rdsadmin_rman_util.crosscheck_archivelog` unverzüglich auf, bevor Sie das Backup ausführen. Andernfalls kann das Backup aufgrund fehlender archivierter Redo-Log-Dateien, die von den Amazon RDS-Verwaltungsverfahren gelöscht wurden, fehlschlagen. |
| `p_include_controlfile` | Boolean | `TRUE`, `FALSE` | `FALSE` | Nein | Geben Sie `TRUE` an, um die Kontrolldatei in das Backup einzuschließen. Geben Sie `FALSE` an, um die Kontrolldatei aus dem Backup auszuschließen. |
| `p_optimize` | Boolean | `TRUE`, `FALSE` | `TRUE` | Nein | Geben Sie `TRUE` zum Aktivieren der Sicherungsoptimierung an, wenn archivierte Redo-Logs eingeschlossen sind, um die Sicherungsgröße zu reduzieren. Geben Sie `FALSE` an, um die Sicherungsoptimierung zu deaktivieren. |
| `p_parallel` | Zahl | Eine gültige Ganzzahl zwischen `1` und `254` für Oracle Database Enterprise Edition (EE) `1` für andere Oracle Datenbankversionen | `1` | Nein | Anzahl von Channels. |
| `p_rman_to_dbms_output` | Boolean | `TRUE`, `FALSE` | `FALSE` | Nein | Bei `TRUE` wird der RMAN-Ausgang an das `DBMS_OUTPUT`-Package und zusätzlich an eine Datei im `BDUMP`-Verzeichnis gesendet. Verwenden Sie in SQL\$1Plus `SET SERVEROUTPUT ON`, um die Ausgabe anzuzeigen. Bei `FALSE` wird der RMAN-Ausgang nur an eine Datei im `BDUMP`-Verzeichnis gesendet. |
| `p_section_size_mb` | Zahl | Eine gültige Ganzzahl | `NULL` | Nein | Die Abschnittsgröße in Megabyte (MB). Validiert parallel, indem jede Datei in die angegebene Abschnittsgröße aufgeteilt wird. Bei `NULL` wird der Parameter ignoriert. |
| `p_validation_type` | varchar2 | `'PHYSICAL'`, `'PHYSICAL+LOGICAL'` | `'PHYSICAL'` | Nein | Der Level der Korruptionserkennung. Geben Sie `'PHYSICAL'` an, um auf physikalische Beschädigung zu überprüfen. Ein Beispiel für physische Korruption oder Beschädigung ist ein Block mit einer Diskrepanz zwischen Kopf- und Fußzeile. Geben Sie `'PHYSICAL+LOGICAL'` an, um zusätzlich zur physischen Korruption auf logische Inkonsistenzen zu prüfen. Ein Beispiel für eine logische Beschädigung ist ein korrupter Block. |
# Validieren von Datenbankdateien von RDS für Oracle
Sie können das Amazon RDS-Paket verwenden, `rdsadmin.rdsadmin_rman_util` um Amazon RDS for Oracle Oracle-Datenbankdateien wie Datendateien, Tablespaces, Steuerdateien und Serverparameterdateien () SPFILEs zu validieren.
Weitere Informationen über die RMAN-Validierung finden Sie unter [ Validating Database Files and Backups](https://docs.oracle.com/database/121/BRADV/rcmvalid.htm#BRADV90063) und [ VALIDATE](https://docs.oracle.com/database/121/RCMRF/rcmsynta2025.htm#RCMRF162) in der Oracle-Dokumentation.
**Topics**
+ [
## Validieren einer Datenbank
](#Appendix.Oracle.CommonDBATasks.ValidateDB)
+ [
## Validieren einer Tenant-Datenbank
](#Appendix.Oracle.CommonDBATasks.ValidateTenantDB)
+ [
## Validieren eines Tablespaces
](#Appendix.Oracle.CommonDBATasks.ValidateTablespace)
+ [
## Validieren einer Steuerdatei
](#Appendix.Oracle.CommonDBATasks.ValidateControlFile)
+ [
## Validieren von SPFILE
](#Appendix.Oracle.CommonDBATasks.ValidateSpfile)
+ [
## Validieren einer Oracle-Datendatei
](#Appendix.Oracle.CommonDBATasks.ValidateDataFile)
## Validieren einer Datenbank
Um alle relevanten Dateien zu validieren, die von einer Oracle-Datenbank in RDS für Oracle verwendet werden, nutzen Sie das Amazon-RDS-Verfahren `rdsadmin.rdsadmin_rman_util.validate_database`.
Bei diesem Verfahren werden die folgenden geläufigen Parameter für RMAN-Aufgaben verwendet:
+ `p_validation_type`
+ `p_parallel`
+ `p_section_size_mb`
+ `p_rman_to_dbms_output`
Weitere Informationen finden Sie unter [Geläufige Parameter für RMAN-Verfahren](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
Im folgenden Beispiel wird die Datenbank mit den Standardwerten für die Parameter validiert.
```
EXEC rdsadmin.rdsadmin_rman_util.validate_database;
```
Im folgenden Beispiel wird die Datenbank mit den angegebenen Werten für die Parameter validiert.
```
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;
/
```
Wenn der `p_rman_to_dbms_output`-Parameter auf `FALSE` gesetzt ist, wird der RMAN-Ausgang in eine Datei im `BDUMP`-Verzeichnis geschrieben.
Um die Dateien im Verzeichnis `BDUMP` anzuzeigen, führen Sie die folgende `SELECT`-Anweisung aus.
```
SELECT * FROM table(rdsadmin.rds_file_util.listdir('BDUMP')) order by mtime;
```
Um den Inhalt einer Datei im Verzeichnis `BDUMP` anzuzeigen, führen Sie die folgende `SELECT`-Anweisung aus.
```
SELECT text FROM table(rdsadmin.rds_file_util.read_text_file('BDUMP','rds-rman-validate-nnn.txt'));
```
Ersetzen Sie den Dateinamen durch den Namen der Datei, die Sie anzeigen möchten.
## Validieren einer Tenant-Datenbank
Verwenden Sie das Amazon-RDS-Verfahren `rdsadmin.rdsadmin_rman_util.validate_tenant`, um die Datendateien der Tenant-Datenbank in einer Container-Datenbank (CDB) zu validieren.
Dieses Verfahren gilt nur für die aktuelle Tenant-Datenbank und verwendet die folgenden geläufigen Parameter für RMAN-Aufgaben:
+ `p_validation_type`
+ `p_parallel`
+ `p_section_size_mb`
+ `p_rman_to_dbms_output`
Weitere Informationen finden Sie unter [Geläufige Parameter für RMAN-Verfahren](Appendix.Oracle.CommonDBATasks.CommonParameters.md). Dieses Verfahren wird für die folgenden DB-Engine-Versionen unterstützt:
+ Oracle Database 21c (21.0.0) CDB
+ Oracle Database 19c (19.0.0) CDB
Im folgenden Beispiel wird die aktuelle Tenant-Datenbank unter Verwendung der Standardwerte für die Parameter validiert.
```
EXEC rdsadmin.rdsadmin_rman_util.validate_tenant;
```
Im folgenden Beispiel wird die aktuelle Tenant-Datenbank unter Verwendung der angegebenen Werte für die Parameter validiert.
```
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;
/
```
Wenn der `p_rman_to_dbms_output`-Parameter auf `FALSE` gesetzt ist, wird der RMAN-Ausgang in eine Datei im `BDUMP`-Verzeichnis geschrieben.
Um die Dateien im Verzeichnis `BDUMP` anzuzeigen, führen Sie die folgende `SELECT`-Anweisung aus.
```
SELECT * FROM table(rdsadmin.rds_file_util.listdir('BDUMP')) order by mtime;
```
Um den Inhalt einer Datei im Verzeichnis `BDUMP` anzuzeigen, führen Sie die folgende `SELECT`-Anweisung aus.
```
SELECT text FROM table(rdsadmin.rds_file_util.read_text_file('BDUMP','rds-rman-validate-nnn.txt'));
```
Ersetzen Sie den Dateinamen durch den Namen der Datei, die Sie anzeigen möchten.
## Validieren eines Tablespaces
Um die einem Tablespace zugeordneten Dateien zu validieren, verwenden Sie die Amazon-RDS-Prozedur `rdsadmin.rdsadmin_rman_util.validate_tablespace`.
Bei diesem Verfahren werden die folgenden geläufigen Parameter für RMAN-Aufgaben verwendet:
+ `p_validation_type`
+ `p_parallel`
+ `p_section_size_mb`
+ `p_rman_to_dbms_output`
Weitere Informationen finden Sie unter [Geläufige Parameter für RMAN-Verfahren](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
Bei diesem Verfahren wird außerdem der folgende zusätzliche Parameter verwendet.
****
| Parametername | Datentyp | Zulässige Werte | Standard | Erforderlich | Beschreibung |
| --- | --- | --- | --- | --- | --- |
| `p_tablespace_name` | varchar2 | Ein gültiger Tabellenraumname | — | Ja | Der Name des Tabellenraums. |
## Validieren einer Steuerdatei
Um nur die von einer Amazon RDS Oracle DB-Instance verwendete Steuerdatei zu validieren, verwenden Sie die Amazon-RDS-Prozedur `rdsadmin.rdsadmin_rman_util.validate_current_controlfile`.
Bei diesem Verfahren wird der folgende geläufige Parameter für RMAN-Aufgaben verwendet:
+ `p_validation_type`
+ `p_rman_to_dbms_output`
Weitere Informationen finden Sie unter [Geläufige Parameter für RMAN-Verfahren](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
## Validieren von SPFILE
Um nur die Serverparameterdatei (SPFILE) zu validieren, die von einer Amazon RDS Oracle DB-Instance verwendet wird, verwenden Sie die Amazon-RDS-Prozedur `rdsadmin.rdsadmin_rman_util.validate_spfile`.
Bei diesem Verfahren wird der folgende geläufige Parameter für RMAN-Aufgaben verwendet:
+ `p_validation_type`
+ `p_rman_to_dbms_output`
Weitere Informationen finden Sie unter [Geläufige Parameter für RMAN-Verfahren](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
## Validieren einer Oracle-Datendatei
Um die einem Tablespace zugeordneten Dateien zu validieren, verwenden Sie die Amazon-RDS-Prozedur `rdsadmin.rdsadmin_rman_util.validate_datafile`.
Bei diesem Verfahren werden die folgenden geläufigen Parameter für RMAN-Aufgaben verwendet:
+ `p_validation_type`
+ `p_parallel`
+ `p_section_size_mb`
+ `p_rman_to_dbms_output`
Weitere Informationen finden Sie unter [Geläufige Parameter für RMAN-Verfahren](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
Bei diesem Verfahren werden außerdem die folgenden zusätzlichen Parameter verwendet.
****
| Parametername | Datentyp | Zulässige Werte | Standard | Erforderlich | Beschreibung |
| --- | --- | --- | --- | --- | --- |
| `p_datafile` | varchar2 | Eine gültige ID-Nummer der Datendatei oder ein gültiger Datendateiname mit vollständigem Pfad | — | Ja | Die ID-Nummer der Datendatei (aus `v$datafile.file#`) oder der vollständige Datendateiname einschließlich des Pfades (aus `v$datafile.name`). |
| `p_from_block` | Zahl | Eine gültige Ganzzahl | `NULL` | Nein | Nummer des Blocks, in dem die Validierung innerhalb der Datendatei beginnt. Bei `NULL` wird `1` verwendet. |
| `p_to_block` | Zahl | Eine gültige Ganzzahl | `NULL` | Nein | Nummer des Blocks, in dem die Validierung innerhalb der Datendatei endet. Bei `NULL` wird der maximale Block in der Datendatei verwendet. |
# Aktivieren und Deaktivieren der Nachverfolgung von Blockänderungen
Block, der Nachverfolgungs-Datensätze ändert, hat Blöcke in einer Nachverfolgungsdatei geändert. Diese Vorgehensweise kann die Leistung inkrementeller RMAN-Backups verbessern. Weitere Informationen finden Sie unter [Using Block Change Tracking to Improve Incremental Backup Performance (Verwenden der Nachverfolgung von Blockänderungen zur Verbesserung der inkrementellen Sicherungs-Performance)](https://docs.oracle.com/en/database/oracle/oracle-database/19/bradv/backing-up-database.html#GUID-4E1F605A-76A7-48D0-9D9B-7343B4327E2A) in der Oracle Database-Dokumentation.
RMAN-Funktionen werden in einem Lesereplikat nicht unterstützt. Im Rahmen Ihrer Hochverfügbarkeitsstrategie können Sie sich jedoch dafür entscheiden, die Blocknachverfolgung mithilfe des Verfahrens `rdsadmin.rdsadmin_rman_util.enable_block_change_tracking` in einem schreibgeschützten Replikat zu aktivieren. Wenn Sie dieses schreibgeschützte Replikat zu einer Quell-DB-Instance heraufstufen, wird die Nachverfolgung von Blockänderungen für die neue Quell-Instance aktiviert. Somit kann Ihre Instance von schnellen inkrementellen Backups profitieren.
Verfahren zur Nachverfolgung von Blockänderungen werden nur in der Enterprise Edition für die folgenden DB-Engine-Versionen unterstützt:
+ Oracle Database 21c (21.0.0)
+ Oracle Database 19c (19.0.0)
**Anmerkung**
In einer Single-Tenant-CDB funktionieren die folgenden Vorgänge, aber kein vom Kunden sichtbarer Mechanismus kann den aktuellen Status der Operationen erkennen. Weitere Informationen finden Sie auch unter [Einschränkungen von RDS für Oracle CDBs](Oracle.Concepts.CDBs.md#Oracle.Concepts.single-tenant-limitations).
Sie können die Nachverfolgung von Blockänderungen für eine DB-Instance mithilfe des Amazon RDS-Verfahrens aktiviere `rdsadmin.rdsadmin_rman_util.enable_block_change_tracking`. Sie können die Nachverfolgung von Blockänderungen mithilfe von deaktivier `disable_block_change_tracking`. Diese Verfahren haben keine Parameter.
Um festzustellen, ob die Verfolgung von Blockänderungen für Ihre DB-Instance aktiviert ist, führen Sie die folgenden Abfrage durch.
```
SELECT STATUS, FILENAME FROM V$BLOCK_CHANGE_TRACKING;
```
Im folgenden Beispiel wird die Verfolgung von Blockänderungen für eine DB-Instance aktiviert.
```
EXEC rdsadmin.rdsadmin_rman_util.enable_block_change_tracking;
```
Im folgenden Beispiel wird die Verfolgung von Blockänderungen für eine DB-Instance deaktiviert.
```
EXEC rdsadmin.rdsadmin_rman_util.disable_block_change_tracking;
```
# Gegenprüfen archivierter Redo-Logs
Sie können archivierte Redo-Logs mit dem Amazon RDS-Verfahren gegenprüfe `rdsadmin.rdsadmin_rman_util.crosscheck_archivelog`.
Mit diesem Verfahren können Sie archivierte Redo-Protokolle, die in der Kontrolldatei registriert sind, gegenprüfen und abgelaufene Protokolldatensätze auf Wunsch löschen. Wenn RMAN ein Backup erstellt, wird ein Datensatz in der Kontrolldatei erstellt. Im Laufe der Zeit vergrößert sich die Kontrolldatei aufgrund dieser Einträge. Es wird empfohlen, abgelaufene Datensätze regelmäßig zu entfernen.
**Anmerkung**
Da RMAN nicht für Amazon RDS-Standardsicherungen verwendet wird, werden keine Einträge in der Kontrolldatei erstellt.
Dieses Verfahren verwendet den Parameter `p_rman_to_dbms_output` für RMAN-Aufgaben.
Weitere Informationen finden Sie unter [Geläufige Parameter für RMAN-Verfahren](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
Bei diesem Verfahren wird außerdem der folgende zusätzliche Parameter verwendet.
****
| Parametername | Datentyp | Zulässige Werte | Standard | Erforderlich | Beschreibung |
| --- | --- | --- | --- | --- | --- |
| `p_delete_expired` | Boolean | `TRUE`, `FALSE` | `TRUE` | Nein | Bei `TRUE` werden abgelaufene, archivierte Redo-Protokolle aus der Kontrolldatei gelöscht. Bei `FALSE` werden abgelaufene, archivierte Redo-Protokolle in der Kontrolldatei beibehalten. |
Dieses Verfahren wird für die folgenden Amazon RDS für Oracle-DB-Engine-Versionen unterstützt:
+ Oracle Database 21c (21.0.0)
+ Oracle Database 19c (19.0.0)
Im folgenden Beispiel werden archivierte Redo-Protokoll-Datensätze in der Kontrolldatei als abgelaufen markiert, die Datensätze jedoch nicht gelöscht.
```
BEGIN
rdsadmin.rdsadmin_rman_util.crosscheck_archivelog(
p_delete_expired => FALSE,
p_rman_to_dbms_output => FALSE);
END;
/
```
Im folgenden Beispiel werden abgelaufene archivierte Redo-Protokolle aus der Kontrolldatei entfernt.
```
BEGIN
rdsadmin.rdsadmin_rman_util.crosscheck_archivelog(
p_delete_expired => TRUE,
p_rman_to_dbms_output => FALSE);
END;
/
```
# Sichern archivierter Redo-Protokolldateien
Sie können das Amazon-RDS-Paket `rdsadmin.rdsadmin_rman_util` zum Sichern archivierter Redo-Logs für eine Amazon-RDS-Oracle-DB-Instance verwenden.
Die Verfahren zum Sichern archivierter Redo-Logs werden für die folgenden Amazon RDS für Oracle-DB-Engine-Versionen unterstützt:
+ Oracle Database 21c (21.0.0)
+ Oracle Database 19c (19.0.0)
**Topics**
+ [
## Sichern aller archivierten Redo-Logs
](#Appendix.Oracle.CommonDBATasks.BackupArchivedLogs.All)
+ [
## Sichern eines archivierten Redo-Logs aus einem Datumsbereich
](#Appendix.Oracle.CommonDBATasks.BackupArchivedLogs.Date)
+ [
## Sichern eines archivierten Redo-Logs aus einem SCN-Bereich
](#Appendix.Oracle.CommonDBATasks.BackupArchivedLogs.SCN)
+ [
## Sichern eines archivierten Redo-Logs aus einem Sequenznummernbereich
](#Appendix.Oracle.CommonDBATasks.BackupArchivedLogs.Sequence)
## Sichern aller archivierten Redo-Logs
Um alle archivierten Wiederherstellungsprotokolle für eine Amazon RDS Oracle DB-Instance zu sichern, verwenden Sie die Amazon-RDS-Prozedur `rdsadmin.rdsadmin_rman_util.backup_archivelog_all`.
Bei diesem Verfahren werden die folgenden geläufigen Parameter für RMAN-Aufgaben verwendet:
+ `p_owner`
+ `p_directory_name`
+ `p_label`
+ `p_parallel`
+ `p_compress`
+ `p_rman_to_dbms_output`
+ `p_tag`
Weitere Informationen finden Sie unter [Geläufige Parameter für RMAN-Verfahren](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
Das folgende Beispiel sichert alle archivierten Redo-Logs für die DB-Instance.
```
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;
/
```
## Sichern eines archivierten Redo-Logs aus einem Datumsbereich
Um bestimmte archivierte Wiederherstellungsprotokolle für eine Amazon RDS Oracle DB-Instance durch Angabe eines Datumsbereichs zu sichern, verwenden Sie die Amazon-RDS-Prozedur `rdsadmin.rdsadmin_rman_util.backup_archivelog_date`. Der Datumsbereich gibt an, welche archivierten Redo-Logs gesichert werden sollen.
Bei diesem Verfahren werden die folgenden geläufigen Parameter für RMAN-Aufgaben verwendet:
+ `p_owner`
+ `p_directory_name`
+ `p_label`
+ `p_parallel`
+ `p_compress`
+ `p_rman_to_dbms_output`
+ `p_tag`
Weitere Informationen finden Sie unter [Geläufige Parameter für RMAN-Verfahren](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
Bei diesem Verfahren werden außerdem die folgenden zusätzlichen Parameter verwendet.
****
| Parametername | Datentyp | Zulässige Werte | Standard | Erforderlich | Beschreibung |
| --- | --- | --- | --- | --- | --- |
| `p_from_date` | date | Ein Datum zwischen dem `start_date` und `next_date` eines archivierten Redo-Logs auf der Festplatte. Der Wert muss kleiner oder gleich dem für angegebenen Wert sei `p_to_date`. | — | Ja | Das Anfangsdatum für die archivierten Protokollsicherungen. |
| `p_to_date` | date | Ein Datum zwischen dem `start_date` und `next_date` eines archivierten Redo-Logs auf der Festplatte. Der Wert muss größer oder gleich dem für angegebenen Wert sei `p_from_date`. | — | Ja | Das Enddatum für die archivierten Protokollsicherungen. |
Das folgende Beispiel sichert archivierte Redo-Logs im Datumsbereich für die DB-Instance.
```
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;
/
```
## Sichern eines archivierten Redo-Logs aus einem SCN-Bereich
Um bestimmte archivierte Wiederherstellungsprotokolle für eine Amazon RDS Oracle DB-Instance durch Angabe eines SCN-Bereichs (System Change Number) zu sichern, verwenden Sie die Amazon-RDS-Prozedur `rdsadmin.rdsadmin_rman_util.backup_archivelog_scn`. Der SCN-Bereich gibt an, welche archivierten Redo-Logs gesichert werden sollen.
Bei diesem Verfahren werden die folgenden geläufigen Parameter für RMAN-Aufgaben verwendet:
+ `p_owner`
+ `p_directory_name`
+ `p_label`
+ `p_parallel`
+ `p_compress`
+ `p_rman_to_dbms_output`
+ `p_tag`
Weitere Informationen finden Sie unter [Geläufige Parameter für RMAN-Verfahren](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
Bei diesem Verfahren werden außerdem die folgenden zusätzlichen Parameter verwendet.
****
| Parametername | Datentyp | Zulässige Werte | Standard | Erforderlich | Beschreibung |
| --- | --- | --- | --- | --- | --- |
| `p_from_scn` | Zahl | Die SCN eines archivierten Redo-Logs, das auf der Festplatte vorhanden ist. Der Wert muss kleiner oder gleich dem für angegebenen Wert sei `p_to_scn`. | — | Ja | Die Anfangs-SCN für die archivierten Protokollsicherungen. |
| `p_to_scn` | Zahl | Die SCN eines archivierten Redo-Logs, das auf der Festplatte vorhanden ist. Der Wert muss größer oder gleich dem für angegebenen Wert sei `p_from_scn`. | — | Ja | Die End-SCN für die archivierten Protokollsicherungen. |
Das folgende Beispiel sichert archivierte Redo-Logs im SCN-Bereich für die DB-Instance.
```
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;
/
```
## Sichern eines archivierten Redo-Logs aus einem Sequenznummernbereich
Um bestimmte archivierte Wiederherstellungsprotokolle für eine Amazon RDS Oracle DB-Instance durch Angabe eines Sequenznummernbereichs zu sichern, verwenden Sie die Amazon-RDS-Prozedur `rdsadmin.rdsadmin_rman_util.backup_archivelog_sequence`. Der Sequenznummernbereich gibt an, welche archivierten Redo-Logs gesichert werden sollen.
Bei diesem Verfahren werden die folgenden geläufigen Parameter für RMAN-Aufgaben verwendet:
+ `p_owner`
+ `p_directory_name`
+ `p_label`
+ `p_parallel`
+ `p_compress`
+ `p_rman_to_dbms_output`
+ `p_tag`
Weitere Informationen finden Sie unter [Geläufige Parameter für RMAN-Verfahren](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
Bei diesem Verfahren werden außerdem die folgenden zusätzlichen Parameter verwendet.
****
| Parametername | Datentyp | Zulässige Werte | Standard | Erforderlich | Beschreibung |
| --- | --- | --- | --- | --- | --- |
| `p_from_sequence` | Zahl | Die Sequenznummer eines archivierten Redo-Logs, das auf der Festplatte vorhanden ist. Der Wert muss kleiner oder gleich dem für angegebenen Wert sei `p_to_sequence`. | — | Ja | Die Anfangssequenznummer für die archivierten Protokollsicherungen. |
| `p_to_sequence` | Zahl | Die Sequenznummer eines archivierten Redo-Logs, das auf der Festplatte vorhanden ist. Der Wert muss größer oder gleich dem für angegebenen Wert sei `p_from_sequence`. | — | Ja | Die Endsequenznummer für die archivierten Protokollsicherungen. |
Das folgende Beispiel sichert archivierte Redo-Logs im Sequenznummernbereich für die DB-Instance.
```
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;
/
```
# Durchführen einer vollständigen Datenbanksicherung
Sie können aller in der Datenbank enthaltenen Blöcke von Datendateien mithilfe des Amazon RDS-Verfahrens sicher `rdsadmin.rdsadmin_rman_util.backup_database_full`.
Bei diesem Verfahren werden die folgenden geläufigen Parameter für RMAN-Aufgaben verwendet:
+ `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`
Weitere Informationen finden Sie unter [Geläufige Parameter für RMAN-Verfahren](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
Dieses Verfahren wird für die folgenden Amazon RDS für Oracle-DB-Engine-Versionen unterstützt:
+ Oracle Database 21c (21.0.0)
+ Oracle Database 19c (19.0.0)
Im folgenden Beispiel wird ein vollständiges Backup der DB-Instance mit den angegebenen Werten für die Parameter durchgeführt.
```
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;
/
```
# Durchführen einer vollständigen Sicherung einer Tenant-Datenbank
Sie können eine Sicherung aller in einer Tenant-Datenbank enthaltenen Datenblöcke in einer Container-Datenbank (CDB) durchführen. Verwenden Sie das Amazon-RDS-Verfahren `rdsadmin.rdsadmin_rman_util.backup_tenant_full`. Dieses Verfahren gilt nur für die Sicherung der aktuellen Datenbank und verwendet die folgenden geläufigen Parameter für RMAN-Aufgaben:
+ `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`
Weitere Informationen finden Sie unter [Geläufige Parameter für RMAN-Verfahren](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
Das Verfahren `rdsadmin_rman_util.backup_tenant_full` wird für die folgenden DB-Engine-Versionen von RDS für Oracle unterstützt:
+ Oracle Database 21c (21.0.0) CDB
+ Oracle Database 19c (19.0.0) CDB
Im folgenden Beispiel wird eine vollständige Sicherung der aktuellen Tenant-Datenbank mit den angegebenen Werten für die Parameter durchgeführt.
```
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;
/
```
# Durchführen einer inkrementellen Datenbanksicherung
Sie können ein inkrementelles Backup Ihrer DB-Instance mithilfe des Amazon RDS-Verfahrens `rdsadmin.rdsadmin_rman_util.backup_database_incremental` durchführen.
Weitere Informationen über inkrementelle Sicherungen finden Sie unter [Incremental Backups](https://docs.oracle.com/database/121/RCMRF/rcmsynta006.htm#GUID-73642FF2-43C5-48B2-9969-99001C52EB50__BGBHABHH) in der Oracle-Dokumentation.
Bei diesem Verfahren werden die folgenden geläufigen Parameter für RMAN-Aufgaben verwendet:
+ `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`
Weitere Informationen finden Sie unter [Geläufige Parameter für RMAN-Verfahren](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
Dieses Verfahren wird für die folgenden Amazon RDS for Oracle-DB-Engine-Versionen unterstützt:
+ Oracle Database 21c (21.0.0)
+ Oracle Database 19c (19.0.0)
Bei diesem Verfahren wird außerdem der folgende zusätzliche Parameter verwendet.
****
| Parametername | Datentyp | Zulässige Werte | Standard | Erforderlich | Beschreibung |
| --- | --- | --- | --- | --- | --- |
| `p_level` | Zahl | `0`, `1` | `0` | Nein | Geben Sie `0` an, um ein vollständiges inkrementelles Backup zu aktivieren. Geben Sie `1` an, um ein nicht kumulatives inkrementelles Backup zu aktivieren. |
Im folgenden Beispiel wird ein inkrementelles Backup der DB-Instance mit den angegebenen Werten für die Parameter durchgeführt.
```
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;
/
```
# Durchführen einer inkrementellen Sicherung einer Tenant-Datenbank
Sie können eine inkrementelle Sicherung der aktuellen Tenant-Datenbank in Ihrer CDB durchführen. Verwenden Sie das Amazon-RDS-Verfahren `rdsadmin.rdsadmin_rman_util.backup_tenant_incremental`.
Weitere Informationen über inkrementelle Sicherungen finden Sie unter [Incremental Backups](https://docs.oracle.com/database/121/RCMRF/rcmsynta006.htm#GUID-73642FF2-43C5-48B2-9969-99001C52EB50__BGBHABHH) in der Oracle-Datenbankdokumentation.
Dieses Verfahren gilt nur für die aktuelle Tenant-Datenbank und verwendet die folgenden geläufigen Parameter für RMAN-Aufgaben:
+ `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`
Weitere Informationen finden Sie unter [Geläufige Parameter für RMAN-Verfahren](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
Dieses Verfahren wird für die folgenden Amazon RDS for Oracle-DB-Engine-Versionen unterstützt:
+ Oracle Database 21c (21.0.0) CDB
+ Oracle Database 19c (19.0.0) CDB
Bei diesem Verfahren wird außerdem der folgende zusätzliche Parameter verwendet.
****
| Parametername | Datentyp | Zulässige Werte | Standard | Erforderlich | Beschreibung |
| --- | --- | --- | --- | --- | --- |
| `p_level` | Zahl | `0`, `1` | `0` | Nein | Geben Sie `0` an, um ein vollständiges inkrementelles Backup zu aktivieren. Geben Sie `1` an, um ein nicht kumulatives inkrementelles Backup zu aktivieren. |
Im folgenden Beispiel wird eine inkrementelle Sicherung der aktuellen Tenant-Datenbank mit den angegebenen Werten für die Parameter durchgeführt.
```
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;
/
```
# Sichern eines Tablespace
Sie können ein Backup des Tablespace mithilfe des Amazon-RDS-Verfahrens `rdsadmin.rdsadmin_rman_util.backup_tablespace` durchführen.
Bei diesem Verfahren werden die folgenden geläufigen Parameter für RMAN-Aufgaben verwendet:
+ `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`
Weitere Informationen finden Sie unter [Geläufige Parameter für RMAN-Verfahren](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
Bei diesem Verfahren wird außerdem der folgende zusätzliche Parameter verwendet.
****
| Parametername | Datentyp | Zulässige Werte | Standard | Erforderlich | Beschreibung |
| --- | --- | --- | --- | --- | --- |
| `p_tablespace_name` | varchar2 | Ein gültiger Tabellenraumname. | — | Ja | Der Name des zu sichernden Tabellenraums. |
Dieses Verfahren wird für die folgenden Amazon RDS für Oracle-DB-Engine-Versionen unterstützt:
+ Oracle Database 21c (21.0.0)
+ Oracle Database 19c (19.0.0)
Im folgenden Beispiel wird ein Tabellenraum-Backup mit den angegebenen Werten für die Parameter durchgeführt.
```
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;
/
```
# Sichern einer Steuerdatei
Sie können ein Backup einer Steuerdatei mithilfe des Amazon-RDS-Verfahrens `rdsadmin.rdsadmin_rman_util.backup_current_controlfile` durchführen.
Bei diesem Verfahren werden die folgenden geläufigen Parameter für RMAN-Aufgaben verwendet:
+ `p_owner`
+ `p_directory_name`
+ `p_label`
+ `p_compress`
+ `p_rman_to_dbms_output`
+ `p_tag`
Weitere Informationen finden Sie unter [Geläufige Parameter für RMAN-Verfahren](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
Dieses Verfahren wird für die folgenden Amazon RDS für Oracle-DB-Engine-Versionen unterstützt:
+ Oracle Database 21c (21.0.0)
+ Oracle Database 19c (19.0.0)
Im folgenden Beispiel wird ein Steuerdatei-Backup mit den angegebenen Werten für die Parameter durchgeführt.
```
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;
/
```
# Durchführen von Blockmedienwiederherstellungen
Sie können einzelne Datenblöcke mithilfe der Amazon-RDS-Verfahren `rdsadmin.rdsadmin_rman_util.recover_datafile_block` wiederherstellen, was als Blockmedienwiederherstellung bezeichnet wird. Sie können dieses überladene Verfahren verwenden, um entweder einen einzelnen Datenblock oder eine Reihe von Datenblöcken wiederherzustellen.
Bei diesem Verfahren wird der folgende geläufige Parameter für RMAN-Aufgaben verwendet:
+ `p_rman_to_dbms_output`
Weitere Informationen finden Sie unter [Geläufige Parameter für RMAN-Verfahren](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
Bei diesem Verfahren werden die folgenden zusätzlichen Parameter verwendet.
****
| Parametername | Datentyp | Zulässige Werte | Standard | Erforderlich | Description |
| --- | --- | --- | --- | --- | --- |
| `p_datafile` | `NUMBER` | Eine gültige Datendatei-ID-Nummer. | — | Ja | Die Datendatei, die die beschädigten Blöcke enthält. Geben Sie die Datendatei mit einer der folgenden Methoden an: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.block-media-recovery.html) |
| `p_block` | `NUMBER` | Eine gültige Ganzzahl | — | Ja | Die Nummer eines einzelnen Blocks, der wiederhergestellt werden soll. Die folgenden Parameter schließen sich gegenseitig aus: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.block-media-recovery.html) |
| `p_from_block` | `NUMBER` | Eine gültige Ganzzahl | — | Ja | Die erste Blocknummer in einer Reihe von Blöcken, die wiederhergestellt werden sollen. Die folgenden Parameter schließen sich gegenseitig aus: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.block-media-recovery.html) |
| `p_to_block` | `NUMBER` | Eine gültige Ganzzahl | — | Ja | Die letzte Blocknummer in einer Reihe von Blöcken, die wiederhergestellt werden sollen. Die folgenden Parameter schließen sich gegenseitig aus: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.block-media-recovery.html) |
Dieses Verfahren wird für die folgenden Amazon RDS für Oracle-DB-Engine-Versionen unterstützt:
+ Oracle Database 21c (21.0.0)
+ Oracle Database 19c (19.0.0)
Im folgenden Beispiel wird Block 100 in der Datendatei 5 wiederhergestellt.
```
BEGIN
rdsadmin.rdsadmin_rman_util.recover_datafile_block(
p_datafile => 5,
p_block => 100,
p_rman_to_dbms_output => TRUE);
END;
/
```
Im folgenden Beispiel werden die Blöcke 100 bis 150 in der Datendatei 5 wiederhergestellt.
```
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;
/
```
# Ausführen allgemeiner Planungsaufgaben für Oracle DB-Instances
Einige `SYS`-eigene Scheduler-Aufträge können den normalen Datenbankbetrieb stören. In solchen Fällen empfiehlt Oracle Support, den Zeitplan zu ändern. Wenn Sie `SYS`-Aufträge aktivieren oder deaktivieren müssen, testen Sie den Vorgang an geplanten Aufträgen in einer Testumgebung, bevor Sie ihn in einer Produktionsumgebung implementieren. Sie können das Amazon-RDS-Paket `rdsadmin.rdsadmin_dbms_scheduler` verwenden, um Aufgaben für `SYS`-eigene Oracle-Scheduler-Jobs auszuführen.
Die `rdsadmin.rdsadmin_dbms_scheduler`-Verfahren werden für die in der folgenden Tabelle gezeigten DB-Engine-Versionen von Amazon RDS für Oracle unterstützt: Wenn Sie dieses Paket verwenden, können Sie die in der Tabelle aufgeführten `SYS`-Aufträge angeben.
| Datenbankversion | Standardmäßig aktivierte Aufträge | Standardmäßig deaktivierte Aufträge |
| --- | --- | --- |
| 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
|
## Geläufige Parameter für Oracle Scheduler-Prozeduren
Um Aufgaben mit dem Oracle Scheduler auszuführen, verwenden Sie Prozeduren im Amazon-RDS-Paket `rdsadmin.rdsadmin_dbms_scheduler`. Den Verfahren im Paket sind mehrere Parameter gemeinsam. Das Paket besitzt die folgenden geläufigen Parameter.
****
| Parametername | Datentyp | Zulässige Werte | Standard | Erforderlich | Beschreibung |
| --- | --- | --- | --- | --- | --- |
| `name` | varchar2 | Die in der Tabelle unter [Ausführen allgemeiner Planungsaufgaben für Oracle DB-Instances](#Appendix.Oracle.CommonDBATasks.Scheduler) aufgeführten Verfahren | — | Ja | Der Name des zu ändernden Jobs. |
| `attribute` | varchar2 | `'REPEAT_INTERVAL'`,`'SCHEDULE_NAME'` | – | Ja | Zu änderndes Attribut. Um das Wiederholungsintervall für den Job zu ändern, geben Sie a `'REPEAT_INTERVAL'`. Um den Zeitplannamen für den Job zu ändern, geben Sie a `'SCHEDULE_NAME'`. |
| `value` | varchar2 | Ein gültiges Zeitintervall oder ein gültiger Zeitplanname, abhängig vom verwendeten Attribut. | – | Ja | Der neue Wert des Attributs. |
## Ändern von DBMS SCHEDULER-Aufgaben
Sie können die Oracle-Prozedur `dbms_scheduler.set_attribute` verwenden, um bestimmte Komponenten des Oracle Schedulers zu ändern. Weitere Informationen finden Sie unter [DBMS\$1SCHEDULER](https://docs.oracle.com/database/121/ARPLS/d_sched.htm#ARPLS72235) und [SET\$1ATTRIBUTE procedure](https://docs.oracle.com/database/121/ARPLS/d_sched.htm#ARPLS72399) in der Oracle-Dokumentation.
Stellen Sie bei der Arbeit mit Amazon-RDS-DB-Instances den Schemanamen `SYS` dem Objektnamen voran. Im folgenden Beispiel wird ein Ressourcenplan-Attribut für das Fensterobjekt "Monday" festgelegt.
```
BEGIN
DBMS_SCHEDULER.SET_ATTRIBUTE(
name => 'SYS.MONDAY_WINDOW',
attribute => 'RESOURCE_PLAN',
value => 'resource_plan_1');
END;
/
```
## AutoTask Wartungsfenster ändern
Instances von Amazon RDS für Oracle werden mit Standardeinstellungen für Wartungsfenster erstellt. Automatisierte Wartungsaufgaben wie die Erfassung von Optimierungsstatistiken werden in diesen Zeitfenstern ausgeführt. Standardmäßig aktivieren die Wartungsfenster Oracle Database Resource Manager.
Sie können das `DBMS_SCHEDULER`-Paket verwenden, um ein Wartungsfenster zu ändern. Möglicherweise müssen Sie die Einstellungen für Wartungsfenster aus den folgenden Gründen ändern:
+ Sie möchten, dass Wartungsaufträge zu einem anderen Zeitpunkt, mit anderen Einstellungen oder gar nicht ausgeführt werden. Sie können beispielsweise die Dauer des Wartungsfensters ändern oder die Wiederholungszeit und das Intervall ändern.
+ Sie möchten die Leistungsbeeinträchtigung durch die Aktivierung von Resource Manager während der Wartung vermeiden. Wenn beispielsweise der Standard-Wartungsplan angegeben ist und das Wartungsfenster beginnt, während die Datenbank ausgelastet ist, können Warteereignisse wie `resmgr:cpu quantum` ausgegeben werden. Dieses Warteereignis bezieht sich auf Database Resource Manager. Ihnen stehen folgende Optionen zur Verfügung:
+ Stellen Sie sicher, dass Wartungsfenster außerhalb der Spitzenzeiten für Ihre DB-Instance aktiv sind.
+ Deaktivieren Sie den Standard-Wartungsplan, indem Sie für das Attribut `resource_plan` eine leere Zeichenfolge angeben.
+ Legen Sie den Parameter `resource_manager_plan` in der Parametergruppe auf `FORCE:` fest. Wenn Ihre Instance die Enterprise Edition verwendet, wird durch diese Einstellung verhindert, dass Database-Resource-Manager-Pläne aktiviert werden.
**Ändern Sie die Einstellungen eines Wartungsfensters wie folgt:**
1. Verbinden Sie Ihren Oracle-SQL-Client mit der Datenbank.
1. Fragen Sie die aktuelle Konfiguration für ein Scheduler-Wartungsfenster ab.
Im folgenden Beispiel wird die Konfiguration für `MONDAY_WINDOW` abgefragt.
```
SELECT ENABLED, RESOURCE_PLAN, DURATION, REPEAT_INTERVAL
FROM DBA_SCHEDULER_WINDOWS
WHERE WINDOW_NAME='MONDAY_WINDOW';
```
Die folgende Ausgabe zeigt, dass für das Wartungsfenster die Standardwerte verwendet werden.
```
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. Ändern Sie das Wartungsfenster mit dem `DBMS_SCHEDULER`-Paket.
Im folgenden Beispiel wird der Ressourcenplan auf null festgelegt, damit Resource Manager nicht während des Wartungsfensters ausgeführt wird.
```
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;
/
```
Im folgenden Beispiel wird die maximale Dauer des Wartungsfensters auf 2 Stunden eingestellt.
```
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;
/
```
Im folgenden Beispiel wird das Wiederholungsintervall auf montags 10 Uhr festgelegt.
```
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;
/
```
## Festlegen der Zeitzone für Oracle Scheduler-Aufgaben
Um die Zeitzone für Oracle Scheduler zu ändern, können Sie die Oracle-Prozedur verwende `dbms_scheduler.set_scheduler_attribute`. Weitere Informationen über das `dbms_scheduler`-Paket finden Sie unter [DBMS\$1SCHULER](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/DBMS_SCHEDULER.html) und [SET\$1SCHULER\$1ATTRIBUTE](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/DBMS_SCHEDULER.html#GUID-2AB97BF7-7154-4E6C-933F-B2659B18A907) in der Oracle-Dokumentation.
**So ändern Sie die Einstellung für die aktuelle Zeitzone**
1. Stellen Sie mithilfe eines Clients wie SQL Developer eine Verbindung zur Datenbank her. Weitere Informationen finden Sie unter [Herstellen der Verbindung zu Ihrer DB-Instance mit Oracle SQL Developer](USER_ConnectToOracleInstance.SQLDeveloper.md).
1. Legen Sie die Standardzeitzone wie folgt fest, indem Sie durch Ihre Zeitzone ersetze `time_zone_name`.
```
BEGIN
DBMS_SCHEDULER.SET_SCHEDULER_ATTRIBUTE(
attribute => 'default_timezone',
value => 'time_zone_name'
);
END;
/
```
Im folgenden Beispiel ändern Sie die Zeitzone in Asia/Shanghai.
Beginnen Sie, indem Sie die aktuelle Zeitzone abfragen, wie im Folgenden gezeigt.
```
SELECT VALUE FROM DBA_SCHEDULER_GLOBAL_ATTRIBUTE WHERE ATTRIBUTE_NAME='DEFAULT_TIMEZONE';
```
Die Ausgabe zeigt an, dass die aktuelle Zeitzone ETC/UTC ist.
```
VALUE
-------
Etc/UTC
```
Dann stellen Sie die Zeitzone auf „Asien/Shanghai“ ein.
```
BEGIN
DBMS_SCHEDULER.SET_SCHEDULER_ATTRIBUTE(
attribute => 'default_timezone',
value => 'Asia/Shanghai'
);
END;
/
```
Weitere Informationen zum Ändern der Systemzeitzone finden Sie unter [Oracle-Zeitzone](Appendix.Oracle.Options.Timezone.md).
## Deaktivieren von Oracle-Scheduler-Aufgaben im Besitz von SYS
Um einen SYS-eigene Oracle-Scheduler-Aufgabe zu deaktivieren, verwenden Sie die Prozedur `rdsadmin.rdsadmin_dbms_scheduler.disable`.
Diese Vorgehensweise verwendet den allgemeinen Parameter `name` für Oracle Scheduler-Tasks. Weitere Informationen finden Sie unter [Geläufige Parameter für Oracle Scheduler-Prozeduren](#Appendix.Oracle.CommonDBATasks.Scheduler.CommonParameters).
Das folgende Beispiel deaktiviert den Oracle Scheduler-Job `SYS.CLEANUP_ONLINE_IND_BUILD`.
```
BEGIN
rdsadmin.rdsadmin_dbms_scheduler.disable('SYS.CLEANUP_ONLINE_IND_BUILD');
END;
/
```
## Aktivieren von Oracle-Scheduler-Aufgaben im Besitz von SYS
Um eine SYS-eigene Oracle-Scheduler-Aufgabe zu aktivieren, verwenden Sie die Prozedur `rdsadmin.rdsadmin_dbms_scheduler.enable`.
Diese Vorgehensweise verwendet den allgemeinen Parameter `name` für Oracle Scheduler-Tasks. Weitere Informationen finden Sie unter [Geläufige Parameter für Oracle Scheduler-Prozeduren](#Appendix.Oracle.CommonDBATasks.Scheduler.CommonParameters).
Das folgende Beispiel aktiviert den Oracle Scheduler-Job `SYS.CLEANUP_ONLINE_IND_BUILD`.
```
BEGIN
rdsadmin.rdsadmin_dbms_scheduler.enable('SYS.CLEANUP_ONLINE_IND_BUILD');
END;
/
```
## Ändern des Wiederholungsintervalls von Oracle Scheduler für Aufgaben des Typs CALENDAR
Um das Wiederholungsintervall für die Änderung eines SYS-eigenen Oracle-Scheduler-Jobs vom Typ `CALENDAR` zu ändern, verwenden Sie die Vorgehensweise `rdsadmin.rdsadmin_dbms_scheduler.disable`.
Diese Vorgehensweise verwendet die folgenden allgemeinen Parameter für Oracle Scheduler-Tasks:
+ `name`
+ `attribute`
+ `value`
Weitere Informationen finden Sie unter [Geläufige Parameter für Oracle Scheduler-Prozeduren](#Appendix.Oracle.CommonDBATasks.Scheduler.CommonParameters).
Das folgende Beispiel ändert das Wiederholungsintervall des Oracle Scheduler-Jobs `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;
/
```
## Ändern des Wiederholungsintervalls von Oracle Scheduler für Aufgaben des Typs NAMED
Einige Oracle Scheduler-Jobs verwenden einen Zeitplannamen anstelle eines Intervalls. Für diese Art von Jobs müssen Sie im Master-Benutzerschema einen neuen benannten Zeitplan anlegen. Verwenden Sie dazu die standardmäßige Oracle `sys.dbms_scheduler.create_schedule`-Prozedur. Verwenden Sie außerdem die `rdsadmin.rdsadmin_dbms_scheduler.set_attribute procedure`, um dem Job den neuen benannten Zeitplan zuzuweisen.
Diese Vorgehensweise verwendet den folgenden allgemeinen Parameter für Oracle Scheduler-Tasks:
+ `name`
+ `attribute`
+ `value`
Weitere Informationen finden Sie unter [Geläufige Parameter für Oracle Scheduler-Prozeduren](#Appendix.Oracle.CommonDBATasks.Scheduler.CommonParameters).
Das folgende Beispiel ändert das Wiederholungsintervall des Oracle Scheduler-Jobs `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;
/
```
## Deaktivieren von Autocommit für die Erstellung von Oracle-Scheduler-Aufgaben
Wenn `DBMS_SCHEDULER.CREATE_JOB` Oracle-Scheduler-Aufgaben erstellt, werden die Aufgaben sofort erstellt und es wird ein Commit für die Änderungen ausgeführt. Möglicherweise müssen Sie die Erstellung von Oracle-Scheduler-Aufgaben in die Benutzertransaktion integrieren, um Folgendes zu tun:
+ Setzen Sie die Oracle-Scheduler-Aufgabe zurück, wenn die Benutzertransaktion zurückgesetzt wird.
+ Erstellen Sie die Oracle-Scheduler-Augabe, wenn ein Commit für die Hauptbenutzertransaktion ausgeführt wird.
Sie können die Prozedur `rdsadmin.rdsadmin_dbms_scheduler.set_no_commit_flag` verwenden, um dieses Verhalten zu aktivieren. Diese Prozedur verwendet keine Parameter. Sie können diese Prozedur in den folgenden Versionen von RDS für Oracle verwenden:
+ 21.0.0.0.ru-2022-07.rur-2022-07.r1 und höhere Versionen
+ 19.0.0.0.ru-2022-07.rur-2022-07.r1 und höhere Versionen
Im folgenden Beispiel wird Autocommit für Oracle Scheduler deaktiviert, eine Oracle-Scheduler-Aufgabe erstellt und anschließend die Transaktion zurückgesetzt. Da Autocommit deaktiviert ist, setzt die Datenbank auch die Erstellung der Oracle-Scheduler-Aufgabe zurück.
```
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
```
# Diagnose von Problemen mit DB-Instances von RDS für Oracle
Oracle Database enthält eine Infrastruktur für die Fehlerdiagnose, mit der Sie Datenbankprobleme untersuchen können. In der Oracle-Terminologie ist ein *Problem* ein kritischer Fehler, z. B. ein Codefehler oder eine Datenbeschädigung. Ein *Vorfall* ist das Auftreten eines Problems. Wenn der gleiche Fehler dreimal auftritt, zeigt die Infrastruktur drei Vorfälle dieses Problems an. Weitere Informationen finden Sie unter [Diagnosing and resolving problems](https://docs.oracle.com/en/database/oracle/oracle-database/19/admin/diagnosing-and-resolving-problems.html#GUID-8DEB1BE0-8FB9-4FB2-A19A-17CF6F5791C3) in der Oracle Database-Dokumentation.
Das Dienstprogramm „Automatic Diagnostic Repository Command Interpreter“ (ADRCI) ist ein Oracle-Befehlszeilentool für die Verwaltung von Diagnosedaten. Sie können dieses Tool beispielsweise verwenden, um Probleme zu untersuchen und Diagnosedaten zu verpacken. Ein *Vorfallpaket* enthält Diagnosedaten für Vorfälle, die auf ein bestimmtes Problem hinweisen. Sie können ein Vorfallpaket, das als ZIP-Datei implementiert wird, zu Oracle Support hochladen.
Um eine verwaltete Service-Erfahrung zu bieten, ermöglicht Amazon RDS keinen Shell-Zugriff auf ADRCI. Um Diagnoseaufgaben für Ihre DB-Instance von RDS für Oracle durchzuführen, verwenden Sie das Amazon-RDS-Paket `rdsadmin.rdsadmin_adrci_util`.
Mithilfe der Funktionen in `rdsadmin_adrci_util` können Sie Probleme und Vorfälle auflisten und verpacken sowie Ablaufverfolgungsdateien anzeigen. Alle Funktionen geben eine Aufgaben-ID zurück. Diese ID ist Teil des Namens der Protokolldatei, die die ADRCI-Ausgabe enthält, z. B. `dbtask-task_id.log`. Die Protokolldatei befindet sich im BDUMP-Verzeichnis. Sie können die Protokolldatei anhand der unter [Herunterladen einer Datenbank-Protokolldatei](USER_LogAccess.Procedural.Downloading.md) beschriebenen Schritte herunterladen.
## Allgemeine Parameter für Diagnoseverfahren
Um Diagnoseaufgaben auszuführen, verwenden Sie die Funktionen im Amazon-RDS-Paket `rdsadmin.rdsadmin_adrci_util`. Das Paket besitzt die folgenden geläufigen Parameter.
****
| Parametername | Datentyp | Zulässige Werte | Standard | Erforderlich | Beschreibung |
| --- | --- | --- | --- | --- | --- |
| `incident_id` | Zahl | Eine gültige Vorfall-ID oder null | Null | Nein | Wenn der Wert null ist, zeigt die Funktion alle Vorfälle an. Wenn der Wert nicht null ist und eine gültige Vorfall-ID darstellt, zeigt die Funktion den angegebenen Vorfall an. |
| `problem_id` | Zahl | Eine gültige Problem-ID oder null | Null | Nein | Wenn der Wert null ist, zeigt die Funktion alle Probleme an. Wenn der Wert nicht null ist und eine gültige Problem-ID darstellt, zeigt die Funktion das angegebene Problem an. |
| `last` | Zahl | Eine gültige Ganzzahl größer als 0 oder null | Null | Nein | Wenn der Wert null ist, zeigt die Funktion maximal 50 Elemente an. Wenn der Wert nicht null ist, zeigt die Funktion die angegebene Anzahl an. |
## Auflistung von Vorfällen
Um Diagnosevorfälle für Oracle aufzulisten, verwenden Sie die Amazon-RDS-Funktion `rdsadmin.rdsadmin_adrci_util.list_adrci_incidents`. Sie können Vorfälle im Basis- oder im Detailmodus auflisten. Standardmäßig listet die Funktion die 50 letzten Vorfälle auf.
Diese Funktion verwendet die folgenden allgemeinen Parameter:
+ `incident_id`
+ `problem_id`
+ `last`
Wenn Sie `incident_id` und `problem_id` angeben, wird `problem_id` von `incident_id` überschrieben. Weitere Informationen finden Sie unter [Allgemeine Parameter für Diagnoseverfahren](#Appendix.Oracle.CommonDBATasks.CommonDiagParameters).
Diese Funktion verwendet den folgenden zusätzlichen Parameter.
****
| Parametername | Datentyp | Zulässige Werte | Standard | Erforderlich | Beschreibung |
| --- | --- | --- | --- | --- | --- |
| `detail` | Boolean | TRUE oder FALSE | `FALSE` | Nein | Wenn `TRUE`, listet die Funktion Vorfälle im Detailmodus auf. Wenn `FALSE`, listet die Funktion Vorfälle im Basismodus auf. |
Um alle Vorfälle aufzulisten, fragen Sie die Funktion `rdsadmin.rdsadmin_adrci_util.list_adrci_incidents` ohne Argumente ab. Die Abfrage gibt die Aufgaben-ID zurück.
```
SQL> SELECT rdsadmin.rdsadmin_adrci_util.list_adrci_incidents AS task_id FROM DUAL;
TASK_ID
------------------
1590786706158-3126
```
Oder rufen Sie die Funktion `rdsadmin.rdsadmin_adrci_util.list_adrci_incidents` ohne Argumente auf und speichern die Ausgabe in einer SQL-Clientvariablen. Sie können die Variable in anderen Anweisungen verwenden.
```
SQL> VAR task_id VARCHAR2(80);
SQL> EXEC :task_id := rdsadmin.rdsadmin_adrci_util.list_adrci_incidents;
PL/SQL procedure successfully completed.
```
Um die Protokolldatei zu lesen, rufen Sie die Amazon-RDS-Prozedur au `rdsadmin.rds_file_util.read_text_file`. Geben Sie die Aufgaben-ID als Teil des Dateinamens an. Die folgende Ausgabe zeigt drei Vorfälle: 53523, 53522 und 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.
```
Um einen bestimmten Vorfall aufzulisten, geben Sie mithilfe des Parameters `incident_id` dessen ID an. Im folgenden Beispiel fragen Sie die Protokolldatei nur für Vorfall 53523 ab.
```
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.
```
## Probleme mit der Auflistung
Um Diagnoseprobleme für Oracle aufzulisten, verwenden Sie die Amazon-RDS-Funktion `rdsadmin.rdsadmin_adrci_util.list_adrci_problems`.
Standardmäßig listet die Funktion die 50 letzten Probleme auf.
Diese Funktion verwendet die allgemeinen Parameter `problem_id` und `last`. Weitere Informationen finden Sie unter [Allgemeine Parameter für Diagnoseverfahren](#Appendix.Oracle.CommonDBATasks.CommonDiagParameters).
Um die Aufgaben-ID für alle Probleme abzurufen, rufen Sie die Funktion `rdsadmin.rdsadmin_adrci_util.list_adrci_problems` ohne Argumente auf und speichern die Ausgabe in einer SQL-Clientvariablen.
```
SQL> EXEC :task_id := rdsadmin.rdsadmin_adrci_util.list_adrci_problems;
PL/SQL procedure successfully completed.
```
Um die Protokolldatei zu lesen, rufen Sie die Funktion `rdsadmin.rds_file_util.read_text_file` auf und geben Aufgaben-ID als Teil des Dateinamens an. In der folgenden Ausgabe zeigt die Protokolldatei drei Probleme an: 1, 2 und 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.
```
Im folgenden Beispiel listen Sie nur Problem 3 auf.
```
SQL> EXEC :task_id := rdsadmin.rdsadmin_adrci_util.list_adrci_problems(problem_id=>3);
PL/SQL procedure successfully completed.
```
Um die Protokolldatei für Problem 3 zu lesen, rufen Sie au `rdsadmin.rds_file_util.read_text_file`. Geben Sie die Aufgaben-ID als Teil des Dateinamens an.
```
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.
```
## Erstellen von Vorfallpaketen
Sie können Vorfallpakete mithilfe der Amazon-RDS-Funktion erstelle `rdsadmin.rdsadmin_adrci_util.create_adrci_package`. Bei der Ausgabe handelt es sich um eine ZIP-Datei, die Sie Oracle Support bereitstellen können.
Diese Funktion verwendet die folgenden allgemeinen Parameter:
+ `problem_id`
+ `incident_id`
Sie müssen einen der vorhergehenden Parameter angeben. Wenn Sie beide Parameter angeben, überschreibt `incident_id` `problem_id`. Weitere Informationen finden Sie unter [Allgemeine Parameter für Diagnoseverfahren](#Appendix.Oracle.CommonDBATasks.CommonDiagParameters).
Um ein Paket für einen bestimmten Vorfall zu erstellen, rufen Sie die Amazon-RDS-Funktion `rdsadmin.rdsadmin_adrci_util.create_adrci_package` mit dem Parameter `incident_id` auf. Im folgenden Beispiel wird ein Paket für den Vorfall 53523 erstellt.
```
SQL> EXEC :task_id := rdsadmin.rdsadmin_adrci_util.create_adrci_package(incident_id=>53523);
PL/SQL procedure successfully completed.
```
Um die Protokolldatei zu lesen, rufen Sie au `rdsadmin.rds_file_util.read_text_file`. Sie können die Aufgaben-ID als Teil des Dateinamens bereitstellen. Die Ausgabe zeigt, dass Sie das Vorfallpaket generiert habe `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.
```
Um Diagnosedaten für ein bestimmtes Problem zu verpacken, geben Sie mithilfe des Parameters `problem_id` dessen ID an. Im folgenden Beispiel verpacken Sie nur für Problem 3 Daten.
```
SQL> EXEC :task_id := rdsadmin.rdsadmin_adrci_util.create_adrci_package(problem_id=>3);
PL/SQL procedure successfully completed.
```
Um die Aufgabenausgabe zu lesen, rufen Sie `rdsadmin.rds_file_util.read_text_file` auf und die Aufgaben-ID als Teil des Dateinamens an. Die Ausgabe zeigt, dass Sie das Vorfallpaket generiert habe `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.
```
Sie können auch die Protokolldatei herunterladen. Weitere Informationen finden Sie unter [Herunterladen einer Datenbank-Protokolldatei](USER_LogAccess.Procedural.Downloading.md).
## Anzeigen von Trace-Dateien
Sie können die Amazon-RDS-Funktion `rdsadmin.rdsadmin_adrci_util.show_adrci_tracefile` verwenden, um Trace-Dateien unter dem Trace-Verzeichnis und alle Incident-Verzeichnisse unter dem aktuellen ADR-Home-Verzeichnis aufzulisten. Außerdem können Sie die Inhalte von Trace-Dateien und Incident-Trace-Dateien anzeigen.
Diese Funktion verwendet den folgenden Parameter.
****
| Parametername | Datentyp | Zulässige Werte | Standard | Erforderlich | Beschreibung |
| --- | --- | --- | --- | --- | --- |
| `filename` | varchar2 | Ein gültiger Name für eine Trace-Datei | Null | Nein | Wenn der Wert null ist, zeigt die Funktion alle Trace-Dateien an. Wenn er nicht null ist, zeigt die Funktion die angegebene Datei an. |
Wenn Sie die Trace-Datei anzeigen möchten, rufen Sie die Amazon-RDS-Funktion `rdsadmin.rdsadmin_adrci_util.show_adrci_tracefile` auf.
```
SQL> EXEC :task_id := rdsadmin.rdsadmin_adrci_util.show_adrci_tracefile;
PL/SQL procedure successfully completed.
```
Um die Namen der Trace-Dateien aufzulisten, rufen Sie die Amazon-RDS-Prozedur `rdsadmin.rds_file_util.read_text_file` auf und geben die Aufgaben-ID als Teil des Dateinamens an.
```
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.
```
Im folgenden Beispiel generieren Sie die Ausgabe für `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.
```
Um die Protokolldatei zu lesen, rufen Sie au `rdsadmin.rds_file_util.read_text_file`. Geben Sie die Aufgaben-ID als Teil des Dateinamens an. Die Ausgabe zeigt die ersten 10 Zeilen von alert\$1ORCL.log an.
```
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.
```
Sie können auch die Protokolldatei herunterladen. Weitere Informationen finden Sie unter [Herunterladen einer Datenbank-Protokolldatei](USER_LogAccess.Procedural.Downloading.md).
# Ausführen verschiedener Aufgaben für Oracle-DB-Instances
Im Folgenden erfahren Sie, wie Sie verschiedene DBA-Aufgaben für Ihre Amazon-RDS-DB-Instances, auf denen Oracle ausgeführt wird, durchführen können. Um eine verwaltete Service-Erfahrung zu bieten, stellt Amazon RDS keinen Shell-Zugriff zu DB-Instances bereit und beschränkt den Zugriff auf bestimmte Systemprozeduren und -tabellen, die erweiterte Sonderrechte erfordern.
**Topics**
+ [
## Erstellen und Löschen von Verzeichnissen im Hauptdatenspeicherbereich
](#Appendix.Oracle.CommonDBATasks.NewDirectories)
+ [
## Auflisten von Dateien in einem DB-Instance-Verzeichnis
](#Appendix.Oracle.CommonDBATasks.ListDirectories)
+ [
## Lesen von Dateien in einem DB-Instance-Verzeichnis
](#Appendix.Oracle.CommonDBATasks.ReadingFiles)
+ [
## Zugreifen auf Opatch-Dateien
](#Appendix.Oracle.CommonDBATasks.accessing-opatch-files)
+ [
## Verwalten von Berateraufgaben
](#Appendix.Oracle.CommonDBATasks.managing-advisor-tasks)
+ [
# Transport von Tabellenbereichen
](rdsadmin_transport_util.md)
## Erstellen und Löschen von Verzeichnissen im Hauptdatenspeicherbereich
Um die Dateien in einem Verzeichnis aufzulisten, verwenden Sie die Amazon-RDS-Prozedur `rdsadmin.rdsadmin_util.create_directory`. Sie können bis zu 10 000 Verzeichnisse erstellen, die sich alle in Ihrem Hauptdatenspeicherplatz befinden. Um Verzeichnisse zu entfernen, verwenden Sie die Amazon-RDS-Prozedur `rdsadmin.rdsadmin_util.drop_directory`.
Die Prozeduren `create_directory` und `drop_directory` haben den folgenden erforderlichen Parameter.
****
| Parametername | Datentyp | Standard | Erforderlich | Beschreibung |
| --- | --- | --- | --- | --- |
| `p_directory_name` | VARCHAR2 | — | Ja | Der Name des Verzeichnisses |
Im folgenden Beispiel wird ein neues Verzeichnis mit dem Namen erstell `PRODUCT_DESCRIPTIONS`.
```
EXEC rdsadmin.rdsadmin_util.create_directory(p_directory_name => 'product_descriptions');
```
Das Datenwörterbuch speichert den Verzeichnisnamen in Großbuchstaben. Sie können die Verzeichnisse durch das Abfragen von auflisten lasse `DBA_DIRECTORIES`. Das System wählt den tatsächlichen Host-Pfadnamen automatisch aus. Im folgenden Beispiel wird der Verzeichnispfad für das Verzeichnis mit dem Namen erhalte `PRODUCT_DESCRIPTIONS`:
```
SELECT DIRECTORY_PATH
FROM DBA_DIRECTORIES
WHERE DIRECTORY_NAME='PRODUCT_DESCRIPTIONS';
DIRECTORY_PATH
----------------------------------------
/rdsdbdata/userdirs/01
```
Der Hauptbenutzername für die DB-Instance hat Lese- und Schreibsonderrechte im neuen Verzeichnis und kann anderen Benutzern Zugriff gewähren. `EXECUTE`-Sonderrechte sind für die Verzeichnisse in einer DB-Instance nicht verfügbar. Verzeichnisse werden in Ihrem Hauptdatenspeicher erstellt und verbrauchen Speicherplatz und I/O Bandbreite.
Im folgenden Beispiel wird das Verzeichnis mit dem Namen „“ entfern `PRODUCT_DESCRIPTIONS`.
```
EXEC rdsadmin.rdsadmin_util.drop_directory(p_directory_name => 'product_descriptions');
```
**Anmerkung**
Sie können ein Verzeichnis auch löschen, indem Sie den Oracle SQL-Befehl verwende `DROP DIRECTORY`.
Das Verwerfen eines Verzeichnisses entfernt nicht seine Inhalte. Da die Prozedur „`rdsadmin.rdsadmin_util.create_directory`“ Pfadnamen wiederverwenden kann, werden in Verzeichnissen verworfene Dateien in einem neu erstellten Verzeichnis wieder auftauchen. Bevor Sie ein Verzeichnis löschen, wird empfohlen, Dateien mit `UTL_FILE.FREMOVE` aus dem Verzeichnis zu entfernen. Weitere Informationen finden Sie unter [FREMOVE Procedure](https://docs.oracle.com/database/121/ARPLS/u_file.htm#ARPLS70924) in der Oracle-Dokumentation.
## Auflisten von Dateien in einem DB-Instance-Verzeichnis
Um die Dateien in einem Verzeichnis aufzulisten, verwenden Sie die Amazon-RDS-Prozedur `rdsadmin.rds_file_util.listdir`. Dieses Verfahren wird auf einem Oracle-Replikat nicht unterstützt. Die Prozedur `listdir` hat die folgenden Parameter.
****
| Parametername | Datentyp | Standard | Erforderlich | Beschreibung |
| --- | --- | --- | --- | --- |
| `p_directory` | varchar2 | — | Ja | Der Name des aufzulistenden Verzeichnisses |
Das folgende Beispiel gewährt dem Benutzer read/write `rdsadmin` Rechte `PRODUCT_DESCRIPTIONS` für das Verzeichnis und listet dann die Dateien in diesem Verzeichnis auf.
```
GRANT READ,WRITE ON DIRECTORY PRODUCT_DESCRIPTIONS TO rdsadmin;
SELECT * FROM TABLE(rdsadmin.rds_file_util.listdir(p_directory => 'PRODUCT_DESCRIPTIONS'));
```
## Lesen von Dateien in einem DB-Instance-Verzeichnis
Um eine Textdatei zu lesen, verwenden Sie die Amazon-RDS-Prozedur `rdsadmin.rds_file_util.read_text_file`. Die Prozedur `read_text_file` hat die folgenden Parameter.
****
| Parametername | Datentyp | Standard | Erforderlich | Beschreibung |
| --- | --- | --- | --- | --- |
| `p_directory` | varchar2 | — | Ja | Der Verzeichnisname der die Datei beinhaltet |
| `p_filename` | varchar2 | — | Ja | Der Name der zu lesenden Datei |
Im folgenden Beispiel wird die Datei `rice.txt` im Verzeichnis `PRODUCT_DESCRIPTIONS` erstellt.
```
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;
/
```
Im folgenden Beispiel wird die Datei `rice.txt` aus dem Verzeichnis `PRODUCT_DESCRIPTIONS` gelesen.
```
SELECT * FROM TABLE
(rdsadmin.rds_file_util.read_text_file(
p_directory => 'PRODUCT_DESCRIPTIONS',
p_filename => 'rice.txt'));
```
## Zugreifen auf Opatch-Dateien
Opatch ist ein Oracle-Dienstprogramm, das die Anwendung und das Rollback von Patches auf Oracle-Software ermöglicht. Die Oracle-Methode, mit der bestimmt wird, welche Patches auf eine Datenbank angewendet wurden, ist der Befehl `opatch lsinventory`. Um Serviceanfragen für Kunden mit Bring Your Own License (BYOL) zu öffnen, fordert Oracle Support die `lsinventory`-Datei und manchmal die von Opatch generierte `lsinventory_detail`-Datei an.
Um eine verwaltete Service-Erfahrung zu bieten, ermöglicht Amazon RDS keinen Shell-Zugriff auf Opatch. Stattdessen enthält die Datei `lsinventory-dbv.txt` im BDUMP-Verzeichnis die Patch-Informationen zu Ihrer aktuellen Engine-Version. Wenn Sie ein Upgrade der Neben- oder Hauptversion durchführen, aktualisiert Amazon RDS `lsinventory-dbv.txt` innerhalb einer Stunde nach Patch-Anwendung. Informationen zur Überprüfung der angewendeten Patches finden Sie in der `lsinventory-dbv.txt`. Diese Aktion entspricht der Ausführung des Befehls `opatch lsinventory`.
**Anmerkung**
In den Beispielen in diesem Abschnitt wird davon ausgegangen, dass das BDUMP-Verzeichnis als benannt is `BDUMP`. Bei einem Lesereplikat unterscheidet sich der Name des BDUMP-Verzeichnisses. Informationen zum Abrufen des BDUMP-Namens durch Abfragen von `V$DATABASE.DB_UNIQUE_NAME` auf einem Lesereplikat finden Sie unter [Auflisten von Dateien](USER_LogAccess.Concepts.Oracle.md#USER_LogAccess.Concepts.Oracle.WorkingWithTracefiles.ViewingBackgroundDumpDest).
Die Inventardateien verwenden die Amazon RDS-Namenskonvention `lsinventory-dbv.txt` und`lsinventory_detail-dbv.txt`, wo *dbv* ist der vollständige Name Ihrer DB-Version. Die Datei `lsinventory-dbv.txt` ist auf allen DB-Versionen verfügbar. Die entsprechende Version `lsinventory_detail-dbv.txt` ist auf 19.0.0.0, ru-2020-01.r1 oder höher verfügbar.
Wenn Ihre DB-Version beispielsweise 19.0.0.0.ru-2021-07.rur-2021-07.r1 ist, haben die Bestandsdateien die folgenden Namen.
```
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
```
Stellen Sie sicher, dass Sie die Dateien herunterladen, die mit der aktuellen Version Ihrer DB-Engine übereinstimmen.
### Konsole
**So laden Sie eine Bestandsdatei über die Konsole herunter**
1. Öffnen Sie die Amazon RDS-Konsole unter [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Wählen Sie im Navigationsbereich **Databases (Datenbanken)** aus.
1. Wählen Sie den Namen der DB-Instance, welche die anzuzeigende Protokolldatei enthält.
1. Wählen Sie die Registerkarte **Logs & events** (Protokolle und Ereignisse).
1. Scrollen Sie nach unten bis zum Abschnitt **Protokolle**.
1. Suchen Sie im Abschnitt **Protokolle** nach `lsinventory`.
1. Wählen Sie die Datei aus, auf die Sie zugreifen möchten, und klicken Sie dann auf **Herunterladen**.
### SQL
Zum Lesen der `lsinventory-dbv.txt` auf einem SQL-Client können Sie eine `SELECT`-Anweisung verwenden. Für diese Methode verwenden Sie eine der folgenden `rdsadmin`-Funktionen: `rdsadmin.rds_file_util.read_text_file` oder `rdsadmin.tracefile_listing`.
Ersetzen Sie in der folgenden Beispielabfrage *dbv* durch Ihre Oracle-DB-Version. Ihre DB-Version könnte beispielsweise 19.0.0.0.ru-2020-04.rur-2020-04.r1 sein.
```
SELECT text
FROM TABLE(rdsadmin.rds_file_util.read_text_file('BDUMP', 'lsinventory-dbv.txt'));
```
### PL/SQL
Um das `lsinventory-dbv.txt` in einem SQL-Client zu lesen, können Sie ein PL/SQL Programm schreiben. Dieses Programm verwendet `utl_file`, um die Datei zu lesen, und `dbms_output`, um sie zu drucken. Dies sind von Oracle bereitgestellte Pakete.
Ersetzen Sie es im folgenden Beispielprogramm *dbv* durch Ihre Oracle-DB-Version. Ihre DB-Version könnte beispielsweise 19.0.0.0.ru-2020-04.rur-2020-04.r1 sein.
```
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;
/
```
Oder fragen Sie `rdsadmin.tracefile_listing` ab und spoolen Sie die Ausgabe in eine Datei. Im folgenden Beispiel wird die Ausgabe in gespool `/tmp/tracefile.txt`.
```
SPOOL /tmp/tracefile.txt
SELECT *
FROM rdsadmin.tracefile_listing
WHERE FILENAME LIKE 'lsinventory%';
SPOOL OFF;
```
## Verwalten von Berateraufgaben
Oracle Database enthält eine Reihe von Beratern. Jeder Berater unterstützt automatisierte und manuelle Aufgaben. Sie können Prozeduren im `rdsadmin.rdsadmin_util`-Paket zur Verwaltung einiger Berateraufgaben verwenden.
Die Prozesse der Berateraufgaben sind in den folgenden Engine-Versionen verfügbar:
+ Oracle Database 21c (21.0.0)
+ Version 19.0.0.0.ru-2021-01.rur-2021-01.r1 und höhere Versionen von Oracle Database 19c
Weitere Informationen finden Sie unter [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) in den *Versionshinweisen zu Amazon RDS für Oracle*.
**Topics**
+ [
### Festlegen von Parametern für Berateraufgaben
](#Appendix.Oracle.CommonDBATasks.setting-task-parameters)
+ [
### Deaktivieren von AUTO\$1STATS\$1ADVISOR\$1TASK
](#Appendix.Oracle.CommonDBATasks.dropping-advisor-task)
+ [
### Erneutes Aktivieren von AUTO\$1STATS\$1ADVISOR\$1TASK
](#Appendix.Oracle.CommonDBATasks.recreating-advisor-task)
### Festlegen von Parametern für Berateraufgaben
Um Parameter für einige Berateraufgaben festzulegen, verwenden Sie das Amazon-RDS-Verfahren `rdsadmin.rdsadmin_util.advisor_task_set_parameter`. Die Prozedur `advisor_task_set_parameter` hat die folgenden Parameter.
****
| Parametername | Datentyp | Standard | Erforderlich | Beschreibung |
| --- | --- | --- | --- | --- |
| `p_task_name` | varchar2 | — | Ja | Der Name der Berateraufgabe, deren Parameter Sie ändern möchten. Die folgenden Werte sind gültig: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.Misc.html) |
| `p_parameter` | varchar2 | — | Ja | Der Name des Aufgaben-Parameters. Um gültige Parameter für eine Berateraufgabe zu finden, führen Sie die folgende Abfrage aus. *p\$1task\$1name*Ersetzen Sie durch einen gültigen Wert für`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 | — | Ja | Der Wert für einen Aufgabenparameter. Um gültige Werte für Aufgabenparameter zu finden, führen Sie die folgende Abfrage aus. Ersetze *p\$1task\$1name* durch einen gültigen Wert für`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;
|
Das folgende PL/SQL Programm setzt `ACCEPT_PLANS` auf `FALSE` for`SYS_AUTO_SPM_EVOLVE_TASK`. Die automatisierte Aufgabe „SQL-Planverwaltung“ überprüft die Pläne und erstellt einen Bericht über ihre Ergebnisse, entwickelt die Pläne jedoch nicht automatisch weiter. Sie können einen Bericht verwenden, um neue SQL-Plan-Baselines zu identifizieren und sie manuell zu akzeptieren.
```
BEGIN
rdsadmin.rdsadmin_util.advisor_task_set_parameter(
p_task_name => 'SYS_AUTO_SPM_EVOLVE_TASK',
p_parameter => 'ACCEPT_PLANS',
p_value => 'FALSE');
END;
```
Das folgende PL/SQL Programm setzt `EXECUTION_DAYS_TO_EXPIRE` auf `10` for`AUTO_STATS_ADVISOR_TASK`. Die vordefinierte Aufgabe `AUTO_STATS_ADVISOR_TASK` läuft automatisch einmal täglich im Wartungsfenster. Im Beispiel wird der Aufbewahrungszeitraum für die Aufgabenausführung auf 10 Tage festgelegt.
```
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;
```
### Deaktivieren von AUTO\$1STATS\$1ADVISOR\$1TASK
Um `AUTO_STATS_ADVISOR_TASK` zu deaktivieren, verwenden Sie das Amazon-RDS-Verfahren `rdsadmin.rdsadmin_util.advisor_task_drop`. Das `advisor_task_drop`-Verfahren akzeptiert den folgenden Parameter.
****
| Parametername | Datentyp | Standard | Erforderlich | Beschreibung |
| --- | --- | --- | --- | --- |
| `p_task_name` | varchar2 | — | Ja | Der Name der Berateraufgabe, die deaktiviert werden soll. Der einzige gültige Wert ist `AUTO_STATS_ADVISOR_TASK`. |
Der folgenden Befehl wird verworfen: `AUTO_STATS_ADVISOR_TASK`.
```
EXEC rdsadmin.rdsadmin_util.advisor_task_drop('AUTO_STATS_ADVISOR_TASK')
```
Sie können `AUTO_STATS_ADVISOR_TASK` unter Verwendung von `rdsadmin.rdsadmin_util.dbms_stats_init` erneut aktivieren.
### Erneutes Aktivieren von AUTO\$1STATS\$1ADVISOR\$1TASK
Um `AUTO_STATS_ADVISOR_TASK` wieder zu aktivieren, verwenden Sie das Amazon-RDS-Verfahren `rdsadmin.rdsadmin_util.dbms_stats_init`. Die `dbms_stats_init`-Prozedur verwendet keine Parameter.
Der folgende Befehl reaktiviert `AUTO_STATS_ADVISOR_TASK`.
```
EXEC rdsadmin.rdsadmin_util.dbms_stats_init()
```
# Transport von Tabellenbereichen
Verwenden Sie das Amazon-RDS-Paket `rdsadmin.rdsadmin_transport_util`, um eine Reihe von Tabellenbereichen aus einer On-Premises-Oracle-Datenbank auf eine DB-Instance von RDS für Oracle zu kopieren. Auf physischer Ebene kopiert die Funktion für transportable Tabellenbereiche inkrementell Quelldatendateien und Metadatendateien auf Ihre Ziel-Instance. Sie können die Dateien entweder mit Amazon EFS oder mit Amazon S3 übertragen. Weitere Informationen finden Sie unter [Migrieren mithilfe von Oracle Transportable Tablespaces](oracle-migrating-tts.md).
**Topics**
+ [
# Importieren transportabler Tabellenbereiche in Ihre DB-Instance
](rdsadmin_transport_util_import_xtts_tablespaces.md)
+ [
# Importieren von Metadaten transportabler Tabellenbereiche in Ihre DB-Instance
](rdsadmin_transport_util_import_xtts_metadata.md)
+ [
# Auflisten verwaister Dateien nach einem Tabellenbereichimport
](rdsadmin_transport_util_list_xtts_orphan_files.md)
+ [
# Löschen verwaister Dateien nach einem Tabellenbereichimport
](rdsadmin_transport_util_cleanup_incomplete_xtts_import.md)
# Importieren transportabler Tabellenbereiche in Ihre DB-Instance
Verwenden Sie das Verfahren `rdsadmin.rdsadmin_transport_util.import_xtts_tablespaces`, um Tabellenbereiche wiederherzustellen, die Sie zuvor aus einer Quell-DB-Instance exportiert haben. In der Transportphase sichern Sie Ihre schreibgeschützten Tabellenbereiche und exportieren Data-Pump-Metadaten, übertragen diese Dateien auf Ihre Ziel-DB-Instance und importieren dann die Tabellenbereiche. Weitere Informationen finden Sie unter [Phase 4: Transportieren der Tabellenbereiche](oracle-migrating-tts.md#oracle-migrating-tts.final-br-phase).
## Syntax
```
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
****
| Parametername | Datentyp | Standard | Erforderlich | Beschreibung |
| --- | --- | --- | --- | --- |
| `p_tablespace_list` | `CLOB` | — | Ja | Die Liste der zu importierenden Tabellenbereiche. |
| `p_directory_name` | `VARCHAR2` | — | Ja | Das Verzeichnis, das die Backups der Tabellenbereiche enthält. |
| `p_platform_id` | `NUMBER` | `13` | Nein | Geben Sie eine Plattform-ID an, die mit der in der Backup-Phase angegebenen ID übereinstimmt. Fragen Sie `V$TRANSPORTABLE_PLATFORM` ab, um eine Liste der Plattformen zu finden. Die Standardplattform ist Linux x86 64-Bit, was das Little-Endian-Format ist. |
| `p_parallel` | `INTEGER` | `0` | Nein | Der Grad der Parallelität. In der Standardeinstellung ist Parallelität deaktiviert. |
## Beispiele
Im folgenden Beispiel werden die Tablespaces *TBS1**TBS2*, und *TBS3* aus dem Verzeichnis importiert. *DATA\$1PUMP\$1DIR* Die Quellplattform ist ein AIX-basiertes System (64-Bit) mit der Plattform-ID `6`. Sie können die Plattform finden, IDs indem Sie sie abfragen. `V$TRANSPORTABLE_PLATFORM`
```
VAR task_id CLOB
BEGIN
:task_id:=rdsadmin.rdsadmin_transport_util.import_xtts_tablespaces(
'TBS1,TBS2,TBS3',
'DATA_PUMP_DIR',
p_platform_id => 6);
END;
/
PRINT task_id
```
# Importieren von Metadaten transportabler Tabellenbereiche in Ihre DB-Instance
Verwenden Sie das Verfahren `rdsadmin.rdsadmin_transport_util.import_xtts_metadata`, um Metadaten transportabler Tabellenbereiche in Ihre DB-Instance von RDS für Oracle zu importieren. Während des Vorgangs wird der Status des Metadatenimports in der Tabelle `rdsadmin.rds_xtts_operation_info` angezeigt. Weitere Informationen finden Sie unter [Schritt 5: Importieren der Tabellenbereich-Metadaten in Ihre Ziel-DB-Instance](oracle-migrating-tts.md#oracle-migrating-tts.transport.import-dmp).
## Syntax
```
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
****
| Parametername | Datentyp | Standard | Erforderlich | Beschreibung |
| --- | --- | --- | --- | --- |
| `p_datapump_metadata_file` | `SYS.DBA_DATA_FILES.FILE_NAME%TYPE` | — | Ja | Der Name der Oracle-Data-Pump-Datei, die die Metadaten für Ihre transportablen Tabellenbereiche enthält. |
| `p_directory_name` | `VARCHAR2` | — | Ja | Das Verzeichnis, das die Data-Pump-Datei enthält. |
| `p_exclude_stats` | `BOOLEAN` | `FALSE` | Nein | Flag, das angibt, ob Statistiken ausgeschlossen werden sollen. |
| `p_remap_tablespace_list` | `CLOB` | NULL | Nein | Eine Liste von Tabellenbereichen, die beim Metadatenimport neu zugeordnet werden sollen. Verwenden Sie dabei das Format `from_tbs:to_tbs`. Geben Sie beispielsweise `users:user_data` an. |
| `p_remap_user_list` | `CLOB` | NULL | Nein | Eine Liste von Benutzerschemata, die beim Metadatenimport neu zugeordnet werden sollen. Verwenden Sie dabei das Format `from_schema_name:to_schema_name`. Geben Sie beispielsweise `hr:human_resources` an. |
## Beispiele
Das Beispiel importiert die Tablespace-Metadaten aus der Datei*xttdump.dmp*, die sich im Verzeichnis *DATA\$1PUMP\$1DIR* befindet.
```
BEGIN
rdsadmin.rdsadmin_transport_util.import_xtts_metadata('xttdump.dmp','DATA_PUMP_DIR');
END;
/
```
# Auflisten verwaister Dateien nach einem Tabellenbereichimport
Verwenden Sie das Verfahren `rdsadmin.rdsadmin_transport_util.list_xtts_orphan_files`, um Datendateien aufzulisten, die nach einem Tabellenbereichimport verwaist waren. Nachdem Sie die Datendateien identifiziert haben, können Sie sie löschen, indem Sie `rdsadmin.rdsadmin_transport_util.cleanup_incomplete_xtts_import` aufrufen.
## Syntax
```
FUNCTION list_xtts_orphan_files RETURN xtts_orphan_files_list_t PIPELINED;
```
## Beispiele
Das folgende Beispiel führt die Prozedur `rdsadmin.rdsadmin_transport_util.list_xtts_orphan_files` aus. Die Ausgabe zeigt zwei verwaiste Datendateien.
```
SQL> SELECT * FROM TABLE(rdsadmin.rdsadmin_transport_util.list_xtts_orphan_files);
FILENAME FILESIZE
-------------- ---------
datafile_7.dbf 104865792
datafile_8.dbf 104865792
```
# Löschen verwaister Dateien nach einem Tabellenbereichimport
Verwenden Sie das Verfahren `rdsadmin.rdsadmin_transport_util.list_xtts_orphan_files`, um Datendateien zu löschen, die nach einem Tabellenbereichimport verwaist waren. Wenn Sie diesen Befehl ausführen, wird eine Protokolldatei generiert, die das Namensformat `rds-xtts-delete_xtts_orphaned_files-YYYY-MM-DD.HH24-MI-SS.FF.log` im Verzeichnis `BDUMP` verwendet. Verwenden Sie das Verfahren `rdsadmin.rdsadmin_transport_util.cleanup_incomplete_xtts_import`, um die verwaisten Dateien zu finden. Sie können die Protokolldatei lesen, indem Sie das Verfahren `rdsadmin.rds_file_util.read_text_file` aufrufen. Weitere Informationen finden Sie unter [Phase 6: Bereinigen übrig gebliebener Dateien](oracle-migrating-tts.md#oracle-migrating-tts.cleanup).
## Syntax
```
PROCEDURE cleanup_incomplete_xtts_import(
p_directory_name IN VARCHAR2);
```
## Parameters
****
| Parametername | Datentyp | Standard | Erforderlich | Beschreibung |
| --- | --- | --- | --- | --- |
| `p_directory_name` | `VARCHAR2` | — | Ja | Das Verzeichnis, das die verwaisten Datendateien enthält. |
## Beispiele
Im folgenden Beispiel werden die verwaisten Datendateien in gelöscht. *DATA\$1PUMP\$1DIR*
```
BEGIN
rdsadmin.rdsadmin_transport_util.cleanup_incomplete_xtts_import('DATA_PUMP_DIR');
END;
/
```
Das folgende Beispiel liest die durch den vorherigen Befehl generierte Protokolldatei.
```
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.
```