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.
# Häufige Aufgaben in Bezug auf Datenbanken
Sie können Datenbanken auf Ihrer DB-Instance von RDS für Db2 erstellen, löschen oder wiederherstellen. Das Erstellen, Löschen oder Wiederherstellen von Datenbanken erfordert eine höhere `SYSADM`-Autoritätsebene, die dem Hauptbenutzer nicht zur Verfügung steht. Verwenden Sie stattdessen gespeicherte Amazon-RDS-Prozeduren.
Sie können auch allgemeine Verwaltungsaufgaben wie Überwachung, Wartung und Erfassung von Informationen über Ihre Datenbanken ausführen.
**Topics**
+ [Erstellen einer Datenbank](#db2-creating-database)
+ [Konfigurieren von Einstellungen für eine Datenbank](#db2-configuring-database)
+ [Ändern von Datenbankparametern](#db2-modifying-db-parameters)
+ [Konfigurieren der Aufbewahrung von Protokollen](#db2-configuring-log-retention)
+ [Auflisten von Protokollinformationen](#db2-listing-log-information)
+ [Verwenden Sie eine fein abgestufte Zugriffskontrolle (FGAC)](#db2-using-fine-grained-access-control)
+ [Deaktivieren einer Datenbank](#db2-deactivating-database)
+ [Aktivieren einer Datenbank](#db2-activating-database)
+ [Reaktivieren einer Datenbank](#db2-reactivating-database)
+ [Löschen einer Datenbank.](#db2-dropping-database)
+ [Sichern einer Datenbank](#db2-backing-up-database)
+ [Archivprotokolle nach Amazon S3 kopieren](#db2-copying-archive-logs-to-s3)
+ [Wiederherstellen einer Datenbank](#db2-restoring-database)
+ [Auflisten von Datenbanken](#db2-listing-databases)
+ [Sammeln von Informationen zu Datenbanken](#db2-collecting-info-db)
+ [Erzwingen, dass Anwendungen von Datenbanken entfernt werden](#db2-forcing-application-off-db)
+ [Generieren von Leistungsberichten](#db2-generating-performance-reports)
## Erstellen einer Datenbank
Rufen Sie die gespeicherte Prozedur `rdsadmin.create_database` auf, um eine Datenbank auf Ihrer DB-Instance von RDS für Db2 zu erstellen. Weitere Informationen finden Sie in der IBM Db2-Dokumentation unter [CREATE DATABASE command](https://www.ibm.com/docs/en/db2/11.5?topic=commands-create-database).
**Anmerkung**
Wenn Sie den Parameter `db2_compatibility_vector` ändern möchten, erledigen Sie dies vor dem Erstellen einer Datenbank. Weitere Informationen finden Sie unter [Festlegen des Parameters db2\$1compatibility\$1vector](db2-known-issues-limitations.md#db2-known-issues-limitations-db2-compatibility-vector).
**So erstellen Sie eine Datenbank**
1. Stellen Sie mithilfe des Hauptbenutzernamens und Hauptpassworts für Ihre DB-Instance von RDS für Db2 eine Verbindung zur `rdsadmin`-Datenbank her. Ersetzen Sie im folgenden Beispiel *master\$1username* und *master\$1password* durch Ihre eigenen Informationen.
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. Erstellen Sie eine Datenbank, indem Sie `rdsadmin.create_database` aufrufen. Weitere Informationen finden Sie unter [rdsadmin.create\$1database](db2-sp-managing-databases.md#db2-sp-create-database).
```
db2 "call rdsadmin.create_database(
'database_name',
'database_page_size',
'database_code_set',
'database_territory',
'database_collation',
'database_autoconfigure_str',
'database_non-restrictive')"
```
1. (Optional) Erstellen Sie weitere Datenbanken, indem Sie für jede Datenbank, die Sie erstellen möchten, `rdsadmin.create_database` aufrufen. Jede Db2-DB-Instance kann bis zu 50 Datenbanken enthalten. Weitere Informationen finden Sie unter [rdsadmin.create\$1database](db2-sp-managing-databases.md#db2-sp-create-database).
```
db2 "call rdsadmin.create_database('database_name')"
```
1. (Optional) Vergewissern Sie sich, dass Ihre Datenbank mithilfe einer der folgenden Methoden erstellt wurde:
+ Rufen Sie die Seite `rdsadmin.list_databases` auf. Weitere Informationen finden Sie unter [rdsadmin.list\$1databases](db2-user-defined-functions.md#db2-udf-list-databases).
+ Führen Sie den folgenden SQL-Befehl aus:
```
db2 "select varchar(r.task_type,25) as task_type, r.database_name,
varchar(r.lifecycle,15) as lifecycle, r.created_at, r.database_name,
varchar(bson_to_json(task_input_params),256) as input_params,
varchar(r.task_output,1024) as task_output
from table(rdsadmin.get_task_status(null,null,'create_database'))
as r order by created_at desc"
```
## Konfigurieren von Einstellungen für eine Datenbank
Rufen Sie die gespeicherte Prozedur `rdsadmin.set_configuration` auf, um die Einstellungen für eine Datenbank auf Ihrer DB-Instance von RDS für Db2 zu konfigurieren. Sie könnten beispielsweise die Anzahl der Puffer oder Puffermanipulatoren konfigurieren, die während eines Wiederherstellungsvorgangs erstellt werden sollen.
**So konfigurieren Sie die Einstellungen für eine Datenbank**
1. Stellen Sie mithilfe des Hauptbenutzernamens und Hauptpassworts für Ihre DB-Instance von RDS für Db2 eine Verbindung zur `rdsadmin`-Datenbank her. Ersetzen Sie im folgenden Beispiel *master\$1username* und *master\$1password* durch Ihre eigenen Informationen.
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. (Optional) Überprüfen Sie Ihre aktuellen Konfigurationseinstellungen, indem Sie `rdsadmin.show_configuration` aufrufen. Weitere Informationen finden Sie unter [rdsadmin.show\$1configuration](db2-sp-managing-databases.md#db2-sp-show-configuration).
```
db2 "call rdsadmin.show_configuration('name')"
```
1. Konfigurieren Sie die Einstellungen für die Datenbank, indem Sie `rdsadmin.set_configuration` aufrufen. Weitere Informationen finden Sie unter [rdsadmin.set\$1configuration](db2-sp-managing-databases.md#db2-sp-set-configuration).
```
db2 "call rdsadmin.set_configuration(
'name',
'value')"
```
## Ändern von Datenbankparametern
In Amazon RDS für Db2 werden drei Typen von Parametern verwendet: Konfigurationsparameter für den Datenbankmanager, Registrierungsvariablen und Datenbankkonfigurationsparameter. Sie können die ersten beiden Typen mithilfe der Parametergruppen und den letzten Typ mithilfe der gespeicherten Prozedur [rdsadmin.update\$1db\$1param](db2-sp-managing-databases.md#db2-sp-update-db-param) aktualisieren.
**Anmerkung**
Sie können nur die Werte vorhandener Parameter ändern. Sie können keine neuen Parameter hinzufügen, die RDS für Db2 nicht unterstützt.
Weitere Informationen zu diesen Parametern und zur Änderung ihrer Werte finden Sie unter [Parameter von Amazon RDS für Db2](db2-supported-parameters.md).
## Konfigurieren der Aufbewahrung von Protokollen
Rufen Sie die gespeicherte Prozedur `rdsadmin.set_archive_log_retention` auf, um zu konfigurieren, wie lange Amazon RDS Protokolldateien für Ihre Datenbank von RDS für Db2 aufbewahrt.
**So konfigurieren die Aufbewahrung von Protokollen für eine Datenbank**
1. Stellen Sie mithilfe des Hauptbenutzernamens und Hauptpassworts für Ihre DB-Instance von RDS für Db2 eine Verbindung zur `rdsadmin`-Datenbank her. Ersetzen Sie im folgenden Beispiel *master\$1username* und *master\$1password* durch Ihre eigenen Informationen.
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. (Optional) Überprüfen Sie Ihre aktuelle Konfiguration für die Aufbewahrung von Protokollen, indem Sie`rdsadmin.show_archive_log_retention` aufrufen. Weitere Informationen finden Sie unter [rdsadmin.show\$1archive\$1log\$1retention](db2-sp-managing-databases.md#db2-sp-show-archive-log-retention).
```
db2 "call rdsadmin.show_archive_log_retention(
?,
'database_name')"
```
1. Konfigurieren Sie die Aufbewahrung von Protokollen für die Datenbank, indem Sie `rdsadmin.set_archive_log_retention` aufrufen. Weitere Informationen finden Sie unter [rdsadmin.set\$1archive\$1log\$1retention](db2-sp-managing-databases.md#db2-sp-set-archive-log-retention).
```
db2 "call rdsadmin.set_archive_log_retention(
?,
'database_name',
'archive_log_retention_hours')"
```
## Auflisten von Protokollinformationen
Rufen Sie die gespeicherte Prozedur `rdsadmin.list_archive_log_information` auf, um Details zu Archivprotokolldateien aufzulisten, einschließlich Angaben zur genutzten Gesamtspeichergröße.
**So listen Sie Protokollinformationen für eine Datenbank auf**
1. Stellen Sie mithilfe des Hauptbenutzernamens und Hauptpassworts für Ihre DB-Instance von RDS für Db2 eine Verbindung zur `rdsadmin`-Datenbank her. Ersetzen Sie im folgenden Beispiel *master\$1username* und *master\$1password* durch Ihre eigenen Informationen.
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. Erhalten Sie eine Liste mit Informationen zu Protokolldateien, indem Sie `rdsadmin.list_archive_log_information` aufrufen. Weitere Informationen finden Sie unter [rdsadmin.list\$1archive\$1log\$1information](db2-sp-managing-databases.md#db2-sp-list-archive-log-information).
```
db2 "call rdsadmin.list_archive_log_information(
?,
'database_name')"
```
## Verwenden Sie eine fein abgestufte Zugriffskontrolle (FGAC)
Rufen Sie die gespeicherte Prozedur auf, um den Zugriff auf Tabellendaten in einer Datenbank auf einer RDS for Db2-DB-Instance mithilfe detaillierter Zugriffskontrollbefehle zu steuern. `rdsadmin.fgac_command` Möglicherweise möchten Sie FGAC verwenden, um den Zugriff auf Daten auf der Grundlage von Benutzerrollen oder Datenattributen zu beschränken. Sie könnten beispielsweise den Zugriff auf Gesundheitsdaten von Patienten auf der Grundlage der Art der Daten oder auf bestimmte medizinische Leistungserbringer einschränken.
**Um den Zugriff auf Tabellendaten in einer Datenbank mithilfe einer detaillierten Zugriffskontrolle zu steuern**
1. Stellen Sie mithilfe des Hauptbenutzernamens und Hauptpassworts für Ihre DB-Instance von RDS für Db2 eine Verbindung zur `rdsadmin`-Datenbank her. Ersetzen Sie im folgenden Beispiel *master\$1username* und *master\$1password* durch Ihre eigenen Informationen.
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. Führen Sie verschiedene detaillierte Befehle zur Zugriffskontrolle aus, indem Sie aufrufen. `rdsadmin.fgac_command` Weitere Informationen finden Sie unter [rdsadmin.fgac\$1commandParameters](db2-sp-managing-databases.md#db2-sp-fgac-command).
```
db2 "call rdsadmin.fgac_command(
?,
'database_name',
'fgac_command')"
```
## Deaktivieren einer Datenbank
Rufen Sie die gespeicherte Prozedur `rdsadmin.deactivate_database` auf, um eine Datenbank auf Ihrer DB-Instance von RDS für Db2 zu deaktivieren.
Standardmäßig aktiviert Amazon RDS die Datenbank, wenn Sie sie auf Ihrer DB-Instance von RDS für Db2 erstellen. Sie können selten verwendete Datenbanken deaktivieren, um Speicherressourcen zu schonen.
**So deaktivieren Sie eine Datenbank**
1. Stellen Sie mithilfe des Hauptbenutzernamens und Hauptpassworts für Ihre DB-Instance von RDS für Db2 eine Verbindung zur `rdsadmin`-Datenbank her. Ersetzen Sie im folgenden Beispiel *master\$1username* und *master\$1password* durch Ihre eigenen Informationen.
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. Deaktivieren Sie eine Datenbank, indem Sie `rdsadmin.deactivate_database` aufrufen. Weitere Informationen finden Sie unter [rdsadmin.deactivate\$1database](db2-sp-managing-databases.md#db2-sp-deactivate-database).
```
db2 "call rdsadmin.deactivate_database(
?,
'database_name')"
```
## Aktivieren einer Datenbank
Rufen Sie die gespeicherte Prozedur `rdsadmin.activate_database` auf, um eine Datenbank auf einer eigenständigen DB-Instance von RDS für Db2 zu aktivieren.
Standardmäßig aktiviert Amazon RDS die Datenbank, wenn Sie sie auf Ihrer DB-Instance von RDS für Db2 erstellen. Sie können selten verwendete Datenbanken deaktivieren, um Speicherressourcen zu schonen, und eine deaktivierte Datenbank später wieder aktivieren.
**So aktivieren Sie eine Datenbank**
1. Stellen Sie mithilfe des Hauptbenutzernamens und Hauptpassworts für Ihre DB-Instance von RDS für Db2 eine Verbindung zur `rdsadmin`-Datenbank her. Ersetzen Sie im folgenden Beispiel *master\$1username* und *master\$1password* durch Ihre eigenen Informationen.
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. Aktivieren Sie eine Datenbank, indem Sie `rdsadmin.activate_database` aufrufen. Weitere Informationen finden Sie unter [rdsadmin.activate\$1database](db2-sp-managing-databases.md#db2-sp-activate-database).
```
db2 "call rdsadmin.activate_database(
?,
'database_name')"
```
## Reaktivieren einer Datenbank
Rufen Sie die gespeicherte Prozedur `rdsadmin.reactivate_database` auf, um eine Datenbank auf einer replizierten Quell-DB-Instance von RDS für Db2 zu reaktivieren. Nachdem Sie Änderungen an den Datenbankkonfigurationen vorgenommen haben, müssen Sie möglicherweise eine Datenbank auf einer DB-Instance von RDS für Db2 erneut aktivieren. Um zu ermitteln, ob Sie eine Datenbank erneut aktivieren müssen, stellen Sie eine Verbindung mit der Datenbank her und führen Sie `db2 get db cfg show detail` aus.
Sie können diese gespeicherte Prozedur auch aufrufen, um eine Datenbank auf einer eigenständigen DB-Instance von RDS für Db2 zu reaktivieren, nachdem Sie Änderungen an den Datenbankkonfigurationen vorgenommen haben. Oder Sie könnten eine Datenbank auf einer eigenständigen DB-Instance von RDS für Db2 reaktivieren, indem Sie zuerst die gespeicherte Prozedur `rdsadmin.deactivate_database` und dann die gespeicherte Prozedur `rdsadmin.activate_database` aufrufen. Weitere Informationen erhalten Sie unter [Deaktivieren einer Datenbank](#db2-deactivating-database) und [Aktivieren einer Datenbank](#db2-activating-database).
**So reaktivieren Sie eine Datenbank**
1. Stellen Sie mithilfe des Hauptbenutzernamens und Hauptpassworts für Ihre DB-Instance von RDS für Db2 eine Verbindung zur `rdsadmin`-Datenbank her. Ersetzen Sie im folgenden Beispiel *master\$1username* und *master\$1password* durch Ihre eigenen Informationen.
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. Reaktivieren Sie eine Datenbank, indem Sie `rdsadmin.reactivate_database` aufrufen. Weitere Informationen finden Sie unter [rdsadmin.reactivate\$1database](db2-sp-managing-databases.md#db2-sp-reactivate-database).
```
db2 "call rdsadmin.reactivate_database(
?,
'database_name')"
```
## Löschen einer Datenbank.
Rufen Sie die gespeicherte Prozedur `rdsadmin.drop_database` auf, um eine Datenbank von Ihrer DB-Instance von RDS für Db2 zu löschen. Weitere Informationen finden Sie unter [Löschen von Datenbanken](https://www.ibm.com/docs/en/db2/11.5?topic=databases-dropping) in der IBM Db2-Dokumentation.
**Anmerkung**
Sie können eine Datenbank nur dann durch Aufrufen der gespeicherten Prozedur löschen, wenn bestimmte Bedingungen erfüllt sind. Weitere Informationen erhalten Sie unter [Nutzungshinweise](db2-sp-managing-databases.md#db2-sp-drop-database-usage-notes) für `rdsadmin.drop_database`.
**So löschen Sie eine Datenbank**
1. Stellen Sie mithilfe des Hauptbenutzernamens und Hauptpassworts für Ihre DB-Instance von RDS für Db2 eine Verbindung zur `rdsadmin`-Datenbank her. Ersetzen Sie im folgenden Beispiel *master\$1username* und *master\$1password* durch Ihre eigenen Informationen.
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. Löschen Sie eine Datenbank, indem Sie `rdsadmin.drop_database` aufrufen. Weitere Informationen finden Sie unter [rdsadmin.drop\$1database](db2-sp-managing-databases.md#db2-sp-drop-database).
```
db2 "call rdsadmin.drop_database('database_name')"
```
## Sichern einer Datenbank
Rufen Sie die `rdsadmin.backup_database` gespeicherte Prozedur auf, um eine Datenbank in Ihrer RDS for Db2-DB-Instance in Amazon S3 zu sichern. Weitere Informationen finden Sie in der IBM Db2 Dokumentation unter [dem Befehl BACKUP DATABASE](https://www.ibm.com/docs/en/db2/11.5.x?topic=commands-backup-database).
**Anmerkung**
Diese gespeicherte Prozedur verwendet die Integration mit Amazon S3. Stellen Sie sicher, dass Sie die Integration konfiguriert haben, bevor Sie fortfahren. Weitere Informationen finden Sie unter [Integration einer DB-Instance von Amazon RDS für Db2 mit Amazon S3](db2-s3-integration.md).
**Um eine Datenbank zu sichern**
1. Stellen Sie mithilfe des Hauptbenutzernamens und Hauptpassworts für Ihre DB-Instance von RDS für Db2 eine Verbindung zur `rdsadmin`-Datenbank her. Ersetzen Sie im folgenden Beispiel *master\$1username* und *master\$1password* durch Ihre eigenen Informationen.
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. Erstellen Sie einen VPC-Gateway-Endpunkt für S3. Wenn Sie bereits einen VPC-Gateway-Endpunkt für S3 haben, fahren Sie mit Schritt 4 fort.
Damit eine RDS for Db2-DB-Instance mit Amazon S3 interagieren kann, benötigen Sie eine VPC und einen Amazon S3 S3-Gateway-Endpunkt für die Nutzung privater Subnetze. Weitere Informationen finden Sie unter [Schritt 1: Erstellen eines VPC-Gateway-Endpunkts für Amazon S3](db2-troubleshooting.md#db2-creating-endpoint).
1. Bestätigen Sie den VPC-Gateway-Endpunkt für S3. Weitere Informationen finden Sie unter [Schritt 2: Überprüfen, ob der VPC-Gateway-Endpunkt für Amazon S3 vorhanden ist](db2-troubleshooting.md#db2-confirming-endpoint).
1. Sichern Sie eine Datenbank, indem Sie anrufen`rdsadmin.backup_database`. Weitere Informationen finden Sie unter [rdsadmin.backup\$1database](db2-sp-managing-databases.md#db2-sp-backup-database).
```
db2 "call rdsadmin.backup_database(
?,
'database_name',
's3_bucket_name',
's3_prefix',
'backup_type',
'compression_option',
'util_impact_priority',
'num_files',
'parallelism',
'num_buffers')"
```
1. Beenden Sie Ihre Verbindung.
```
terminate
```
1. (Optional) Vergewissern Sie sich, dass die Sicherungsdateien in Ihren Amazon S3 S3-Bucket unter hochgeladen wurden*s3\$1prefix/dbi\$1resource\$1id/db\$1name*. Wenn die Dateien nicht unter angezeigt werden*s3\$1prefix/dbi\$1resource\$1id/db\$1name*, überprüfen Sie den Status der Sicherung Ihrer Datenbank, um Probleme zu identifizieren. Weitere Informationen finden Sie unter [rdsadmin.get\$1task\$1status](db2-user-defined-functions.md#db2-udf-get-task-status). Wenn Sie identifizierte Probleme nicht lösen können, wenden Sie sich an den [AWS Support](https://aws.amazon.com/premiumsupport/).
1. (Optional) Nach Abschluss der Sicherung auf Amazon S3 können Sie die Sicherung auf einer RDS for Db2-DB-Instance oder an einem anderen Ort, z. B. einem lokalen Server, wiederherstellen. Informationen zur Wiederherstellung auf einer RDS for Db2-DB-Instance finden Sie unter. [Wiederherstellen einer Datenbank](#db2-restoring-database)
## Archivprotokolle nach Amazon S3 kopieren
Db2-Archivprotokolle können jetzt von Ihrer RDS for Db2-DB-Instance nach Amazon S3 kopiert werden. Die Archivprotokolle `rdsadmin.backup_database` können in Kombination mit dem nativen Backup, das mit erstellt wurde, verwendet werden, um die Datenbank auf einer anderen RDS für Db2-Instance oder EC2-Datenbank wiederherzustellen und zu einem bestimmten Zeitpunkt weiterzuleiten.
Bevor Sie diese Funktion konfigurieren, verwenden Sie die gespeicherte Prozedur, `rdsadmin.backup_database` um RDS für die Db2-Datenbank einzurichten.
Diese Funktion funktioniert auf der DB-Instance-Ebene von RDS for Db2, obwohl das Kopieren von Archivprotokollen pro Datenbank aktiviert oder deaktiviert werden kann.
**So konfigurieren Sie das Kopieren von Archivprotokollen nach Amazon S3**
1. Stellen Sie mithilfe des Master-Benutzernamens und des Master-Passworts für Ihre RDS for Db2-DB-Instance eine Connect zur `rdsadmin` Datenbank her. Ersetzen Sie im folgenden Beispiel *master\$1username* und *master\$1password* durch Ihre eigenen Informationen.
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. Richten Sie die Sicherung des Archivprotokolls auf S3 ein, indem Sie aufrufen[rdsadmin.set\$1configuration](db2-sp-managing-databases.md#db2-sp-set-configuration).
```
db2 "call rdsadmin.set_configuration(
'name',
'value')"
```
**Beispiel:**
```
db2 "call rdsadmin.set_configuration('ARCHIVE_LOG_COPY_TARGET_S3_ARN', 'arn:aws:s3:::my_rds_db2_backups/archive-log-copy/')"
```
1. Aktivieren Sie das Kopieren von Archivprotokollen für eine Datenbank, indem Sie aufrufen`rdsadmin.enable_archive_log_copy`. *database\$1name*Ersetzen Sie es durch Ihren Datenbanknamen.
```
db2 "call rdsadmin.enable_archive_log_copy(?, 'database_name')"
```
1. Rufen Sie auf ähnliche Weise auf, um das Kopieren von Archivprotokollen für eine Datenbank zu deaktivieren`rdsadmin.disable_archive_log_copy`.
```
db2 "call rdsadmin.disable_archive_log_copy(?, 'database_name')"
```
1. Bestätigen Sie den Status des Kopierens des Archivprotokolls, indem Sie anrufen`rdsadmin.list_databases`.
```
db2 "select * from table(rdsadmin.list_databases())"
```
**Beispielausgabe:**
```
DATABASE_NAME CREATE_TIME DATABASE_UNIQUE_ID ARCHIVE_LOG_RETENTION_HOURS ARCHIVE_LOG_COPY ARCHIVE_LOG_LAST_UPLOAD_FILE ARCHIVE_LOG_LAST_UPLOAD_FILE_TIME ARCHIVE_LOG_COPY_STATUS
--------------- -------------------------- -------------------------------------------------- --------------------------- ---------------- ---------------------------- --------------------------------- ------------------------------
RDSADMIN 2026-01-06-02.03.42.569069 RDSADMIN 0 DISABLED - - -
FOO 2026-01-06-02.13.42.885650 F0D81C7E-7213-4565-B376-4F33FCF420E3 7 ENABLED S0006536.LOG 2026-01-28-19.15.10.000000 UPLOADING
CODEP 2026-01-14-19.42.42.508476 106EEF95-6E30-4FFF-85AE-B044352DF095 0 DISABLED - - -
...
```
## Wiederherstellen einer Datenbank
Rufen Sie die gespeicherte Prozedur `rdsadmin.restore_database` auf, um eine Datenbank aus einem Amazon-S3-Bucket in Ihre DB-Instance von RDS für Db2 zu verschieben. Weitere Informationen finden Sie in der IBM Db2-Dokumentation unter [RESTORE DATABASE command](https://www.ibm.com/docs/en/db2/11.5?topic=commands-restore-database).
**So stellen Sie eine Datenbank wieder her**
1. Stellen Sie mithilfe des Hauptbenutzernamens und Hauptpassworts für Ihre DB-Instance von RDS für Db2 eine Verbindung zur `rdsadmin`-Datenbank her. Ersetzen Sie im folgenden Beispiel *master\$1username* und *master\$1password* durch Ihre eigenen Informationen.
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. (Optional) Überprüfen Sie Ihre aktuellen Konfigurationseinstellungen, um den Wiederherstellungsvorgang zu optimieren, indem Sie `rdsadmin.show_configuration` aufrufen. Weitere Informationen finden Sie unter [rdsadmin.show\$1configuration](db2-sp-managing-databases.md#db2-sp-show-configuration).
```
db2 "call rdsadmin.show_configuration('name')"
```
1. Konfigurieren Sie die Einstellungen, um den Wiederherstellungsvorgang zu optimieren, indem Sie `rdsadmin.set_configuration` aufrufen. Das explizite Festlegen dieser Werte kann beim Wiederherstellen von Datenbanken mit großen Datenmengen die Leistung verbessern. Weitere Informationen finden Sie unter [rdsadmin.set\$1configuration](db2-sp-managing-databases.md#db2-sp-set-configuration).
```
db2 "call rdsadmin.set_configuration(
'name',
'value')"
```
1. Stellen Sie die Datenbank wieder her, indem Sie `rdsadmin.restore_database` aufrufen. Weitere Informationen finden Sie unter [rdsadmin.restore\$1database](db2-sp-managing-databases.md#db2-sp-restore-database).
```
db2 "call rdsadmin.restore_database(
?,
'database_name',
's3_bucket_name',
's3_prefix',
restore_timestamp,
'backup_type')"
```
1. (Optional) Vergewissern Sie sich, dass Ihre Datenbank wiederhergestellt wurde, indem Sie `rdsadmin.list_databases` aufrufen und überprüfen, ob die wiederhergestellte Datenbank aufgeführt ist. Weitere Informationen finden Sie unter [rdsadmin.list\$1databases](db2-user-defined-functions.md#db2-udf-list-databases).
1. Schalten Sie die Datenbank wieder online und wenden Sie zusätzliche Transaktionsprotokolle an, indem Sie `rdsadmin.rollforward_database` aufrufen. Weitere Informationen finden Sie unter [rdsadmin.rollforward\$1database](db2-sp-managing-databases.md#db2-sp-rollforward-database).
```
db2 "call rdsadmin.rollforward_database(
?,
'database_name',
's3_bucket_name',
s3_prefix,
'rollforward_to_option',
'complete_rollforward')"
```
1. (Optional) Überprüfen Sie den Status der gespeicherten Prozedur `rdsadmin.rollforward_database`, indem Sie die gespeicherte Prozedur [rdsadmin.rollforward\$1status](db2-sp-managing-databases.md#db2-sp-rollforward-status) aufrufen.
1. Wenn Sie `complete_rollforward` im vorherigen Schritt auf `FALSE` gesetzt haben, müssen Sie die Datenbank abschließend online schalten, indem Sie `rdsadmin.complete_rollforward` aufrufen. Weitere Informationen finden Sie unter [rdsadmin.complete\$1rollforward](db2-sp-managing-databases.md#db2-sp-complete-rollforward).
```
db2 "call rdsadmin.complete_rollforward(
?,
'database_name')"
```
1. (Optional) Überprüfen Sie den Status der gespeicherten Prozedur `rdsadmin.complete_rollforward`, indem Sie die gespeicherte Prozedur [rdsadmin.rollforward\$1status](db2-sp-managing-databases.md#db2-sp-rollforward-status) aufrufen.
## Auflisten von Datenbanken
Sie können alle Datenbanken auflisten, die auf Amazon RDS für Db2 ausgeführt werden, indem Sie die benutzerdefinierte Funktion `rdsadmin.list_databases` aufrufen.
**So listen Sie Ihre Datenbanken auf**
1. Stellen Sie mithilfe des Hauptbenutzernamens und Hauptpassworts für Ihre DB-Instance von RDS für Db2 eine Verbindung zur `rdsadmin`-Datenbank her. Ersetzen Sie im folgenden Beispiel *master\$1username* und *master\$1password* durch Ihre eigenen Informationen.
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. Listen Sie Ihre Datenbanken auf, indem Sie `rdsadmin.list_databases` aufrufen. Weitere Informationen finden Sie unter [rdsadmin.list\$1databases](db2-user-defined-functions.md#db2-udf-list-databases).
```
db2 "select * from table(rdsadmin.list_databases())"
```
## Sammeln von Informationen zu Datenbanken
Rufen Sie die gespeicherte Prozedur `rdsadmin.db2pd_command` auf, um Informationen über eine Datenbank auf einer DB-Instance von RDS für Db2 zu sammeln. Diese Informationen können Ihnen bei der Überwachung Ihrer Datenbanken oder bei der Behebung von Fehlern behilflich sein.
**So sammeln Sie Informationen zu einer Datenbank**
1. Stellen Sie mithilfe des Hauptbenutzernamens und Hauptpassworts für Ihre DB-Instance von RDS für Db2 eine Verbindung zur `rdsadmin`-Datenbank her. Ersetzen Sie im folgenden Beispiel *master\$1username* und *master\$1password* durch Ihre eigenen Informationen.
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. Sammeln Sie Informationen zur Datenbank, indem Sie `rdsadmin.db2pd_command` aufrufen. Weitere Informationen finden Sie unter [rdsadmin.db2pd\$1command](db2-sp-managing-databases.md#db2-sp-db2pd-command).
```
db2 "call rdsadmin.db2pd_command('db2pd_cmd')"
```
## Erzwingen, dass Anwendungen von Datenbanken entfernt werden
Rufen Sie die gespeicherte Prozedur `rdsadmin.force_application` auf, um zu erzwingen, dass Anwendungen aus einer Datenbank auf Ihrer DB-Instance von RDS für Db2 entfernt werden. Bevor Sie Wartungsarbeiten an Ihren Datenbanken durchführen, erzwingen Sie, dass Anwendungen von Ihren Datenbanken entfernt werden.
**So erzwingen Sie, dass Anwendungen aus einer Datenbank entfernt werden**
1. Stellen Sie mithilfe des Hauptbenutzernamens und Hauptpassworts für Ihre DB-Instance von RDS für Db2 eine Verbindung zur `rdsadmin`-Datenbank her. Ersetzen Sie im folgenden Beispiel *master\$1username* und *master\$1password* durch Ihre eigenen Informationen.
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. Erzwingen Sie, dass Anwendungen aus einer Datenbank entfernt werden, indem Sie `rdsadmin.force_application` aufrufen. Weitere Informationen finden Sie unter [rdsadmin.force\$1application](db2-sp-managing-databases.md#db2-sp-force-application).
```
db2 "call rdsadmin.force_application(
?,
'applications')"
```
## Generieren von Leistungsberichten
Sie können Leistungsberichte mithilfe einer Prozedur oder eines Skripts generieren. Informationen zur Verwendung einer Prozedur finden Sie in der IBM Db2-Dokumentation unter [DBSUMMARY procedure – Generate a summary report of system and application performance metrics](https://www.ibm.com/docs/en/db2/11.5?topic=mm-dbsummary-procedure-generate-summary-report-system-application-performance-metrics).
Das Verzeichnis `~sqllib/sample/perf` von Db2 umfasst eine `db2mon.sh`-Datei. Durch die Ausführung des Skripts wird ein kostengünstiger, umfangreicher SQL-Metrikbericht erstellt. Informationen zum Herunterladen der `db2mon.sh`-Datei und der zugehörigen Skriptdateien finden Sie im Verzeichnis [https://github.com/IBM/db2-samples/tree/master/perf](https://github.com/IBM/db2-samples/tree/master/perf) im IBM-GitHub-Repository db2-samples.
**So generieren Sie Leistungsberichte mithilfe des Skripts**
1. Stellen Sie mithilfe des Hauptbenutzernamens und Hauptpassworts für Ihre DB-Instance von RDS für Db2 eine Verbindung zu Ihrer Db2-Datenbank her. Ersetzen Sie im folgenden Beispiel *master\$1username* und *master\$1password* durch Ihre eigenen Informationen.
```
db2 connect to rdsadmin user master_username using master_password
```
1. Erstellen Sie einen Pufferpool mit dem Namen `db2monbp` und einer Seitengröße von 4 096, indem Sie `rdsadmin.create_bufferpool` aufrufen. Weitere Informationen finden Sie unter [rdsadmin.create\$1bufferpool](db2-sp-managing-buffer-pools.md#db2-sp-create-buffer-pool).
```
db2 "call rdsadmin.create_bufferpool('database_name','db2monbp',4096)"
```
1. Erstellen Sie einen temporären Tablespace mit dem Namen `db2montmptbsp`, der den `db2monbp`-Pufferpool verwendet, indem Sie `rdsadmin.create_tablespace` aufrufen. Weitere Informationen finden Sie unter [rdsadmin.create\$1tablespace](db2-sp-managing-tablespaces.md#db2-sp-create-tablespace).
```
db2 "call rdsadmin.create_tablespace('database_name',\
'db2montmptbsp','db2monbp',4096,1000,100,'T')"
```
1. Öffnen Sie das Skript `db2mon.sh` und ändern Sie die Zeile, die sich auf die Verbindung zur Datenbank bezieht.
1. Entfernen Sie die folgende Zeile.
```
db2 -v connect to $dbName
```
1. Ersetzen Sie die Zeile im vorherigen Schritt durch die folgende Zeile. Ersetzen Sie im folgenden Beispiel *master\$1username* und *master\$1password* durch den Master-Benutzernamen und das Master-Passwort für Ihre RDS for Db2-DB-Instance.
```
db2 -v connect to $dbName user master_username using master_password
```
1. Entfernen Sie die folgenden Zeilen.
```
db2 -v create bufferpool db2monbp
db2 -v create user temporary tablespace db2montmptbsp bufferpool db2monbp
db2 -v drop tablespace db2montmptbsp
db2 -v drop bufferpool db2monbp
```
1. Führen Sie das Skript `db2mon.sh` aus, um in bestimmten Intervallen einen Bericht auszugeben. *absolute\$1path*Ersetzen Sie im folgenden Beispiel durch den vollständigen Pfad zur Skriptdatei, *rds\$1database\$1alias* durch den Namen Ihrer Datenbank und *seconds* durch die Anzahl der Sekunden (0 bis 3600) zwischen der Berichtsgenerierung.
```
absolute_path/db2mon.sh rds_database_alias seconds | tee -a db2mon.out
```
**Beispiele**
Das folgende Beispiel zeigt, dass sich die Skriptdatei im Verzeichnis `perf` unter dem Verzeichnis `home` befindet.
```
/home/db2inst1/sqllib/samples/perf/db2mon.sh rds_database_alias seconds | tee -a db2mon.out
```
1. Löschen Sie den Pufferpool und den Tablespace, die für die Datei `db2mon.sh` erstellt wurden. Ersetzen Sie im folgenden Beispiel und durch den Master-Benutzernamen *master\$1username* und *master\$1password* das Master-Passwort für Ihre RDS for Db2-DB-Instance. *database\$1name*Ersetzen Sie durch den Namen Ihrer Datenbank. Weitere Informationen erhalten Sie unter [rdsadmin.drop\$1tablespace](db2-sp-managing-tablespaces.md#db2-sp-drop-tablespace) und [rdsadmin.drop\$1bufferpool](db2-sp-managing-buffer-pools.md#db2-sp-drop-buffer-pool).
```
db2 connect to rdsadmin user master_username using master_password
db2 "call rdsadmin.drop_tablespace('database_name','db2montmptbsp')"
db2 "call rdsadmin.drop_bufferpool('database_name','db2monbp')"
```