> ## Documentation Index
> Fetch the complete documentation index at: https://docs.kameleoon.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Amazon Redshift einrichten

> Konfigurieren Sie IAM-Benutzer, Rollen und Berechtigungen in AWS und verbinden Sie Ihren Amazon Redshift-Cluster mit Kameleoon für die Data-Warehouse-Integration.

Diese Anleitung beschreibt die Schritte, die zur Einrichtung der Kameleoon-Integration mit Amazon Redshift erforderlich sind. Die Einrichtung ist sowohl in der Kameleoon-Benutzeroberfläche als auch in Ihrem AWS-Konto erforderlich. Einige dieser Aktionen müssen möglicherweise an Ihre spezifische AWS-Umgebung angepasst werden. In jedem Fall sollten diese Schritte von Ihrem AWS-Kontoadministrator durchgeführt werden.

## Schritt 1: AWS-IAM-Benutzer und -Rolle erstellen

Sie müssen einen IAM-Benutzer und eine IAM-Rolle erstellen, die Kameleoon für den Zugriff auf Ihren Redshift-Cluster verwenden wird. Sie können diese in der AWS Management Console oder in der AWS CLI erstellen. Wir stellen Beispielbefehle für die AWS CLI bereit.

### 1. Einen IAM-Benutzer erstellen

Verwenden Sie den folgenden Befehl, um einen dedizierten IAM-Benutzer für Kameleoon zu erstellen:

`aws iam create-user --user-name kameleoon_user`

Generieren Sie als Nächstes einen Access Key für den kameleoon\_user:

`aws iam create-access-key --user-name kameleoon_user`

Achten Sie darauf, die Felder `AccessKeyId` und `SecretAccessKey` aus dem von diesem Befehl zurückgegebenen JSON zu behalten, da Sie aufgefordert werden, diese Kameleoon bei der Einrichtung in der Kameleoon-Benutzeroberfläche bereitzustellen.

### 2. Eine IAM-Rolle erstellen

Erstellen Sie eine Rolle, die Kameleoon übernehmen kann, damit es mit Ihrem Redshift-Cluster interagieren kann. Verwenden Sie den folgenden Befehl, um die Rolle mit einer Inline-JSON-Trust-Policy zu erstellen:

```shell theme={null}
aws iam create-role --role-name kameleoon_role --assume-role-policy-document '{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Principal": {
                "AWS": "arn:aws:iam::{account_id}:user/kameleoon_user",
                "Service": [
    				"s3.amazonaws.com",
    				"redshift.amazonaws.com",
   				"iam.amazonaws.com",
    				"redshift-serverless.amazonaws.com"
]
            },
            "Action": "sts:AssumeRole"
        }
    ]
}'

```

Ersetzen Sie `{account_id}` durch Ihre AWS-Konto-ID.

Wenn Sie Redshift als Quelle verwenden, kann `s3.amazonaws.com` weggelassen werden. Wenn Sie Provisioned verwenden, kann `redshift-serverless.amazonaws.com` weggelassen werden.

#### Für Amazon Redshift als Ziel — S3 Redshift-Zugriffsrechte einer IAM-Rolle gewähren

Erstellen und hängen Sie eine S3-Rolle an, damit Kameleoon mit dem S3-Bucket Ihrer Wahl interagieren und Daten von S3 nach Redshift kopieren kann.

```shell theme={null}
aws iam attach-role-policy \
  --role-name kameleoon_role \
  --policy-document '{
  	  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "s3:PutObject",
        "s3:GetObject",
        "s3:ListBucket",
        "s3:DeleteObject"
      ],
      "Resource": "arn:aws:s3:::{s3_bucket_name}/*"
    },
    {
"Effect": "Allow",
"Action": [
  "redshift:GetClusterCredentialsWithIAM",
  "redshift:GetClusterCredentials",
  "redshift:DescribeClusters"
],
"Resource": "arn:aws:redshift:{aws_region}:{account_id}:dbuser:kameleoon_user"
    }
  ]
}'
```

Ersetzen Sie `{s3_bucket_name}`, `{aws_region}` und `{account_id}` durch Ihre Daten.

Alternativ verwenden Sie die vorhandenen Richtlinien [AmazonS3FullAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonS3FullAccess.html) und [AmazonRedshiftFullAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonRedshiftFullAccess.html).

## Schritt 2: Berechtigungen für die Kameleoon-Rolle erteilen

