Como hospedar um bot teloxide 24/7

Para hospedar um bot teloxide 24/7, você o executa em uma máquina que fica sempre ligada: um VPS Linux com um serviço systemd que o inicia de novo quando ele para, ou um plano de bots na PlayNHost (a partir de US$1,99 por mês), em que você envia o programa pronto e o painel entrega o token e o inicia de novo se ele travar. No nosso teste, um bot com teloxide 0.17.0 usou cerca de 13 MB de memória. Um bot em Rust é compilado no seu próprio computador como um único programa Linux x86-64: nada é compilado no servidor. Bot::from_env() do teloxide lê o token de TELOXIDE_TOKEN, um nome que o painel define para você. Os passos na PlayNHost:

1. Compile seu bot para Linux x86-64 no seu computador, como mostrado abaixo em Compile para Linux.
2. Em hospedagem de bots do Telegram, clique em Criar servidor em um plano. Na janela do pedido, responda Para qual plataforma é o seu bot? com Telegram e escolha Rust.
3. Abra seu servidor no painel. O cartão Configurar seu bot em Visão geral abre em Conectar ao Telegram; o primeiro passo dele, O que roda, deve dizer Este bot roda Rust Bot.
4. Em Conectar ao Telegram, cole o token do @BotFather em Cole o token do seu bot, clique em Conectar, confira o nome do bot exibido e clique em Sim, continuar.
5. Em Seu código, clique em Enviar arquivos, depois em Files clique em Enviar e escolha seu programa, chamado bot. Ou deixe o servidor buscá-lo: na página Bot, painel Código, cartão Configurações, defina Link de download (opcional) como um link https para o programa e clique em Salvar.
6. Clique em Iniciar bot e abra Console. Depois de [PlayNHost] Starting your bot, seu bot imprime Logged in as @your_bot, e o indicador em Visão geral passa para Online no Telegram.
7. Na página Bot, painel Telegram, clique em Abrir no Telegram e envie /start ao seu bot.

Criar o bot no @BotFather e o cartão de configuração são explicados em Como hospedar um bot do Telegram. O tipo Rust Bot em si (o Arquivo de entrada, os Argumentos de início (opcional) e o link de download) é o mesmo para bots do Discord e do Telegram: Como hospedar um bot do Discord em Rust. Esta página trata do teloxide: o que ele usa em um servidor e o que saber antes de hospedá-lo.

O que medimos

Como: no nosso próprio nó, em um contêiner descartável configurado como um plano de bots de 1 GB com uma CPU e a imagem Debian em que o nosso tipo Rust Bot roda, cada programa chamou o Telegram ou o Discord com um token falso, que foi recusado. A memória é a memória residente 15 segundos depois dessa resposta, o tempo de início vai do lançamento até a resposta, e cada valor é a mediana das execuções 2 a 4. Os dois programas foram compilados com Rust estável e cargo build --release nessa mesma imagem, com pkg-config e libssl-dev adicionados para a compilação; a compilação do teloxide levou 107 s com uma CPU, downloads incluídos, então trate isso como um valor aproximado.

São valores mínimos: um programa sem conversas e ainda sem dados. Seu próprio código, o que ele guarda na memória e o número de conversas se somam a eles, então um programa teloxide mínimo usa uma pequena parte do plano STARTER de 0,5 GB.

Um bot teloxide mínimo

Ele responde a /start, lê o token que o painel entrega, imprime uma linha de pronto e avisa claramente quando o Telegram recusa o token. Crie um projeto com cargo new bot e use estes dois arquivos. O nome de pacote bot faz o programa se chamar bot, o Arquivo de entrada padrão.

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

A linha Logged in as @your_bot é o que faz o indicador passar para Online no Telegram. Command::repl roda até o bot ser parado. O código segue o exemplo de comandos do próprio repositório do teloxide; pretty_env_logger é o logger que os exemplos do teloxide usam.

Compile para Linux

O servidor executa seu programa em Debian 13, com glibc 2.41 e OpenSSL 3. Um .exe do Windows ou uma compilação para macOS não roda lá: o console então mostra [PlayNHost] bot is not a Linux program. Build it for Linux x86-64 (not Windows or macOS) and upload it again. Há duas formas de compilar:

No Linux, com os recursos padrão do teloxide

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

