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.
# Verwalten Ihrer DB-Instance von Amazon RDS für Db2
Dieses Thema behandelt die häufigsten Verwaltungsaufgaben, die Sie mit einer DB-Instance von Amazon RDS für Db2 ausführen. Einige Aufgaben sind für alle DB-Instances von Amazon RDS gleich. Andere Aufgaben sind spezifisch für RDS für Db2.
Die folgenden Aufgaben sind für alle RDS-Datenbanken gleich. Es gibt auch spezielle Aufgaben für RDS für Db2, z. B. die Verbindung zu einer Datenbank von RDS für Db2 mit einem Standard-SQL-Client.
| 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. | [](Concepts.DBInstanceClass.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 Sie AWS-Konto über eine standardmäßige Virtual Private Cloud (VPC) verfügen, 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. | [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** Da Ihre DB-Instance von RDS für Db2 erfordert, dass Sie die Parameter `rds.ibm_customer_id` und `rds.ibm_site_id` hinzufügen, erstellen Sie vor der DB-Instance eine Parametergruppe. Wenn Ihre DB-Instance weitere spezifische Datenbankparameter erfordert, fügen Sie diese ebenfalls zu dieser Parametergruppe hinzu, bevor Sie die DB-Instance erstellen. | [Hinzufügen IBM IDs zu einer Parametergruppe für RDS für Db2-DB-Instances](db2-licensing.md#db2-licensing-options-byol-adding-ids) [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. | [Optionen für DB-Instances von Amazon RDS für Db2](Db2.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 standardmäßigen SQL-Client-Anwendung wie IBM Db2 CLP eine Verbindung mit dieser DB-Instance herstellen. | [Herstellen einer Verbindung mit Ihrer Db2-DB-Instance](USER_ConnectToDb2DBInstance.md) |
| **Backup und Wiederherstellung** Sie können Ihre DB-Instance so konfigurieren, dass sie automatische Speicher-Backups oder manuelle Speicher-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 DB-Instance von RDS für Db2 mit IBM Db2 Data Management Console überwachen. Sie können eine RDS for Db2-DB-Instance auch mithilfe von CloudWatch Amazon RDS-Metriken, Ereignissen und erweiterter Überwachung überwachen. | [Herstellen einer Verbindung zu Ihrer DB-Instance von RDS für Db2 mit IBM Db2 Data Management Console](db2-connecting-with-ibm-data-management-console.md) [Anzeigen von Metriken in der Amazon-RDS-Konsole](USER_Monitoring.md) [Anzeigen von Amazon-RDS-Ereignissen](USER_ListEvents.md) [Überwachen von Betriebssystem-Metriken mithilfe von „Enhanced Monitoring“·(Erweiterte·Überwachung)](USER_Monitoring.OS.md) |
| **Protokolldateien** Sie können auf die Protokolldateien für Ihre DB-Instance von RDS für Db2 zugreifen. | [Überwachen von Amazon RDS-Protokolldateien](USER_LogAccess.md) |
**Topics**
+ [Ausführen allgemeiner Systemaufgaben für DB-Instances von Amazon RDS für Db2](db2-performing-common-system-tasks-db-instances.md)
+ [Ausführen allgemeiner Datenbank-Aufgaben für DB-Instances von Amazon RDS für Db2](db2-performing-common-database-tasks-db-instances.md)
# Ausführen allgemeiner Systemaufgaben für DB-Instances von Amazon RDS für Db2
Sie können bestimmte allgemeine Datenbankadministrator-Aufgaben durchführen, die mit dem System auf Ihren DB-Instances von Amazon RDS zusammenhängen, die Db2 ausführen. 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.
Informationen zum Gewähren und Widerrufen von Berechtigungen und zum Anhängen an die Remote-Datenbank für RDS für Db2 finden Sie in den folgenden Themen.
**Topics**
+ [Gewähren und Widerrufen von Berechtigungen für RDS für Db2](db2-granting-revoking-privileges.md)
+ [Anfügen an die Remote-DB-Instance von RDS für Db2](db2-attaching-to-remote.md)
## Erstellen eines benutzerdefinierten Datenbank-Endpunkts
Wenn Sie zu Amazon RDS for Db2 migrieren, können Sie einen benutzerdefinierten Datenbank-Endpunkt verwenden, URLs um Änderungen an Ihrer Anwendung zu minimieren. Wenn Sie beispielsweise `db2.example.com` als Ihren aktuellen DNS-Eintrag verwenden, können Sie ihn zu Amazon Route 53 hinzufügen. In Route 53 können Sie private gehostete Zonen verwenden, um Ihren aktuellen DNS-Datenbankendpunkt einem Datenbankendpunkt von RDS für Db2 zuzuordnen. Informationen zum Hinzufügen eines benutzerdefinierten `A`- oder `CNAME`-Datensatzes für einen Datenbankendpunkt von Amazon RDS finden Sie unter [Registrierung und Management von Domains mit Amazon Route 53](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/registrar.html) im *Entwicklerhandbuch zu Amazon Route 53*.
**Anmerkung**
Wenn Sie Ihre Domain nicht auf Route 53 übertragen können, können Sie Ihren DNS-Anbieter verwenden, um einen `CNAME`-Eintrag für die Datenbankendpunkt-URL von RDS für Db2 zu erstellen. Schlagen Sie dazu in der Dokumentation Ihres DNS-Anbieters nach.
# Gewähren und Widerrufen von Berechtigungen für RDS für Db2
Benutzer erhalten Zugriff auf Datenbanken, wenn sie Mitglied von Gruppen sind, die Datenbanken zugeordnet sind.
Gehen Sie wie folgt vor, um Berechtigungen zu gewähren oder zu widerrufen und somit den Zugriff auf Ihre Datenbank zu steuern.
Bei diesen Verfahren wird IBM Db2 CLP auf einem lokalen Computer verwendet, um eine Verbindung zu einer DB-Instance von RDS für Db2 herzustellen. Achten Sie darauf, den TCPIP-Knoten und die Datenbank zu katalogisieren, um eine Verbindung zu Ihrer DB-Instance von RDS für Db2 herzustellen, die auf Ihrem lokalen Computer ausgeführt wird. Weitere Informationen finden Sie unter [Herstellen einer Verbindung zu Ihrer DB-Instance von RDS für Db2 mit IBM Db2 CLP](db2-connecting-with-clp-client.md).
**Topics**
+ [Gewähren von Benutzerzugriff auf Ihre Datenbank](#db2-granting-user-access)
+ [Ändern des Passworts eines Benutzers](#db2-changing-user-password)
+ [Hinzufügen von Gruppen zu einem Benutzer](#db2-adding-group-to-user)
+ [Entfernen von Gruppen von einem Benutzer](#db2-removing-groups-from-user)
+ [Entfernen eines Benutzers](#db2-removing-user)
+ [Auflisten von Benutzern](#db2-listing-users-database)
+ [Erstellen einer Rolle](#db2-creating-role)
+ [Gewähren einer Rolle](#db2-granting-role)
+ [Widerrufen einer Rolle](#db2-revoking-role)
+ [Entfernen einer Rolle](#db2-dropping-role)
+ [Gewähren einer Datenbankautorisierung](#db2-granting-dbadmin-auth)
+ [Widerrufen der Datenbankautorisierung](#db2-revoking-dbadmin-auth)
## Gewähren von Benutzerzugriff auf Ihre Datenbank
**So gewähren Sie einem Benutzer Zugriff auf Ihre 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
```
Die Ausgabe dieses Befehls sieht etwa so aus:
```
Database Connection Information
Database server = DB2/LINUXX8664 11.5.8.0
SQL authorization ID = ADMIN
Local database alias = RDSADMIN
```
1. Fügen Sie Ihrer Autorisierungsliste einen Benutzer hinzu, indem Sie `rdsadmin.add_user` aufrufen. Weitere Informationen finden Sie unter [rdsadmin.add\$1user](db2-sp-granting-revoking-privileges.md#db2-sp-add-user).
```
db2 "call rdsadmin.add_user(
'username',
'password',
'group_name,group_name')"
```
1. (Optional) Fügen Sie dem Benutzer weitere Gruppen hinzu, indem Sie `rdsadmin.add_groups` aufrufen. Weitere Informationen finden Sie unter [rdsadmin.add\$1groups](db2-sp-granting-revoking-privileges.md#db2-sp-add-groups).
```
db2 "call rdsadmin.add_groups(
'username',
'group_name,group_name')"
```
1. Bestätigen Sie die Berechtigungen, die dem Benutzer zur Verfügung stehen. Ersetzen Sie im folgenden Beispiel *rds\$1database\$1alias**master\$1user*, und *master\$1password* durch Ihre eigenen Informationen. Ersetzen Sie es auch *username* durch den Benutzernamen des Benutzers.
```
db2 terminate
db2 connect to rds_database_alias user master_user using master_password
db2 "SELECT SUBSTR(AUTHORITY,1,20) AUTHORITY, D_USER, D_GROUP, D_PUBLIC
FROM TABLE (SYSPROC.AUTH_LIST_AUTHORITIES_FOR_AUTHID ('username', 'U') ) AS T
ORDER BY AUTHORITY"
```
Die Ausgabe dieses Befehls sieht etwa so aus:
```
AUTHORITY D_USER D_GROUP D_PUBLIC
-------------------- ------ ------- --------
ACCESSCTRL N N N
BINDADD N N N
CONNECT N N N
CREATETAB N N N
CREATE_EXTERNAL_ROUT N N N
CREATE_NOT_FENCED_RO N N N
CREATE_SECURE_OBJECT N N N
DATAACCESS N N N
DBADM N N N
EXPLAIN N N N
IMPLICIT_SCHEMA N N N
LOAD N N N
QUIESCE_CONNECT N N N
SECADM N N N
SQLADM N N N
SYSADM * N *
SYSCTRL * N *
SYSMAINT * N *
SYSMON * N *
WLMADM N N N
```
1. Gewähren Sie der Gruppe, zu der Sie den Benutzer hinzugefügt haben, die Rollen `ROLE_NULLID_PACKAGES`, `ROLE_TABLESPACES` und `ROLE_PROCEDURES` von RDS für Db2. Weitere Informationen finden Sie unter [Standardrollen in Amazon RDS für Db2](db2-default-roles.md).
**Anmerkung**
Wir erstellen DB-Instances von RDS für Db2 im `RESTRICTIVE`-Modus. Daher gewähren die Rollen `ROLE_NULLID_PACKAGES`, `ROLE_TABLESPACES` und `ROLE_PROCEDURES` von RDS für Db2 Ausführungsberechtigungen für `NULLID`-Pakete für IBM Db2 CLP und Dynamic SQL. Diese Rollen gewähren auch Benutzerberechtigungen für Tablespaces.
1. Stellen Sie eine Verbindung zu Ihrer Db2-Datenbank her. Ersetzen Sie im folgenden Beispiel *database\$1name**master\$1user*, und *master\$1password* durch Ihre eigenen Informationen.
```
db2 connect to database_name user master_user using master_password
```
1. Gewähren Sie einer Gruppe die Rolle `ROLE_NULLED_PACKAGES`. Ersetzen Sie im folgenden Beispiel *group\$1name* durch den Namen der Gruppe, zu der Sie die Rolle hinzufügen möchten.
```
db2 "grant role ROLE_NULLID_PACKAGES to group group_name"
```
1. Gewähren Sie derselben Gruppe die Rolle `ROLE_TABLESPACES`. Im folgenden Beispiel *group\$1name* ersetzen Sie es durch den Namen der Gruppe, zu der Sie die Rolle hinzufügen möchten.
```
db2 "grant role ROLE_TABLESPACES to group group_name"
```
1. Gewähren Sie derselben Gruppe die Rolle `ROLE_PROCEDURES`. Im folgenden Beispiel *group\$1name* ersetzen Sie es durch den Namen der Gruppe, zu der Sie die Rolle hinzufügen möchten.
```
db2 "grant role ROLE_PROCEDURES to group group_name"
```
1. Gewähren Sie der Gruppe, zu der Sie den Benutzer hinzugefügt haben, die Berechtigungen `connect`, `bindadd`, `createtab` und `IMPLICIT_SCHEMA`. Im folgenden Beispiel *group\$1name* ersetzen Sie es durch den Namen der zweiten Gruppe, zu der Sie den Benutzer hinzugefügt haben.
```
db2 "grant usage on workload SYSDEFAULTUSERWORKLOAD to public"
db2 "grant connect, bindadd, createtab, implicit_schema on database to group group_name"
```
1. Wiederholen Sie Schritt 4–6 für jede weitere Gruppe, zu der Sie den Benutzer hinzugefügt haben.
1. Testen Sie den Zugriff des Benutzers, indem Sie als Benutzer eine Verbindung herstellen, eine Tabelle erstellen, Werte in die Tabelle einfügen und Daten aus der Tabelle zurückgeben. Ersetzen Sie im folgenden Beispiel *rds\$1database\$1alias**username*, und *password* durch den Namen der Datenbank sowie den Benutzernamen und das Passwort des Benutzers.
```
db2 connect to rds_database_alias user username using password
db2 "create table t1(c1 int not null)"
db2 "insert into t1 values (1),(2),(3),(4)"
db2 "select * from t1"
```
## Ändern des Passworts eines Benutzers
**So ändern Sie das Passwort eines Benutzers**
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. Ändern Sie das Passwort, indem Sie `rdsadmin.change_password` aufrufen. Weitere Informationen finden Sie unter [rdsadmin.change\$1password](db2-sp-granting-revoking-privileges.md#db2-sp-change-password).
```
db2 "call rdsadmin.change_password(
'username',
'new_password')"
```
## Hinzufügen von Gruppen zu einem Benutzer
**So fügen Sie Gruppen zu einem Benutzer hinzu**
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ügen Sie einem Benutzer Gruppen hinzu, indem Sie `rdsadmin.add_groups` aufrufen. Weitere Informationen finden Sie unter [rdsadmin.add\$1groups](db2-sp-granting-revoking-privileges.md#db2-sp-add-groups).
```
db2 "call rdsadmin.add_groups(
'username',
'group_name,group_name')"
```
## Entfernen von Gruppen von einem Benutzer
**So entfernen Sie Gruppen von einem Benutzer**
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. Entfernen Sie Gruppen, indem Sie `rdsadmin.remove_groups` aufrufen. Weitere Informationen finden Sie unter [rdsadmin.remove\$1groups](db2-sp-granting-revoking-privileges.md#db2-sp-remove-groups).
```
db2 "call rdsadmin.remove_groups(
'username',
'group_name,group_name')"
```
## Entfernen eines Benutzers
**So entfernen Sie einen Benutzer aus der Autorisierungsliste**
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. Entfernen Sie einen Benutzer aus Ihrer Autorisierungsliste, indem Sie `rdsadmin.remove_user` aufrufen. Weitere Informationen finden Sie unter [rdsadmin.remove\$1user](db2-sp-granting-revoking-privileges.md#db2-sp-remove-user).
```
db2 "call rdsadmin.remove_user('username')"
```
## Auflisten von Benutzern
Rufen Sie die gespeicherte Prozedur `rdsadmin.list_users` auf, um Benutzer in einer Autorisierungsliste aufzulisten. Weitere Informationen finden Sie unter [rdsadmin.list\$1users](db2-sp-granting-revoking-privileges.md#db2-sp-list-users).
```
db2 "call rdsadmin.list_users()"
```
## Erstellen einer Rolle
Sie können die gespeicherte Prozedur [rdsadmin.create\$1role](db2-sp-granting-revoking-privileges.md#db2-sp-create-role) verwenden, um eine Rolle zu erstellen.
**So erstellen Sie eine Rolle**
1. Stellen Sie eine Verbindung zur Datenbank `rdsadmin` her. Ersetzen Sie im folgenden Beispiel *master\$1username* und *master\$1password* durch Ihre Informationen.
```
db2 connect to rdsadmin user master_username using master_password
```
1. Stellen Sie Db2 für die Ausgabe von Inhalten ein.
```
db2 set serveroutput on
```
1. Erstellen Sie eine Rolle. Weitere Informationen finden Sie unter [rdsadmin.create\$1role](db2-sp-granting-revoking-privileges.md#db2-sp-create-role).
```
db2 "call rdsadmin.create_role(
'database_name',
'role_name')"
```
1. Stellen Sie Db2 so ein, dass kein Inhalt ausgegeben wird.
```
db2 set serveroutput off
```
## Gewähren einer Rolle
Sie können die gespeicherte Prozedur [rdsadmin.grant\$1role](db2-sp-granting-revoking-privileges.md#db2-sp-grant-role) verwenden, um einer Rolle, einem Benutzer oder einer Gruppe eine Rolle zuzuweisen.
**So weisen Sie eine Rolle zu**
1. Stellen Sie eine Verbindung zur Datenbank `rdsadmin` her. Ersetzen Sie im folgenden Beispiel *master\$1username* und *master\$1password* durch Ihre Informationen.
```
db2 connect to rdsadmin user master_username using master_password
```
1. Stellen Sie Db2 für die Ausgabe von Inhalten ein.
```
db2 set serveroutput on
```
1. Weisen Sie eine Rolle zu. Weitere Informationen finden Sie unter [rdsadmin.grant\$1role](db2-sp-granting-revoking-privileges.md#db2-sp-grant-role).
```
db2 "call rdsadmin.grant_role(
'database_name',
'role_name',
'grantee',
'admin_option')"
```
1. Stellen Sie Db2 so ein, dass kein Inhalt ausgegeben wird.
```
db2 set serveroutput off
```
## Widerrufen einer Rolle
Sie können die gespeicherte Prozedur [rdsadmin.revoke\$1role](db2-sp-granting-revoking-privileges.md#db2-sp-revoke-role) verwenden, um eine Rolle für eine Rolle, einen Benutzer oder eine Gruppe zu widerrufen.
**So widerrufen Sie eine Rolle**
1. Stellen Sie eine Verbindung zur Datenbank `rdsadmin` her. Ersetzen Sie im folgenden Beispiel *master\$1username* und *master\$1password* durch Ihre Informationen.
```
db2 connect to rdsadmin user master_username using master_password
```
1. Widerrufen Sie eine Rolle. Weitere Informationen finden Sie unter [rdsadmin.revoke\$1role](db2-sp-granting-revoking-privileges.md#db2-sp-revoke-role).
```
db2 "call rdsadmin.revoke_role(
?,
'database_name',
'role_name',
'grantee')"
```
## Entfernen einer Rolle
Sie können die gespeicherte Prozedur [rdsadmin.drop\$1role](db2-sp-granting-revoking-privileges.md#db2-sp-drop-role) verwenden, um eine Rolle zu entfernen.
**So entfernen Sie eine Rolle**
1. Stellen Sie eine Verbindung zur Datenbank `rdsadmin` her. Ersetzen Sie im folgenden Beispiel *master\$1username* und *master\$1password* durch Ihre Informationen.
```
db2 connect to rdsadmin user master_username using master_password
```
1. Entfernen Sie eine Rolle. Weitere Informationen finden Sie unter [rdsadmin.drop\$1role](db2-sp-granting-revoking-privileges.md#db2-sp-drop-role).
```
db2 "call rdsadmin.drop_role(
?,
'database_name',
'role_name')"
```
## Gewähren einer Datenbankautorisierung
Der Hauptbenutzer, der über eine `DBADM`-Autorisierung verfügt, kann einer Rolle, einem Benutzer oder einer Gruppe die Berechtigung `DBADM`, `ACCESSCTRL` oder `DATAACCESS` gewähren.
**So gewähren Sie eine Datenbankautorisierung**
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. Gewähren Sie einem Benutzer Zugriff, indem Sie `rdsadmin.dbadm_grant` aufrufen. Weitere Informationen finden Sie unter [rdsadmin.dbadm\$1grant](db2-sp-granting-revoking-privileges.md#db2-sp-dbadm-grant).
```
db2 "call rdsadmin.dbadm_grant(
?,
'database_name,
'authorization',
'grantee')"
```
**Beispiel für einen Anwendungsfall**
Das folgende Verfahren führt Sie durch das Erstellen einer Rolle, das Gewähren der Berechtigung `DBADM` für die Rolle, das Zuweisen der Rolle zu einem Benutzer und das Gewähren der Rolle für eine Gruppe.
****
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 Rolle namens `PROD_ROLE` für eine Datenbank namens `TESTDB`. Weitere Informationen finden Sie unter [rdsadmin.create\$1role](db2-sp-granting-revoking-privileges.md#db2-sp-create-role).
```
db2 "call rdsadmin.create_role(
'TESTDB',
'PROD_ROLE')"
```
1. Weisen Sie die Rolle dann einem Benutzer namens `PROD_USER` zu. `PROD_USER` erhält die Administratorberechtigung zur Zuweisung von Rollen. Weitere Informationen finden Sie unter [rdsadmin.grant\$1role](db2-sp-granting-revoking-privileges.md#db2-sp-grant-role).
```
db2 "call rdsadmin.grant_role(
?,
'TESTDB',
'PROD_ROLE',
'USER PROD_USER',
'Y')"
```
1. (Optional) Geben Sie zusätzliche Autorisierungen oder Berechtigungen ein. Im folgenden Beispiel wird einer Rolle namens `PROD_ROLE` die Berechtigung `DBADM` für die Datenbank `FUNDPROD` gewährt. Weitere Informationen finden Sie unter [rdsadmin.dbadm\$1grant](db2-sp-granting-revoking-privileges.md#db2-sp-dbadm-grant).
```
db2 "call rdsadmin.dbadm_grant(
?,
'FUNDPROD',
'DBADM',
'ROLE PROD_ROLE')"
```
1. Beenden Sie Ihre Sitzung.
```
db2 terminate
```
1. Stellen Sie mithilfe des Hauptbenutzernamens und Hauptpassworts für Ihre DB-Instance von RDS für Db2 eine Verbindung zur `TESTDB`-Datenbank her. Ersetzen Sie im folgenden Beispiel *master\$1username* und *master\$1password* durch Ihre eigenen Informationen.
```
db2 connect to TESTDB user master_username using master_password
```
1. Fügen Sie der Rolle weitere Autorisierungen hinzu.
```
db2 "grant connect, implicit_schema on database to role PROD_ROLE"
```
1. Gewähren Sie einer Gruppe die Rolle `PROD_ROLE`.
```
db2 "grant role PROD_ROLE to group PRODGRP"
```
Benutzer, die der Gruppe `PRODGRP` angehören, können jetzt Aktionen wie das Herstellen einer Verbindung zur Datenbank `TESTDB`, das Erstellen von Tabellen oder das Erstellen von Schemas ausführen.
## Widerrufen der Datenbankautorisierung
Der Hauptbenutzer, der über eine `DBADM`-Autorisierung verfügt, kann einer Rolle, einem Benutzer oder einer Gruppe die Berechtigung `DBADM`, `ACCESSCTRL` oder `DATAACCESS` entziehen.
**So widerrufen Sie die Datenbankautorisierung**
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. Widerrufen Sie den Benutzerzugriff, indem Sie `rdsadmin.dbadm_revoke` aufrufen. Weitere Informationen finden Sie unter [rdsadmin.dbadm\$1revoke](db2-sp-granting-revoking-privileges.md#db2-sp-dbadm-revoke).
```
db2 "call rdsadmin.dbadm_revoke(
?,
'database_name,
'authorization',
'grantee')"
```
# Anfügen an die Remote-DB-Instance von RDS für Db2
Gehen Sie wie folgt vor, um Elemente an Ihre Remote-DB-Instance von RDS für Db2 anzufügen und `get snapshot`-Vorgänge auszuführen.
**So fügen Sie Elemente an die Remote-DB-Instance von RDS für Db2 an**
1. Führen einer clientseitigen IBM Db2 CLP-Sitzung aus. Informationen zur Katalogisierung Ihrer DB-Instance und Datenbank von RDS für Db2 finden Sie unter [Herstellen einer Verbindung zu Ihrer DB-Instance von RDS für Db2 mit IBM Db2 CLP](db2-connecting-with-clp-client.md). Notieren Sie sich den Hauptbenutzernamen und das Hauptpasswort für Ihre DB-Instance von RDS für Db2.
1. Fügen Sie Elemente an die DB-Instance von RDS für DB2 an. Ersetzen Sie im folgenden Beispiel *node\$1name**master\$1username*, und *master\$1password* durch den TCPIP-Knotennamen, den Sie katalogisiert haben, sowie den Master-Benutzernamen und das Master-Passwort für Ihre RDS for Db2-DB-Instance.
```
db2 attach to node_name user master_username using master_password
```
Nachdem Sie die Anbindung an die Remote-DB-Instance von RDS für Db2 durchgeführt haben, können Sie die folgenden Befehle und andere `get snapshot`-Befehle ausführen. Weitere Informationen finden Sie in der IBM Db2-Dokumentation unter [GET SNAPSHOT command](https://www.ibm.com/docs/en/db2/11.5?topic=commands-get-snapshot).
```
db2 list applications
db2 get snapshot for all databases
db2 get snapshot for database manager
db2 get snapshot for all applications
```
# Ausführen allgemeiner Datenbank-Aufgaben für DB-Instances von Amazon RDS für Db2
Sie können bestimmte allgemeine DBA-Aufgaben durchführen, die mit den Datenbanken auf Ihren DB-Instances von Amazon RDS für Db2 zusammenhängen. Um eine verwaltete Service-Erfahrung zu bieten, ermöglicht Amazon RDS keinen Shell-Zugriff auf DB-Instances. Außerdem kann der Hauptbenutzer keine Befehle oder Dienstprogramme ausführen, für die `SYSADM`-, `SYSMAINT`- oder `SYSCTRL`-Berechtigungen erforderlich sind.
Weitere Informationen zu allgemeinen Aufgaben für Pufferpools, Datenbanken und Tablespaces finden Sie in den folgenden Themen.
**Topics**
+ [Allgemeine Aufgaben für Pufferpools](db2-managing-buffer-pools.md)
+ [Häufige Aufgaben in Bezug auf Datenbanken](db2-managing-databases.md)
+ [Häufige Aufgaben in Bezug auf Tablespaces](db2-managing-tablespaces.md)
# Allgemeine Aufgaben für Pufferpools
Sie können Pufferpools für eine Datenbank von RDS für Db2 erstellen, ändern oder entfernen. Das Erstellen, Ändern oder Entfernen von Pufferpools erfordert eine höhere `SYSADM`- oder `SYSCTRL`-Autoritätsebene, die dem Hauptbenutzer nicht zur Verfügung steht. Verwenden Sie stattdessen gespeicherte Amazon-RDS-Prozeduren.
Sie können Pufferpools auch leeren.
**Topics**
+ [Erstellen eines Pufferpools](#db2-creating-buffer-pool)
+ [Ändern eines Pufferpools](#db2-altering-buffer-pool)
+ [Entfernen eines Pufferpools](#db2-dropping-buffer-pool)
+ [Leeren der Pufferpools](#db2-flushing-buffer-pools)
## Erstellen eines Pufferpools
Rufen Sie die gespeicherte Prozedur `rdsadmin.create_bufferpool` auf, um einen Pufferpool für Ihre Datenbank von RDS für Db2 zu erstellen. Weitere Informationen finden Sie in der IBM Db2-Dokumentation unter [CREATE BUFFERPOOL statement](https://www.ibm.com/docs/en/db2/11.5?topic=statements-create-bufferpool).
**So erstellen Sie einen Pufferpool**
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 Informationen.
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. Erstellen Sie einen Pufferpool, 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',
'buffer_pool_name',
buffer_pool_size,
'immediate',
'automatic',
page_size,
number_block_pages,
block_size)"
```
## Ändern eines Pufferpools
Rufen Sie die gespeicherte Prozedur `rdsadmin.alter_bufferpool` auf, um einen Pufferpool für Ihre Datenbank von RDS für Db2 zu ändern. Weitere Informationen finden Sie in der IBM Db2-Dokumentation unter [ALTER BUFFERPOOL statement](https://www.ibm.com/docs/en/db2/11.5?topic=statements-alter-bufferpool).
**So ändern Sie einen Pufferpool**
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 Informationen.
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. Ändern Sie einen Pufferpool, indem Sie `rdsadmin.alter_bufferpool` aufrufen. Weitere Informationen finden Sie unter [rdsadmin.alter\$1bufferpool](db2-sp-managing-buffer-pools.md#db2-sp-alter-buffer-pool).
```
db2 "call rdsadmin.alter_bufferpool(
'database_name',
'buffer_pool_name',
buffer_pool_size,
'immediate',
'automatic',
change_number_blocks,
number_block_pages,
block_size)"
```
## Entfernen eines Pufferpools
Rufen Sie die gespeicherte Prozedur `rdsadmin.drop_bufferpool` auf, um einen Pufferpool für Ihre Datenbank von RDS für Db2 zu entfernen. Weitere Informationen finden Sie unter [Dropping buffer pools](https://www.ibm.com/docs/en/db2/11.5?topic=pools-dropping-buffer) in der IBM Db2-Dokumentation.
**Wichtig**
Stellen Sie sicher, dass dem Pufferpool, den Sie entfernen möchten, keine Tablespaces zugewiesen sind.
**So entfernen Sie einen Pufferpool**
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 Informationen.
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. Entfernen Sie einen Pufferpool, indem Sie `rdsadmin.drop_bufferpool` aufrufen. Weitere Informationen finden Sie unter [rdsadmin.drop\$1bufferpool](db2-sp-managing-buffer-pools.md#db2-sp-drop-buffer-pool).
```
db2 "call rdsadmin.drop_bufferpool(
'database_name',
'buffer_pool_name')"
```
## Leeren der Pufferpools
Sie können die Pufferpools leeren, um einen Prüfpoint zu erzwingen, sodass RDS für Db2 Seiten aus dem Arbeitsspeicher in den Speicher schreibt.
**Anmerkung**
Sie müssen die Pufferpools nicht leeren. Db2 schreibt Protokolle synchron, bevor es Transaktionen bestätigt. Die modifizierten Seiten befinden sich möglicherweise noch in einem Pufferpool, aber Db2 schreibt sie asynchron in den Speicher. Selbst wenn das System unerwartet heruntergefahren wird, führt Db2 beim Neustart der Datenbank automatisch eine Wiederherstellung nach einem Absturz durch. Während der Wiederherstellung nach einem Absturz schreibt Db2 festgeschriebene Änderungen in die Datenbank oder macht Änderungen für nicht festgeschriebene Transaktionen rückgängig.
**So leeren Sie die Pufferpools**
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 *rds\$1database\$1alias*, *master\$1username* und *master\$1password* durch Ihre Informationen.
```
db2 connect to rds_database_alias user master_username using master_password
```
1. Leeren Sie die Pufferpools.
```
db2 flush bufferpools all
```
# 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')"
```
## Verwalten des Speichers
Db2 verwendet automatischen Speicher, um den physischen Speicher für Datenbankobjekte wie Tabellen, Indizes und temporäre Dateien zu verwalten. Anstatt Speicherplatz manuell zuzuweisen und zu verfolgen, welche Speicherpfade verwendet werden, ermöglicht die automatische Speicherung dem Db2-System, Speicherpfade nach Bedarf zu erstellen und zu verwalten. Dies kann die Verwaltung von Db2-Datenbanken vereinfachen und die Wahrscheinlichkeit von Problemen aufgrund menschlicher Fehler verringern. Weitere Informationen finden Sie unter [Automatic storage](https://www.ibm.com/docs/en/db2/11.5?topic=overview-automatic-storage) in der IBM Db2-Dokumentation.
Mit RDS für Db2 können Sie die Speichergröße dynamisch erhöhen, indem Sie die logischen Volumes und das Dateisystem automatisch erweitern. Weitere Informationen finden Sie unter [Arbeiten mit Speicher für Amazon RDS-DB-Instances](USER_PIOPS.StorageTypes.md).
# Häufige Aufgaben in Bezug auf Tablespaces
Sie können Tablespaces für eine Datenbank von RDS für Db2 erstellen, ändern, umbenennen oder löschen. Das Erstellen, Ändern, Umbenennen oder Löschen von Tablespaces erfordert eine höhere `SYSADM`-Autoritätsebene, die dem Hauptbenutzer nicht zur Verfügung stehen. Verwenden Sie stattdessen gespeicherte Amazon-RDS-Prozeduren.
**Topics**
+ [Erstellen eines Tablespaces](#db2-creating-tablespace)
+ [Ändern eines Tablespaces](#db2-altering-tablespace)
+ [Umbenennen eines Tablespaces](#db2-renaming-tablespace)
+ [Löschen eines Tablespaces](#db2-dropping-tablespace)
+ [Prüfen des Status eines Tablespaces](#db2-checking-tablespaces-procedure)
+ [Generieren detaillierter Informationen zu Tablespaces](#db2-tablespaces-info-db2pd)
+ [Auflisten des Status und der Speichergruppe für einen Tablespace](#db2-state-storage-group-tablespace-sql)
+ [Auflisten der Tablespaces einer Tabelle](#db2-return-tablespaces-sql)
+ [Auflisten von Tablespace-Containern](#db2-listing-tablespace-containers)
## Erstellen eines Tablespaces
Rufen Sie die gespeicherte Prozedur `rdsadmin.create_tablespace` auf, um einen Tablespace für Ihre Datenbank von RDS für Db2 zu erstellen. Weitere Informationen finden Sie in der IBM Db2-Dokumentation unter [CREATE TABLESPACE statement](https://www.ibm.com/docs/en/db2/11.5?topic=statements-create-tablespace).
**Wichtig**
Um einen Tablespace zu erstellen, müssen Sie über einen Pufferpool mit derselben Seitengröße verfügen, den Sie mit dem Tablespace verknüpfen können. Weitere Informationen finden Sie unter [Allgemeine Aufgaben für Pufferpools](db2-managing-buffer-pools.md).
**So erstellen Sie einen Tablespace**
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 Tablespace, 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',
'tablespace_name',
'buffer_pool_name',
tablespace_initial_size,
tablespace_increase_size,
'tablespace_type')"
```
## Ändern eines Tablespaces
Rufen Sie die gespeicherte Prozedur `rdsadmin.alter_tablespace` auf, um einen Tablespace für Ihre Datenbank von RDS für Db2 zu ändern. Sie können diese gespeicherte Prozedur verwenden, um den Pufferpool eines Tablespaces zu ändern, die sogenannte „High Water Mark“ zu senken oder einen Tablespace online zu schalten. Weitere Informationen finden Sie in der IBM Db2-Dokumentation unter [ALTER TABLESPACE statement](https://www.ibm.com/docs/en/db2/11.5?topic=statements-alter-tablespace).
**So ändern Sie einen Tablespace**
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. Ändern Sie einen Tablespace, indem Sie `rdsadmin.alter_tablespace` aufrufen. Weitere Informationen finden Sie unter [rdsadmin.alter\$1tablespace](db2-sp-managing-tablespaces.md#db2-sp-alter-tablespace).
```
db2 "call rdsadmin.alter_tablespace(
'database_name',
'tablespace_name',
'buffer_pool_name',
buffer_pool_size,
tablespace_increase_size,
'max_size', 'reduce_max',
'reduce_stop',
'reduce_value',
'lower_high_water',
'lower_high_water_stop',
'switch_online')"
```
## Umbenennen eines Tablespaces
Rufen Sie die gespeicherte Prozedur `rdsadmin.rename_tablespace` auf, um den Namen eines Tablespaces für Ihre Datenbank von RDS für Db2 zu ändern. Weitere Informationen finden Sie in der IBM Db2-Dokumentation unter [RENAME TABLESPACE statement](https://www.ibm.com/docs/en/db2/11.5?topic=statements-rename-tablespace).
**So benennen Sie einen Tablespaces um**
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. Benennen Sie einen Tablespace um, indem Sie `rdsadmin.rename_tablespace` aufrufen. Weitere Informationen, einschließlich der Einschränkungen, die für Tablespace-Namen gelten, finden Sie unter [rdsadmin.rename\$1tablespace](db2-sp-managing-tablespaces.md#db2-sp-rename-tablespace).
```
db2 "call rdsadmin.rename_tablespace(
'database_name',
'source_tablespace_name',
'target_tablespace_name')"
```
## Löschen eines Tablespaces
Rufen Sie die gespeicherte Prozedur `rdsadmin.drop_tablespace` auf, um einen Tablespace von Ihrer Datenbank von RDS für Db2 zu löschen. Bevor Sie einen Tablespace löschen, löschen Sie zunächst alle Objekte im Tablespace, z. B. Tabellen, Indizes oder große Objekte (). LOBs Weitere Informationen finden Sie unter [Löschen von Tablespaces](https://www.ibm.com/docs/en/db2/11.5?topic=spaces-dropping-table) in der IBM Db2-Dokumentation.
**So löschen Sie einen Tablespace**
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 durch Ihre *master\$1password* eigenen Informationen.
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. Löschen Sie einen Tablespace, indem Sie `rdsadmin.drop_tablespace` aufrufen. Weitere Informationen finden Sie unter [rdsadmin.drop\$1tablespace](db2-sp-managing-tablespaces.md#db2-sp-drop-tablespace).
```
db2 "call rdsadmin.drop_tablespace(
'database_name',
'tablespace_name')"
```
## Prüfen des Status eines Tablespaces
Sie können den Status eines Tablespaces mithilfe der `cast`-Funktion überprüfen.
**So überprüfen Sie den Status eines Tablespaces**
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 *rds\$1database\$1alias**master\$1username*, und *master\$1password* durch Ihre eigenen Informationen.
```
db2 connect to rds_database_alias user master_username using master_password
```
1. Generieren Sie eine Ausgabe zur Übersicht.
Für eine Ausgabe zur Übersicht:
```
db2 "select cast(tbsp_id as smallint) as tbsp_id,
cast(tbsp_name as varchar(35)) as tbsp_name,
cast(tbsp_type as varchar(3)) as tbsp_type,
cast(tbsp_state as varchar(10)) as state,
cast(tbsp_content_type as varchar(8)) as contents from table(mon_get_tablespace(null,-1)) order by tbsp_id"
```
## Generieren detaillierter Informationen zu Tablespaces
Mithilfe der Funktion `cast` können Sie Informationen über einen Tablespace für ein Mitglied oder alle Mitglieder generieren.
**So generieren Sie detaillierte Informationen zu Tablespaces**
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 *rds\$1database\$1alias**master\$1username*, und *master\$1password* durch Ihre eigenen Informationen.
```
db2 connect to rds_database_alias user master_username using master_password
```
1. Generieren Sie Details zu allen Tablespaces in der Datenbank für ein Mitglied oder für alle Mitglieder.
Für ein Mitglied:
```
db2 "select cast(member as smallint) as member,
cast(tbsp_id as smallint) as tbsp_id,
cast(tbsp_name as varchar(35)) as tbsp_name,
cast(tbsp_type as varchar(3)) as tbsp_type,
cast(tbsp_state as varchar(10)) as state,
cast(tbsp_content_type as varchar(8)) as contents,
cast(tbsp_total_pages as integer) as total_pages,
cast(tbsp_used_pages as integer) as used_pages,
cast(tbsp_free_pages as integer) as free_pages,
cast(tbsp_page_top as integer) as page_hwm,
cast(tbsp_page_size as integer) as page_sz,
cast(tbsp_extent_size as smallint) as extent_sz,
cast(tbsp_prefetch_size as smallint) as prefetch_sz,
cast(tbsp_initial_size as integer) as initial_size,
cast(tbsp_increase_size_percent as smallint) as increase_pct,
cast(storage_group_name as varchar(12)) as stogroup from table(mon_get_tablespace(null,-1)) order by member, tbsp_id "
```
Für alle Mitglieder:
```
db2 "select cast(member as smallint) as member
cast(tbsp_id as smallint) as tbsp_id,
cast(tbsp_name as varchar(35)) as tbsp_name,
cast(tbsp_type as varchar(3)) as tbsp_type,
cast(tbsp_state as varchar(10)) as state,
cast(tbsp_content_type as varchar(8)) as contents,
cast(tbsp_total_pages as integer) as total_pages,
cast(tbsp_used_pages as integer) as used_pages,
cast(tbsp_free_pages as integer) as free_pages,
cast(tbsp_page_top as integer) as page_hwm,
cast(tbsp_page_size as integer) as page_sz,
cast(tbsp_extent_size as smallint) as extent_sz,
cast(tbsp_prefetch_size as smallint) as prefetch_sz,
cast(tbsp_initial_size as integer) as initial_size,
cast(tbsp_increase_size_percent as smallint) as increase_pct,
cast(storage_group_name as varchar(12)) as stogroup from table(mon_get_tablespace(null,-2)) order by member, tbsp_id "
```
## Auflisten des Status und der Speichergruppe für einen Tablespace
Sie können den Status und die Speichergruppe für einen Tablespace auflisten, indem Sie eine SQL-Anweisung ausführen.
Führen Sie die folgende SQL-Anweisung aus, um den Status und die Speichergruppe für einen Tablespace aufzulisten:
```
db2 "SELECT varchar(tbsp_name, 30) as tbsp_name,
varchar(TBSP_STATE, 30) state,
tbsp_type,
varchar(storage_group_name,30) storage_group
FROM TABLE(MON_GET_TABLESPACE('',-2)) AS t"
```
## Auflisten der Tablespaces einer Tabelle
Sie können die Tablespaces für eine Tabelle auflisten, indem Sie eine SQL-Anweisung ausführen.
Führen Sie die folgende SQL-Anweisung aus, um die Tablespaces einer Tabelle aufzulisten. Ersetzen Sie im folgenden Beispiel *SCHEMA\$1NAME* und *TABLE\$1NAME* durch die Namen Ihres Schemas und Ihrer Tabelle:
```
db2 "SELECT
VARCHAR(SD.TBSPACE,30) AS DATA_SPACE,
VARCHAR(SL.TBSPACE,30) AS LONG_SPACE,
VARCHAR(SI.TBSPACE,30) AS INDEX_SPACE
FROM
SYSCAT.DATAPARTITIONS P
JOIN SYSCAT.TABLESPACES SD ON SD.TBSPACEID = P.TBSPACEID
LEFT JOIN SYSCAT.TABLESPACES SL ON SL.TBSPACEID = P.LONG_TBSPACEID
LEFT JOIN SYSCAT.TABLESPACES SI ON SI.TBSPACEID = P.INDEX_TBSPACEID
WHERE
TABSCHEMA = 'SCHEMA_NAME'
AND TABNAME = 'TABLE_NAME'"
```
## Auflisten von Tablespace-Containern
Sie können alle Tablespace-Container oder bestimmte Tablespace-Container auflisten, indem Sie den Befehl `cast` verwenden.
**So listen Sie die Tablespace-Container für einen Tablespace auf**
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 *rds\$1database\$1alias**master\$1username*, und *master\$1password* durch Ihre eigenen Informationen:
```
db2 connect to rds_database_alias user master_username using master_password
```
1. Generieren Sie eine Liste aller Tablespace-Container in der Datenbank oder bestimmter Tablespace-Container.
Für alle Tablespace-Container:
```
db2 "select cast(member as smallint) as member,
cast(tbsp_name as varchar(35)) as tbsp_name,
cast(container_id as smallint) as id,
cast(container_name as varchar(60)) as container_path, container_type as type from table(mon_get_container(null,-2)) order by member,tbsp_id,container_id"
```
Für bestimmte Tablespace-Container:
```
db2 "select cast(member as smallint) as member,
cast(tbsp_name as varchar(35)) as tbsp_name,
cast(container_id as smallint) as id,
cast(container_name as varchar(60)) as container_path, container_type as type from table(mon_get_container('TBSP_1',-2)) order by member, tbsp_id,container_id"
```