Come costruire e distribuire un bot Telegram?

In questo articolo, costruirete un bot Telegram con Node.js e Backend-as-a-service di Back4app. Quindi, lo distribuirete utilizzando i container di Back4app.

I bot sono software in grado di eseguire compiti ripetitivi automatizzati su una rete o su una piattaforma. I bot di Telegram sono creati utilizzando l’API dei bot di Telegram e sono progettati specificamente per funzionare su Telegram.

È possibile progettare bot Telegram per svolgere varie attività su Telegram, come recuperare informazioni come aggiornamenti meteo o titoli di notizie e ospitare quiz per l’intrattenimento.

Possono anche automatizzare attività come la programmazione di promemoria ed eseguire una semplice autenticazione dell’utente, tra le altre cose.

Impostazione dell’ambiente di sviluppo

Questo articolo presenta un bot di Telegram che consente agli utenti di impostare aggiornamenti meteo automatici per la loro città preferita ogni 6 ore o di ottenere informazioni meteo istantanee per qualsiasi città scelta.

Per impostare la directory del progetto, eseguire i comandi seguenti:

# Crea la directory del tuo progetto
mkdir telegram-weather-bot

# cd nella directory del tuo progetto
cd telegram-weather-bot

# Inizializza npm
npm init -y

I comandi precedenti creano una cartella telegram-weather-bot, si spostano al suo interno e inizializzano npm.

Nel file package.json, aggiungere il seguente script di avvio per eseguire il bot:

"start": "node server.js"

Quindi, eseguire il comando seguente per installare i pacchetti necessari per questo progetto:

npm install axios node-telegram-bot-api dotenv node-schedule parse

Il comando precedente ha installato i seguenti pacchetti:

• axios: Si utilizzerà questa libreria per effettuare richieste HTTP a un’API meteo.

• nodo-telegram-bot-api: Questa libreria semplifica l’interazione con l’API di Telegram Bot.

• dotenv: questo pacchetto aiuta a caricare le variabili d’ambiente da un file .env.

• node-schedule: Questo pacchetto è necessario per programmare le attività e automatizzare gli aggiornamenti meteo.

• parse: Questo pacchetto è necessario per interagire con il backend Back4app Parse.

Ora avete configurato il vostro ambiente di sviluppo. Successivamente, è necessario creare un account bot su Telegram.

Creare l’account del bot di Telegram

Un account bot Telegram servirà come identità del bot sulla piattaforma Telegram. Gli utenti potranno interagire con il bot attraverso questo account.

Per creare il vostro bot Telegram, avviate l’app Telegram, inserite “BotFather” nella barra di ricerca e cliccate sul risultato verificato.

BotFather è un bot di Telegram che consente di sviluppare rapidamente altri bot. Digitate il comando /newbot per avviare il processo di creazione del vostro bot. Dovrete fornire un nome e un nome utente unico per il vostro bot.

Una volta forniti il nome e il nome utente del bot, BotFather fornirà un token unico che consente di interagire con l’account del bot e di gestirlo.

Memorizzare il token del bot nel progetto creando un file .env nella directory principale e incollando il token del bot nel file. In questo modo:

TELEGRAM_BOT_TOKEN = <YOUR_BOT_TOKEN>

Ora che avete il vostro token bot e lo avete memorizzato nel vostro progetto, potete costruire il vostro bot Telegram.

Costruire il Bot Telegram

Questa sezione vi guiderà nella creazione del vostro bot meteo di Telegram e nell’integrazione delle librerie installate per eseguire funzioni come la gestione dei comandi, la gestione dello stato dell’utente e il recupero dei dati dall’API meteo.

Strutturare la cartella del bot in modo simile a quello riportato di seguito per iniziare il processo di creazione:

telegram-weather-bot/
├── node_modules/          
├── src/                        
|   ├── bot.js                    # file per la gestione dell'interazione del bot con l'utente
|   ├── weather.js                # Modulo per il recupero dei dati meteo 
|   ├── stateManager.js           # Modulo per la gestione dello stato utente con Back4App
|   └── cityManager.js            # Gestisce le impostazioni della città dell'utente e invia aggiornamenti meteo
├── .env                        
├── package.json                  
├── server.js                     # Punto di ingresso per la tua candidatura
└── package-lock.json            

Ottenere informazioni meteo

Per ottenere informazioni meteo, si utilizza l’API OpenWeatherMap.

