> ## Documentation Index
> Fetch the complete documentation index at: https://docs.devinenterprise.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Avvio rapido
> 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 scope Outposts appropriati:
* `account.outposts.orchestrator` per gli orchestratori che gestiscono gli outpost (implica lo scope della macchina)
* `account.outposts.machine` per i worker che leggono la coda e rivendicano/rilasciano le sessioni
* Una macchina (VM o container) con:
* Devin CLI installato
* Le [dipendenze della macchina](/it/onboard-devin/outposts#machine-dependencies)
* I repository clonati, con i remoti configurati
* Accesso ai build tools, ai registri 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 sei a tuo agio a
lasciare che un agent operi liberamente — o, meglio ancora, su una macchina riservata
a lavoro agentic 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 Outpost che i worker che vuoi assegnargli useranno per autenticarsi con Devin.
Copia il token e conservalo in un posto sicuro per utilizzarlo in futuro. **Il token verrà mostrato una sola volta quando crei l'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 configúrala per l'esecuzione sul tuo Outpost. In "Configuration" → "Virtual environment" vedrai il tuo nuovo Outpost nell'elenco. Selezionalo per eseguire lì la sessione.
Ora puoi chiedere a Devin di iniziare a sviluppare sulla tua macchina! Prova qualcosa di semplice come
```
Create a "hello world" python script for me
```
e guarda lo script comparire nella directory del worker!
### Passaggi successivi
Avvia il worker in una directory in cui si trova il tuo codice e chiedi a Devin di svilupparci sopra. Le sessioni vedono le repo estratte 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 concorrenti e le altre restano in coda.
Esegui automaticamente il provisioning delle macchine man mano che le sessioni entrano in coda, invece di mantenere worker attivi a lungo.
Esegui il tuo outpost sulla piattaforma che già utilizzi — Namespace, Modal, E2B e altre.
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 Linux come piattaforma (i tuoi container vengono eseguiti su Linux). Quindi fai clic sul pulsante "Create".
Dopo aver creato l'Outpost, riceverai un token 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**.
Parti dall'immagine ufficiale di Devin CLI (`public.ecr.aws/e0h8a4b6/devin-cli`), aggiungendo le [dipendenze della macchina](/it/onboard-devin/outposts#machine-dependencies) e tutti i repository o strumenti necessari per le 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:
```
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 repo
nella directory di lavoro in cui il worker viene eseguito: . Il comando default
dovrebbe essere ["worker", "start"].
```
Le funzionalità del 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 di 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. [build secrets](https://docs.docker.com/build/building/secrets/)), in modo che il clone e i remote funzionino correttamente in esecuzione.
Quando sei soddisfatto del tuo Dockerfile, crea l'immagine:
```bash theme={null}
docker build -t devin-worker .
```
Avvia un container dalla tua image con il comando `worker start`, passando il nome del tuo Outpost e il token che hai copiato in precedenza (l'entrypoint dell'image è la 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 configúrala per l'esecuzione sul tuo Outpost. In "Configurazione" → "Ambiente virtuale", vedrai il tuo nuovo Outpost nell'elenco. Selezionalo per eseguire la sessione su di esso.
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 eseguire 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 man mano che le sessioni vengono accodate, invece di mantenere attivi worker di lunga durata.
Esegui il tuo outpost sulla piattaforma che già utilizzi — Namespace, Modal, E2B e altro ancora.