Come ospitare un bot teloxide 24/7

Per ospitare un bot teloxide 24/7 lo fai girare su una macchina sempre accesa: un VPS Linux con un servizio systemd che lo riavvia quando si ferma, oppure un piano bot su PlayNHost (da 1,99 US$ al mese), dove carichi il programma finito e il pannello gli dà il token e lo riavvia se va in crash. Nel nostro test un bot teloxide 0.17.0 ha usato circa 13 MB di memoria. Un bot Rust si compila sul tuo computer come un unico programma Linux x86-64: sul server non si compila nulla. Bot::from_env() di teloxide legge il token da TELOXIDE_TOKEN, un nome che il pannello imposta per te. I passaggi su PlayNHost:

1. Compila il tuo bot per Linux x86-64 sul tuo computer, come mostrato sotto in Compilare per Linux.
2. Su hosting per bot Telegram, fai clic su Crea server su un piano. Nella finestra dell'ordine rispondi a Per quale piattaforma è il tuo bot? con Telegram e scegli Rust.
3. Apri il tuo server nel pannello. La scheda Configura il tuo bot in Panoramica si apre su Connetti a Telegram; il suo primo passaggio, Cosa viene eseguito, dovrebbe dire Questo bot esegue Rust Bot.
4. In Connetti a Telegram, incolla il token di @BotFather sotto Incolla il token del bot, fai clic su Connessione, controlla il nome del bot mostrato e fai clic su Sì, continua.
5. In Il tuo codice, fai clic su Carica i file, poi in Files fai clic su Carica e scegli il tuo programma, chiamato bot. Oppure lascia che lo scarichi il server: nella pagina Bot, riquadro Codice, scheda Impostazioni, imposta Link di download (facoltativo) su un link https al programma e fai clic su Salva.
6. Fai clic su Avvia il bot e apri Console. Dopo [PlayNHost] Starting your bot il tuo bot stampa Logged in as @your_bot, e l'indicatore in Panoramica passa a Online su Telegram.
7. Nella pagina Bot, riquadro Telegram, fai clic su Apri in Telegram e invia al tuo bot /start.

La creazione del bot in @BotFather e la scheda di configurazione sono spiegate in Come ospitare un bot Telegram. Il tipo Rust Bot in sé (il File di avvio, gli Argomenti di avvio (facoltativo) e il link di download) è lo stesso per i bot Discord e Telegram: Come ospitare un bot Discord in Rust. Questa pagina parla di teloxide: cosa usa su un server e cosa sapere prima di ospitarlo.

Cosa abbiamo misurato

Come: sul nostro nodo, in un container usa e getta configurato come un piano bot da 1 GB con una CPU e l'immagine Debian su cui gira il nostro tipo Rust Bot, ogni programma ha chiamato Telegram o Discord con un token falso, che è stato rifiutato. La memoria è la memoria residente 15 secondi dopo quella risposta, il tempo di avvio va dal lancio alla risposta, e ogni valore è la mediana delle esecuzioni da 2 a 4. Entrambi i programmi sono stati compilati con Rust stabile e cargo build --release su quella stessa immagine, con pkg-config e libssl-dev aggiunti per la compilazione; la compilazione di teloxide ha richiesto 107 s con una CPU, download inclusi, quindi consideralo un valore indicativo.

Sono valori minimi: un programma senza chat e senza dati. Il tuo codice, ciò che tiene in memoria e il numero di chat si aggiungono, quindi un programma teloxide minimo usa una piccola parte del piano STARTER da 0,5 GB.

Un bot teloxide minimo

Risponde a /start, legge il token che gli dà il pannello, stampa una riga di pronto e dice chiaramente quando Telegram rifiuta il token. Crea un progetto con cargo new bot e usa questi due file. Il nome del pacchetto bot fa chiamare il programma bot, il File di avvio predefinito.

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

La riga Logged in as @your_bot è ciò che fa passare l'indicatore a Online su Telegram. Command::repl resta in esecuzione finché il bot non viene fermato. Il codice segue l'esempio dei comandi nel repository di teloxide; pretty_env_logger è il logger usato dagli esempi di teloxide.

Compilare per Linux

Il server esegue il tuo programma su Debian 13, con glibc 2.41 e OpenSSL 3. Un .exe di Windows o una compilazione per macOS non gira lì: la console dice allora [PlayNHost] bot is not a Linux program. Build it for Linux x86-64 (not Windows or macOS) and upload it again. Due modi per compilare:

Su Linux, con le funzionalità predefinite di teloxide

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

