So hostest du einen teloxide-Bot 24/7

Um einen teloxide-Bot 24/7 zu hosten, lässt du ihn auf einem Rechner laufen, der immer an bleibt: auf einem Linux-VPS mit einem systemd-Dienst, der ihn neu startet, wenn er stoppt, oder mit einem Bot-Tarif bei PlayNHost (ab 1,99 US$ im Monat). Dort lädst du das fertige Programm hoch, und das Panel gibt ihm das Token und startet es neu, falls es abstürzt. In unserem Test brauchte ein Bot mit teloxide 0.17.0 etwa 13 MB Speicher. Ein Rust-Bot wird auf deinem eigenen Computer als ein Linux-x86-64-Programm gebaut: Auf dem Server wird nichts kompiliert. Bot::from_env() von teloxide liest das Token aus TELOXIDE_TOKEN, einem Namen, den das Panel für dich setzt. Die Schritte bei PlayNHost:

1. Baue deinen Bot auf deinem Computer für Linux x86-64, wie unter Für Linux bauen weiter unten gezeigt.
2. Klicke bei Telegram-Bot-Hosting bei einem Tarif auf Server erstellen. Beantworte im Bestellfenster Wofür ist dein Bot? mit Telegram und wähle Rust.
3. Öffne deinen Server im Panel. Die Karte Deinen Bot einrichten auf Übersicht öffnet sich bei Mit Telegram verbinden; der erste Schritt, Was läuft, sollte Dieser Bot führt Rust Bot aus. anzeigen.
4. Füge bei Mit Telegram verbinden das Token von @BotFather unter Füge deinen Bot-Token ein ein, klicke auf Verbinden, prüfe den angezeigten Bot-Namen und klicke auf Ja, weiter.
5. Klicke bei Dein Code auf Dateien hochladen, dann in Files auf Hochladen und wähle dein Programm mit dem Namen bot. Oder lass es den Server holen: Setze auf der Seite Bot, Bereich Code, Karte Einstellungen, bei Download-Link (optional) einen https-Link zum Programm und klicke auf Speichern.
6. Klicke auf Bot starten und öffne Console. Nach [PlayNHost] Starting your bot gibt dein Bot Logged in as @your_bot aus, und der Chip auf Übersicht wechselt zu Online in Telegram.
7. Klicke auf der Seite Bot, Bereich Telegram, auf In Telegram öffnen und schicke deinem Bot /start.

Wie du den Bot in @BotFather anlegst und wie die Einrichtungskarte funktioniert, steht in So hostest du einen Telegram-Bot. Der Bot-Typ Rust Bot selbst (die Startdatei, die Startargumente (optional) und der Download-Link) ist für Discord- und Telegram-Bots derselbe: Einen Rust-Discord-Bot hosten. Diese Seite handelt von teloxide: was es auf einem Server braucht und was du vor dem Hosten wissen solltest.

Was wir gemessen haben

So haben wir gemessen: auf unserem eigenen Node, in einem Wegwerf-Container, der wie ein Bot-Tarif mit 1 GB und einer CPU eingerichtet war, mit dem Debian-Image, auf dem unser Rust-Bot-Typ läuft. Jedes Programm rief Telegram oder Discord mit einem falschen Token auf, was abgelehnt wurde. Der Speicher ist der resident belegte Speicher 15 Sekunden nach dieser Antwort, die Startzeit reicht vom Start bis zur Antwort, und jeder Wert ist der Median der Läufe 2 bis 4. Beide Programme wurden auf demselben Image mit stabilem Rust und cargo build --release gebaut, wobei für den Build pkg-config und libssl-dev hinzugefügt wurden; der teloxide-Build dauerte mit einer CPU 107 s, Downloads eingeschlossen, nimm das also als grobe Zahl.

Das sind Untergrenzen: ein Programm ohne Chats und ohne Daten. Dein eigener Code, was er im Speicher hält, und die Zahl der Chats kommen dazu, ein minimales teloxide-Programm braucht aber nur einen kleinen Teil des 0,5-GB-Tarifs STARTER.

Ein minimaler teloxide-Bot

Er antwortet auf /start, liest das Token, das ihm das Panel gibt, gibt eine Bereitschaftszeile aus und sagt klar, wenn Telegram das Token ablehnt. Lege mit cargo new bot ein Projekt an und nutze diese zwei Dateien. Der Paketname bot macht das Programm zu bot, der Standard-Startdatei.

Cargo.toml

[package]
name = "bot"
version = "0.1.0"
edition = "2021"

[dependencies]
teloxide = { version = "0.17", features = ["macros"] }
tokio = { version = "1", features = ["macros", "rt-multi-thread"] }
pretty_env_logger = "0.5"

