Déployer votre première application sur un serveur avec erpc worker

Créez une petite API HTTP en Rust avec erpc worker, exécutez-la sur votre machine et déployez-la sur un serveur en quatre commandes.

Cette page décrit ERPC CLI v0.1.0-rc.4, une préversion.

erpc worker (alias erpc w) compile votre application en binaire Linux natif et l'exécute sur un ERPC VPS, sur un nouveau VPS horaire ou sur votre propre serveur, sous une unité systemd durcie, sans Docker ni runtime intermédiaire.

Une release qui ne démarre pas saine est ramenée à la release précédente, et plusieurs applications peuvent partager un même serveur, chacune sur son propre port. Tout ce qui concerne l'application se trouve dans erpc.toml, à sa racine ; ce fichier ne contient aucun secret et peut être commité.

Prérequis

Un compte ERPC, connecté sur cette machine avec erpc login (Connexion et clés).
Des ERPC Credits, pour un nouveau VPS horaire. Un produit horaire est payé en ERPC Credits, achetés à l'avance, et un démarrage que le crédit ne couvre pas est refusé. Les prix figurent sur la page Tarifs et dans l'ERPC Web Dashboard.
Une clé SSH sur cette machine : ssh-keygen -t ed25519, ou erpc config set ssh_key <path>.pub pour une clé que vous avez déjà.
Un moyen de compiler pour Linux. Depuis un Mac ou Windows : la cible Rust du serveur (rustup target add x86_64-unknown-linux-gnu), zig (brew install zig sur macOS) et cargo-zigbuild (cargo install cargo-zigbuild --locked). Depuis une machine Linux du même type que le serveur (x86-64 pour tous les serveurs ERPC), cargo suffit. Sans les outils de compilation croisée, l'application est compilée avec la chaîne d'outils de cette machine, et le binaire a alors besoin de la glibc avec laquelle il a été lié, que build et deploy indiquent. Avec ces outils, il est compilé pour glibc 2.31 et les versions ultérieures.

Déployer HelloWorld

HelloWorld est une petite API HTTP en Rust qui n'a besoin d'aucune clé, d'aucun secret ni d'aucune ligne de données. Elle répond à GET /, GET /hello/{name} et 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

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

init crée l'application dans ./hello-world, avec son erpc.toml.
run compile l'application et l'exécute sur votre machine, pour que vous puissiez d'abord l'appeler avec curl.
deploy la compile pour le serveur et la déploie. Tout ce qui coûte de l'argent est d'abord affiché avec son prix horaire, votre solde et la durée que couvre le crédit, et, dans un terminal, ne démarre qu'après un oui.
api appelle l'API de l'application déployée depuis votre machine, l'API restant sur le loopback du serveur.

erpc worker check liste ce qui manque à l'application, et deploy refuse avant d'acheter quoi que ce soit s'il manque quelque chose. erpc worker build lance la compilation seule : c'est le moyen de voir une compilation échouer avant l'achat d'un serveur.

Choisir un modèle

erpc worker init ne demande qu'une chose : quoi créer, à choisir avec les flèches.

HelloWorld est celui par lequel commencer.
HFT et pumpfun-bot sont tous deux créés à partir du modèle pumpfun pour l'instant : un bot de trading pump.fun (PumpSwap) porté depuis ValidatorsDAO/solana-stream.

--template hft (ou helloworld, pumpfun-bot, ou un identifiant de modèle) saute le sélecteur, et --name donne son nom à l'application. Sans nom, l'application prend le nom du choix (hello-world, hft-bot, pumpfun-bot). Lorsqu'un répertoire de ce nom existe, une personne qui choisit obtient -2, -3 et ainsi de suite, et un script (--yes, --json, sans terminal) obtient une erreur. Sans personne à qui demander et sans --template, c'est HelloWorld qui est créé.

Un bot de trading a besoin d'une clé et de quelques paramètres avant de s'exécuter. Dans l'ordre :

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

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 affiche cet ordre pour l'application qu'il a créée. Clés et secrets explique où la clé et les secrets sont conservés.

Choisir le serveur

deploy utilise le premier des choix suivants :