Per effettuare richieste a questa API è necessaria una chiave API. Per ottenere questa chiave API, accedere al proprio account (o crearne uno se non se ne possiede uno).

Quindi, navigare nella sezione “Le mie chiavi API” del proprio profilo e copiare la propria chiave API.

Memorizzare la chiave API di OpenWeatherMap nel file .env:

OPENWEATHERMAP_TOKEN = <YOUR_OPEN_WEATHER_MAP_APIKEY>

Poiché la funzionalità del bot ruota attorno all’ottenimento di informazioni meteorologiche, definire una funzione che effettui una richiesta GET all’API di OpenWeatherMap per recuperare le informazioni meteorologiche con il metodo axios.get.

Aggiungere il blocco di codice sottostante al file weather.js per effettuare una richiesta GET di informazioni meteo dall’API OpenWeatherMap:

const axios = require('axios');
const apiKey = process.env.OPENWEATHERMAP_TOKEN;

async function getWeather(city) {
  try {
    const url = `https://api.openweathermap.org/data/2.5/weather?q=${city}&appid=${apiKey}&units=metric`;
    const response = await axios.get(url);
    const temp = response.data.main.temp;  
    const description = response.data.weather[0].description;  
    return `The weather in ${city} is ${temp}°C with ${description}.`;
  } catch (error) {
    console.error('Error fetching weather:', error);
    throw error;
  }
}

module.exports = { getWeather } 

Il blocco di codice precedente definisce una funzione getWeather che prende come argomento il nome di una città e restituisce la temperatura e la descrizione del tempo dalla risposta dell’API.

Per fornire agli utenti aggiornamenti meteo regolari ogni 6 ore, è necessario implementare una funzione di pianificazione che esegua la funzione getWeather per restituire gli aggiornamenti meteo per una città preferita.

Programmazione degli aggiornamenti meteo

Per programmare il lavoro di restituzione degli aggiornamenti meteo per una città preferita, aggiungere il blocco di codice sottostante nel file cityManager.js:

const schedule = require('node-schedule');
const weather = require('./weather');

let userCities = {};

function setCity(chatId, city) {
  userCities[chatId] = city;
}

function init(bot) {
  schedule.scheduleJob('0 */6 * * *', function() {
    for (let chatId in userCities) {
      const city = userCities[chatId];
      weather.getWeather(city).then(response => {
        bot.sendMessage(chatId, response);
      }).catch(error => {
        bot.sendMessage(chatId, "Failed to retrieve weather.");
      });
    }
  });
}

module.exports = { setCity, init };

Il blocco di codice precedente crea due funzioni: setCity e init.

Il blocco di codice dichiara un oggetto userCities per tracciare le città a cui gli utenti del bot sono interessati, mappando i loro ID di chat di Telegram con i nomi delle città usando la funzione setCity.

Questa funzione consente al bot di persistere la preferenza dell’utente sulla città per la quale desidera ricevere gli aggiornamenti meteo.

La funzione init nel blocco di codice imposta un’attività pianificata ogni 6 ore che itera su tutti gli ID delle chat memorizzati in userCities. La funzione init utilizza il modulo meteo per recuperare il tempo corrente per quella città.

Il bot deve persistere lo stato dell’utente per tenere traccia dei diversi utenti e delle loro città preferite. È possibile ottenere questo risultato utilizzando il backend as a service di Back4app.

Per far sì che il bot tenga traccia di diversi utenti e delle loro città preferite, memorizzate la città preferita di un utente del bot utilizzando il backend di Back4app come servizio.

Creare un backend Back4app

Per utilizzare il backend di Back4app come servizio, è necessario disporre di un account Back4app. Se non ne avete uno, potete registrarvi gratuitamente.

Accedere al proprio account e fare clic sul pulsante “NUOVA APP” nell’angolo in alto a destra. Assegnare un nome all’applicazione e fare clic sul pulsante “CREA”.

Dopo aver fatto clic sul pulsante “CREA”, Back4app genererà la vostra applicazione e vi indirizzerà alla dashboard dell’applicazione.

La connessione all’istanza della vostra applicazione su Back4App dal vostro progetto Node.js richiede di inizializzare il parse SDK installato con le credenziali dell’applicazione di Back4app: ID applicazione e KEY Javascript.

Ottenere l’ID dell'applicazione e la chiave JavaScript da Back4app, accedendo alla sezione “Sicurezza e chiavi” e facendo clic su “Impostazioni dell’app” nella barra laterale.

