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.
# Einrichtung von Oracle AWS Database@-Integrationen mit Amazon Redshift
Gehen Sie wie folgt vor, um die Zero-ETL-Integration zwischen Ihrer Oracle-Datenbank und Amazon Redshift einzurichten:
1. Aktivieren Sie Zero-ETL in Ihrem ODB-Netzwerk.
1. Konfigurieren Sie die Voraussetzungen für die Oracle-Datenbank.
1. Richten Sie AWS Secrets Manager und AWS Key Management Service ein.
1. Konfigurieren Sie IAM-Berechtigungen.
1. Richten Sie Amazon Redshift Redshift-Ressourcenrichtlinien ein.
1. Erstellen Sie die Zero-ETL-Integration.
1. Erstellen Sie die Zieldatenbank in Amazon Redshift.
## Schritt 1: Aktivieren Sie Zero-ETL für Ihr ODB-Netzwerk
Sie können die Zero-ETL-Integration für das ODB-Netzwerk aktivieren, das Ihrem Quell-VM-Cluster zugeordnet ist. Diese Integration ist standardmäßig deaktiviert.
### Konsole
**Um die Zero-ETL-Integration zu aktivieren**
1. Öffnen Sie die Oracle AWS Database@-Konsole unter. [https://console.aws.amazon.com/odb/](https://console.aws.amazon.com/odb/)
1. Wählen Sie im Navigationsbereich **ODB-Netzwerke** aus.
1. Wählen Sie das ODB-Netzwerk aus, für das Sie die Zero-ETL-Integration aktivieren möchten.
1. Wählen Sie **Ändern** aus.
1. **Wählen Sie Zero-ETL aus.**
1. **Wählen Sie **Weiter** und dann Ändern.**
### AWS CLI
Um die Zero-ETL-Integration zu aktivieren, verwenden Sie den `update-odb-network` Befehl mit dem `--zero-etl-access` folgenden Parameter:
```
aws odb update-odb-network \
--odb-network-id {{odb-network-id}} \
--zero-etl-access ENABLED
```
Verwenden Sie den Befehl, um die Zero-ETL-Integration für das ODB-Netzwerk zu aktivieren, das Ihrem Quell-VM-Cluster zugeordnet ist. `update-odb-network` Dieser Befehl konfiguriert die Netzwerkinfrastruktur, die für die Zero-ETL-Integration erforderlich ist.
```
aws odb update-odb-network \
--odb-network-id {{your-odb-network-id}} \
--zero-etl-access ENABLED
```
## Schritt 2: Konfigurieren Sie Ihre Oracle-Datenbank
Vervollständigen Sie die Oracle-Datenbankkonfiguration wie in den [Voraussetzungen](zero-etl-prerequisites.md) beschrieben:
+ Erstellen Sie Replikationsbenutzer und gewähren Sie die erforderlichen Berechtigungen.
+ Aktivieren Sie archivierte Redo-Logs.
+ SSL konfigurieren (nur Oracle Exadata).
+ Richten Sie gegebenenfalls ASM-Benutzer ein (nur Oracle Exadata).
## Schritt 3: AWS Secrets Manager und AWS Key Management Service einrichten
Erstellen Sie einen vom Kunden verwalteten Schlüssel (CMK) und speichern Sie Ihre Datenbankanmeldeinformationen.
1. Erstellen Sie mit dem Befehl einen CMK im AWS Key Management Service. `create-key`
```
aws kms create-key \
--description "ODB Zero-ETL Integration Key" \
--key-usage ENCRYPT_DECRYPT \
--key-spec SYMMETRIC_DEFAULT
```
1. Speichern Sie Ihre Datenbankanmeldedaten in AWS Secrets Manager.
```
aws secretsmanager create-secret \
--name "ODBZeroETLCredentials" \
--description "Credentials for Oracle Database@AWS Zero-ETL integration" \
--kms-key-id {{your-cmk-key-arn}} \
--secret-string file://secret-content.json
```
1. Fügen Sie dem Secret eine Ressourcenrichtlinie hinzu, um Oracle Database@AWS Zugriff zu gewähren.
```
aws secretsmanager put-resource-policy \
--secret-id "ODBZeroETLCredentials" \
--resource-policy file://secret-resource-policy.json
```
`secret-resource-policy.json`Enthält im vorherigen Befehl den folgenden JSON-Code.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "zetl.odb.amazonaws.com"
},
"Action": [
"secretsmanager:GetSecretValue",
"secretsmanager:DescribeSecret"
],
"Resource": "*"
}
]
}
```
------
1. Hängen Sie eine Ressourcenrichtlinie an den CMK an. Die CMK-Ressourcenrichtlinie muss Berechtigungen sowohl für den Oracle Database@AWS Service Principal als auch für den Amazon Redshift Service Principal enthalten, um die verschlüsselte Zero-ETL-Integration zu unterstützen.
```
aws kms put-key-policy \
--key-id {{your-cmk-key-arn}} \
--policy-name default \
--policy file://cmk-resource-policy.json
```
Die `cmk-resource-policy.json` Datei sollte die folgenden Richtlinienerklärungen enthalten. Die erste Anweisung ermöglicht den Zugriff auf den Oracle Database@AWS Service, und die zweite Anweisung ermöglicht Amazon Redshift, Grants für den KMS-Schlüssel für verschlüsselte Datenoperationen zu erstellen.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "Allow ODB service access",
"Effect": "Allow",
"Principal": {
"Service": "zetl.odb.amazonaws.com"
},
"Action": [
"kms:Decrypt",
"kms:GenerateDataKey",
"kms:CreateGrant"
],
"Resource": "*"
},
{
"Sid": "Allows the Redshift service principal to add a grant to a KMS key",
"Effect": "Allow",
"Principal": {
"Service": "redshift.amazonaws.com"
},
"Action": "kms:CreateGrant",
"Resource": "*",
"Condition": {
"StringEquals": {
"kms:EncryptionContext:{context-key}": "{context-value}"
},
"ForAllValues:StringEquals": {
"kms:GrantOperations": [
"Decrypt",
"GenerateDataKey",
"CreateGrant"
]
}
}
}
]
}
```
------
## Schritt 4: IAM-Berechtigungen konfigurieren
Erstellen und fügen Sie IAM-Richtlinien hinzu, die Zero-ETL-Integrationsvorgänge ermöglichen.
```
aws iam create-policy \
--policy-name "ODBZeroETLIntegrationPolicy" \
--policy-document file://odb-zetl-iam-policy.json
aws iam attach-user-policy \
--user-name {{your-iam-username}} \
--policy-arn {{policy-arn}}
```
Die folgende Richtlinie gewährt die erforderlichen Berechtigungen.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "ODBGlueIntegrationAccess",
"Effect": "Allow",
"Action": [
"glue:CreateIntegration",
"glue:ModifyIntegration",
"glue:DeleteIntegration",
"glue:DescribeIntegrations",
"glue:DescribeInboundIntegrations"
],
"Resource": "*"
},
{
"Sid": "ODBZetlOperations",
"Effect": "Allow",
"Action": "odb:CreateOutboundIntegration",
"Resource": "*"
},
{
"Sid": "ODBRedshiftFullAccess",
"Effect": "Allow",
"Action": [
"redshift:*",
"redshift-serverless:*",
"ec2:DescribeAccountAttributes",
"ec2:DescribeAddresses",
"ec2:DescribeAvailabilityZones",
"ec2:DescribeSecurityGroups",
"ec2:DescribeSubnets",
"ec2:DescribeVpcs",
"ec2:DescribeInternetGateways",
"sns:CreateTopic",
"sns:Get*",
"sns:List*",
"cloudwatch:Describe*",
"cloudwatch:Get*",
"cloudwatch:List*",
"cloudwatch:PutMetricAlarm",
"cloudwatch:EnableAlarmActions",
"cloudwatch:DisableAlarmActions",
"tag:GetResources",
"tag:UntagResources",
"tag:GetTagValues",
"tag:GetTagKeys",
"tag:TagResources"
],
"Resource": "*"
},
{
"Sid": "ODBRedshiftDataAPI",
"Effect": "Allow",
"Action": [
"redshift-data:ExecuteStatement",
"redshift-data:CancelStatement",
"redshift-data:ListStatements",
"redshift-data:GetStatementResult",
"redshift-data:DescribeStatement",
"redshift-data:ListDatabases",
"redshift-data:ListSchemas",
"redshift-data:ListTables",
"redshift-data:DescribeTable"
],
"Resource": "*"
},
{
"Sid": "ODBKMSAccess",
"Effect": "Allow",
"Action": [
"kms:CreateKey",
"kms:DescribeKey",
"kms:Encrypt",
"kms:Decrypt",
"kms:GenerateDataKey",
"kms:ListKeys",
"kms:CreateAlias",
"kms:ListAliases"
],
"Resource": "*"
},
{
"Sid": "ODBSecretsManagerAccess",
"Effect": "Allow",
"Action": [
"secretsmanager:GetSecretValue",
"secretsmanager:PutSecretValue",
"secretsmanager:CreateSecret",
"secretsmanager:UpdateSecret",
"secretsmanager:DeleteSecret",
"secretsmanager:DescribeSecret",
"secretsmanager:ListSecrets",
"secretsmanager:GetResourcePolicy",
"secretsmanager:PutResourcePolicy",
"secretsmanager:ValidateResourcePolicy"
],
"Resource": "*"
}
]
}
```
------
## Schritt 5: Amazon Redshift Redshift-Ressourcenrichtlinien konfigurieren
Richten Sie Ressourcenrichtlinien in Ihrem Amazon Redshift Redshift-Cluster ein, um eingehende Integrationen zu autorisieren.
```
aws redshift put-resource-policy \
--no-verify-ssl \
--resource-arn "{{your-redshift-cluster-arn}}" \
--policy '{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "redshift.amazonaws.com"
},
"Action": [
"redshift:AuthorizeInboundIntegration"
],
"Condition": {
"StringEquals": {
"aws:SourceArn": "{{your-vm-cluster-arn}}"
}
}
},
{
"Effect": "Allow",
"Principal": {
"AWS": "{{your-account-id}}"
},
"Action": [
"redshift:CreateInboundIntegration"
]
}
]
}' \
--region us-west-2
```
**Tipp**
Alternativ können Sie die Option **Fix it for me** in der Konsole verwenden. AWS Diese Option konfiguriert automatisch die erforderlichen Amazon Redshift Redshift-Richtlinien, ohne dass Sie dies manuell tun müssen.
## Schritt 6: Erstellen Sie die Zero-ETL-Integration mit AWS Glue
Erstellen Sie die Zero-ETL-Integration mit dem Befehl. AWS Glue `create-integration` In diesem Befehl geben Sie den Quell-VM-Cluster und den Amazon Redshift Redshift-Ziel-Namespace an.
Das folgende Beispiel erstellt eine Integration mit einer PDB namens `pdb1` running in einem Exadata-VM-Cluster. Sie können auch einen autonomen VM-Cluster erstellen, indem Sie `cloud-vm-cluster` ihn `cloud-autonomous-vm-cluster` im Quell-ARN ersetzen. Die Angabe eines KMS-Schlüssels ist optional. Wenn Sie einen Schlüssel angeben, kann er sich von dem unterscheiden, in dem Sie ihn erstellt haben[Schritt 3: AWS Secrets Manager und AWS Key Management Service einrichten](#zero-etl-setup-secrets).
```
aws glue create-integration \
--integration-name "MyODBZeroETLIntegration" \
--source-arn "arn:aws:odb:{{region}}:{{account}}:cloud-vm-cluster/{{cluster-id}}" \
--target-arn "arn:aws:redshift:{{region:account}}:namespace/{{namespace-id}}" \
--data-filter "include: {{pdb1}}.*.*" \
--integration-config '{
"RefreshInterval": "10",
"IntegrationMode": "DEFAULT",
"SourcePropertiesMap": {
"secret-arn": "arn:aws:secretsmanager:{{region}}:{{account}}:secret:{{secret-name}}"
}
}' \
--description "Zero-ETL integration for Oracle to Amazon Redshift" \
--kms-key-id "arn:aws:kms:{{region:account}}:key/{{key-id}}"
```
Der Befehl gibt einen Integrations-ARN zurück und setzt den Status auf`creating`. Sie können den Integrationsstatus mit dem `describe-integrations` Befehl überwachen.
```
aws glue describe-integrations \
--integration-identifier {{integration-id}}
```
**Wichtig**
Pro Integration wird nur eine PDB unterstützt. Der Datenfilter muss beispielsweise eine einzelne PDB angeben. `include: pdb1.*.*` Die Quelle muss sich in derselben AWS Region und demselben Konto befinden, in der die Integration erstellt wird.
## Schritt 7: Erstellen Sie eine Zieldatenbank in Amazon Redshift
Nachdem die Integration aktiv ist, erstellen Sie eine Zieldatenbank in Ihrem Amazon Redshift Redshift-Cluster.
```
-- Connect to your Amazon Redshift cluster
psql -h {{your-redshift-endpoint}} -U {{username}} -d {{database}}
-- Create database from integration
CREATE DATABASE {{target_database_name}}
FROM INTEGRATION '{{integration-id}}'
DATABASE "{{source_pdb_name}}";
```
Nachdem Sie die Zieldatenbank erstellt haben, können Sie die replizierten Daten abfragen.
```
-- List databases to verify creation
\l
-- Connect to the new database
\c {{target_database_name}}
-- List tables to see replicated data
\dt
```
## Überprüfen Sie die Zero-ETL-Integration
Stellen Sie sicher, dass die Integration funktioniert, indem Sie den Integrationsstatus in abfragen AWS Glue und sicherstellen, dass Ihre Oracle-Änderungen auf Amazon Redshift repliziert werden.
**Um zu überprüfen, ob Ihre Zero-ETL-Integration ordnungsgemäß funktioniert**
1. Überprüfen Sie den Integrationsstatus.
```
aws glue describe-integrations \
--integration-identifier {{integration-id}}
```
Der Status sollte `ACTIVE` oder sein`REPLICATING`.
1. Überprüfen Sie die Datenreplikation, indem Sie Änderungen an Ihrer Oracle-Datenbank vornehmen und überprüfen, ob sie in Amazon Redshift erscheinen.
1. Überwachen Sie die Replikationsmetriken in Amazon CloudWatch (falls verfügbar).