Il programma è target/release/bot. Le funzionalità predefinite di teloxide usano native-tls, che su Linux collega l'OpenSSL del sistema, quindi la compilazione richiede pkg-config e libssl-dev; il server ha OpenSSL 3. Compila su Debian 12 o 13, oppure su Ubuntu 22.04 o 24.04: la loro glibc (2.36, 2.41, 2.35 e 2.39) non è più recente di quella del server. Un programma compilato su un sistema più nuovo, come Ubuntu 26.04 con glibc 2.43, può richiedere funzioni che il server non ha, e allora si ferma all'avvio con un errore che dice che una versione GLIBC_ non è stata trovata. La compilazione musl lo evita.

Da Windows, macOS o qualsiasi Linux: una compilazione musl

Un programma musl è un unico file autonomo che non dipende dalle librerie di sistema del server. Passa teloxide da OpenSSL a rustls, che non richiede OpenSSL e include una propria lista di certificati attendibili. In Cargo.toml, sostituisci la riga di teloxide con:

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

Tieni ctrlc_handler nell'elenco: teloxide compila repl solo con quella funzionalità. Poi compila con cargo-zigbuild, che usa Zig come linker (installandolo con pip si installa anche Zig):

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

Il programma si trova in target/x86_64-unknown-linux-musl/release/bot. teloxide 0.17 indica Rust 1.82 come minimo, e i crate che usa possono chiederne uno più recente, quindi esegui rustup update stable prima di compilare.

Se il token è sbagliato