src/main.rs

use teloxide::{prelude::*, utils::command::BotCommands, ApiError, RequestError};

#[derive(BotCommands, Clone)]
#[command(rename_rule = "lowercase")]
enum Command {
    /// Say hello.
    Start,
}

async fn answer(bot: Bot, msg: Message, cmd: Command) -> ResponseResult<()> {
    match cmd {
        Command::Start => {
            bot.send_message(msg.chat.id, "Hello! I am running on PlayNHost.").await?;
        }
    }
    Ok(())
}

#[tokio::main]
async fn main() {
    // Prints teloxide's errors, such as a 409 Conflict while polling. Without a logger they are silent.
    pretty_env_logger::init();

    // Reads TELOXIDE_TOKEN, which the panel sets from the token on the Telegram pane.
    let bot = Bot::from_env();

    match bot.get_me().await {
        Ok(me) => println!("Logged in as @{}", me.username()),
        Err(RequestError::Api(ApiError::InvalidToken)) => {
            println!("Telegram did not accept the bot token. Paste the current one from @BotFather, then restart.");
            std::process::exit(1);
        }
        Err(err) => {
            println!("Could not start the bot: {err}");
            std::process::exit(1);
        }
    }

    // Long polling: removes a webhook left on the bot, then asks Telegram for messages.
    Command::repl(bot, answer).await;
}

Die Zeile Logged in as @your_bot lässt den Chip zu Online in Telegram wechseln. Command::repl läuft, bis der Bot gestoppt wird. Der Code folgt dem Befehlsbeispiel im eigenen Repository von teloxide; pretty_env_logger ist der Logger, den die Beispiele von teloxide verwenden.

Für Linux bauen

Der Server führt dein Programm auf Debian 13 aus, mit glibc 2.41 und OpenSSL 3. Eine Windows-.exe oder ein macOS-Build läuft dort nicht: Die Konsole meldet dann [PlayNHost] bot is not a Linux program. Build it for Linux x86-64 (not Windows or macOS) and upload it again. Zwei Wege zum Bauen:

Unter Linux, mit den Standard-Features von teloxide

sudo apt install build-essential pkg-config libssl-dev
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
cargo build --release

Das Programm ist target/release/bot. Die Standard-Features von teloxide nutzen native-tls, was unter Linux das OpenSSL des Systems einbindet, deshalb braucht der Build pkg-config und libssl-dev; der Server hat OpenSSL 3. Baue unter Debian 12 oder 13 oder Ubuntu 22.04 oder 24.04: Deren glibc (2.36, 2.41, 2.35 und 2.39) ist nicht neuer als die des Servers. Ein Programm, das auf einem neueren System gebaut wurde, etwa Ubuntu 26.04 mit glibc 2.43, kann Funktionen verlangen, die der Server nicht hat, und bricht dann beim Start mit einem Fehler ab, dass eine GLIBC_-Version nicht gefunden wurde. Der musl-Build vermeidet das.

Von Windows, macOS oder jedem Linux: ein musl-Build

Ein musl-Programm ist eine in sich geschlossene Datei, die nicht von den Systembibliotheken des Servers abhängt. Stelle teloxide von OpenSSL auf rustls um, das kein OpenSSL braucht und seine eigene Liste vertrauenswürdiger Zertifikate mitbringt. Ersetze in Cargo.toml die teloxide-Zeile durch:

teloxide = { version = "0.17", default-features = false, features = ["macros", "ctrlc_handler", "rustls"] }

Lass ctrlc_handler in der Liste: teloxide baut repl nur mit diesem Feature. Baue dann mit cargo-zigbuild, das Zig als Linker nutzt (die Installation per pip installiert auch Zig):

rustup target add x86_64-unknown-linux-musl
pip install cargo-zigbuild
cargo zigbuild --release --target x86_64-unknown-linux-musl

Das Programm liegt unter target/x86_64-unknown-linux-musl/release/bot. teloxide 0.17 nennt Rust 1.82 als Minimum, und die genutzten Crates können eine neuere Version verlangen, führe also vor dem Bauen rustup update stable aus.

Wenn das Token falsch ist

In unserem Test lieferte bot.get_me() mit einem falschen Token diesen Fehler (unser Testprogramm gab ihn nach dem Typ des Fehlers aus):

teloxide::RequestError: A Telegram's error: Invalid bot token