O programa é target/release/bot. Os recursos padrão do teloxide usam native-tls, que no Linux vincula o OpenSSL do sistema, então a compilação precisa de pkg-config e libssl-dev; o servidor tem OpenSSL 3. Compile em Debian 12 ou 13, ou Ubuntu 22.04 ou 24.04: a glibc deles (2.36, 2.41, 2.35 e 2.39) não é mais nova que a do servidor. Um programa compilado em um sistema mais novo, como Ubuntu 26.04 com glibc 2.43, pode pedir funções que o servidor não tem e então para no início com um erro dizendo que uma versão GLIBC_ não foi encontrada. A compilação com musl evita isso.

No Windows, macOS ou qualquer Linux: uma compilação com musl

Um programa musl é um único arquivo autocontido que não depende das bibliotecas do sistema do servidor. Troque o teloxide de OpenSSL para rustls, que não precisa de OpenSSL e traz a sua própria lista de certificados confiáveis. Em Cargo.toml, substitua a linha do teloxide por:

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

Mantenha ctrlc_handler na lista: o teloxide só compila repl com esse recurso. Depois compile com cargo-zigbuild, que usa o Zig como linker (instalá-lo com pip também instala o Zig):

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

O programa fica em target/x86_64-unknown-linux-musl/release/bot. O teloxide 0.17 indica Rust 1.82 como mínimo, e os crates que ele usa podem pedir um mais novo, então execute rustup update stable antes de compilar.

Se o token estiver errado

No nosso teste, com um token falso, bot.get_me() retornou este erro (nosso programa de teste o imprimiu depois do tipo do erro):

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

O teloxide transforma a resposta Unauthorized do Telegram, e o Not Found que um token mal formado recebe, em ApiError::InvalidToken. O bot acima verifica isso antes de começar o polling, imprime Telegram did not accept the bot token. Paste the current one from @BotFather, then restart. e para. Sem essa verificação, Command::repl encerra o programa com um panic, Couldn't prepare dispatching context: Api(InvalidToken). O painel reconhece os dois e mostra o aviso O Telegram não aceitou o token do seu bot acima de Console.

Para corrigir, no @BotFather envie /mybots, escolha seu bot, depois API Token, e copie o token de novo. Na página Bot, painel Telegram, clique em Substituir token, cole-o, clique em Salvar token e depois em Reiniciar agora.

O que saber sobre o teloxide em um servidor

• O nome do token. Bot::from_env() lê TELOXIDE_TOKEN e entra em panic com Cannot get the TELOXIDE_TOKEN env variable quando ele falta. O painel o define assim que um token é salvo no painel Telegram, junto com TELEGRAM_BOT_TOKEN, BOT_TOKEN, TOKEN e TELEGRAM_TOKEN. from_env() também lê TELOXIDE_API_URL e TELOXIDE_PROXY quando estão definidas; deixe-as de fora para falar com o Telegram diretamente.
• Sem logger, sem erros. O teloxide relata problemas pelo crate log, então um programa sem logger não imprime nada quando o polling falha. pretty_env_logger::init() mostra apenas erros, o que basta: quando outra cópia do bot faz polling com o mesmo token, o console recebe uma linha terminando em An error from the update listener: Api(TerminatedByOtherGetUpdates) e o painel mostra Seu bot também está rodando em outro lugar. Para mais detalhes, na página Bot, painel Ambiente, adicione a variável RUST_LOG com o valor info (Adicionar variável) e reinicie.
• O polling nunca desiste. Quando a busca de mensagens no Telegram falha, o teloxide espera e tenta de novo, dobrando a espera de 1 segundo até 64 segundos, ou pelo tempo que o Telegram pedir após 429 Too Many Requests. Uma segunda cópia do bot ou um token revogado enquanto ele roda não para o programa: ele continua rodando, mas recebe poucas mensagens ou nenhuma, e só o erro registrado mostra o motivo: Api(TerminatedByOtherGetUpdates) para uma segunda cópia, Api(InvalidToken) para um token revogado. Veja Como corrigir o erro 409 Conflict do bot do Telegram.
• Um webhook deixado no bot é removido para você. repl e Dispatcher::dispatch() iniciam long polling com timeout de 10 segundos e primeiro chamam deleteWebhook quando há um webhook definido, mantendo as mensagens que estavam esperando. Os recursos webhooks do teloxide precisam de um endereço HTTPS público, que nossos planos ainda não incluem, então use repl ou dispatch().
• Uma parada limpa. O painel para um bot em Rust com Ctrl+C (SIGINT). repl ativa o manipulador de Ctrl+C do teloxide, que interrompe o polling e informa ao Telegram quais mensagens já foram recebidas, para que o próximo início não as receba de novo. Com o seu próprio Dispatcher, adicione .enable_ctrlc_handler() ao builder, como fazem os exemplos do teloxide.
• Atualizações. O tipo Rust Bot não tem o campo Pacotes nem origem Git: seus crates estão dentro do programa. Para atualizar, apague o programa antigo em Files, envie a nova compilação e reinicie. Com um link de download, publique a nova compilação nesse link, apague o programa em Files e pressione Iniciar.