Memorizzarli nel file .env. Il file .env attuale dovrebbe essere simile a quello qui sotto:

TELEGRAM_BOT_TOKEN= "<YOUR_TELEGRAM_BOT_TOKEN_HERE>"
OPENWEATHERMAP_TOKEN= "<YOUR_OPENWEATHERMAP_TOKEN_HERE>"
BACK4APP_APP_ID= "<YOUR_BACK4APP_APP_ID_HERE>"
BACK4APP_JAVASCRIPT_KEY= "<YOUR_BACK4APP_JAVASCRIPT_KEY_HERE>"

Successivamente, occorre creare una nuova classe “UserState” con due campi: userId (stringa) e state (oggetto). Per svolgere questo compito, si utilizzerà l’agente AI di Back4app.

Per creare questa classe con i rispettivi campi, passare alla scheda “Agente AI” sullo schermo e dare all’agente la richiesta seguente:

Create a new class, "UserState," in my Back4app application with the APP ID “<YOUR_BACK4APP_APP_ID_HERE>”. The "UserState" class will have two fields: userId (string) and state (object).

Si dovrebbe ottenere una risposta simile all’immagine seguente:

Se si controlla la dashboard di Back4app, si dovrebbe vedere la classe UserState creata con successo.

Gestione dello stato dell’utente nel bot Telegram

Per gestire il flusso di interazione tra l’utente del bot e il bot, è necessario definire uno stato utente che indichi quale comando il bot si aspetta dall’utente.

Oltre al comando /start, il bot comprende due comandi principali. Ogni interazione con l’utente (compresi i comandi) determina un aggiornamento dello stato dell’utente, memorizzato insieme all’ID della chat nella classe UserState.

Questa gestione dello stato permette al bot di ricordare particolari dettagli per ogni utente all’interno di una conversazione, come la città preferita per gli aggiornamenti meteo.

Per iniziare a tracciare gli stati degli utenti con la classe UserState creata nel database di Back4App, è necessario inizializzare il Parse SDK con le proprie credenziali.

Aggiungere il blocco di codice sottostante a stateManager.js per inizializzare l’SDK Parse con le credenziali necessarie per connettersi al backend Parse di Back4app:

// stateManager.js
const Parse = require('parse/node');

Parse.initialize(
  process.env.BACK4APP_APP_ID,
  process.env.BACK4APP_JAVASCRIPT_KEY
);

Parse.serverURL = '<https://parseapi.back4app.com/>';

Quindi, definire un oggetto Parse nel file stateManager.js per rappresentare lo schema della classe UserState nel backend Parse di Back4app, consentendo al bot di interagire con lo stato dell’utente memorizzato nel database.

Così:

// stateManager.js
const UserState = Parse.Object.extend('UserState');

Successivamente, è necessario abilitare il bot a recuperare lo stato di conversazione attuale di un particolare utente in base al suo ID utente memorizzato nel database.

Per recuperare lo stato di un utente, è necessario eseguire una query sulla classe UserState con l’ID dell’utente per trovare lo stato salvato nel database.

Così:

// stateManager.js
async function getUserState(userId) {
  const query = new Parse.Query(UserState);
  query.equalTo('userId', userId.toString());
  const userState = await query.first();
  return userState ? userState.get('state') : null;
}

Il blocco di codice precedente definisce una funzione getUserState che recupera in modo asincrono i dati sullo stato dell’utente.

La funzione costruisce una query per trovare l’oggetto di stato dell’utente in base all’argomento(userId) e recupera lo stato dell’utente, se trovato.

Dopo aver recuperato lo stato di un utente, è necessario abilitare il bot ad aggiornare lo stato di conversazione associato a quell’utente in base al suo ID utente e alle informazioni sullo stato fornite.

Ad esempio, l’aggiornamento dello stato della conversazione consentirà al bot di aggiornare la città preferita per ottenere aggiornamenti meteo regolari.

Così:

// stateManager.js
async function setUserState(userId, state) {
  const query = new Parse.Query(UserState);
  query.equalTo('userId', userId.toString());
  let userState = await query.first();

  if (!userState) {
    userState = new UserState();
    userState.set('userId', userId.toString());
  }

  userState.set('state', state);
  await userState.save();
}

La funzione nel blocco di codice precedente costruisce una query per trovare l’oggetto Stato utente in base all’ID utente, crea un nuovo oggetto Stato utente se non esiste, imposta l’attributo Stato e salva l’oggetto nel database.