Erteilen Sie der mit Kameleoon verknüpften IAM-Rolle die erforderlichen Berechtigungen, um die Interaktion mit Ihrer Redshift-Datenbank zu ermöglichen. Berechtigungen sollten auf SQL-Benutzerebene über SQL-Befehle erteilt werden. Der standardmäßige SQL-Benutzer, der für eine IAM-Rolle erstellt wird, heißt `IAMR:{role_name}`. Wenn die von Ihnen verwendete Rolle also `kameleoon_role` heißt, werden diese Befehle für den SQL-Benutzer `IAMR:kameleoon_role` ausgeführt.

### Für Amazon Redshift als Quelle

#### 1. Zugriff auf vorhandenes Schema gewähren

Gewähren Sie der Kameleoon IAM-Rolle Zugriff auf das relevante Schema und die Tabellen in Ihrer Redshift-Datenbank. Wenn Sie beispielsweise möchten, dass Kameleoon Daten aus Ihrer „users"-Tabelle im Schema `schema_containing_data` aufnimmt, führen Sie die folgenden SQL-Befehle aus:

```sql theme={null}
GRANT USAGE ON SCHEMA "schema_containing_data" TO "IAMR:kameleoon_role";
GRANT SELECT ON TABLE "schema_containing_data"."users" TO "IAMR:kameleoon_role";
```

#### 2. Kameleoon-Konfigurationsschema erstellen

Erstellen Sie ein neues Schema für Kameleoon-Konfigurationen und erteilen Sie die erforderlichen Berechtigungen:

```sql theme={null}
CREATE SCHEMA "kameleoon_configuration";

GRANT USAGE ON SCHEMA "kameleoon_configuration" TO "IAMR:kameleoon_role";
GRANT CREATE ON SCHEMA "kameleoon_configuration" TO "IAMR:kameleoon_role"
```

#### 3. DML-Berechtigungen im Kameleoon-Konfigurationsschema erteilen

Erteilen Sie der Kameleoon-Rolle Berechtigungen zum Einfügen, Aktualisieren und Löschen von Daten im Schema `kameleoon_configuration`:

```sql theme={null}
GRANT INSERT, UPDATE, DELETE ON ALL TABLES IN SCHEMA "kameleoon_configuration" TO "IAMR:kameleoon_role";
```

#### 4. Standardberechtigungen für zukünftige Tabellen festlegen

Stellen Sie sicher, dass alle zukünftigen Tabellen, die im Schema `kameleoon_configuration` erstellt werden, der Kameleoon-Rolle automatisch die erforderlichen Berechtigungen erteilen:

```sql theme={null}
ALTER DEFAULT PRIVILEGES IN SCHEMA "kameleoon_configuration" 
GRANT INSERT, UPDATE, DELETE ON TABLES TO "IAMR:kameleoon_role";
```

### Für Amazon Redshift als Ziel

#### 1. Kameleoon-Ereignisschema erstellen

Erstellen Sie ein neues Schema für Kameleoon-Ereignisse und erteilen Sie die erforderlichen Berechtigungen:

```sql theme={null}
CREATE SCHEMA "kameleoon_events";

GRANT USAGE ON SCHEMA "kameleoon_events" TO "IAMR:kameleoon_role";
GRANT CREATE ON SCHEMA "kameleoon_events" TO "IAMR:kameleoon_role";
```

#### 2. DML-Berechtigungen für das Kameleoon-Ereignisschema erteilen

Erteilen Sie der Kameleoon-Rolle Berechtigungen zum Einfügen, Aktualisieren und Löschen von Daten im Schema `kameleoon_events`:

```sql theme={null}
GRANT INSERT, UPDATE, DELETE ON ALL TABLES IN SCHEMA "kameleoon_events" TO "IAMR:kameleoon_role";
```

#### 3. Standardberechtigungen für zukünftige Tabellen festlegen

Stellen Sie sicher, dass alle zukünftigen Tabellen, die im Schema `kameleoon_events` erstellt werden, der Kameleoon-Rolle automatisch die erforderlichen Berechtigungen erteilen:

```sql theme={null}
ALTER DEFAULT PRIVILEGES IN SCHEMA "kameleoon_events" 
GRANT INSERT, UPDATE, DELETE ON TABLES TO "IAMR:kameleoon_role";
```

## Schritt 3: Aktivieren und Konfigurieren der Integration in der Kameleoon-Benutzeroberfläche

Gehen Sie in Ihrem Kameleoon-Konto zur Seite **Integrations** und suchen Sie Amazon Redshift in der Liste.

