> ## 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.

# Configuration d'un VPC AWS

> Guide de configuration de Devin dans votre VPC AWS

<div id="devin-aws-vpc-deployment-guide">
  # **Guide de déploiement de Devin dans un VPC AWS**
</div>

Ce guide décrit le processus de déploiement de Devin dans votre environnement AWS Virtual Private Cloud (VPC), afin de permettre l'accès aux ressources situées à l'intérieur de votre pare-feu d'entreprise.

<Tabs>
  <Tab title="Mise en place simple (Terraform)">
    ## Déploiement avec Terraform (recommandé)

    Le déploiement avec Terraform est notre approche recommandée pour configurer Devin dans votre VPC AWS. Cette méthode automatisée garantit un provisionnement d'infrastructure cohérent et reproductible avec une configuration manuelle minimale.

    <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>

    ### Prérequis

    Avant de commencer le processus de déploiement avec Terraform, assurez-vous de disposer des éléments suivants :

    * VPC configuré pour Devin (utilisez un VPC existant ou provisionnez-en un nouveau)
    * Assurez-vous de disposer d'un rôle IAM ou d'un compte de service ayant l'autorisation de :
      * créer des instances EC2 dans un groupe Auto Scaling
      * créer des buckets S3 dans votre région
    * Assurez-vous que votre compte AWS peut prendre en charge des instances avec au moins 70 vCPUs
    * Terraform (version 1.0 ou ultérieure) installé

    ### Processus de déploiement étape par étape

    <Steps>
      <Step title="Collecter les informations sur l'environnement AWS">
        Rassemblez les informations suivantes, qui seront requises pour la configuration Terraform :

        * Numéro de compte AWS (numéro à 12 chiffres)
        * ID du VPC (vpc-xxxxxxxxxxxxxxxxx)
        * Deux IDs de sous-réseau (subnets) :
          * subnet-xxxxxxxxxxxxxxxxx
          * subnet-xxxxxxxxxxxxxxxxx

        **Commandes AWS CLI utiles :**

        ```bash theme={null}
        # Lister vos VPC
        aws ec2 describe-vpcs

        # Lister les sous-réseaux dans un VPC spécifique
        aws ec2 describe-subnets --filters "Name=vpc-id,Values=<your-vpc-id>"
        ```
      </Step>

      <Step title="Configurer l'accès au pare-feu">
        <Tabs>
          <Tab title="Pare-feu des appareils utilisateurs">
            Assurez-vous que vos systèmes de sécurité de terminaux (appareils des utilisateurs qui accéderont à Devin) autorisent l'accès à :

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

          <Tab title="Pare-feu du VPC">
            Assurez-vous que les groupes de sécurité de votre VPC autorisent l'accès à :

            * 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="Obtenir la configuration Terraform et le jeton d'authentification">
        Contactez Cognition pour recevoir :

        1. Un jeton d'authentification pour récupérer l'image de l'hyperviseur
        2. Les fichiers de configuration Terraform personnalisés pour votre environnement

        Une fois que vous aurez partagé les informations sur votre environnement (de l'étape 1), nous vous fournirons ces ressources.
      </Step>

      <Step title="Exécuter le script Terraform">
        Nous pouvons planifier un appel pour exécuter cette étape ensemble. Le processus consiste à :

        1. Extraire les fichiers de configuration Terraform dans un répertoire sur votre machine locale :
           ```bash theme={null}
           mkdir -p ~/devin-terraform && cd ~/devin-terraform
           # Extraire les fichiers reçus de Cognition
           ```

        2. Initialiser l'environnement Terraform :
           ```bash theme={null}
           terraform init
           ```

        3. Examiner les modifications d'infrastructure planifiées :
           ```bash theme={null}
           terraform plan
           ```

        4. Appliquer la configuration pour provisionner l'infrastructure :
           ```bash theme={null}
           terraform apply
           ```

        5. Confirmer les modifications lorsque vous y êtes invité.

        <Note>
          Les scripts Terraform configureront tous les composants nécessaires, y compris les instances EC2, les buckets S3, les groupes de sécurité, les rôles IAM et l'enregistrement de l'hyperviseur.
        </Note>
      </Step>

      <Step title="Lancer la première session Devin">
        Une fois le script Terraform exécuté avec succès, nous collaborerons pour :

        1. Vérifier que les ressources ont été créées dans votre console AWS
        2. Lancer une première session Devin afin de vérifier la connectivité aux services requis
        3. Déboguer tout problème éventuel avec le support de l'équipe Cognition
      </Step>
    </Steps>
  </Tab>

  <Tab title="Configuration avancée (mode manuel)">
    ## Déploiement manuel

    Si le déploiement de Terraform n'est pas possible dans votre environnement, cette section présente les étapes manuelles requises pour provisionner l'infrastructure.

    ### Exigences réseau

    Notez que la configuration manuelle des composants réseau est nécessaire. Vous pouvez consulter nos ressources pour obtenir de l'aide.

    ### Étapes de déploiement

    <Steps>
      <Step title="Configurer des instances pour exécuter des machines virtuelles">
        Devin nécessite une instance hôte pour exécuter des **machines virtuelles isolées** pour chaque session.

        #### **Exigences relatives à l’instance**

        | Exigence                          | Détails                                                                                        |
        | :-------------------------------- | :--------------------------------------------------------------------------------------------- |
        | **Type d’instance**               | Instances bare metal (`i3.metal`)                                                              |
        | **Système d’exploitation**        | Ubuntu 24.04                                                                                   |
        | **Dimensionnement de l’instance** | - 2 vCPUs, 8 Go de RAM, 128 Go de stockage  <br /> - 8 vCPUs, 32 Go de RAM, 128 Go de stockage |
        | **Remarque**                      | La taille de l’instance détermine le nombre maximal de sessions Devin simultanées.             |
        | **Recommandation**                | Nous recommandons `i3.metal` comme référence de base.                                          |

        <Tip>
          Vous pouvez effectuer une **mise à l’échelle horizontale** en ajoutant davantage d’instances hôtes pour augmenter la capacité de Devin.
        </Tip>

        #### **Règles du groupe de sécurité**

        | **Configuration**               | **Détails**                                           |
        | :------------------------------ | :---------------------------------------------------- |
        | **Configuration du VPC**        | Configurez le VPC et les règles du groupe de sécurité |
        | **Règles de pare-feu requises** | **Accès Internet sortant sur le port 443 vers :**     |
        |                                 | `frp-server-0.devin.ai`                               |
        |                                 | `static.devin.ai`                                     |
        |                                 | `api.devin.ai`                                        |

        <Warning>
          Un accès général à Internet est **fortement recommandé**, mais pas obligatoire.
        </Warning>
      </Step>

      <Step title="Configurer le stockage des machines virtuelles">
        Lorsque les **sessions Devin** sont suspendues, leur état est **compressé et stocké**.

        #### **2.1 Créer un bucket S3**

        1. Accédez à **S3** dans la **console de gestion AWS**
        2. Sélectionnez la région appropriée
        3. Cliquez sur **Create bucket**
        4. Définissez le **Bucket name** comme :

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

           *(Remplacez `${YOUR_ORGANIZATION}` et `${BUCKET_REGION}` par des valeurs réelles)*
        5. Cliquez sur **Create bucket**

        #### **2.2 Appliquer la stratégie de bucket S3 et CORS**

        1. Ouvrez le **bucket S3** que vous avez créé
        2. Accédez à l’onglet **Permissions**
        3. Faites défiler jusqu’à **Bucket Policy** et cliquez sur **Edit**
        4. Ajoutez la stratégie suivante, en remplaçant les valeurs de paramètres fictifs :

        ```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. Cliquez sur **Save**
        6. Faites défiler la page jusqu’à **Cross-Origin Resource Sharing (CORS)** et cliquez sur **Edit**
        7. Saisissez la stratégie CORS suivante :

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

        8. Cliquez sur **Save**

        <Note>
          Une fois ces ressources créées, veuillez fournir à Cognition :

          * Votre **AWS Account ID**
          * Le **nom du bucket S3**
          * Le **VPC et les sous-réseaux (subnets)** pour le déploiement
          * L’**ID du Security Group**
          * Tous les **tags** des ressources liées à Devin
        </Note>
      </Step>

      <Step title="Enregistrer un Host Runner">
        Exécutez la commande suivante :

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

        <Note>
          Nous vous fournirons le **AUTH\_TOKEN** séparément. Une fois la configuration terminée, **Devin** sera prêt à lancer des sessions dans votre environnement **VPC**.
        </Note>
      </Step>

      <Step title="Pare-feu : prérequis">
        Si les appareils des utilisateurs sont protégés par un pare-feu, ajoutez les URL suivantes à la liste d’autorisation :

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

        **Exemple de règle AWS WAF**

        <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>