Quindi, definire una funzione per resettare lo stato di un utente, aggiungendo il seguente blocco di codice al file stateManager.js:

// stateManager.js
async function resetUserState(userId) {
  await setUserState(userId, {});
}

La funzione resetUserState imposta in modo asincrono lo stato di un utente a un oggetto vuoto {}, per resettare lo stato dell’utente nel database.

Assicurarsi che un oggetto stato sia sempre presente per tenere traccia delle azioni del precedente e del nuovo utente del bot. Aggiungere il seguente blocco di codice al file stateManager.js:

// stateManager.js
async function ensureUserState(userId) {
  let state = await getUserState(userId);
  if (!state) {
    await setUserState(userId, {});
  }
}

Il blocco di codice definisce una funzione ensureUserState che recupera l’oggetto stato in base all’ID utente, assicurandosi che i dati di stato dell’utente esistano per l’ID utente fornito nella classe UserState sul backend Back4app Parse.

Recupera lo stato dell’utente con la funzione getUserState e, se non esiste, imposta lo stato su un oggetto vuoto {} con la funzione setUserState.

Esporta tutte le funzioni per poterle utilizzare in altri file sorgente Javascript:

// stateManager.js
module.exports = {
  getUserState,
  setUserState,
  resetUserState,
  ensureUserState,
};

Gestione dell’interazione dell’utente con il bot

Per consentire al bot di ascoltare i comandi start, getWeather e setCity, si definiranno degli ascoltatori di eventi che abbinino il testo ai tre comandi per eseguire le funzioni di callback.

In questo modo il bot potrà eseguire i compiti relativi ai comandi.

Per interagire con le API di Telegram Bot e definire il comportamento del bot, importare la classe TelegramBot dalla libreria node-telegram-bot-api e creare una nuova istanza della classe:

// bot.js
const TelegramBot = require('node-telegram-bot-api');
const token = process.env.TELEGRAM_BOT_TOKEN;
const bot = new TelegramBot(token, { polling: true });

Il blocco di codice precedente crea una nuova istanza della classe TelegramBot con due argomenti: il token del bot e un oggetto.

L’oggetto imposta il valore polling su true per consentire al bot di controllare continuamente i messaggi e gli aggiornamenti dai server di Telegram.

Quindi, importare i moduli creati in questo progetto. Questi moduli verranno utilizzati per implementare le funzioni del bot, come ricevere aggiornamenti sul meteo, impostare una città preferita e gestire lo stato di un utente.

Aggiungere il seguente codice per importare i moduli necessari:

// bot.js
const weather = require('./weather');
const cityManager = require('./cityManager');
const stateManager = require('./stateManager');

Il blocco di codice precedente importa le funzioni create in tutti i file sorgenti, consentendo di richiamarle nel file bot.js.

Per impostare un comando, si utilizza il metodo onText disponibile per la classe TelegramBot. Questo metodo imposta un ascoltatore che implementa una funzione di callback per eseguire una certa logica.

Aggiungete il blocco di codice sottostante al file bot.js per impostare un gestore di comandi /start che il bot ascolterà attivamente con il metodo onText:

// bot.js

bot.onText(/\\/start/, async (msg) => {
    const welcomeMessage = "Welcome to the Weather Bot! Use the commands below to interact:\\n" +
    "/setCity - Set your preferred city for weather updates.\\n" +
    "/getWeather - Get instant weather information for any city.\\n";
    await bot.sendMessage(msg.chat.id, welcomeMessage);
    stateManager.ensureUserState(msg.chat.id);
});

Il blocco di codice precedente consentirà al bot di eseguire una funzione di callback, inviando all’utente un messaggio di benvenuto che illustra il funzionamento del bot.

Il bot imposta lo stato iniziale dell’utente con la funzione ensureUserState, garantendo una tabula rasa per ogni interazione con l’utente.

Quindi, aggiungere il blocco di codice sottostante al file bot.js per impostare un gestore di comandi /setCity che il bot ascolterà attivamente con il metodo onText:

// bot.js

bot.onText(/\\/setCity$/, async (msg) => {
    stateManager.setUserState(msg.chat.id, { expect: 'SET_CITY' });
    bot.sendMessage(msg.chat.id, "Which city do you want to set as your preferred city for weather updates?");
});

Il blocco di codice qui sopra consente agli utenti di specificare la città preferita per gli aggiornamenti meteo con il comando"/setCity“.