<Frame>
  ![](https://storage.googleapis.com/kameleoon-storage-documentation/user-manual/images/integrations/data-warehouses/amazon-redshift/setting-up-amazon-redshift/0.png)
</Frame>

Klicken Sie auf **Install the tool** und füllen Sie die folgenden Felder aus, um Kameleoon Zugangsdaten zu Ihrem Redshift-Cluster zu geben, nachdem Sie zunächst aus der links angezeigten Liste das Projekt ausgewählt haben, für das Sie diesen Zugriff konfigurieren möchten.

<Frame>
  ![](https://storage.googleapis.com/kameleoon-storage-documentation/user-manual/images/integrations/data-warehouses/amazon-redshift/setting-up-amazon-redshift/1.png)
</Frame>

Die erforderlichen Felder sind:

* **AWS Account ID:** die eindeutige numerische Kennung Ihres Amazon Web Services-Kontos
* **AWS Role name:** der Name der AWS IAM-Rolle, die Sie für Kameleoon gemäß den Anweisungen in den vorherigen Abschnitten erstellt haben
* **AWS Access key ID und Secret access key ID:** Diese beiden Felder werden beim Erstellen von Anmeldedaten für die AWS-Rolle bereitgestellt. Wenn Sie die AWS-Befehlszeilenschnittstelle zum Erstellen dieses Schlüssels verwendet haben, wie in [Schritt 1](#schritt-1-aws-iam-benutzer-und-rolle-erstellen) dieses Artikels beschrieben, wurden diese beiden Werte in der JSON-Antwort auf diesen Befehl bereitgestellt.

Klicken Sie auf **Confirm**. Ihre Anmeldeinformationen wurden für das Projekt hochgeladen. Unten gibt es eine **ADVANCED SETUP**-Vorschau, die die IP-Adressen enthält, die Kameleoon verwendet, um eine Verbindung zu Ihrem Warehouse herzustellen. Viele Organisationen filtern die IP-Adressen, die zur Verbindung mit ihrem Warehouse autorisiert sind. Falls dies der Fall ist, können Sie diese IPs von Ihrem AWS-Konto aus mit den folgenden Schritten autorisieren.

## Schritt 4: Sicherheitsgruppe für Redshift konfigurieren

Um Kameleoon den Zugriff auf Ihren Redshift-Cluster zu ermöglichen, autorisieren Sie Abfragen von den IP-Adressen von Kameleoon in Ihrer Sicherheitsgruppe. Dies kann in der AWS-Konsole erfolgen:

1. **Sicherheitsgruppe identifizieren:** Die Sicherheitsgruppe, die Ihrem Redshift-Cluster zugeordnet ist, kann im Redshift-Dashboard angezeigt werden, und Sie können von dort aus auf die Konfigurationsseite dieser Sicherheitsgruppe zugreifen. Wenn Sie Redshift Serverless verwenden, suchen Sie die Sicherheitsgruppe Ihres Workgroups.
2. **Eingehende Regeln hinzufügen**
   * Navigieren Sie zum Tab **Inbound Rules**.
   * Klicken Sie auf **Edit inbound rules** > **Add rule**.
   * Setzen Sie die folgenden Parameter:
     * **Type:** Custom TCP rule
     * **Port range:** 5439 (Standard-Redshift-Port)
     * **Source:** Custom (fügen Sie die Kameleoon-IP-Adressen hinzu, die im Abschnitt zur Redshift-Integration in der Kameleoon-Benutzeroberfläche angezeigt werden)

## Schritt 5: Workgroup-VPC für externe Verbindungen öffnen

Stellen Sie sicher, dass das mit Ihrem Redshift-Cluster verknüpfte VPC so konfiguriert ist, dass es externe Verbindungen zulässt. Zur Vereinfachung können Sie das VPC öffentlich zugänglich machen und sich ausschließlich auf die Sicherheitsgruppen-Einstellungen verlassen. Ein sichererer Ansatz besteht darin, die Network Access Control List Ihres VPC-Subnetzes fein abzustimmen. Ändern Sie hierzu die VPC-Einstellungen in Ihrer AWS-Konsole wie folgt:

1. **Zugriff auf VPC-Einstellungen:** Gehen Sie zum VPC-Dashboard in der AWS Management Console.
2. **Netzwerk-ACLs ändern:**
   * Navigieren Sie zum Abschnitt **Network ACLs**.
   * Suchen Sie die mit Ihrem VPC verknüpfte ACL.
   * Ändern Sie die eingehenden und ausgehenden Regeln, um den Datenverkehr von den IP-Adressen von Kameleoon auf Port 5439 zuzulassen.
3. **Routentabellen aktualisieren:** Stellen Sie sicher, dass die mit Ihrem VPC verknüpften Routentabellen korrekt konfiguriert sind, um den Datenverkehr zu Ihrem Redshift-Cluster zu leiten.
