Come ospitare un bot grammY 24/7

Per ospitare un bot grammY 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 il pannello installa i tuoi pacchetti, dà il token al tuo codice e riavvia il bot se va in crash. Nel nostro test un bot grammY 1.46.0 ha usato circa 60 MB di memoria su Node.js 22. bot.start() di grammY usa il long polling, che è ciò che serve ai nostri piani: non hanno ancora un indirizzo HTTPS pubblico per un webhook. I passi su PlayNHost:

1. 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 Node.js.
2. 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 Node.js Bot.
3. 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.
4. In Il tuo codice, fai clic su Carica i file e carica package.json e index.js senza node_modules, oppure fai clic su Collega Git. Non hai ancora codice? Crea un bot di partenza scrive per te un piccolo bot grammY.
5. Nella pagina Bot, riquadro Codice, controlla che File di avvio sia il file che avvia il tuo bot (index.js per impostazione predefinita). Fai clic su Salva se lo cambi.
6. Fai clic su Avvia il bot e apri Console. npm installa grammY al primo avvio, poi il tuo bot stampa Logged in as @your_bot e l’indicatore in Panoramica diventa Online su Telegram.
7. Nella pagina Bot, riquadro Telegram, fai clic su Apri in Telegram e invia /start al tuo bot.

Come creare il bot in @BotFather e cosa fanno i passi del pannello è spiegato in Come ospitare un bot Telegram. Questa pagina riguarda grammY in sé: 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 (l’immagine Node.js 22 e il comando di avvio del nostro tipo di bot Node.js, con il limite di memoria di Node all’80 per cento), ogni bot ha chiamato Telegram con un token falso, che Telegram ha rifiutato. La memoria è quella 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.

Sono valori minimi: un bot senza chat e senza dati. Il tuo codice, ciò che tiene in memoria e il numero di chat si sommano, quindi la libreria è una piccola parte del piano STARTER da 0,5 GB.

Un bot grammY minimo

Risponde a /start, legge il token che gli dà il pannello e stampa una riga di pronto. Metti entrambi i file nella cartella principale del tuo bot.

package.json

{
  "name": "my-grammy-bot",
  "private": true,
  "main": "index.js",
  "dependencies": {
    "grammy": "^1.46.0"
  }
}

index.js

const { Bot, GrammyError } = require("grammy");

const bot = new Bot(process.env.TELEGRAM_BOT_TOKEN);

bot.command("start", (ctx) => ctx.reply("Hello! I am running on PlayNHost."));

// Without this, an error in one command stops the whole bot.
bot.catch((err) => {
  console.error(`Error while handling update ${err.ctx.update.update_id}:`, err.error);
});

// bot.start() only returns when the bot stops, so the ready line goes in onStart.
bot.start({
  onStart: (me) => console.log(`Logged in as @${me.username}`),
}).catch((err) => {
  if (err instanceof GrammyError && err.error_code === 401) {
    console.log("Telegram did not accept the bot token. Paste the current one from @BotFather, then restart.");
  } else {
    console.error(err);
  }
  process.exit(1);
});

Il pannello dà il token al tuo codice come TELEGRAM_BOT_TOKEN, e anche come BOT_TOKEN, TOKEN, TELEGRAM_TOKEN e TELOXIDE_TOKEN, quindi funziona anche process.env.BOT_TOKEN degli altri esempi. La riga Logged in as @your_bot è ciò che porta l’indicatore a Online su Telegram.

Se il token è sbagliato

Nel nostro test, con un token falso, bot.start() di grammY si è fermato con questo errore:

GrammyError: Call to 'deleteWebhook' failed! (401: Unauthorized)

bot.start() invia getMe e deleteWebhook nello stesso momento, quindi l’errore indica la chiamata che Telegram ha rifiutato per prima: in alcune nostre esecuzioni era Call to 'getMe' failed! (401: Unauthorized). grammY non ritenta un token rifiutato: bot.start() fallisce subito. Il bot qui sopra intercetta questo caso e stampa invece Telegram did not accept the bot token. Paste the current one from @BotFather, then restart., e il pannello 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 e poi su Riavvia ora.

Cosa sapere su grammY su un server