Alla ricezione di questo comando, il bot aggiorna lo stato dell’utente a “SET_CITY” utilizzando la funzione setUserState e chiede all’utente di inserire la città desiderata.

Aggiungete il blocco di codice sottostante al file bot.js per impostare un gestore di comandi /getWeather che il bot ascolterà attivamente con il metodo onText:

// bot.js
bot.onText(/\\/getWeather$/, async (msg) => {
    stateManager.setUserState(msg.chat.id, { expect: 'GET_WEATHER' });
    bot.sendMessage(msg.chat.id, "Which city do you want to get weather information for?");
});

Il comando “/getWeather” fa sì che il bot aggiorni lo stato dell’utente a “GET_WEATHER” e gli chieda di fornire una città per la quale desidera immediatamente informazioni sul tempo.

Gestione dei messaggi in arrivo

Per gestire i messaggi in arrivo per il vostro bot Telegram, dovrete impostare un ascoltatore di eventi che attivi una funzione di callback ogni volta che il bot riceve un nuovo messaggio.

Aggiungere il blocco di codice sottostante al file bot.js per impostare un gestore di messaggi che ascolti i comandi e le risposte dell’utente:

// bot.js

// Handle incoming messages
bot.on('message', async (msg) => {
    if (msg.text.startsWith('/')) {
        // If the message is a command, reset the user state
        stateManager.resetUserState(msg.chat.id);
    } else {
        // If it's not a command, check user state
        const state = await stateManager.getUserState(msg.chat.id);
        if (state && state.expect === 'SET_CITY') {
            // If expecting SET_CITY, set city and reset state
            const city = msg.text;
            cityManager.setCity(msg.chat.id, city);
            bot.sendMessage(msg.chat.id, `City set to ${city}. You will receive weather updates every 2 minutes.`);
            stateManager.resetUserState(msg.chat.id);
        } else if (state && state.expect === 'GET_WEATHER') {
            // If expecting GET_WEATHER, get weather and reset state
            const city = msg.text;
            weather.getWeather(city).then(response => {
                bot.sendMessage(msg.chat.id, response);
            }).catch(error => {
                bot.sendMessage(msg.chat.id, "Failed to retrieve weather.");
            });
            stateManager.resetUserState(msg.chat.id);
        }
    }
});

// Initialize the init function from cityManager.js for regular weather updates
cityManager.init(bot);

Il blocco di codice imposta un gestore di messaggi generale che ascolta i messaggi di testo inviati e funge da nucleo della logica di interazione.

Se un messaggio inizia con una barra in avanti (“/”), è considerato un comando. In questo caso, il gestore azzera lo stato dell’utente per garantire un nuovo inizio per il nuovo comando.

Altrimenti, il gestore controlla lo stato attuale dell’utente(stateManager.getUserState) per capire la sua intenzione.

Se l’utente passa il comando “/setCity”, il gestore del bot utilizza cityManager.setCity per memorizzare la città scelta e conferma l’aggiornamento.

Se l’utente passa il comando “/getWeather“, il gestore recupera le informazioni meteo per la città fornita utilizzando la funzione weather.getWeather e invia la risposta all’utente.

Il blocco di codice precedente esegue quindi cityManager.init(bot) per eseguire l’attività pianificata di recupero degli aggiornamenti meteo per la città preferita.

Ora che avete completato la gestione della logica del vostro bot, impostate un server per consentirne l’esecuzione quando lo distribuite in un contenitore Back4app.

Creazione di un file di inserimento

Si creerà un file di ingresso che inizializzerà l’intera applicazione bot. Questo file avrà due funzioni.

• Il file di inserimento eseguirà la logica del bot, richiedendo il file JavaScript che gestisce il modo in cui il bot interagisce con l’API di Telegram e risponde ai messaggi degli utenti.

• Il file di inserimento imposterà anche un server per consentire l’esecuzione del bot su un contenitore Back4app. I contenitori Back4app richiedono porte esposte affinché la distribuzione dell’applicazione abbia successo.

Passare al file server.js nella cartella del progetto. Questo file gestirà la creazione del server. Aggiungere il blocco di codice sottostante nel file server.js:

const http = require('http');
require('./src/bot'); // Import bot logic
const port = 3000;

http
  .createServer((req, res) => {
    res.writeHead(200, { 'Content-Type': 'text/plain' });
    res.end('My Telegram bot is running\\n');
  })
  .listen(port, () => {
    console.log(`Server running on port ${port}`);
  });

