> ## 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.
# Démarrage rapide
> Créer un outpost et exécuter des sessions depuis une seule machine
* Une organization avec Outposts activé
* Un [jeton d’API v3](/fr/api-reference/v3/overview) avec les périmètres Outposts appropriés :
* `account.outposts.orchestrator` pour les orchestrators qui gèrent les outposts (inclut le périmètre machine)
* `account.outposts.machine` pour les workers qui lisent la file d’attente et récupèrent/libèrent les sessions
* Une machine (VM ou container) avec :
* Le Devin CLI installé
* Les [dépendances de la machine](/fr/cloud/outposts/overview#machine-dependencies)
* Vos repositories clonés, avec des remotes configurés
* L’accès aux build tools, aux registries de packages, aux secrets et aux services internes dont vos sessions ont besoin
Les sessions s’exécutent directement sur la machine avec les autorisations associées à votre compte utilisateur. Nous
recommandons d’exécuter le worker dans un répertoire dédié où vous êtes à l’aise
de laisser un agent travailler librement — ou, mieux encore, sur une machine réservée
à des tâches agentiques de longue durée, comme un Mac Mini sur votre bureau.
Téléchargez et installez le [Devin CLI](/fr/cli) :
```bash theme={null}
curl -fsSL https://cli.devin.ai/install.sh | bash
```
Dans [Devin Cloud](https://app.devin.ai), accédez à Settings → Environment → Outposts, puis cliquez sur le bouton "Create Outpost".
Donnez un nom à votre Outpost et choisissez le type de machines qu’il prendra en charge (p. ex. Linux, Windows ou Mac). Ensuite, cliquez sur le bouton "Create".
Après avoir créé votre Outpost, vous obtiendrez un jeton Outpost que les workers que vous souhaitez y affecter utiliseront pour s’authentifier auprès de Devin.
Copiez le jeton et conservez-le dans un endroit sûr pour une utilisation ultérieure. **Le jeton ne sera affiché qu’une seule fois lors de la création de l’Outpost**.
Accédez au répertoire dans lequel vous souhaitez exécuter votre worker :
```bash theme={null}
cd /path/to/worker/directory
```
Exécutez ensuite la commande `devin worker start` avec le nom de votre Outpost et le jeton que vous avez copiés précédemment :
```bash theme={null}
devin worker start --outpost= --token=
```
Dans [Devin Cloud](https://app.devin.ai), démarrez une nouvelle session et configurez-la pour qu’elle s’exécute sur votre Outpost. Sous "Configuration" → "Virtual environment", vous verrez votre nouvel Outpost dans la liste. Sélectionnez-le pour y exécuter votre session.
Vous pouvez maintenant demander à Devin de commencer à développer sur votre machine ! Essayez quelque chose de simple, comme
```
Create a "hello world" python script for me
```
et regardez le script apparaître dans le répertoire de votre worker !
### Prochaines étapes
Démarrez le worker dans un répertoire où se trouve votre code et demandez à Devin de développer à partir de celui-ci. Les sessions voient les dépôts clonés dans le répertoire de travail du worker. Pour traiter plus de sessions en parallèle, exécutez le worker sur davantage de machines pointant vers le même outpost : N workers servent N sessions simultanées, et les autres attendent dans la file d’attente.
Provisionnez automatiquement les machines à mesure que des sessions entrent dans la file d’attente, au lieu de conserver des workers persistants.
Exécutez votre outpost sur la plateforme que vous utilisez déjà — Namespace, Modal, E2B, et bien plus encore.
Sur [Devin Cloud](https://app.devin.ai), accédez à Settings → Environment → Outposts, puis cliquez sur le bouton "Create Outpost".
Donnez un nom à votre Outpost et choisissez Linux comme plateforme (vos conteneurs s’exécutent sous Linux). Cliquez ensuite sur le bouton "Create".
Une fois votre Outpost créé, vous obtiendrez un token d’Outpost que les workers que vous souhaitez y affecter utiliseront pour s’authentifier auprès de Devin.
Copiez le token et conservez-le dans un endroit sûr pour une utilisation ultérieure. **Le token ne sera affiché qu’une seule fois, lors de la création de l’Outpost**.
Partez de l’image officielle de Devin CLI (`public.ecr.aws/e0h8a4b6/devin-cli`) en y ajoutant les [dépendances de la machine](/fr/cloud/outposts/overview#machine-dependencies) ainsi que tous les dépôts ou outils dont vos sessions ont besoin :
```dockerfile Dockerfile theme={null}
# Le Devin CLI est préinstallé et constitue l'entrypoint de l'image.
# Utilisez :stable, ou épinglez un tag de version spécifique du CLI.
FROM public.ecr.aws/e0h8a4b6/devin-cli:stable
# git est requis ; ffmpeg active les fonctionnalités d'enregistrement d'écran
RUN apt-get update && apt-get install -y --no-install-recommends \
ca-certificates git ffmpeg \
&& rm -rf /var/lib/apt/lists/*
# Le répertoire dans lequel le worker s'exécute
WORKDIR /repos
# Si nécessaire, clonez les dépôts dont vos sessions ont besoin :
# RUN git clone https://github.com/your-org/app.git \
# && git clone https://github.com/your-org/infra.git
CMD ["worker", "start"]
```
Ou demandez à Devin de créer un Dockerfile :
```
Écris un Dockerfile pour une image worker Devin Outposts. Base-la sur
public.ecr.aws/e0h8a4b6/devin-cli:stable, qui a le Devin CLI préinstallé
en tant qu'entrypoint de l'image. Installe git et ffmpeg. Clone ces dépôts
dans le répertoire de travail où le worker s'exécute : . La commande
par défaut doit être ["worker", "start"].
```
Les fonctionnalités du Browser nécessitent Chrome ou Chromium dans l’image, avec
`DEVIN_CHROME_PATH` pointant vers le binaire. L’image de base est Ubuntu, et
le package apt `chromium` d’Ubuntu est un stub Snap qui ne fonctionne pas dans
les conteneurs — pour les images amd64, installez plutôt Google Chrome :
```dockerfile theme={null}
RUN apt-get update && apt-get install -y --no-install-recommends curl \
&& curl -fsSL https://dl.google.com/linux/direct/google-chrome-stable_current_amd64.deb -o /tmp/chrome.deb \
&& apt-get install -y --no-install-recommends /tmp/chrome.deb \
&& rm /tmp/chrome.deb && rm -rf /var/lib/apt/lists/*
ENV DEVIN_CHROME_PATH=/usr/bin/google-chrome
```
Pour les dépôts privés, intégrez les identifiants avec le mécanisme de votre choix (p. ex. les [build secrets](https://docs.docker.com/build/building/secrets/)) afin que les clones et les remotes fonctionnent au moment de l’exécution.
Lorsque votre Dockerfile vous convient, construisez l’image :
```bash theme={null}
docker build -t devin-worker .
```
Démarrez un conteneur à partir de votre image avec la commande `worker start`, en indiquant le nom de votre Outpost et le jeton copié précédemment (le point d’entrée de l’image est Devin CLI, donc les arguments sont transmis directement à `devin`) :
```bash theme={null}
docker run devin-worker \
worker start --outpost= --token=
```
Sur [Devin Cloud](https://app.devin.ai), démarrez une nouvelle session et configurez-la pour qu’elle s’exécute sur votre Outpost. Dans "Configuration" → "Environnement virtuel", votre nouvel Outpost apparaîtra dans la liste. Sélectionnez-le pour y exécuter votre session.
Vous pouvez maintenant demander à Devin de lancer un build dans votre container ! Essayez quelque chose de simple comme
```
Create a "hello world" python script for me
```
Et regardez le script apparaître dans le répertoire de travail du conteneur !
### Étapes suivantes
Intégrez les repositories sur lesquels vous souhaitez que Devin travaille dans l'image et demandez à Devin d'effectuer des builds par-dessus — les sessions voient les repositories extraits dans le répertoire de travail du worker. Pour traiter davantage de sessions en parallèle, lancez davantage de containers pointant vers le même outpost : N workers traitent N sessions simultanées, et les autres attendent dans la file d'attente.
Provisionnez automatiquement des conteneurs lorsque des sessions sont mises en file d’attente, au lieu de maintenir des workers persistants.
Exécutez votre outpost sur la plateforme que vous utilisez déjà — Namespace, Modal, E2B, et bien d’autres.