---
title: "Distribuisci la tua prima app su un server con erpc worker"
description: "Crea l'app HelloWorld con erpc worker, eseguila sulla tua macchina e distribuiscila su un ERPC VPS o su un server tuo."
canonical: "https://erpc.global/it/doc/erpc-cli/worker-quickstart/"
locale: "it"
---

# Distribuisci la tua prima app su un server con erpc worker

Crea una piccola API HTTP in Rust con `erpc worker`, eseguila sulla tua macchina e distribuiscila su un server con quattro comandi.

Questa pagina descrive ERPC CLI `v0.1.0-rc.4`, una versione pre-release.

`erpc worker` (alias `erpc w`) compila la tua app in un binario Linux nativo e la esegue su un ERPC VPS, su un nuovo VPS orario o su un server tuo, sotto un'unità systemd con hardening, senza Docker e senza alcun runtime nel mezzo.

Una release che all'avvio non risulta integra subisce il rollback alla release precedente, e più app possono condividere un server, ciascuna su una porta propria. Tutto ciò che riguarda l'app si trova in `erpc.toml` nella sua radice, che non contiene alcun secret e può essere incluso in un commit.

## Prerequisiti

- **Un account ERPC**, con l'accesso effettuato su questa macchina tramite `erpc login` ([Accesso e chiavi](https://erpc.global/it/doc/erpc-cli/sign-in-and-keys/)).
- **ERPC Credit**, per un nuovo VPS orario. Un prodotto orario si paga con ERPC Credit, acquistato in anticipo, e un avvio che il credito non copre viene rifiutato. I prezzi sono su [Prezzi](https://erpc.global/it/price/) e nella [ERPC Web Dashboard](https://dashboard.erpc.global/it).
- **Una chiave SSH** su questa macchina: `ssh-keygen -t ed25519`, oppure `erpc config set ssh_key <path>.pub` per una chiave che hai già.
- **Un modo per compilare per Linux.** Da un Mac o da Windows, il target Rust del server (`rustup target add x86_64-unknown-linux-gnu`), `zig` (`brew install zig` su macOS) e `cargo-zigbuild` (`cargo install cargo-zigbuild --locked`). Da una macchina Linux dello stesso tipo del server (x86-64 per ogni server ERPC), non serve altro che cargo. Senza gli strumenti di cross-build, l'app viene compilata con la toolchain di questa macchina, e il binario richiede poi la glibc con cui è stato collegato, che `build` e `deploy` indicano. Con questi strumenti, viene compilata per glibc 2.31 e versioni successive.

## Distribuire HelloWorld

HelloWorld è una piccola API HTTP in Rust che non ha bisogno di nessuna chiave, nessun secret e nessuna linea dati. Risponde a `GET /`, `GET /hello/{name}` e `GET /healthz`.

```bash
erpc worker init --template helloworld   # makes ./hello-world
erpc worker run hello-world              # here: curl http://127.0.0.1:3000/
erpc worker deploy hello-world           # your VPS, or a new hourly one (price asked first)
erpc worker api / --dir hello-world      # {"message":"Hello, World!",…} from the server
```

1. `init` crea l'app in `./hello-world`, con il suo `erpc.toml`.
2. `run` compila l'app e la esegue sulla tua macchina, così puoi prima chiamarla con curl.
3. `deploy` la compila per il server e la distribuisce. Tutto ciò che costa denaro viene mostrato prima, con il prezzo orario, il tuo saldo e quanto dura il credito, e in un terminale parte solo dopo un sì.
4. `api` chiama l'API dell'app distribuita dalla tua macchina, mentre l'API resta sul loopback del server.

`erpc worker check` elenca ciò che manca all'app, e `deploy` si rifiuta di procedere prima di acquistare qualsiasi cosa quando manca qualcosa. `erpc worker build` esegue solo la compilazione: è il modo per vedere una compilazione fallire prima che venga acquistato un server.

## Scegliere un template

`erpc worker init` chiede una sola cosa: che cosa creare, da scegliere con i tasti freccia.

- **HelloWorld** è quello da cui partire.
- **HFT** e **pumpfun-bot** sono entrambi creati, per ora, dal template pumpfun: un trading bot per pump.fun (PumpSwap) portato da ValidatorsDAO/solana-stream.

`--template hft` (oppure `helloworld`, `pumpfun-bot` o l'id di un template) salta la selezione, e `--name` dà il nome all'app. Senza un nome, l'app prende il nome della scelta (`hello-world`, `hft-bot`, `pumpfun-bot`). Quando esiste già una directory con quel nome, una persona che sceglie ottiene `-2`, `-3` e così via, mentre uno script (`--yes`, `--json`, nessun terminale) riceve un errore. Senza nessuno a cui chiedere e senza `--template`, viene creato HelloWorld.

Un trading bot ha bisogno di una chiave e di alcune impostazioni prima di essere eseguito. Ecco l'ordine:

```bash
erpc login                             # once per machine: the session in 1Password or the keychain
erpc worker init                       # pick with the arrow keys; makes ./<name> with erpc.toml
cd <name>
erpc worker key new                    # the trading key, in 1Password, the keychain or the keystore; prints the public key to fund
erpc worker secret put API_TOKEN --generate          # the bot's own API token, made for you and shown to nobody
erpc worker secret put ERPC_API_KEY --from-account   # the account's RPC key, read from your account (or SOLANA_RPC_ENDPOINT in [vars])
erpc worker check                      # what erpc.toml describes, and what is missing
erpc worker run --grpc --ip <IPV4>     # build and run here, with an hourly gRPC line letting this machine in
erpc worker run --check --grpc --ip <IPV4>   # the same, stopped once healthy
erpc worker deploy --new-vps --grpc    # a new hourly VPS and gRPC line, prices asked first
```

`init` stampa questo ordine per l'app che ha creato. [Chiavi e secret](https://erpc.global/it/doc/erpc-cli/worker-secrets/) spiega dove vengono conservati la chiave e i secret.

## Scegliere il server

`deploy` usa la prima di queste opzioni:

1. il server che `[env.<name>]` dell'app indica già;
2. `--vps <id>`, un ERPC VPS del tuo account;
3. `--new-vps`, il VPS orario più economico nella regione più vicina a questa macchina in base al suo fuso orario (`--region` e `--plan` scelgono diversamente);
4. `--host <address>`, un server tuo: Ubuntu o Debian con systemd, nftables, `sudo` e Python 3 in `/usr/bin/python3`, raggiunto come root o come un utente con sudo senza password;
5. altrimenti, in un terminale, un elenco dei VPS in esecuzione del tuo account, con "start a new one" in fondo.

Su un server tuo, il firewall del worker scarta ogni connessione in entrata tranne SSH e la porta dell'app, quindi un server che serve qualsiasi altra cosa non è quello da usare.

## Distribuire senza una persona al terminale

Uno script, o un agente come `erpc ai`, non ha un terminale da cui rispondere. Due flag gli permettono di fare comunque il lavoro:

```bash
erpc worker deploy hello-world --new-vps --yes                     # no key: all the way, unattended
erpc worker deploy pump-sniper --new-vps --grpc --yes --prepare    # a bot: everything but its key
erpc worker deploy pump-sniper                                     # then you, at a terminal: the key, and the start
```

- **`--yes`** risponde al prezzo di ogni prodotto orario che il comando nomina (`--new-vps`, `--grpc`, `--shreds`, `--unlimited`). Risponde anche al primo login su un server che erpc non ha ancora reso accessibile solo con chiave, uno nuovo o uno indicato con `--vps <ID>`: erpc accede una volta con la password del server, inserisce la tua chiave e disattiva i login con password. Senza `--yes` e senza un terminale, un avvio viene rifiutato prima che venga acquistata qualsiasi cosa, con stato di uscita 3.
- **Scegliere tra i tuoi server richiede ancora una persona.** Indica il server con `--new-vps`, `--vps <ID>` o `--host`.
- **`--prepare`** fa tutto ciò che non richiede né la chiave di trading né un secret, e non avvia, arresta né riavvia nulla. Il successivo `erpc worker deploy` in un terminale consegna la chiave e i secret e avvia l'app. La chiave di trading viene letta solo per una persona al terminale.

## Collegare la tua app a gRPC, Shreds e Unlimited RPC

Le linee orarie di ERPC ammettono il server in base al suo indirizzo e non accettano alcun token. Ciascuna linea viene avviata per il server da un flag proprio su `deploy`, e l'app riceve l'endpoint della linea come impostazione:

| Flag | Linea | L'app riceve |
| --- | --- | --- |
| `--grpc` | Geyser gRPC | `GRPC_ENDPOINT` |
| `--shreds` | Shreds (Shredstream gRPC) | `SHREDS_ENDPOINT` |
| `--unlimited` | Unlimited RPC nella regione del server | `SOLANA_SEND_RPC_ENDPOINT` |

- Ogni linea è la più economica della sua famiglia, a meno che `--grpc-plan`, `--shreds-plan` o `--unlimited-plan` non ne indichi una.
- L'Unlimited RPC gira su un server dedicato che richiede fino a 45 minuti per essere configurato. Serve `sendTransaction` e un breve elenco di letture, non `getProgramAccounts` né `getTokenAccountsByOwner`. Il suo endpoint è HTTP semplice (senza TLS) e ammette solo l'indirizzo in whitelist.

### Linee per un'esecuzione sulla tua macchina

Anche `erpc worker run` accetta `--grpc` e `--shreds`, per provare l'app qui con dati reali prima che passi su un server.

- **L'indirizzo:** le linee ammettono l'indirizzo IPv4 pubblico di questa macchina, che passi con `--ip`. erpc non lo ricava da solo.
- **L'acquisto:** una nuova linea si acquista solo in un terminale, dopo che ne è stato mostrato il prezzo. `run` non ha `--yes`.
- **La chiusura:** quando l'esecuzione termina, ogni linea oraria viene terminata dopo una richiesta di conferma. `--keep-lines` le mantiene, e l'addebito continua. Se l'esecuzione termina in un altro modo (il terminale chiuso, un secondo Ctrl-C), le linee restano e vengono addebitate.
- **I numeri:** ciò che l'app misura qui include la distanza tra questa macchina e la linea, quindi risulta più lenta della stessa app su un server vicino alla linea.

## Prossimi passi

- [Importare un'app](https://erpc.global/it/doc/erpc-cli/worker-import/): distribuisci un'app che hai già, in qualsiasi linguaggio.
- [Chiavi e secret](https://erpc.global/it/doc/erpc-cli/worker-secrets/): tieni la chiave di trading e i secret lontano dal disco del server.
- [Firewall e WAF](https://erpc.global/it/doc/erpc-cli/worker-firewall-and-waf/): metti un'API pubblica dietro un WAF.
- [Stato e fatturazione](https://erpc.global/it/doc/erpc-cli/worker-status-and-billing/): tieni d'occhio l'app e vedi quanto costa all'ora.