teloxide macht aus Telegrams Antwort Unauthorized und aus dem Not Found, das ein falsch geformtes Token bekommt, ein ApiError::InvalidToken. Der Bot oben prüft darauf, bevor er mit dem Polling beginnt, gibt Telegram did not accept the bot token. Paste the current one from @BotFather, then restart. aus und stoppt. Ohne diese Prüfung beendet Command::repl das Programm mit einer Panic, Couldn't prepare dispatching context: Api(InvalidToken). Das Panel erkennt beides und zeigt über Console das Banner Telegram hat deinen Bot-Token nicht akzeptiert.

Zum Beheben sendest du in @BotFather /mybots, wählst deinen Bot, dann API Token, und kopierst das Token erneut. Klicke auf der Seite Bot, Bereich Telegram, auf Token ersetzen, füge es ein, klicke auf Token speichern, dann auf Jetzt neu starten.

Was du über teloxide auf einem Server wissen solltest

• Der Token-Name. Bot::from_env() liest TELOXIDE_TOKEN und bricht mit Cannot get the TELOXIDE_TOKEN env variable ab, wenn es fehlt. Das Panel setzt es, sobald im Bereich Telegram ein Token gespeichert ist, zusammen mit TELEGRAM_BOT_TOKEN, BOT_TOKEN, TOKEN und TELEGRAM_TOKEN. from_env() liest außerdem TELOXIDE_API_URL und TELOXIDE_PROXY, wenn sie gesetzt sind; lass sie weg, um direkt mit Telegram zu sprechen.
• Ohne Logger keine Fehler. teloxide meldet Probleme über das Crate log, ein Programm ohne Logger gibt also nichts aus, wenn das Polling fehlschlägt. pretty_env_logger::init() zeigt nur Fehler, was reicht: Wenn eine andere Kopie des Bots mit demselben Token pollt, bekommt die Konsole eine Zeile, die auf An error from the update listener: Api(TerminatedByOtherGetUpdates) endet, und das Panel zeigt Dein Bot läuft auch noch woanders. Für mehr Details fügst du auf der Seite Bot, Bereich Umgebung, die Variable RUST_LOG mit dem Wert info hinzu (Variable hinzufügen) und startest neu.
• Das Polling gibt nie auf. Wenn das Abfragen von Nachrichten bei Telegram fehlschlägt, wartet teloxide und versucht es erneut, wobei sich die Wartezeit von 1 Sekunde bis auf 64 Sekunden verdoppelt, oder so lange, wie Telegram nach 429 Too Many Requests verlangt. Eine zweite Kopie des Bots oder ein Token, das während des Betriebs widerrufen wird, stoppt das Programm nicht: Es läuft weiter, bekommt aber wenige oder keine Nachrichten, und nur der geloggte Fehler zeigt den Grund: Api(TerminatedByOtherGetUpdates) bei einer zweiten Kopie, Api(InvalidToken) bei einem widerrufenen Token. Siehe Telegram-Bot-Fehler 409 Conflict beheben.
• Ein auf dem Bot hinterlassener Webhook wird für dich entfernt. repl und Dispatcher::dispatch() starten Long Polling mit 10 Sekunden Timeout und rufen zuerst deleteWebhook auf, wenn ein Webhook gesetzt ist, wobei die wartenden Nachrichten erhalten bleiben. Die Features webhooks von teloxide brauchen eine öffentliche HTTPS-Adresse, die unsere Tarife noch nicht enthalten, nutze also repl oder dispatch().
• Ein sauberer Stopp. Das Panel stoppt einen Rust-Bot mit Ctrl+C (SIGINT). repl schaltet den Ctrl+C-Handler von teloxide ein, der das Polling stoppt und Telegram mitteilt, welche Nachrichten schon angekommen sind, damit der nächste Start sie nicht erneut bekommt. Mit deinem eigenen Dispatcher fügst du .enable_ctrlc_handler() zum Builder hinzu, wie es die Beispiele von teloxide tun.
• Updates. Der Bot-Typ Rust Bot hat kein Feld Pakete und keine Git-Quelle: Deine Crates stecken im Programm. Zum Aktualisieren löschst du das alte Programm in Files, lädst den neuen Build hoch und startest neu. Bei einem Download-Link veröffentlichst du den neuen Build unter diesem Link, löschst das Programm in Files und klickst auf Starten.

Selbst hosten auf einem Linux-VPS

Kopiere das gebaute Programm auf den VPS; dort braucht es kein Rust. Ein mit den Standard-Features gebautes Programm braucht OpenSSL 3, das Debian 12 und 13 sowie Ubuntu 22.04 und 24.04 haben, und eine glibc, die mindestens so neu ist wie die des Systems, auf dem du gebaut hast. Der musl-Build braucht beides nicht.

