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

# AWS-VPC-Einrichtung

> Leitfaden für die Einrichtung von Devin in Ihrer AWS-VPC

<div id="devin-aws-vpc-deployment-guide">
  # **Devin AWS VPC-Bereitstellungsleitfaden**
</div>

Dieser Leitfaden beschreibt den Prozess zur Bereitstellung von Devin in Ihrer AWS Virtual Private Cloud (VPC)-Umgebung, sodass Devin auf Ressourcen innerhalb Ihrer Unternehmensfirewall zugreifen kann.

<Tabs>
  <Tab title="Einfache Einrichtung mit Terraform">
    ## Terraform-Bereitstellung (empfohlen)

    Die Terraform-Bereitstellung ist unser empfohlener Ansatz, um Devin in Ihrer AWS-VPC einzurichten. Diese automatisierte Methode stellt eine konsistente, wiederholbare Bereitstellung der Infrastruktur mit minimaler manueller Konfiguration sicher.

    <Frame>
      <img src="https://mintcdn.com/cognitionai/jlReMiXrsokGIcK7/images/terraform-workflow.png?fit=max&auto=format&n=jlReMiXrsokGIcK7&q=85&s=9a4846f3083d5cca7903a3982cb44552" alt="Terraform Deployment Workflow" width="2284" height="1282" data-path="images/terraform-workflow.png" />
    </Frame>

    ### Voraussetzungen

    Stellen Sie vor Beginn des Terraform-Bereitstellungsprozesses sicher, dass Folgendes vorhanden ist:

    * Eine für Devin eingerichtete VPC (verwenden Sie entweder eine bestehende VPC oder stellen Sie eine neue bereit)
    * Eine IAM-Rolle oder ein Servicekonto mit Berechtigungen, um:
      * EC2-Auto-Scaling-Instanzen zu erstellen
      * S3-Buckets in Ihrer Region zu erstellen
    * Ein AWS-Konto, das Instanzen mit mindestens 70 vCPUs bereitstellen kann
    * Terraform (Version 1.0 oder höher) ist installiert

    ### Schritt-für-Schritt-Bereitstellungsprozess

    <Steps>
      <Step title="AWS-Umgebungsinformationen sammeln">
        Sammeln Sie die folgenden Informationen, die für die Terraform-Konfiguration benötigt werden:

        * AWS-Kontonummer (12-stellige Nummer)
        * VPC-ID (vpc-xxxxxxxxxxxxxxxxx)
        * Zwei Subnetz-IDs:
          * subnet-xxxxxxxxxxxxxxxxx
          * subnet-xxxxxxxxxxxxxxxxx

        **Nützliche AWS-CLI-Befehle:**

        ```bash theme={null}
        # Ihre VPCs auflisten
        aws ec2 describe-vpcs

        # Subnetze in einer bestimmten VPC auflisten
        aws ec2 describe-subnets --filters "Name=vpc-id,Values=<your-vpc-id>"
        ```
      </Step>

      <Step title="Firewall-Zugriff konfigurieren">
        <Tabs>
          <Tab title="Firewall auf Benutzergeräten">
            Stellen Sie sicher, dass Ihre Endpoint-Sicherheitssysteme (Benutzergeräte, die auf Devin zugreifen werden) den Zugriff auf Folgendes erlauben:

            * \*.devin.ai
            * \*.devinenterprise.com
            * \*.devinapps.com
          </Tab>

          <Tab title="VPC-Firewall">
            Stellen Sie sicher, dass Ihre VPC-Sicherheitsgruppen den Zugriff auf Folgendes erlauben:

            * frp-server-0.devin.ai
            * static.devin.ai
            * api.devin.ai
          </Tab>
        </Tabs>

        <Frame>
          <img src="https://mintcdn.com/cognitionai/SST7qBOGO28X2sVc/images/aws-firewall.png?fit=max&auto=format&n=SST7qBOGO28X2sVc&q=85&s=a687822a8153c6ca63ac981167388ac0" alt="AWS Firewall Configuration" width="1609" height="739" data-path="images/aws-firewall.png" />
        </Frame>
      </Step>

      <Step title="Terraform-Konfiguration und Auth-Token erhalten">
        Kontaktieren Sie Cognition, um Folgendes zu erhalten:

        1. Ein Authentifizierungs-Token zum Pullen (Herunterladen) des Hypervisor-Images
        2. Die Terraform-Konfigurationsdateien, die für Ihre Umgebung angepasst sind

        Sobald Sie Ihre Umgebungsinformationen (aus Schritt 1) bereitgestellt haben, stellen wir Ihnen diese Ressourcen zur Verfügung.
      </Step>

      <Step title="Terraform-Skript ausführen">
        Wir können einen Call vereinbaren, um diesen Schritt gemeinsam auszuführen. Der Prozess umfasst:

        1. Extrahieren Sie die Terraform-Konfigurationsdateien in ein Verzeichnis auf Ihrem lokalen Rechner:
           ```bash theme={null}
           mkdir -p ~/devin-terraform && cd ~/devin-terraform
           # Dateien extrahieren, die Sie von Cognition erhalten haben
           ```

        2. Initialisieren Sie die Terraform-Umgebung:
           ```bash theme={null}
           terraform init
           ```

        3. Überprüfen Sie die geplanten Infrastrukturänderungen:
           ```bash theme={null}
           terraform plan
           ```

        4. Wenden Sie die Konfiguration an, um die Infrastruktur bereitzustellen:
           ```bash theme={null}
           terraform apply
           ```

        5. Bestätigen Sie die Änderungen, wenn Sie dazu aufgefordert werden.

        <Note>
          Die Terraform-Skripte richten alle erforderlichen Komponenten ein, einschließlich EC2-Instanzen, S3-Buckets, Sicherheitsgruppen, IAM-Rollen und der Hypervisor-Registrierung.
        </Note>
      </Step>

      <Step title="Erste Devin-Session ausführen">
        Nachdem das Terraform-Skript erfolgreich abgeschlossen wurde, arbeiten wir gemeinsam daran:

        1. Zu überprüfen, dass die Ressourcen in Ihrer AWS-Konsole erstellt wurden
        2. Eine erste Devin-Session auszuführen, um die Konnektivität zu den benötigten Diensten sicherzustellen
        3. Alle auftretenden Probleme mit Unterstützung des Cognition-Teams zu debuggen
      </Step>
    </Steps>
  </Tab>

  <Tab title="Erweiterte Einrichtung (manuelle Konfiguration)">
    ## Manuelle Bereitstellung

    Falls eine Terraform-Bereitstellung in Ihrer Umgebung nicht durchführbar ist, werden in diesem Abschnitt die erforderlichen manuellen Schritte zur Bereitstellung der Infrastruktur beschrieben.

    ### Netzwerkanforderungen

    Beachten Sie, dass eine manuelle Konfiguration der Netzwerkkomponenten erforderlich ist. Weitere Informationen finden Sie in unseren bereitgestellten Ressourcen.

    ### Bereitstellungsschritte

    <Steps>
      <Step title="Instanzen für den Betrieb von VMs einrichten">
        Devin benötigt eine Host-Instanz, um **isolierte virtuelle Maschinen** für jede Sitzung auszuführen.

        #### **Instanzanforderungen**

        | Anforderung          | Details                                                                       |
        | :------------------- | :---------------------------------------------------------------------------- |
        | **Instance Type**    | Metal-Instanzen (`i3.metal`)                                                  |
        | **Operating System** | Ubuntu 24.04                                                                  |
        | **Instance Sizing**  | - 2 vCPUs, 8GB RAM, 128GB Storage  <br /> - 8 vCPUs, 32GB RAM, 128GB Storage  |
        | **Note**             | Die Instanzgröße bestimmt die maximale Anzahl gleichzeitiger Devin-Sitzungen. |
        | **Recommendation**   | Wir empfehlen `i3.metal` als Basis.                                           |

        <Tip>
          Sie können **horizontal skalieren**, indem Sie weitere Host-Instanzen hinzufügen, um Devins Kapazität zu erhöhen.
        </Tip>

        #### **Security-Group-Regeln**

        | **Configuration**           | **Details**                                          |
        | :-------------------------- | :--------------------------------------------------- |
        | **VPC Setup**               | Konfigurieren Sie die VPC- und Security-Group-Regeln |
        | **Required Firewall Rules** | **Ausgehender Internetzugriff auf Port 443 zu:**     |
        |                             | `frp-server-0.devin.ai`                              |
        |                             | `static.devin.ai`                                    |
        |                             | `api.devin.ai`                                       |

        <Warning>
          Allgemeiner Internetzugang wird **dringend empfohlen**, ist aber nicht zwingend erforderlich.
        </Warning>
      </Step>

      <Step title="Speicher für VMs konfigurieren">
        Wenn **Devin-Sitzungen** ausgesetzt werden, wird ihr Zustand **komprimiert und gespeichert**.

        #### **2.1 Erstellen eines S3-Buckets**

        1. Navigiere zu **S3** in der **AWS Management Console**
        2. Wähle die passende Region aus
        3. Klicke auf **Create bucket**
        4. Setze den **Bucket-Namen** auf:

           ```
           devin-${YOUR_ORGANIZATION}-${BUCKET_REGION}
           ```

           *(Ersetze `${YOUR_ORGANIZATION}` und `${BUCKET_REGION}` durch die tatsächlichen Werte)*
        5. Klicke auf **Create bucket**

        #### **2.2 S3-Bucket-Policy & CORS anwenden**

        1. Öffne den erstellten **S3-Bucket**
        2. Navigiere zur Registerkarte **Permissions**
        3. Scrolle zu **Bucket Policy** und klicke auf **Edit**
        4. Füge die folgende Richtlinie hinzu und ersetze die Platzhalter:

        ```json theme={null}
        {
            "Version": "2012-10-17",
            "Statement": [
                {
                    "Principal": {"AWS": "arn:aws:iam::272506498303:role/customer-bucket-access-role"},
                    "Effect": "Allow",
                    "Action": ["s3:GetObject", "s3:PutObject", "s3:DeleteObject"],
                    "Resource": "arn:aws:s3:::devin-${YOUR_ORGANIZATION}-${BUCKET_REGION}/*"
                },
                {
                    "Principal": {"AWS": "arn:aws:iam::272506498303:role/customer-bucket-access-role"},
                    "Effect": "Allow",
                    "Action": ["s3:ListBucket"],
                    "Resource": "arn:aws:s3:::devin-${YOUR_ORGANIZATION}-${BUCKET_REGION}"
                }
            ]
        }
        ```

        5. Klicken Sie auf **Save**.
        6. Scrollen Sie nach unten zu **Cross-Origin Resource Sharing (CORS)** und klicken Sie auf **Edit**.
        7. Geben Sie die folgende CORS-Richtlinie ein:

        ```json theme={null}
        [
            {
                "AllowedHeaders": ["*"],
                "AllowedMethods": ["GET"],
                "AllowedOrigins": ["*"],
                "ExposeHeaders": []
            }
        ]
        ```

        8. Klicken Sie auf **Save**

        <Note>
          Sobald diese Ressourcen erstellt sind, stellen Sie Cognition bitte Folgendes zur Verfügung:

          * Ihre **AWS-Konto-ID**
          * **Name des S3-Buckets**
          * **VPC und Subnetze** für die Bereitstellung
          * **Security-Group-ID**
          * Alle **Tags** für Devin-bezogene Ressourcen
        </Note>
      </Step>

      <Step title="Host-Runner registrieren">
        Führen Sie den folgenden Befehl aus:

        ```bash theme={null}
        curl -sSL https://api.devin.ai/hypervisor/setup?token=AUTH_TOKEN -o setup.sh && bash setup.sh
        ```

        <Note>
          Wir werden Ihnen das **AUTH\_TOKEN** separat zukommen lassen. Wenn das Setup abgeschlossen ist, sollte **Devin** bereit sein, Sitzungen in Ihrer **VPC**-Umgebung zu starten.
        </Note>
      </Step>

      <Step title="Firewall: Anforderungen">
        Wenn auf den Geräten der Benutzer eine Firewall aktiv ist, fügen Sie die folgenden URLs zur Allowlist hinzu:

        * `*.devin.ai`
        * `*.devinenterprise.com`
        * `*.devinapps.com`
                  <br />

        **Beispiel für eine AWS-WAF-Regel**

        <img src="https://mintcdn.com/cognitionai/SST7qBOGO28X2sVc/images/aws-firewall.png?fit=max&auto=format&n=SST7qBOGO28X2sVc&q=85&s=a687822a8153c6ca63ac981167388ac0" alt="AWS-Firewall" width="1609" height="739" data-path="images/aws-firewall.png" />
      </Step>
    </Steps>
  </Tab>
</Tabs>