> ## 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.
# Guida rapida
> Crea un outpost ed esegui sessioni da una singola macchina
* Un'organizzazione con Outposts abilitato
* Un [token API v3](/it/api-reference/v3/overview) con gli ambiti Outposts appropriati:
* `account.outposts.orchestrator` per gli orchestrator che gestiscono gli outpost (include anche l'ambito macchina)
* `account.outposts.machine` per i worker che leggono la coda e rivendicano e rilasciano le sessioni
* Una macchina (VM o container) con:
* Devin CLI installata
* Le [dipendenze della macchina](/it/cloud/outposts/overview#machine-dependencies)
* I repository clonati, con i remote configurati
* Accesso ai build tools, ai registry di pacchetti, ai secret e ai servizi interni necessari per le sessioni
Le sessioni vengono eseguite direttamente sulla macchina con le autorizzazioni del tuo utente. Ti
consigliamo di eseguire il worker in una directory dedicata in cui ti senti a tuo agio
nel lasciare lavorare liberamente un agente — o, meglio ancora, su una macchina riservata
ad attività agentiche di lunga durata, come un Mac Mini sulla tua scrivania.
Scarica e installa [Devin CLI](/it/cli):
```bash theme={null}
curl -fsSL https://cli.devin.ai/install.sh | bash
```
In [Devin Cloud](https://app.devin.ai) vai su Settings → Environment → Outposts e fai clic sul pulsante "Create Outpost".
Assegna un nome al tuo Outpost e scegli il tipo di macchine che gestirà (ad es. Linux, Windows o Mac). Quindi, fai clic sul pulsante "Create".
Dopo aver creato il tuo Outpost, riceverai un token dell'Outpost che i worker che vuoi assegnargli useranno per autenticarsi con Devin.
Copia il token e conservalo in un luogo sicuro per usarlo in futuro. **Il token verrà mostrato una sola volta, al momento della creazione dell'Outpost**.
Vai alla directory in cui vuoi eseguire il worker:
```bash theme={null}
cd /path/to/worker/directory
```
Quindi esegui il comando `devin worker start` con il nome del tuo Outpost e il token che hai copiato in precedenza:
```bash theme={null}
devin worker start --outpost= --token=
```
In [Devin Cloud](https://app.devin.ai), avvia una nuova sessione e configurala perché venga eseguita sul tuo Outpost. In "Configuration" → "Virtual environment", vedrai il tuo nuovo Outpost nell'elenco. Selezionalo per eseguire la sessione lì.
Ora puoi chiedere a Devin di iniziare a lavorare sulla tua macchina! Prova con qualcosa di semplice, ad esempio
```
Create a "hello world" python script for me
```
E vedrai comparire lo script nella directory del tuo worker!
### Passaggi successivi
Avvia il worker in una directory in cui si trova il tuo codice e chiedi a Devin di sviluppare partendo da lì. Le sessioni vedono i repository presenti nella directory di lavoro del worker. Per gestire più sessioni contemporaneamente, esegui il worker su più macchine che puntano allo stesso outpost: N worker gestiscono N sessioni simultanee, mentre le altre restano in coda.
Esegui automaticamente il provisioning delle macchine quando le sessioni entrano in coda, invece di mantenere worker di lunga durata.
Esegui il tuo outpost sulla piattaforma che usi già — Namespace, Modal, E2B e altre.
In [Devin Cloud](https://app.devin.ai), vai a Settings → Environment → Outposts e fai clic sul pulsante "Create Outpost".
Assegna un nome all'Outpost e scegli Linux come piattaforma (i container vengono eseguiti su Linux). Quindi fai clic sul pulsante "Create".
Dopo aver creato l'Outpost, riceverai un token dell'Outpost che i workers che vuoi assegnargli useranno per autenticarsi con Devin.
Copia il token e conservalo in un luogo sicuro per usarlo in futuro. **Il token viene mostrato una sola volta, quando crei l'Outpost**.
Parti dall'immagine ufficiale di Devin CLI (`public.ecr.aws/e0h8a4b6/devin-cli`), aggiungendo le [dipendenze della macchina](/it/cloud/outposts/overview#machine-dependencies) e tutti i repository o gli strumenti necessari alle tue sessioni:
```dockerfile Dockerfile theme={null}
# Il Devin CLI è preinstallato ed è l'entrypoint dell'immagine.
# Usa :stable, o blocca una versione specifica del CLI tramite tag.
FROM public.ecr.aws/e0h8a4b6/devin-cli:stable
# git è obbligatorio; ffmpeg abilita le funzionalità di registrazione dello schermo
RUN apt-get update && apt-get install -y --no-install-recommends \
ca-certificates git ffmpeg \
&& rm -rf /var/lib/apt/lists/*
# La directory in cui viene eseguito il worker
WORKDIR /repos
# Facoltativamente, clona i repo necessari alle tue sessioni:
# RUN git clone https://github.com/your-org/app.git \
# && git clone https://github.com/your-org/infra.git
CMD ["worker", "start"]
```
Oppure chiedi a Devin di creare un Dockerfile per te:
```
Scrivi un Dockerfile per un'immagine worker di Devin Outposts. Basala su
public.ecr.aws/e0h8a4b6/devin-cli:stable, che ha il Devin CLI preinstallato
come entrypoint dell'immagine. Installa git e ffmpeg. Clona questi repository
nella directory di lavoro in cui viene eseguito il worker: . Il comando
default deve essere ["worker", "start"].
```
Le funzionalità di Browser richiedono Chrome o Chromium nell'immagine, con
`DEVIN_CHROME_PATH` che punta al binario. L'immagine di base è Ubuntu e il
pacchetto apt `chromium` di Ubuntu è uno stub snap che non funziona nei
container: per le immagini amd64, installa invece 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
```
Per i repository privati, includi le credenziali con il meccanismo che preferisci (ad es. [secret di build](https://docs.docker.com/build/building/secrets/)), in modo che i clone e i remote funzionino in fase di esecuzione.
Quando sei soddisfatto del tuo Dockerfile, crea l'immagine:
```bash theme={null}
docker build -t devin-worker .
```
Avvia un container dalla tua immagine con il comando `worker start`, passando il nome del tuo Outpost e il token che hai copiato in precedenza (l'entrypoint dell'immagine è Devin CLI, quindi gli argomenti vengono passati direttamente a `devin`):
```bash theme={null}
docker run devin-worker \
worker start --outpost= --token=
```
Su [Devin Cloud](https://app.devin.ai), avvia una nuova sessione e configurala per l'esecuzione sul tuo Outpost. In "Configurazione" → "Ambiente virtuale", vedrai il tuo nuovo Outpost nell'elenco. Selezionalo per eseguire la sessione lì.
Ora puoi chiedere a Devin di iniziare a sviluppare nel tuo container! Prova qualcosa di semplice come
```
Create a "hello world" python script for me
```
E vedrai comparire lo script nella directory di lavoro del container!
### Passaggi successivi
Incorpora i repository su cui vuoi che Devin lavori nell'image e chiedi a Devin di fare il build a partire da essi — le session vedono i repository estratti nella directory di lavoro del worker. Per gestire più session in contemporanea, esegui più container puntati allo stesso outpost: N worker gestiscono N session concorrenti, mentre le restanti attendono in coda.
Esegui automaticamente il provisioning dei container quando le sessioni entrano in coda, invece di mantenere worker persistenti.
Esegui il tuo outpost sulla piattaforma che usi già — Namespace, Modal, E2B e altro ancora.