Een teloxide-bot 24/7 hosten

Om een teloxide-bot 24/7 te hosten laat je hem draaien op een machine die altijd aan blijft: een Linux-VPS met een systemd-service die hem opnieuw start als hij stopt, of een botabonnement bij PlayNHost (vanaf US$1.99 per maand), waar je het kant-en-klare programma uploadt en het paneel er het token aan geeft en hem opnieuw start als hij crasht. In onze test gebruikte een teloxide 0.17.0-bot ongeveer 13 MB geheugen. Een Rust-bot bouw je op je eigen computer als één Linux x86-64-programma: op de server wordt niets gecompileerd. Bot::from_env() van teloxide leest het token uit TELOXIDE_TOKEN, een naam die het paneel voor je instelt. De stappen op PlayNHost:

1. Bouw je bot op je computer voor Linux x86-64, zoals hieronder getoond onder Voor Linux bouwen.
2. Klik bij Telegram-bothosting bij een abonnement op Server aanmaken. Beantwoord in het bestelvenster Voor welk platform is je bot? met Telegram en kies Rust.
3. Open je server in het paneel. De kaart Je bot instellen op Overzicht opent bij Verbinden met Telegram; de eerste stap, Wat er draait, hoort Deze bot draait Rust Bot. te tonen.
4. Plak bij Verbinden met Telegram het token van @BotFather onder Plak je bottoken, klik op Verbinden, controleer de getoonde botnaam en klik op Ja, doorgaan.
5. Klik bij Je code op Bestanden uploaden, klik dan in Files op Uploaden en kies je programma, genaamd bot. Of laat de server het ophalen: zet op de pagina Bot, paneel Code, kaart Instellingen, bij Downloadlink (optioneel) een https-link naar het programma en klik op Opslaan.
6. Klik op Bot starten en open Console. Na [PlayNHost] Starting your bot print je bot Logged in as @your_bot, en het label op Overzicht verandert in Online in Telegram.
7. Klik op de pagina Bot, paneel Telegram, op Openen in Telegram en stuur je bot /start.

Het maken van de bot in @BotFather en de instelkaart worden uitgelegd in Een Telegram-bot hosten. Het bottype Rust Bot zelf (het Startbestand, de Startargumenten (optioneel) en de downloadlink) is hetzelfde voor Discord- en Telegram-bots: Een Rust Discord-bot hosten. Deze pagina gaat over teloxide: wat het op een server gebruikt en wat je moet weten voordat je het host.

Wat we hebben gemeten

Zo: op onze eigen node, in een wegwerpcontainer ingesteld als een botabonnement van 1 GB met één CPU en de Debian-image waarop ons Rust Bot-type draait, riep elk programma Telegram of Discord aan met een nep-token, dat werd geweigerd. Het geheugen is het resident geheugen 15 seconden na dat antwoord, de starttijd loopt van het opstarten tot het antwoord, en elke waarde is de mediaan van de runs 2 tot 4. Beide programma's zijn op diezelfde image gebouwd met stable Rust en cargo build --release, met pkg-config en libssl-dev toegevoegd voor de build; de teloxide-build duurde 107 s met één CPU, downloads inbegrepen, zie dat dus als een ruwe waarde.

Dit zijn ondergrenzen: een programma zonder chats en nog zonder gegevens. Je eigen code, wat die in het geheugen bewaart en het aantal chats komen erbij, dus een minimaal teloxide-programma gebruikt een klein deel van het STARTER-abonnement van 0,5 GB.

Een minimale teloxide-bot

Hij antwoordt op /start, leest het token dat het paneel hem geeft, print een klaar-regel en meldt duidelijk wanneer Telegram het token weigert. Maak een project met cargo new bot en gebruik deze twee bestanden. De pakketnaam bot maakt het programma bot, het standaard Startbestand.

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;
}

De regel Logged in as @your_bot zorgt dat het label verandert in Online in Telegram. Command::repl blijft draaien tot de bot wordt gestopt. De code volgt het commandovoorbeeld uit de eigen repository van teloxide; pretty_env_logger is de logger die de voorbeelden van teloxide gebruiken.

Voor Linux bouwen

De server draait je programma op Debian 13, met glibc 2.41 en OpenSSL 3. Een Windows-.exe of een macOS-build draait daar niet: de console zegt dan [PlayNHost] bot is not a Linux program. Build it for Linux x86-64 (not Windows or macOS) and upload it again. Twee manieren om te bouwen:

Op Linux, met de standaardfeatures van teloxide

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