• La riga di pronto va in onStart. bot.start() ritorna solo quando il bot si ferma, quindi un console.log dopo await bot.start() non viene mai stampato mentre gira. grammY chiama onStart con i dati del tuo bot appena prima di chiedere a Telegram i primi messaggi.
• Un errore in un comando ferma il bot se non imposti bot.catch. Senza, grammY stampa No error handler was set!, ferma il polling e lancia l’errore, quindi il processo termina. Il nostro pannello riavvia un bot andato in crash entro circa un minuto, ma fino ad allora è offline. Con bot.catch, come sopra, l’errore viene stampato e il bot continua.
• Un webhook rimasto sul bot viene rimosso per te. bot.start() chiama deleteWebhook prima di fare polling e tiene i messaggi in attesa, a meno che tu non passi drop_pending_updates: true. Conta quando sposti un bot da un host che usava un webhook: Come spostare un bot Telegram su PlayNHost.
• Un’altra copia del bot ferma questa. Con 409 Conflict (lo stesso token in polling altrove) bot.start() fallisce invece di ritentare. Il pannello mostra Il tuo bot è in esecuzione anche altrove: ferma la copia sul tuo PC o sul vecchio host. Vedi Come risolvere l’errore 409 Conflict di un bot Telegram.
• Gli errori di rete all’avvio vengono ritentati in silenzio. Se la prima chiamata a Telegram fallisce per la rete, grammY riprova con attese sempre più lunghe (fino a 20 minuti tra un tentativo e l’altro nella versione 1.46.0) e non stampa nulla. Per vedere questi tentativi, nella pagina Bot, riquadro Ambiente, aggiungi la variabile DEBUG con il valore grammy* (Aggiungi variabile) e riavvia.
• Versione di Node.js: grammY 1.46.0 richiede Node.js 12.20 o 14.13.1 e successivi. Il Runtime nel riquadro Codice offre Node.js 20, 22 (recommended), 24, 25 e 26.
• Limite di memoria: lo script di avvio imposta NODE_OPTIONS=--max-old-space-size all’80 per cento della memoria del tuo piano, così il resto del processo ha spazio. Dettagli sullo script di avvio di Node.js: Come ospitare un bot Discord Node.js.

Ospitarlo da solo su un VPS Linux

Su Debian 12 o 13, o Ubuntu 24.04, basta il pacchetto della distribuzione per grammY (Debian 12 include Node.js 18.20, Debian 13 include 20.19, Ubuntu 24.04 include 18.19):

sudo apt update
sudo apt install nodejs npm
node --version

Crea un utente per il bot, copia i tuoi file e installa i pacchetti:

sudo useradd --system --create-home --home-dir /opt/mybot mybot
sudo cp package.json index.js /opt/mybot/
sudo chown -R mybot: /opt/mybot
cd /opt/mybot && sudo -u mybot npm install --omit=dev

Tieni il token fuori dal codice, in un file leggibile solo da root:

sudo sh -c 'echo "TELEGRAM_BOT_TOKEN=123456789:your-token" > /etc/mybot.env'
sudo chmod 600 /etc/mybot.env

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

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

[Service]
User=mybot
WorkingDirectory=/opt/mybot
EnvironmentFile=/etc/mybot.env
ExecStart=/usr/bin/node index.js
Restart=always
RestartSec=5

[Install]
WantedBy=multi-user.target

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

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

Restart=always riavvia il bot dopo un crash o un process.exit(1). Ferma prima ogni altra copia, altrimenti Telegram risponde a entrambe con 409 Conflict.

Self-hosting o piano bot

Su un VPS che gestisci tu, ti occupi di:

• Aggiornamenti e sicurezza del sistema operativo, e aggiornamenti di Node.js.
• Eseguire npm install dopo ogni modifica, il file del servizio, il file del token e i suoi permessi.
• Leggere journalctl per capire perché il bot si è fermato.
• I 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 tutto questo per te:

• Un selettore della versione di Node.js e npm install quando cambiano package.json, il file di lock o la versione di Node.js.
• Il token, verificato con Telegram prima di essere salvato, conservato cifrato e dato al tuo codice.
• 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, un’altra copia è in esecuzione o c’è un webhook impostato, con un pulsante Rimuovi il webhook nel riquadro Telegram.
• Caricamento file, deploy da Git e backup dal pannello.

Vedi anche Come usare un database MySQL con un bot grammY (mysql2).

Domande frequenti

È la stessa cosa del bot di partenza del pannello?

Quasi. Su un server Node.js, Crea un bot di partenza scrive index.js e package.json con grammY ^1.46.0: risponde a /start con il tuo nome, stampa Logged in as @your_bot, intercetta gli errori con bot.catch e stampa una riga chiara quando Telegram rifiuta il token. Modificalo come vuoi, poi riavvia.

Devo rimuovere il mio webhook prima di bot.start()?

No. bot.start() lo rimuove con deleteWebhook prima di fare polling, e i messaggi che erano in attesa vengono conservati. Se il tuo vecchio codice usava webhookCallback(bot, ...) con un web server, sostituiscilo con bot.start(): questi piani non hanno ancora un indirizzo HTTPS pubblico per un webhook.

bot.start() basta per un bot molto usato?

Per la maggior parte dei bot, sì. bot.start() gestisce i messaggi uno dopo l’altro; le note di grammY dicono che va bene fino a circa 5.000 messaggi all’ora e rimandano al pacchetto @grammyjs/runner per averne di più, o per comandi lunghi, come grandi trasferimenti di file. Anche il runner usa il long polling, quindi funziona sui nostri piani.

Posso usare grammY su Bun o Deno invece che su Node.js?

Sì. Quando ordini, scegli Bun o Deno al posto di Node.js: la nostra pagina di hosting per bot Telegram elenca grammY per entrambi. I passi di questa pagina valgono per Node.js.

Pronto a far girare il tuo bot grammY senza sosta? Vedi i piani su hosting per bot Telegram.