Die erste Anwendung mit erpc worker auf einem Server bereitstellen

Erstellen Sie mit erpc worker eine kleine HTTP API in Rust, führen Sie sie auf Ihrem Rechner aus und stellen Sie sie mit vier Befehlen auf einem Server bereit.

Diese Seite beschreibt ERPC CLI v0.1.0-rc.4, eine Vorabversion.

erpc worker (Alias erpc w) kompiliert Ihre Anwendung zu einer nativen Linux-Binärdatei und führt sie auf einem ERPC VPS, einem neuen stündlich abgerechneten VPS oder einem eigenen Server aus, unter einer gehärteten systemd-Unit, ohne Docker und ohne Laufzeitumgebung dazwischen.

Ein Release, das nicht gesund hochkommt, wird auf das vorherige zurückgerollt, und mehrere Anwendungen können sich einen Server teilen, jede auf einem eigenen Port. Alles über die Anwendung steht in erpc.toml in ihrem Stammverzeichnis; die Datei enthält kein Secret und kann committet werden.

Voraussetzungen

Ein ERPC-Konto, mit dem Sie auf diesem Rechner per erpc login angemeldet sind (Anmeldung und Schlüssel).
ERPC Credit für einen neuen stündlich abgerechneten VPS. Ein stündlich abgerechnetes Produkt wird aus ERPC Credit bezahlt, das vorab gekauft wird, und ein Start, den das Guthaben nicht deckt, wird abgelehnt. Die Preise stehen auf der Seite Preise und im ERPC Web Dashboard.
Ein SSH-Schlüssel auf diesem Rechner: ssh-keygen -t ed25519, oder erpc config set ssh_key <path>.pub für einen Schlüssel, den Sie bereits haben.
Eine Möglichkeit, für Linux zu bauen. Von einem Mac oder unter Windows: das Rust-Target für den Server (rustup target add x86_64-unknown-linux-gnu), zig (brew install zig unter macOS) und cargo-zigbuild (cargo install cargo-zigbuild --locked). Von einem Linux-Rechner derselben Art wie der Server (x86-64 bei jedem ERPC-Server) nichts außer cargo. Ohne die Cross-Build-Werkzeuge wird die Anwendung mit der eigenen Toolchain dieses Rechners gebaut, und die Binärdatei braucht dann die glibc, gegen die sie gelinkt wurde; build und deploy nennen diese. Mit ihnen wird sie für glibc 2.31 und neuer gebaut.

HelloWorld bereitstellen

HelloWorld ist eine kleine HTTP API in Rust, die keinen Schlüssel, kein Secret und keine Datenleitung braucht. Sie beantwortet GET /, GET /hello/{name} und 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 erstellt die Anwendung in ./hello-world, mit ihrer erpc.toml.
run baut die Anwendung und führt sie auf Ihrem Rechner aus, sodass Sie sie zuerst mit curl aufrufen können.
deploy baut sie für den Server und stellt sie dort bereit. Alles, was Geld kostet, wird zuerst mit seinem Stundenpreis, Ihrem Guthaben und der Dauer, für die das Guthaben reicht, angezeigt, und an einem Terminal startet es erst nach einem Ja.
api ruft die API der bereitgestellten Anwendung von Ihrem Rechner aus auf, während die API weiterhin auf dem Loopback des Servers bleibt.

erpc worker check listet auf, was der Anwendung fehlt, und deploy lehnt ab, bevor es etwas kauft, wenn etwas fehlt. erpc worker build führt nur den Build aus; so sehen Sie einen fehlschlagenden Build, bevor ein Server gekauft wird.

Eine Vorlage wählen

erpc worker init fragt nur eines: was erstellt werden soll, ausgewählt mit den Pfeiltasten.

HelloWorld ist die Vorlage für den Einstieg.
HFT und pumpfun-bot werden vorerst beide aus der Vorlage pumpfun erstellt: ein Trading-Bot für pump.fun (PumpSwap), portiert aus ValidatorsDAO/solana-stream.

--template hft (oder helloworld, pumpfun-bot oder eine Vorlagen-ID) überspringt die Auswahl, und --name benennt die Anwendung. Ohne Namen wird die Anwendung nach der Auswahl benannt (hello-world, hft-bot, pumpfun-bot). Existiert bereits ein Verzeichnis dieses Namens, erhält eine Person, die auswählt, -2, -3 und so weiter, und ein Skript (--yes, --json, kein Terminal) erhält einen Fehler. Ist niemand zu fragen und fehlt --template, wird HelloWorld erstellt.

Ein Trading-Bot braucht einen Schlüssel und einige Einstellungen, bevor er läuft. Die Reihenfolge:

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 gibt diese Reihenfolge für die erstellte Anwendung aus. Schlüssel und Secrets beschreibt, wo der Schlüssel und die Secrets aufbewahrt werden.

Den Server wählen

deploy verwendet die erste dieser Möglichkeiten:

den Server, den [env.<name>] der Anwendung bereits nennt;
--vps <id>, einen ERPC VPS Ihres Kontos;
--new-vps, den günstigsten stündlich abgerechneten VPS in der Region, die diesem Rechner nach seiner Zeitzone am nächsten liegt (--region und --plan wählen anders);
--host <address>, einen eigenen Server: Ubuntu oder Debian mit systemd, nftables, sudo und Python 3 unter /usr/bin/python3, mit Zugang als root oder als Benutzer mit passwortlosem sudo;
andernfalls, an einem Terminal, eine Liste der laufenden VPS Ihres Kontos, mit "start a new one" am Ende.

Auf einem eigenen Server verwirft die Firewall des Workers jede eingehende Verbindung außer SSH und dem Port der Anwendung; ein Server, der noch etwas anderes ausliefert, ist daher nicht der richtige.

Ohne Person am Terminal bereitstellen

Ein Skript oder ein Agent wie erpc ai hat kein Terminal, an dem es antworten kann. Mit zwei Optionen erledigt es die Arbeit trotzdem:

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 beantwortet die Preisfrage jedes stündlich abgerechneten Produkts, das der Befehl nennt (--new-vps, --grpc, --shreds, --unlimited). Es beantwortet auch die erste Anmeldung an einem Server, den erpc noch nicht auf reine Schlüssel-Anmeldung umgestellt hat, einem neuen oder einem mit --vps <ID> genannten: erpc meldet sich einmal mit dem Passwort des Servers an, hinterlegt Ihren Schlüssel und schaltet Passwort-Anmeldungen ab. Ohne --yes und ohne Terminal wird ein Start abgelehnt, bevor etwas gekauft wird, mit Exit-Status 3.
Die Auswahl zwischen Ihren Servern braucht weiterhin eine Person. Nennen Sie den Server mit --new-vps, --vps <ID> oder --host.
--prepare erledigt alles, was weder den Trading-Schlüssel noch ein Secret braucht, und startet, stoppt und startet nichts neu. Das nächste erpc worker deploy an einem Terminal übergibt den Schlüssel und die Secrets und startet die Anwendung. Der Trading-Schlüssel wird nur für eine Person am Terminal gelesen.

Ihre Anwendung mit gRPC, Shreds und Unlimited RPC verbinden

Die stündlich abgerechneten Leitungen von ERPC lassen den Server anhand seiner Adresse zu und nehmen kein Token an. Jede Leitung startet für den Server mit ihrer eigenen Option an deploy, und die Anwendung erhält ihren Endpunkt als Einstellung:

Option	Leitung	Die Anwendung erhält
`--grpc`	Geyser gRPC	`GRPC_ENDPOINT`
`--shreds`	Shreds (Shredstream gRPC)	`SHREDS_ENDPOINT`
`--unlimited`	Unlimited RPC in der Region des Servers	`SOLANA_SEND_RPC_ENDPOINT`

Jede Leitung ist die günstigste ihrer Familie, sofern nicht --grpc-plan, --shreds-plan oder --unlimited-plan eine bestimmte nennt.
Das Unlimited RPC läuft auf einem dedizierten Server, dessen Einrichtung bis zu 45 Minuten dauert. Es bedient sendTransaction und eine kurze Liste von Lesemethoden, nicht getProgramAccounts oder getTokenAccountsByOwner. Sein Endpunkt ist einfaches HTTP (kein TLS) und lässt nur die auf der Whitelist stehende Adresse zu.

Leitungen für eine Ausführung auf Ihrem Rechner

erpc worker run nimmt ebenfalls --grpc und --shreds an, um die Anwendung hier mit echten Daten auszuprobieren, bevor sie auf einen Server kommt.

Die Adresse: Die Leitungen lassen die öffentliche IPv4-Adresse dieses Rechners zu, die Sie mit --ip übergeben. erpc ermittelt sie nicht selbst.
Kaufen: Eine neue Leitung wird nur an einem Terminal gekauft, nachdem ihr Preis angezeigt wurde. run hat kein --yes.
Beenden: Wenn die Ausführung endet, wird jede stündlich abgerechnete Leitung nach einer Rückfrage beendet. --keep-lines behält sie, weiterhin kostenpflichtig. Endet die Ausführung auf andere Weise (Terminal geschlossen, ein zweites Ctrl-C), bleiben die Leitungen bestehen und werden berechnet.
Die Messwerte: Was die Anwendung hier misst, schließt die Strecke von diesem Rechner zur Leitung ein; die Anwendung ist hier daher langsamer als auf einem Server in der Nähe der Leitung.

Nächste Schritte

Anwendung importieren: Stellen Sie eine vorhandene Anwendung in beliebiger Sprache bereit.
Schlüssel und Secrets: Halten Sie einen Trading-Schlüssel und Secrets vom Datenträger des Servers fern.
Firewall und WAF: Stellen Sie eine öffentliche API hinter eine WAF.
Status und Abrechnung: Beobachten Sie die Anwendung und sehen Sie, was sie pro Stunde kostet.