Het programma is target/release/bot. De standaardfeatures van teloxide gebruiken native-tls, dat op Linux het OpenSSL van het systeem linkt, dus de build heeft pkg-config en libssl-dev nodig; de server heeft OpenSSL 3. Bouw op Debian 12 of 13, of Ubuntu 22.04 of 24.04: hun glibc (2.36, 2.41, 2.35 en 2.39) is niet nieuwer dan die van de server. Een programma dat op een nieuwer systeem is gebouwd, zoals Ubuntu 26.04 met glibc 2.43, kan functies vragen die de server niet heeft en stopt dan bij het starten met een fout dat een GLIBC_-versie niet is gevonden. De musl-build voorkomt dat.

Vanaf Windows, macOS of elke Linux: een musl-build

Een musl-programma is één op zichzelf staand bestand dat niet afhangt van de systeembibliotheken van de server. Schakel teloxide van OpenSSL over naar rustls, dat geen OpenSSL nodig heeft en zijn eigen lijst vertrouwde certificaten meebrengt. Vervang in Cargo.toml de teloxide-regel door:

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

Houd ctrlc_handler in de lijst: teloxide bouwt repl alleen met die feature. Bouw dan met cargo-zigbuild, dat Zig als linker gebruikt (installeren via pip installeert ook Zig):

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

Het programma staat in target/x86_64-unknown-linux-musl/release/bot. teloxide 0.17 noemt Rust 1.82 als minimum, en de crates die het gebruikt kunnen een nieuwere vragen, dus voer rustup update stable uit voordat je bouwt.

Als het token fout is

In onze test gaf bot.get_me() met een nep-token deze fout (ons testprogramma printte hem na het type van de fout):

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

teloxide maakt van het antwoord Unauthorized van Telegram, en de Not Found die een slecht gevormd token krijgt, een ApiError::InvalidToken. De bot hierboven controleert hierop voordat hij begint met pollen, print Telegram did not accept the bot token. Paste the current one from @BotFather, then restart. en stopt. Zonder die controle stopt Command::repl het programma met een panic, Couldn't prepare dispatching context: Api(InvalidToken). Het paneel herkent beide en toont de banner Telegram heeft je bottoken niet geaccepteerd boven Console.

Om het op te lossen stuur je in @BotFather /mybots, kies je je bot, dan API Token, en kopieer je het token opnieuw. Klik op de pagina Bot, paneel Telegram, op Token vervangen, plak het, klik op Token opslaan, en dan op Nu herstarten.

Wat je moet weten over teloxide op een server

• De tokennaam. Bot::from_env() leest TELOXIDE_TOKEN en geeft een panic met Cannot get the TELOXIDE_TOKEN env variable als het ontbreekt. Het paneel stelt het in zodra er een token is opgeslagen in het paneel Telegram, samen met TELEGRAM_BOT_TOKEN, BOT_TOKEN, TOKEN en TELEGRAM_TOKEN. from_env() leest ook TELOXIDE_API_URL en TELOXIDE_PROXY als ze zijn ingesteld; laat ze weg om rechtstreeks met Telegram te praten.
• Geen logger, geen fouten. teloxide meldt problemen via de crate log, dus een programma zonder logger print niets als het pollen mislukt. pretty_env_logger::init() toont alleen fouten, en dat is genoeg: wanneer een andere kopie van de bot met hetzelfde token pollt, krijgt de console een regel die eindigt op An error from the update listener: Api(TerminatedByOtherGetUpdates) en toont het paneel Je bot draait ook ergens anders. Voor meer detail voeg je op de pagina Bot, paneel Omgeving, de variabele RUST_LOG toe met de waarde info (Variabele toevoegen) en herstart je.
• Pollen geeft nooit op. Als het opvragen van berichten bij Telegram mislukt, wacht teloxide en probeert het opnieuw, waarbij de wachttijd verdubbelt van 1 seconde tot 64 seconden, of zo lang als Telegram vraagt na 429 Too Many Requests. Een tweede kopie van de bot of een token dat tijdens het draaien wordt ingetrokken, stopt het programma niet: het blijft draaien maar krijgt weinig of geen berichten, en alleen de gelogde fout toont waarom: Api(TerminatedByOtherGetUpdates) voor een tweede kopie, Api(InvalidToken) voor een ingetrokken token. Zie Telegram-bot 409 Conflict oplossen.
• Een webhook die op de bot is achtergebleven, wordt voor je verwijderd. repl en Dispatcher::dispatch() starten long polling met een time-out van 10 seconden en roepen eerst deleteWebhook aan als er een webhook is ingesteld, waarbij de wachtende berichten behouden blijven. De webhooks-features van teloxide hebben een openbaar HTTPS-adres nodig, dat onze abonnementen nog niet bevatten, dus gebruik repl of dispatch().
• Een nette stop. Het paneel stopt een Rust-bot met Ctrl+C (SIGINT). repl schakelt de Ctrl+C-handler van teloxide in, die het pollen stopt en Telegram vertelt welke berichten al zijn ontvangen, zodat de volgende start ze niet opnieuw krijgt. Voeg bij je eigen Dispatcher .enable_ctrlc_handler() toe aan de builder, zoals de voorbeelden van teloxide doen.
• Updates. Het bottype Rust Bot heeft geen veld Packages en geen Git-bron: je crates zitten in het programma. Om te updaten verwijder je het oude programma in Files, upload je de nieuwe build en herstart je. Bij een downloadlink publiceer je de nieuwe build op die link, verwijder je het programma in Files en druk je op Starten.