Hospede você mesmo em um VPS Linux

Copie o programa compilado para o VPS; ele não precisa de Rust lá. Um programa compilado com os recursos padrão precisa de OpenSSL 3, que Debian 12 e 13 e Ubuntu 22.04 e 24.04 têm, e de uma glibc pelo menos tão nova quanto a do sistema em que você compilou. A compilação com musl não precisa de nenhum dos dois.

Crie um usuário para o bot, coloque o programa na pasta dele e guarde o token em um arquivo que só o root possa ler:

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

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

Inicie-o agora e a cada boot, depois acompanhe a saída:

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

KillSignal=SIGINT faz systemctl stop enviar Ctrl+C, que o manipulador do teloxide captura para uma parada limpa; o padrão do systemd, SIGTERM, encerra o programa na hora. Restart=always inicia o bot de novo após uma falha ou uma saída. Pare qualquer outra cópia antes, ou o Telegram responde com 409 Conflict.

Auto-hospedagem ou plano de bots

Em um VPS que você mesmo gerencia:

• Atualizações e segurança do sistema operacional, e versões de OpenSSL e glibc compatíveis com a sua compilação.
• Copiar cada nova compilação, o arquivo de serviço, o arquivo do token e as permissões dele.
• Ler journalctl para descobrir por que o bot parou.
• Backups dos dados do bot.

Em troca, um VPS executa qualquer coisa, e você pode dar a ele um domínio com HTTPS para um webhook.

Em um plano de bots da PlayNHost, o painel faz isso por você:

• Uma imagem Debian que executa um programa Linux x86-64 e uma verificação ao iniciar que avisa quando o arquivo é uma compilação para Windows ou macOS.
• Envio em Files, ou um link de download que o servidor busca ao iniciar.
• O token, verificado com o Telegram, guardado criptografado e entregue ao seu programa como TELOXIDE_TOKEN.
• Reinício do bot após uma falha. Se ele falhar de novo em menos de um minuto, fica parado e o Console diz o motivo.
• Avisos acima de Console que indicam a causa quando o Telegram recusa o token ou outra cópia está rodando, e um botão Remover webhook no painel Telegram.

Perguntas frequentes

Por que meu bot teloxide não imprime nada?

O teloxide escreve pelo crate log e não imprime nada até que um logger seja configurado. Chame pretty_env_logger::init() (ou outro logger) no início de main, como o bot acima faz. Suas próprias linhas println! sempre aparecem no Console.

Preciso do recurso de webhooks do teloxide?

Não. Um webhook precisa de um endereço HTTPS público, que nossos planos ainda não incluem. repl e dispatch() usam long polling, que não precisa de endereço: o bot pede ao Telegram as mensagens novas. Eles também removem um webhook deixado no bot por um host antigo.

O servidor pode compilar meu código Rust?

Não. O tipo Rust Bot executa um programa pronto e não compila nada, então toda a memória do seu plano vai para o bot. Compile no seu computador, ou em um workflow do GitHub Actions, anexe o programa a uma release e coloque o link do arquivo em Link de download (opcional).

Um bot teloxide usa menos memória que um bot em Python?

Compare os números: no mesmo teste, o python-telegram-bot 22.8 usou 44 MB e o aiogram 3.31.0 usou 173 MB, contra 13 MB do teloxide. Os três cabem no plano STARTER de 0,5 GB com folga para o seu código, então escolha a linguagem em que você quer escrever.

Pronto para manter seu bot teloxide rodando o dia todo? Veja os planos em hospedagem de bots do Telegram.