le serveur que [env.<name>] de l'application désigne déjà ;
--vps <id>, un ERPC VPS de votre compte ;
--new-vps, le VPS horaire le moins cher dans la région la plus proche de cette machine d'après son fuseau horaire (--region et --plan en décident autrement) ;
--host <address>, votre propre serveur : Ubuntu ou Debian avec systemd, nftables, sudo et Python 3 dans /usr/bin/python3, accessible en root ou via un utilisateur disposant de sudo sans mot de passe ;
sinon, dans un terminal, une liste des VPS de votre compte en cours d'exécution, avec "start a new one" à la fin.

Sur votre propre serveur, le pare-feu du worker ignore toute connexion entrante sauf SSH et le port de l'application ; un serveur qui sert autre chose n'est donc pas celui à utiliser.

Déployer sans personne devant le terminal

Un script, ou un agent comme erpc ai, n'a pas de terminal où répondre. Deux options lui permettent malgré tout de faire le travail :

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

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 répond à la demande de prix de chaque produit horaire que nomme la commande (--new-vps, --grpc, --shreds, --unlimited). Il répond aussi à la première connexion à un serveur qu'erpc n'a pas encore passé en connexion par clé uniquement, qu'il soit nouveau ou désigné avec --vps <ID> : erpc se connecte une fois avec le mot de passe du serveur, y installe votre clé et désactive les connexions par mot de passe. Sans --yes et sans terminal, un démarrage est refusé avant tout achat, avec le statut de sortie 3.
Choisir parmi vos serveurs nécessite toujours une personne. Désignez le serveur avec --new-vps, --vps <ID> ou --host.
--prepare fait tout ce qui ne nécessite ni la clé de trading ni un secret, et ne démarre, n'arrête ni ne redémarre rien. Le erpc worker deploy suivant, dans un terminal, transmet la clé et les secrets et démarre l'application. La clé de trading n'est lue que pour une personne devant le terminal.

Connecter votre application à gRPC, Shreds et Unlimited RPC

Les lignes horaires d'ERPC admettent le serveur d'après son adresse et n'acceptent aucun token. Chaque ligne est démarrée pour le serveur par sa propre option de deploy, et l'application reçoit son endpoint sous forme de paramètre :

Option	Ligne	L'application reçoit
`--grpc`	Geyser gRPC	`GRPC_ENDPOINT`
`--shreds`	Shreds (Shredstream gRPC)	`SHREDS_ENDPOINT`
`--unlimited`	Unlimited RPC dans la région du serveur	`SOLANA_SEND_RPC_ENDPOINT`

Chaque ligne est la moins chère de sa famille, sauf si --grpc-plan, --shreds-plan ou --unlimited-plan en désigne une.
L'Unlimited RPC s'exécute sur un serveur dédié dont la mise en place prend jusqu'à 45 minutes. Il sert sendTransaction et une courte liste de lectures, mais pas getProgramAccounts ni getTokenAccountsByOwner. Son endpoint est en HTTP simple (sans TLS) et n'admet que l'adresse en liste blanche.

Lignes pour une exécution sur votre machine

erpc worker run accepte aussi --grpc et --shreds, pour essayer l'application ici sur des données réelles avant qu'elle parte sur un serveur.

L'adresse : les lignes admettent l'adresse IPv4 publique de cette machine, que vous passez avec --ip. erpc ne la détermine pas lui-même.
L'achat : une nouvelle ligne n'est achetée que dans un terminal, après l'affichage de son prix. run n'a pas de --yes.
La fin : à la fin de l'exécution, il est mis fin à chaque ligne horaire après confirmation. --keep-lines les conserve, toujours facturées. Si l'exécution se termine autrement (terminal fermé, second Ctrl-C), les lignes restent et sont facturées.
Les chiffres : ce que l'application mesure ici inclut la distance entre cette machine et la ligne ; l'application y est donc plus lente que sur un serveur proche de la ligne.

Prochaines étapes

Importer une application : déployez une application que vous avez déjà, dans n'importe quel langage.
Clés et secrets : gardez une clé de trading et des secrets hors du disque du serveur.
Pare-feu et WAF : placez une API publique derrière un WAF.
Statut et facturation : surveillez l'application et voyez ce qu'elle coûte à l'heure.