Zelf hosten op een Linux-VPS

Kopieer het gebouwde programma naar de VPS; daar is geen Rust nodig. Een programma dat met de standaardfeatures is gebouwd heeft OpenSSL 3 nodig, dat Debian 12 en 13 en Ubuntu 22.04 en 24.04 hebben, en een glibc die minstens zo nieuw is als die van het systeem waarop je hebt gebouwd. De musl-build heeft geen van beide nodig.

Maak een gebruiker voor de bot, zet het programma in zijn map en bewaar het token in een bestand dat alleen root kan lezen:

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

Maak /etc/systemd/system/mybot.service aan:

[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

Start hem nu en bij elke boot, en volg dan de uitvoer:

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

KillSignal=SIGINT laat systemctl stop Ctrl+C sturen, dat de handler van teloxide opvangt voor een nette stop; de standaard van systemd, SIGTERM, beëindigt het programma meteen. Restart=always start de bot opnieuw na een crash of een exit. Stop eerst elke andere kopie, anders antwoordt Telegram met 409 Conflict.

Zelf hosten of een botabonnement

Op een VPS die je zelf beheert:

• Updates en beveiliging van het besturingssysteem, en OpenSSL- en glibc-versies die bij je build passen.
• Elke nieuwe build kopiëren, het servicebestand, het tokenbestand en de rechten ervan.
• journalctl lezen om te zien waarom de bot is gestopt.
• Back-ups van de gegevens van de bot.

In ruil daarvoor draait een VPS alles, en kun je er een domein met HTTPS aan geven voor een webhook.

Bij een botabonnement van PlayNHost doet het paneel dit voor je:

• Een Debian-image die een Linux x86-64-programma draait, en een controle bij het starten die dat meldt als het bestand een Windows- of macOS-build is.
• Uploaden in Files, of een downloadlink die de server bij het starten ophaalt.
• Het token, gecontroleerd bij Telegram, versleuteld opgeslagen en als TELOXIDE_TOKEN aan je programma doorgegeven.
• De bot opnieuw starten na een crash. Crasht hij binnen een minuut weer, dan blijft hij gestopt en zegt Console waarom.
• Banners boven Console die de oorzaak noemen als Telegram het token weigert of een andere kopie draait, en een knop Webhook verwijderen in het paneel Telegram.

Veelgestelde vragen

Waarom print mijn teloxide-bot helemaal niets?

teloxide schrijft via de crate log en print niets totdat een logger is ingesteld. Roep pretty_env_logger::init() (of een andere logger) aan bovenaan main, zoals de bot hierboven doet. Je eigen println!-regels verschijnen altijd in Console.

Heb ik de webhooks-feature van teloxide nodig?

Nee. Een webhook heeft een openbaar HTTPS-adres nodig, dat onze abonnementen nog niet bevatten. repl en dispatch() gebruiken long polling, dat geen adres nodig heeft: de bot vraagt Telegram om nieuwe berichten. Ze verwijderen ook een webhook die een oude host op de bot heeft achtergelaten.

Kan de server mijn Rust-code compileren?

Nee. Het Rust Bot-type draait een kant-en-klaar programma en compileert niets, dus al het geheugen van je abonnement gaat naar de bot. Bouw op je computer, of in een GitHub Actions-workflow, voeg het programma toe aan een release en zet de link naar het bestand bij Downloadlink (optioneel).

Gebruikt een teloxide-bot minder geheugen dan een Python-bot?

Vergelijk de cijfers: in dezelfde test gebruikte python-telegram-bot 22.8 44 MB en aiogram 3.31.0 173 MB, tegen 13 MB voor teloxide. Alle drie passen ze in het STARTER-abonnement van 0,5 GB met ruimte voor je eigen code, dus kies de taal waarin je wilt schrijven.

Klaar om je teloxide-bot dag en nacht te laten draaien? Bekijk de abonnementen bij Telegram-bothosting.