Lege einen Benutzer für den Bot an, kopiere das Programm in seinen Ordner und bewahre das Token in einer Datei auf, die nur root lesen kann:

sudo useradd --system --create-home --home-dir /opt/mybot mybot
sudo install -o mybot -m 755 bot /opt/mybot/bot
sudo sh -c 'echo "TELOXIDE_TOKEN=123456789:your-token" > /etc/mybot.env'
sudo chmod 600 /etc/mybot.env

Erstelle /etc/systemd/system/mybot.service:

[Unit]
Description=teloxide Telegram bot
Wants=network-online.target
After=network-online.target

[Service]
User=mybot
WorkingDirectory=/opt/mybot
EnvironmentFile=/etc/mybot.env
ExecStart=/opt/mybot/bot
Restart=always
RestartSec=5
KillSignal=SIGINT

[Install]
WantedBy=multi-user.target

Starte ihn jetzt und bei jedem Boot und verfolge dann seine Ausgabe:

sudo systemctl daemon-reload
sudo systemctl enable --now mybot
sudo journalctl -u mybot -f

KillSignal=SIGINT lässt systemctl stop ein Ctrl+C senden, das der Handler von teloxide für einen sauberen Stopp abfängt; der Standard von systemd, SIGTERM, beendet das Programm sofort. Restart=always startet den Bot nach einem Absturz oder einem Ende wieder. Stoppe vorher jede andere Kopie, sonst antwortet Telegram mit 409 Conflict.

Selbst hosten oder Bot-Tarif

Auf einem VPS, den du selbst verwaltest:

• Betriebssystem-Updates und Sicherheit sowie OpenSSL- und glibc-Versionen, die zu deinem Build passen.
• Jeden neuen Build kopieren, die Service-Datei, die Token-Datei und deren Berechtigungen.
• journalctl lesen, um herauszufinden, warum der Bot gestoppt ist.
• Backups der Daten des Bots.

Dafür läuft auf einem VPS alles, und du kannst ihm für einen Webhook eine Domain mit HTTPS geben.

Bei einem Bot-Tarif von PlayNHost übernimmt das Panel das für dich:

• Ein Debian-Image, das ein Linux-x86-64-Programm ausführt, und eine Prüfung beim Start, die das meldet, wenn die Datei ein Windows- oder macOS-Build ist.
• Upload in Files oder ein Download-Link, den der Server beim Start abruft.
• Das Token, mit Telegram geprüft, verschlüsselt gespeichert und als TELOXIDE_TOKEN an dein Programm übergeben.
• Neustart des Bots nach einem Absturz. Stürzt er innerhalb einer Minute erneut ab, bleibt er gestoppt, und Console nennt den Grund.
• Banner über Console, die die Ursache nennen, wenn Telegram das Token ablehnt oder eine andere Kopie läuft, und eine Schaltfläche Webhook entfernen im Bereich Telegram.

Fragen, die Leute stellen

Warum gibt mein teloxide-Bot gar nichts aus?

teloxide schreibt über das Crate log und gibt nichts aus, bis ein Logger eingerichtet ist. Rufe pretty_env_logger::init() (oder einen anderen Logger) am Anfang von main auf, wie es der Bot oben tut. Deine eigenen println!-Zeilen erscheinen immer in Console.

Brauche ich das Webhook-Feature von teloxide?

Nein. Ein Webhook braucht eine öffentliche HTTPS-Adresse, die unsere Tarife noch nicht enthalten. repl und dispatch() nutzen Long Polling, das keine Adresse braucht: Der Bot fragt Telegram nach neuen Nachrichten. Sie entfernen außerdem einen Webhook, den ein alter Host auf dem Bot hinterlassen hat.

Kann der Server meinen Rust-Code kompilieren?

Nein. Der Rust-Bot-Typ führt ein fertiges Programm aus und kompiliert nichts, sodass der gesamte Speicher deines Tarifs dem Bot zugutekommt. Baue auf deinem Computer oder in einem GitHub-Actions-Workflow, hänge das Programm an ein Release und trage den Link zur Datei bei Download-Link (optional) ein.

Braucht ein teloxide-Bot weniger Speicher als ein Python-Bot?

Vergleiche die Zahlen: Im selben Test brauchte python-telegram-bot 22.8 44 MB und aiogram 3.31.0 173 MB, gegen 13 MB bei teloxide. Alle drei passen mit Luft für deinen eigenen Code in den 0,5-GB-Tarif STARTER, wähle also die Sprache, in der du schreiben möchtest.

Bereit, deinen teloxide-Bot rund um die Uhr laufen zu lassen? Die Tarife findest du bei Telegram-Bot-Hosting.