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.
# Verwendung nativer Db2-Tools zur Migration von Daten von Db2 zu Amazon RDS für Db2
Mit verschiedenen nativen Db2-Tools, -Dienstprogrammen und -Befehlen können Sie Daten direkt von einer Db2-Datenbank zu einer Datenbank von Amazon RDS für Db2 verschieben. Um diese systemeigenen Db2-Tools verwenden zu können, müssen Sie in der Lage sein, Ihren Client-Computer mit einer DB-Instance von RDS für Db2 zu verbinden. Weitere Informationen finden Sie unter [Verbinden eines Client-Computers mit einer DB-Instance von Amazon RDS für Db2](db2-connecting-client-rds.md).
**Anmerkung**
Eine andere Möglichkeit, Ihre Daten zu verschieben, besteht darin, sie zuerst in einem Amazon-S3-Bucket zu speichern und dann den `LOAD`-Befehl zu verwenden, um diese Daten in eine Tabelle in Ihrer Datenbank von RDS für Db2 zu übertragen. Diese Methode bietet aufgrund der guten Netzwerkkonnektivität zwischen RDS für Db2 und S3 die beste Leistung bei der Migration großer Datenmengen. Weitere Informationen finden Sie unter [Migrieren von Db2-Daten über Amazon S3 zu Amazon RDS für Db2](db2-migration-load-from-s3.md).
| Name des Tools | Anwendungsfall | Einschränkungen |
| --- | --- | --- |
| [db2look](db2-native-db2-tools-db2look.md) | Kopieren von Metadaten aus einer selbstverwalteten Db2-Datenbank in eine Datenbank von RDS für Db2 | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/db2-native-db2-tools.html) |
| [IMPORT](db2-native-db2-tools-import.md)-Befehl | Migrieren kleiner Tabellen und Tabellen mit großen Objekten (LOBs) von einem Client-Computer zur DB-Instance von RDS für Db2. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/db2-native-db2-tools.html) |
| [Dienstprogramm INGEST](db2-native-db2-tools-ingest.md) | Kontinuierliches Streamen von Daten aus Dateien und Pipes *ohne* große Objekte (LOBs) auf dem Client-Computer zur DB-Instance von RDS für Db2. Unterstützt die Operationen `INSERT` und `MERGE`. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/db2-native-db2-tools.html) |
| [INSERT](db2-native-db2-tools-insert.md)-Befehl | Kopieren von Daten in kleinen Tabellen aus einer selbstverwalteten Db2-Datenbank in eine Datenbank von RDS für Db2 | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/db2-native-db2-tools.html) |
| [LOAD CLIENT](db2-native-db2-tools-load.md)-Befehl | Migrieren kleiner Tabellen *ohne* große Objekte (LOBs) von einem Client-Computer zur DB-Instance von RDS für Db2. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/db2-native-db2-tools.html) |
# Verbinden eines Client-Computers mit einer DB-Instance von Amazon RDS für Db2
Um eines der nativen Db2-Tools zum Verschieben von Daten aus einer Db2-Datenbank in eine Datenbank von Amazon RDS für Db2 zu verwenden, müssen Sie zuerst Ihren Client-Computer mit einer DB-Instance von RDS für Db2 verbinden.
Beim Client-Computer kann es sich um folgende handeln:
+ Amazon Elastic Compute Cloud (Amazon EC2)-Instance auf Linux, Windows oder macOS. Diese Instance sollte sich in derselben Virtual Private Cloud (VPC) wie Ihre RDS for Db2-DB-Instance befinden AWS Cloud9, oder. AWS CloudShell
+ Selbstverwaltete Db2-Instance in einer Amazon-EC2-Instance. Die Instances sollten sich in derselben VPC befinden.
+ Selbstverwaltete Db2-Instance in einer Amazon-EC2-Instance. Die Instanzen können unterschiedlich sein, VPCs wenn Sie VPC-Peering aktiviert haben. Weitere Informationen finden Sie unter [Erstellen einer VPC-Peering-Verbindung](https://docs.aws.amazon.com/vpc/latest/peering/create-vpc-peering-connection.html) im *Handbuch zu Amazon Virtual Private Cloud (VPC)-Peering*.
+ Lokaler Computer, der Linux, Windows oder macOS in einer selbstverwalteten Umgebung ausführt. Sie müssen entweder über eine öffentliche Verbindung zu RDS für Db2 verfügen oder die VPN-Konnektivität zwischen selbstverwalteten Db2-Instances und AWS aktivieren.
Um Ihren Client-Computer mit Ihrer DB-Instance von RDS für Db2 zu verbinden, melden Sie sich bei Ihrem Client-Computer mit IBM Db2 Data Management Console an. Weitere Informationen erhalten Sie unter [Erstellen einer Amazon-RDS-DB-Instance](USER_CreateDBInstance.md) und [IBM Db2 Data Management Console](db2-connecting-with-ibm-data-management-console.md).
Sie können AWS Database Migration Service (AWS DMS) verwenden, um Abfragen in der Datenbank auszuführen, einen SQL-Ausführungsplan auszuführen und die Datenbank zu überwachen. Weitere Informationen finden Sie unter [Was ist der AWS Database Migration Service?](https://docs.aws.amazon.com/dms/latest/userguide/Welcome.html) im *AWS Database Migration Service Benutzerhandbuch*.
Nachdem Sie Ihren Client-Computer erfolgreich mit Ihrer DB-Instance von RDS für Db2 verbunden haben, können Sie jedes native Db2-Tool zum Kopieren von Daten verwenden. Weitere Informationen finden Sie unter [Verwendung nativer Db2-Tools zur Migration von Daten von Db2 zu Amazon RDS für Db2](db2-native-db2-tools.md).
# Kopieren von Datenbank-Metadaten von Db2 nach Amazon RDS für Db2 mit db2look
`db2look` ist ein systemeigenes Db2-Tool, das DDL-Dateien, Objekte, Autorisierungen, Konfigurationen, WLM und Datenbanklayouts extrahiert. Sie können `db2look` verwenden, um Datenbank-Metadaten aus einer selbstverwalteten Db2-Datenbank in eine Datenbank von Amazon RDS für Db2 zu kopieren. Weitere Informationen finden Sie unter [Mimicking databases using db2look](https://www.ibm.com/docs/en/db2/11.5?topic=tools-db2look) in der IBM Db2-Dokumentation.
**So kopieren Sie Datenbank-Metadaten**
1. Führen Sie das Tool `db2look` auf Ihrem selbstverwalteten Db2-System aus, um die DDL-Datei zu extrahieren. Ersetzen Sie im folgenden Beispiel *database\$1name* durch den Namen Ihrer Db2-Datenbank.
```
db2look -d database_name -e -l -a -f -wlm -cor -createdb -printdbcfg -o db2look.sql
```
1. Wenn Ihr Client-Computer Zugriff auf die (selbstverwaltete Db2-)Quelldatenbank und die DB-Instance von RDS für Db2 hat, können Sie die Datei `db2look.sql` auf dem Client-Computer erstellen, indem Sie sie direkt an die Remote-Instance anhängen. Katalogisieren Sie anschließend die selbstverwaltete Db2-Remote-Instance.
1. Katalogisieren Sie den Knoten. Ersetzen Sie im folgenden Beispiel *dns\$1ip\$1address* und *port* durch den DNS-Namen oder die IP-Adresse und die Portnummer der selbstverwalteten Db2-Datenbank.
```
db2 catalog tcpip node srcnode REMOTE dns_ip_address server port
```
1. Katalogisieren Sie die Datenbank. Ersetzen Sie im folgenden Beispiel *source\$1database\$1name* und *source\$1database\$1alias* durch den Namen der selbstverwalteten Db2-Datenbank und den Alias, den Sie für diese Datenbank verwenden möchten.
```
db2 catalog database source_database_name as source_database_alias at node srcnode \
authentication server_encrypt
```
1. Hängen Sie sie an die Quelldatenbank an. Ersetzen Sie im folgenden Beispiel *source\$1database\$1alias*, *user\$1id* und *user\$1password* durch den Alias, den Sie im vorherigen Schritt erstellt haben, sowie durch die Benutzer-ID und das Kennwort für die selbstverwaltete Db2-Datenbank.
```
db2look -d source_database_alias -i user_id -w user_password -e -l -a -f -wlm \
-cor -createdb -printdbcfg -o db2look.sql
```
1. Wenn Sie vom Client-Computer aus nicht auf die selbstverwaltete Db2-Remote-Datenbank zugreifen können, kopieren Sie die Datei `db2look.sql` auf den Client-Computer. Katalogisieren Sie dann die DB-Instance von RDS für Db2.
1. Katalogisieren Sie den Knoten. Ersetzen Sie im folgenden Beispiel *dns\$1ip\$1address* und *port* durch den DNS-Namen oder die IP-Adresse und die Portnummer der DB-Instance von RDS für Db2.
```
db2 catalog tcpip node remnode REMOTE dns_ip_address server port
```
1. Katalogisieren Sie die Datenbank. Ersetzen Sie im folgenden Beispiel *rds\$1database\$1name* und *rds\$1database\$1alias* durch den Namen der Datenbank von RDS für Db2 und den Alias, den Sie für diese Datenbank verwenden möchten.
```
db2 catalog database rds_database_name as rds_database_alias at node remnode \
authentication server_encrypt
```
1. Katalogisieren Sie die Admin-Datenbank, die RDS für Db2 verwaltet. Sie können diese Datenbank nicht verwenden, um Daten zu speichern.
```
db2 catalog database rdsadmin as rdsadmin at node remnode authentication server_encrypt
```
1. Erstellen Sie Pufferpools und Tablespaces. Der Administrator hat keine Rechte zum Erstellen von Pufferpools oder Tablespaces. Sie können jedoch gespeicherte Amazon-RDS-Prozeduren verwenden, um sie zu erstellen.
1. Suchen Sie in der Datei `db2look.sql` nach den Namen und Definitionen der Pufferpools und Tablespaces.
1. Stellen Sie mithilfe des Hauptbenutzernamens und Hauptpassworts für Ihre DB-Instance von RDS für Db2 eine Verbindung zu Amazon RDS 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)"
```
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')"
```
1. Wiederholen Sie die Schritte c oder d für jeden zusätzlichen Pufferpool oder Tablespace, den Sie hinzufügen möchten.
1. Beenden Sie Ihre Verbindung.
```
db2 terminate
```
1. Erstellen Sie Tabellen und Objekte.
1. Stellen Sie mithilfe des Hauptbenutzernamens und Hauptpassworts für Ihre DB-Instance von RDS für Db2 eine Verbindung zur Ihrer Datenbank von RDS für Db2 her. Ersetzen Sie im folgenden Beispiel *rds\$1database\$1name*, *master\$1username* und *master\$1password* durch Ihre Informationen.
```
db2 connect to rds_database_name user master_username using master_password
```
1. Führen Sie die Datei `db2look.sql` aus.
```
db2 -tvf db2look.sql
```
1. Beenden Sie Ihre Verbindung.
```
db2 terminate
```
# Importieren von Daten aus einem Client-Computer in Amazon RDS für Db2 mit dem Befehl IMPORT
Sie können den `IMPORT`-Befehl von einem Client-Computer aus verwenden, um Ihre Daten in den Server von Amazon RDS für Db2 zu importieren.
**Wichtig**
Die Methode per `IMPORT`-Befehl ist hilfreich, um kleine Tabellen zu migrieren und Tabellen, die große Objekte (LOBs) enthalten. Der Befehl `IMPORT` ist aufgrund der Protokollierungsvorgänge `INSERT` und `DELETE` langsamer als das `LOAD`-Dienstprogramm. Wenn Ihre Netzwerkbandbreite zwischen dem Client-Computer und RDS für Db2 begrenzt ist, empfehlen wir Ihnen, einen anderen Migrationsansatz zu verwenden. Weitere Informationen finden Sie unter [Verwendung nativer Db2-Tools zur Migration von Daten von Db2 zu Amazon RDS für Db2](db2-native-db2-tools.md).
**So importieren Sie Daten in den Server von RDS für Db2**
1. Melden Sie sich über die IBM Db2 Data Management Console bei Ihrem Client-Computer an. Weitere Informationen finden Sie unter [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).
1. Katalogisieren Sie die Datenbank von RDS für Db2 auf dem Client-Computer.
1. Katalogisieren Sie den Knoten. Ersetzen Sie im folgenden Beispiel *dns\$1ip\$1address* und *port* durch den DNS-Namen oder die IP-Adresse und die Portnummer der selbstverwalteten Db2-Datenbank.
```
db2 catalog tcpip node srcnode REMOTE dns_ip_address server port
```
1. Katalogisieren Sie die Datenbank. Ersetzen Sie im folgenden Beispiel *source\$1database\$1name* und *source\$1database\$1alias* durch den Namen der selbstverwalteten Db2-Datenbank und den Alias, den Sie für diese Datenbank verwenden möchten.
```
db2 catalog database source_database_name as source_database_alias at node srcnode \
authentication server_encrypt
```
1. Hängen Sie sie an die Quelldatenbank an. Ersetzen Sie im folgenden Beispiel *source\$1database\$1alias*, *user\$1id* und *user\$1password* durch den Alias, den Sie im vorherigen Schritt erstellt haben, sowie durch die Benutzer-ID und das Kennwort für die selbstverwaltete Db2-Datenbank.
```
db2look -d source_database_alias -i user_id -w user_password -e -l -a -f -wlm \
-cor -createdb -printdbcfg -o db2look.sql
```
1. Generieren Sie die Datendatei mithilfe des ` EXPORT`-Befehls auf Ihrem selbstverwalteten Db2-System. Ersetzen Sie im folgenden Beispiel *directory* durch das Verzeichnis auf Ihrem Client-Computer, in dem sich Ihre Datendatei befindet. Ersetzen Sie *file\$1name* und *table\$1name* durch den Namen der Datendatei und den Namen der Tabelle.
```
db2 "export to /directory/file_name.txt of del lobs to /directory/lobs/ \
modified by coldel\| select * from table_name"
```
1. Stellen Sie mithilfe des Hauptbenutzernamens und Hauptpassworts für Ihre DB-Instance von RDS für Db2 eine Verbindung zur Ihrer Datenbank von RDS für Db2 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. Verwenden Sie den `IMPORT`-Befehl, um Daten aus einer Datei auf dem Client-Computer in die Remotedatenbank von RDS für Db2 zu importieren. Weitere Informationen finden Sie in der IBM Db2-Dokumentation unter [IMPORT command](https://www.ibm.com/docs/en/db2/11.5?topic=commands-import). Ersetzen Sie im folgenden Beispiel *directory* und *file\$1name* durch das Verzeichnis auf Ihrem Client-Computer, in dem sich Ihre Datendatei befindet, und durch den Namen der Datendatei. Ersetzen Sie *SCHEMA\$1NAME* und *TABLE\$1NAME* durch den Namen Ihres Schemas und Ihrer Tabelle.
```
db2 "IMPORT from /directory/file_name.tbl OF DEL LOBS FROM /directory/lobs/ \
modified by coldel\| replace into SCHEMA_NAME.TABLE_NAME"
```
1. Beenden Sie Ihre Verbindung.
```
db2 terminate
```
# Importieren von Daten aus einem Client-Computer in Amazon RDS für Db2 mit dem Befehl LOAD
Sie können den `LOAD CLIENT`-Befehl verwenden, um Daten aus einer Datei auf einem Client-Computer auf den Server von RDS für Db2 zu laden. Da keine SSH-Konnektivität zum Server von RDS für Db2 besteht, können Sie den `LOAD CLIENT`-Befehl entweder auf Ihrem selbst verwalteten Db2-Server oder auf Ihrem Db2-Client-Computer verwenden.
**Wichtig**
Die Methode per `LOAD CLIENT`-Befehl ist nützlich für die Migration kleiner Tabellen. Wenn Ihre Netzwerkbandbreite zwischen dem Client und RDS für Db2 begrenzt ist, empfehlen wir Ihnen, einen anderen Migrationsansatz zu verwenden. Weitere Informationen hierzu finden Sie unter [Verwendung nativer Db2-Tools zur Migration von Daten von Db2 zu Amazon RDS für Db2](db2-native-db2-tools.md).
Wenn Ihre Datendatei Verweise auf große Objektdateinamen enthält, funktioniert der `LOAD`-Befehl nicht, da sich große Objekte (LOBs) auf dem Db2-Server befinden müssen. Wenn Sie versuchen, LOBs vom Client-Computer auf den Server von RDS für Db2 zu laden, erhalten Sie die Fehlermeldung SQL3025N. Verwenden Sie stattdessen den [IMPORT Befehl](db2-native-db2-tools-import.md).
**So laden Sie Daten in den Server von RDS für Db2**
1. Melden Sie sich über die IBM Db2 Data Management Console bei Ihrem Client-Computer an. Weitere Informationen finden Sie unter [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).
1. Katalogisieren Sie die Datenbank von RDS für Db2 auf dem Client-Computer.
1. Katalogisieren Sie den Knoten. Ersetzen Sie im folgenden Beispiel *dns\$1ip\$1address* und *port* durch den DNS-Namen oder die IP-Adresse und die Portnummer der selbstverwalteten Db2-Datenbank.
```
db2 catalog tcpip node srcnode REMOTE dns_ip_address server port
```
1. Katalogisieren Sie die Datenbank. Ersetzen Sie im folgenden Beispiel *source\$1database\$1name* und *source\$1database\$1alias* durch den Namen der selbstverwalteten Db2-Datenbank und den Alias, den Sie für diese Datenbank verwenden möchten.
```
db2 catalog database source_database_name as source_database_alias at node srcnode \
authentication server_encrypt
```
1. Hängen Sie sie an die Quelldatenbank an. Ersetzen Sie im folgenden Beispiel *source\$1database\$1alias*, *user\$1id* und *user\$1password* durch den Alias, den Sie im vorherigen Schritt erstellt haben, sowie durch die Benutzer-ID und das Kennwort für die selbstverwaltete Db2-Datenbank.
```
db2look -d source_database_alias -i user_id -w user_password -e -l -a -f -wlm \
-cor -createdb -printdbcfg -o db2look.sql
```
1. Generieren Sie die Datendatei mithilfe des `EXPORT`-Befehls auf Ihrem selbstverwalteten Db2-System. Ersetzen Sie im folgenden Beispiel *directory* durch das Verzeichnis auf Ihrem Client-Computer, in dem sich Ihre Datendatei befindet. Ersetzen Sie *file\$1name* und *TABLE\$1NAME* durch den Namen der Datendatei und den Namen der Tabelle.
```
db2 "export to /directory/file_name.txt of del modified by coldel\| \
select * from TPCH.TABLE_NAME"
```
1. Stellen Sie mithilfe des Hauptbenutzernamens und Hauptpassworts für Ihre DB-Instance von RDS für Db2 eine Verbindung zur Ihrer Datenbank von RDS für Db2 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. Verwenden Sie den `LOAD`-Befehl, um Daten aus einer Datei auf dem Client-Computer in die Remotedatenbank von RDS für Db2 zu laden. Weitere Informationen finden Sie in der IBM Db2-Dokumentation unter [LOAD command](https://www.ibm.com/docs/en/db2/11.5?topic=commands-load). Ersetzen Sie im folgenden Beispiel *directory* durch das Verzeichnis auf Ihrem Client-Computer, in dem sich Ihre Datendatei befindet. Ersetzen Sie *file\$1name* und *TABLE\$1NAME* durch den Namen der Datendatei und den Namen der Tabelle.
```
db2 "LOAD CLIENT from /directory/file_name.txt \
modified by coldel\| replace into TPCH.TABLE_NAME \
nonrecoverable without prompting"
```
1. Beenden Sie Ihre Verbindung.
```
db2 terminate
```
# Importieren von Daten aus Db2 in Amazon RDS für Db2 mit dem Befehl INSERT
Sie können den Befehl `INSERT` von einem selbstverwalteten Db2-Server aus verwenden, um Ihre Daten in eine Datenbank von Amazon RDS für Db2 einzufügen. Bei diesem Migrationsansatz verwenden Sie einen Spitznamen für die Remote-DB-Instance von RDS für Db2. Ihre selbstverwaltete Db2-Datenbank (Quelle) muss in der Lage sein, eine Verbindung zur Datenbank (Ziel) von RDS für Db2 herzustellen.
**Wichtig**
Die Methode per `INSERT`-Befehl ist nützlich für die Migration kleiner Tabellen. Wenn Ihre Netzwerkbandbreite zwischen Ihrer selbst verwalteten Db2-Datenbank und der Datenbank von RDS für Db2 begrenzt ist, empfehlen wir Ihnen, einen anderen Migrationsansatz zu verwenden. Weitere Informationen finden Sie unter [Verwendung nativer Db2-Tools zur Migration von Daten von Db2 zu Amazon RDS für Db2](db2-native-db2-tools.md).
**So kopieren Sie Daten aus einer selbstverwalteten Db2-Datenbank in eine Datenbank von RDS für Db2**
1. Katalogisieren Sie die DB-Instance von RDS für Db2 auf der selbstverwalteten Db2-Instance.
1. Katalogisieren Sie den Knoten. Ersetzen Sie im folgenden Beispiel *dns\$1ip\$1address* und *port* durch den DNS-Namen oder die IP-Adresse und die Portnummer der selbstverwalteten Db2-Datenbank.
```
db2 catalog tcpip node remnode REMOTE dns_ip_address SERVER port
```
1. Katalogisieren Sie die Datenbank. Ersetzen Sie im folgenden Beispiel *rds\$1database\$1name* durch den Namen der Datenbank auf Ihrer DB-Instance von RDS für Db2.
```
db2 catalog database rds_database_name as remdb at node remnode \
authentication server_encrypt
```
1. Aktivieren Sie „Verbund“ auf der selbstverwalteten Db2-Instance. Ersetzen Sie im folgenden Beispiel *source\$1database\$1name* durch den Namen Ihrer Datenbank auf der selbstverwalteten Db2-Instance.
```
db2 update dbm cfg using FEDERATED YES source_database_name
```
1. Erstellen Sie Tabellen auf der DB-Instance von RDS für Db2.
1. Katalogisieren Sie den Knoten. Ersetzen Sie im folgenden Beispiel *dns\$1ip\$1address* und *port* durch den DNS-Namen oder die IP-Adresse und die Portnummer der selbstverwalteten Db2-Datenbank.
```
db2 catalog tcpip node srcnode REMOTE dns_ip_address server port
```
1. Katalogisieren Sie die Datenbank. Ersetzen Sie im folgenden Beispiel *source\$1database\$1name* und *source\$1database\$1alias* durch den Namen der selbstverwalteten Db2-Datenbank und den Alias, den Sie für diese Datenbank verwenden möchten.
```
db2 catalog database source_database_name as source_database_alias at node srcnode \
authentication server_encrypt
```
1. Hängen Sie sie an die Quelldatenbank an. Ersetzen Sie im folgenden Beispiel *source\$1database\$1alias*, *user\$1id* und *user\$1password* durch den Alias, den Sie im vorherigen Schritt erstellt haben, sowie durch die Benutzer-ID und das Kennwort für die selbstverwaltete Db2-Datenbank.
```
db2look -d source_database_alias -i user_id -w user_password -e -l -a -f -wlm \
-cor -createdb -printdbcfg -o db2look.sql
```
1. Richten Sie die Verbundoption ein und erstellen Sie auf der selbstverwalteten Db2-Instance einen Spitznamen für die Datenbanktabelle von RDS für Db2.
1. Stellen Sie eine Verbindung mit Ihrer lokalen Datenbank her. Ersetzen Sie im folgenden Beispiel *source\$1database\$1name* durch den Namen der Datenbank auf Ihrer selbstverwalteten Db2-Instance.
```
db2 connect to source_database_name
```
1. Erstellen Sie einen Wrapper für den Zugriff auf Db2-Datenquellen.
```
db2 create wrapper drda
```
1. Definieren Sie eine Datenquelle in einer Verbunddatenbank. Ersetzen Sie im folgenden Beispiel *admin* und *admin\$1password* durch Ihre Anmeldeinformationen für Ihre selbstverwaltete Db2-Instance. Ersetzen Sie *rds\$1database\$1name* durch den Namen der Datenbank auf Ihrer DB-Instance von RDS für Db2.
```
db2 "create server rdsdb2 type DB2/LUW version '11.5.9.0' \
wrapper drda authorization "admin" password "admin_password" \
options( dbname 'rds_database_name', node 'remnode')"
```
1. Ordnen Sie die Benutzer in den beiden Datenbanken zu. Ersetzen Sie im folgenden Beispiel *master\$1username* und *master\$1password* durch die Anmeldeinformationen für Ihre DB-Instance von RDS für Db2.
```
db2 "create user mapping for user server rdsdb2 \
options (REMOTE_AUTHID 'master_username', REMOTE_PASSWORD 'master_password')"
```
1. Überprüfen Sie die Verbindung zum Server von RDS für Db2.
```
db2 set passthru rdsdb2
```
1. Erstellen Sie einen Spitznamen für die Tabelle in der Remote-Datenbank von RDS für Db2. Ersetzen Sie im folgenden Beispiel *NICKNAME* und *TABLE\$1NAME* durch einen Spitznamen für die Tabelle und ihren Namen.
```
db2 create nickname REMOTE.NICKNAME for RDSDB2.TABLE_NAME.NICKNAME
```
1. Fügen Sie in die Tabelle in der Remote-Datenbank von RDS für Db2 Daten ein. Verwenden Sie den Spitznamen in einer `select`-Anweisung in der lokalen Tabelle auf der selbstverwalteten Db2-Instance. Ersetzen Sie im folgenden Beispiel *NICKNAME* und *TABLE\$1NAME* durch einen Spitznamen für die Tabelle und ihren Namen.
```
db2 "INSERT into REMOTE.NICKNAME select * from RDS2DB2.TABLE_NAME.NICKNAME"
```
# Importieren von Daten aus Db2 in Amazon RDS für Db2 mit dem Dienstprogramm INGEST
Sie können das Dienstprogramm `INGEST` verwenden, um kontinuierlich Daten aus Dateien und Pipes auf einem Client-Computer zu einer DB-Ziel-Instance von Amazon RDS für Db2 zu streamen. Das Dienstprogramm `INGEST` unterstützt `INSERT`- und `MERGE`-Operationen. Weitere Informationen finden Sie in der IBM Db2-Dokumentation unter [Ingest utility](https://www.ibm.com/docs/en/db2/11.1?topic=reference-ingest-utility).
Da das Dienstprogramm `INGEST` Spitznamen unterstützt, können Sie es verwenden, um Daten aus Ihrer selbstverwalteten Db2-Datenbank in eine Datenbank von RDS für Db2 zu übertragen. Dieser Ansatz funktioniert, solange Netzwerkkonnektivität zwischen den beiden Datenbanken besteht.
**Wichtig**
Das Dienstprogramm `INGEST` unterstützt keine großen Objekte (LOBs). Verwenden Sie stattdessen den [`IMPORT`-Befehl](db2-native-db2-tools-import.md).
Um das Feature `RESTARTABLE` des Dienstprogramms `INGEST` zu verwenden, führen Sie den folgenden Befehl in der Datenbank von RDS für Db2 aus.
```
db2 "call sysproc.sysinstallobjects(‘INGEST’,‘C’,NULL,NULL)"
```