Nel nostro test, con un token falso, bot.get_me() ha restituito questo errore (il nostro programma di test lo ha stampato dopo il tipo dell'errore):

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

teloxide trasforma la risposta Unauthorized di Telegram, e il Not Found che riceve un token mal formato, in ApiError::InvalidToken. Il bot qui sopra lo controlla prima di iniziare il polling, stampa Telegram did not accept the bot token. Paste the current one from @BotFather, then restart. e si ferma. Senza quel controllo, Command::repl ferma il programma con un panic, Couldn't prepare dispatching context: Api(InvalidToken). Il pannello riconosce entrambi e mostra il banner Telegram non ha accettato il token del bot sopra Console.

Per risolvere, in @BotFather invia /mybots, scegli il tuo bot, poi API Token, e copia di nuovo il token. Nella pagina Bot, riquadro Telegram, fai clic su Sostituisci il token, incollalo, fai clic su Salva il token, poi su Riavvia ora.

Cosa sapere su teloxide su un server

• Il nome del token. Bot::from_env() legge TELOXIDE_TOKEN e va in panic con Cannot get the TELOXIDE_TOKEN env variable quando manca. Il pannello lo imposta appena un token viene salvato nel riquadro Telegram, insieme a TELEGRAM_BOT_TOKEN, BOT_TOKEN, TOKEN e TELEGRAM_TOKEN. from_env() legge anche TELOXIDE_API_URL e TELOXIDE_PROXY quando sono impostate; omettile per parlare direttamente con Telegram.
• Senza logger, niente errori. teloxide segnala i problemi tramite il crate log, quindi un programma senza logger non stampa nulla quando il polling fallisce. pretty_env_logger::init() mostra solo gli errori, il che basta: quando un'altra copia del bot fa polling con lo stesso token, la console riceve una riga che termina con An error from the update listener: Api(TerminatedByOtherGetUpdates) e il pannello mostra Il tuo bot è in esecuzione anche altrove. Per più dettagli, nella pagina Bot, riquadro Ambiente, aggiungi la variabile RUST_LOG con il valore info (Aggiungi variabile) e riavvia.
• Il polling non si arrende mai. Quando la richiesta di messaggi a Telegram fallisce, teloxide aspetta e riprova, raddoppiando l'attesa da 1 secondo fino a 64 secondi, o per quanto Telegram lo chiede dopo 429 Too Many Requests. Una seconda copia del bot o un token revocato mentre è in esecuzione non ferma il programma: continua a girare ma riceve pochi messaggi o nessuno, e solo l'errore registrato ne mostra il motivo: Api(TerminatedByOtherGetUpdates) per una seconda copia, Api(InvalidToken) per un token revocato. Vedi Come risolvere l’errore 409 Conflict di un bot Telegram.
• Un webhook rimasto sul bot viene rimosso per te. repl e Dispatcher::dispatch() avviano il long polling con un timeout di 10 secondi e chiamano prima deleteWebhook quando è impostato un webhook, mantenendo i messaggi in attesa. Le funzionalità webhooks di teloxide richiedono un indirizzo HTTPS pubblico, che i nostri piani non includono ancora, quindi usa repl o dispatch().
• Un arresto pulito. Il pannello ferma un bot Rust con Ctrl+C (SIGINT). repl attiva il gestore Ctrl+C di teloxide, che ferma il polling e dice a Telegram quali messaggi ha già ricevuto, così il prossimo avvio non li riceve di nuovo. Con il tuo Dispatcher, aggiungi .enable_ctrlc_handler() al builder, come fanno gli esempi di teloxide.
• Aggiornamenti. Il tipo Rust Bot non ha il campo Pacchetti né una sorgente Git: i tuoi crate sono dentro il programma. Per aggiornare, elimina il vecchio programma in Files, carica la nuova compilazione e riavvia. Con un link di download, pubblica la nuova compilazione a quel link, elimina il programma in Files e premi Avvia.

Ospitarlo da solo su un VPS Linux

Copia il programma compilato sul VPS; lì non serve Rust. Un programma compilato con le funzionalità predefinite richiede OpenSSL 3, che hanno Debian 12 e 13 e Ubuntu 22.04 e 24.04, e una glibc almeno recente quanto quella del sistema su cui hai compilato. La compilazione musl non richiede nessuna delle due cose.

Crea un utente per il bot, metti il programma nella sua cartella e tieni il token in un file leggibile solo da root:

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

Crea /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

Avvialo subito e a ogni avvio del sistema, poi segui il suo output:

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

KillSignal=SIGINT fa inviare Ctrl+C a systemctl stop, che il gestore di teloxide intercetta per un arresto pulito; il valore predefinito di systemd, SIGTERM, termina subito il programma. Restart=always riavvia il bot dopo un crash o un'uscita. Ferma prima qualsiasi altra copia, altrimenti Telegram risponde con 409 Conflict.

Self-hosting o piano bot

Su un VPS che gestisci tu:

• Aggiornamenti e sicurezza del sistema operativo, e versioni di OpenSSL e glibc compatibili con la tua compilazione.
• Copiare ogni nuova compilazione, il file di servizio, il file del token e i suoi permessi.
• Leggere journalctl per capire perché il bot si è fermato.
• Backup dei dati del bot.

In cambio un VPS esegue qualsiasi cosa, e puoi dargli un dominio con HTTPS per un webhook.

Su un piano bot PlayNHost il pannello fa questo per te:

• Un'immagine Debian che esegue un programma Linux x86-64, e un controllo all'avvio che lo segnala quando il file è una compilazione per Windows o macOS.
• Il caricamento in Files, o un link di download che il server scarica all'avvio.
• Il token, verificato con Telegram, salvato cifrato e passato al tuo programma come TELOXIDE_TOKEN.
• Il riavvio del bot dopo un crash. Se va in crash di nuovo entro un minuto, resta fermo e Console ne spiega il motivo.
• Banner sopra Console che indicano la causa quando Telegram rifiuta il token o è in esecuzione un'altra copia, e un pulsante Rimuovi il webhook nel riquadro Telegram.

Domande frequenti

Perché il mio bot teloxide non stampa niente?

teloxide scrive tramite il crate log e non stampa nulla finché non viene configurato un logger. Chiama pretty_env_logger::init() (o un altro logger) all'inizio di main, come fa il bot qui sopra. Le tue righe println! compaiono sempre in Console.

Mi serve la funzionalità webhooks di teloxide?

No. Un webhook richiede un indirizzo HTTPS pubblico, che i nostri piani non includono ancora. repl e dispatch() usano il long polling, che non richiede un indirizzo: il bot chiede a Telegram i nuovi messaggi. Rimuovono anche un webhook lasciato sul bot da un vecchio host.

Il server può compilare il mio codice Rust?

No. Il tipo Rust Bot esegue un programma finito e non compila nulla, quindi tutta la memoria del tuo piano va al bot. Compila sul tuo computer, oppure in un workflow di GitHub Actions, allega il programma a una release e metti il link al file in Link di download (facoltativo).

Un bot teloxide usa meno memoria di uno Python?

Confronta i numeri: nello stesso test python-telegram-bot 22.8 ha usato 44 MB e aiogram 3.31.0 ne ha usati 173 MB, contro i 13 MB di teloxide. Tutti e tre stanno nel piano STARTER da 0,5 GB con margine per il tuo codice, quindi scegli il linguaggio in cui vuoi scrivere.

Pronto a far girare il tuo bot teloxide a ciclo continuo? Guarda i piani su hosting per bot Telegram.