Il blocco di codice qui sopra imposta un bot Telegram da eseguire creando un semplice server HTTP. Questo server funge da punto di ingresso, consentendo al bot di funzionare all’interno dell’ambiente del contenitore.

Lo script importa la logica di base del bot e specifica una porta Back4app per consentire al bot di essere distribuito su un container Back4app.

Dopo aver creato il file di inserimento, è possibile testare il bot Telegram in locale prima di distribuirlo in un contenitore Back4app.

Testare il bot di Telegram

Avviate il vostro bot Telegram eseguendo il comando seguente:

node server.js

Per interagire con il vostro bot, aprite l’app Telegram e cercate il nome del vostro bot nella barra di ricerca. Entrate nella chat con il vostro bot e inviate il comando /start.

Il bot dovrebbe rispondere con un messaggio di benvenuto e un elenco di comandi. Inviare al bot un comando.

Il bot consente di impostare la città preferita e di ricevere aggiornamenti meteo regolari con il comando /setCity.

Il comando /getWeather, come mostrato nell’immagine qui sopra, permette di ottenere istantaneamente le informazioni meteorologiche di una determinata città.

Il bot dovrebbe comportarsi in modo simile a quello mostrato nell’immagine precedente, rispondendo ai vostri comandi e interagendo con voi come previsto.

Distribuzione del Bot Telegram nei contenitori Back4App

Dopo aver testato il bot e averne verificato il corretto funzionamento, è possibile distribuirlo sui container Back4app. Per farlo, è necessario creare un file Docker per il progetto.

Nella cartella principale del progetto, creare un file Dockerfile e aggiungervi il blocco di codice sottostante:

# Specify base image
FROM node:18-alpine

# Specify the working directory
WORKDIR /app

# Copy package.json and package-lock.json
COPY package*.json ./

RUN npm install

COPY . .

EXPOSE 3000

# Run the app
CMD ["npm", "start"]

Dopo aver creato il file Docker, spingere il repository locale su GitHub per renderlo accessibile per la distribuzione sui container Back4app.

Quindi, installate l’applicazione Back4App Containers GitHub sul vostro account GitHub e date all’applicazione le autorizzazioni necessarie per accedere al repository di codice della vostra applicazione.

Una volta terminata la configurazione di GitHub, visitate la homepage di Back4app e fate clic sul pulsante “Nuova app” nell’angolo in alto a destra dello schermo.

Si aprirà una schermata di inizializzazione, in cui si dovrà scegliere il tipo di applicazione che si desidera creare. Selezionare l’opzione agente Back4app, come mostrato nell’immagine seguente.

Quando si seleziona l’opzione Back4app Agent, si viene reindirizzati alla pagina dell’agente Back4app AI.

Inserite il prompt sottostante per distribuire la vostra applicazione sui container Back4app:

Deploy my "YOUR_REPOSITORY_URL" repository on GitHub to Back4App Containers.
Here are the required environmental variables:
TELEGRAM_BOT_TOKEN = "TELEGRAM_BOT_TOKEN"
OPENWEATHERMAP_TOKEN = "WEATHER_API_TOKEN"
BACK4APP_APP_ID = "BACK4APP_APP_ID"
BACK4APP_JAVASCRIPT_KEY = "BACK4APP_JAVASCRIPT_KEY"

Sostituire i segnaposto con i valori reali. La richiesta di cui sopra avvierà il processo di distribuzione. Al termine, l’agente AI risponderà indicando il successo o la sospensione dell’installazione.

Si dovrebbe ottenere una risposta simile a quella riportata di seguito:

Se si ottiene un deployment in sospeso, è possibile monitorare lo stato di deployment della propria applicazione sulla dashboard del container Back4app. In alternativa, è possibile distribuire manualmente l’applicazione sui contenitori Back4app.

Conclusione

In questo articolo avete imparato a creare un bot Telegram con Node.js. Avete esplorato come creare un account di bot Telegram, gestire i comandi del bot e gestire le interazioni con gli utenti.

Avete anche creato un backend per il vostro bot con l’aiuto dell’agente AI Back4app, che vi ha permesso di gestire efficacemente lo stato dell’utente e di memorizzare informazioni nelle conversazioni, come la città preferita dall’utente per ricevere regolarmente gli aggiornamenti meteo.

Il codice completo è disponibile in questo repository GitHub.