Bagaimana cara membuat dan menggunakan bot Telegram?

Dalam artikel ini, Anda akan membangun bot Telegram dengan Node.js dan backend-as-a-service Back4app. Kemudian, Anda akan menerapkannya menggunakan kontainer Back4app.

Bot adalah perangkat lunak yang dapat melakukan tugas berulang secara otomatis melalui jaringan atau platform. Bot Telegram dibuat menggunakan API bot Telegram dan dirancang khusus untuk bekerja di Telegram.

Anda dapat mendesain bot Telegram untuk melakukan berbagai tugas di Telegram, seperti mengambil informasi seperti pembaruan cuaca atau berita utama dan menyelenggarakan kuis untuk hiburan.

Mereka juga dapat mengotomatiskan tugas-tugas seperti menjadwalkan pengingat dan melakukan autentikasi pengguna yang sederhana, di antaranya.

Menyiapkan Lingkungan Pengembangan Anda

Artikel ini menampilkan bot Telegram yang memungkinkan pengguna untuk mengatur pembaruan cuaca otomatis untuk kota favorit mereka setiap 6 jam atau mendapatkan informasi cuaca instan untuk kota mana pun yang mereka pilih.

Untuk mengatur direktori proyek Anda, jalankan perintah di bawah ini:

# buat direktori proyek Anda
mkdir telegram-weather-bot

# cd ke direktori proyek Anda
cd telegram-weather-bot

# Inisialisasi npm
npm init -y

Perintah-perintah di atas membuat direktori telegram-weather-bot, pindah ke dalamnya, dan inisialisasi npm di dalamnya.

Di file package.json Anda, tambahkan skrip awal berikut ini untuk menjalankan bot Anda:

"start": "node server.js"

Selanjutnya, jalankan perintah di bawah ini untuk menginstal paket-paket yang diperlukan untuk proyek ini:

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

Perintah di atas menginstal paket-paket berikut:

• axios: Anda akan menggunakan pustaka ini untuk membuat permintaan HTTP ke API cuaca.

• node-telegram-bot-api: Pustaka ini menyederhanakan interaksi dengan Telegram Bot API.

• dotenv: Paket ini akan membantu Anda memuat variabel lingkungan dari file .env.

• jadwal-simpul: Anda akan membutuhkan paket ini untuk menjadwalkan tugas dan mengotomatiskan pembaruan cuaca Anda.

• parse: Anda akan membutuhkan paket ini untuk berinteraksi dengan Back4app Parse Backend.

Sekarang, Anda telah menyiapkan lingkungan pengembangan Anda. Selanjutnya, Anda perlu membuat akun bot di Telegram.

Membuat Akun Bot Telegram Anda

Akun bot Telegram akan berfungsi sebagai identitas bot Anda di platform Telegram. Pengguna akan dapat berinteraksi dengan bot melalui akun ini.

Untuk membuat bot Telegram, luncurkan aplikasi Telegram, masukkan “BotFather” di kolom pencarian, dan klik hasil teratas yang terverifikasi.

BotFather adalah bot Telegram yang memungkinkan Anda mengembangkan bot lain dengan cepat. Ketik perintah /newbot untuk memulai proses pembuatan bot Anda. Anda akan memberikan nama dan nama pengguna yang unik untuk bot Anda.

Setelah Anda memberikan nama dan nama pengguna bot Anda, BotFather akan memberikan token unik yang memungkinkan Anda untuk berinteraksi dan mengelola akun bot.

Simpan token bot Anda di dalam proyek Anda dengan membuat berkas .env di direktori root dan tempelkan token bot ke dalam berkas tersebut. Seperti itu:

TELEGRAM_BOT_TOKEN = <YOUR_BOT_TOKEN>

Sekarang setelah Anda memiliki token bot dan menyimpannya di proyek Anda, Anda dapat membangun bot Telegram Anda.

Membangun Bot Telegram

Bagian ini akan memandu Anda dalam membuat bot cuaca Telegram dan mengintegrasikan pustaka yang telah Anda instal untuk menjalankan fungsi-fungsi seperti menangani perintah, mengelola status pengguna, dan mengambil data dari API cuaca.

Susun direktori bot Anda dengan cara yang sama seperti di bawah ini untuk memulai proses pembuatan:

telegram-weather-bot/
├── node_modules/          
├── src/                        
|   ├── bot.js                    # file untuk menangani interaksi bot dengan pengguna
|   ├── weather.js                # file untuk menangani interaksi bot dengan pengguna
|   ├── stateManager.js           # Modul untuk mengelola status pengguna dengan Back4App
|   └── cityManager.js            # Mengelola pengaturan kota pengguna dan mengirimkan pembaruan cuaca
├── .env                        
├── package.json                  
├── server.js                     # Titik masuk untuk aplikasi Anda
└── package-lock.json            

Mendapatkan Informasi Cuaca

Untuk mendapatkan informasi cuaca, Anda akan menggunakan API OpenWeatherMap.

Untuk membuat permintaan ke API ini, Anda memerlukan kunci API. Untuk mendapatkan kunci API ini, masuk ke akun Anda (atau buat jika Anda belum memilikinya).

Kemudian, buka bagian “Kunci API Saya” di profil Anda dan salin Kunci API Anda.

Simpan kunci API OpenWeatherMap Anda di dalam file .env Anda:

OPENWEATHERMAP_TOKEN = <YOUR_OPEN_WEATHER_MAP_APIKEY>

Karena fungsionalitas bot berkisar pada mendapatkan informasi cuaca, tentukan sebuah fungsi yang akan membuat permintaan GET ke API OpenWeatherMap untuk mengambil informasi cuaca dengan metode axios.get.

Tambahkan blok kode di bawah ini ke file weather.js Anda untuk membuat permintaan GET untuk informasi cuaca dari 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 } 

Blok kode di atas mendefinisikan fungsi getWeather yang mengambil nama kota sebagai argumen dan mengembalikan deskripsi suhu dan cuaca dari respons API.

Untuk menyediakan pembaruan cuaca secara teratur kepada pengguna setiap 6 jam, Anda perlu mengimplementasikan fungsi penjadwal yang akan menjalankan fungsi getWeather untuk mengembalikan pembaruan cuaca untuk kota yang diinginkan.

Menjadwalkan Pembaruan Cuaca

Untuk menjadwalkan pekerjaan mengembalikan pembaruan cuaca untuk kota yang diinginkan, tambahkan blok kode di bawah ini di cityManager.js Anda:

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

Blok kode di atas menciptakan dua fungsi: setCity dan init.

Blok kode mendeklarasikan objek userCities untuk melacak kota yang diminati pengguna bot dengan memetakan ID obrolan Telegram mereka ke nama kota menggunakan fungsi setCity.

Fungsi ini memungkinkan bot Anda untuk mempertahankan preferensi pengguna tentang kota mana yang ingin mereka terima pembaruan cuaca.

Fungsi init dalam blok kode mengatur tugas terjadwal setiap 6 jam yang mengulang semua ID obrolan yang tersimpan di userCities. Fungsi init menggunakan modul cuaca untuk mengambil cuaca saat ini untuk kota tersebut.

Bot Anda perlu mempertahankan status pengguna untuk melacak pengguna yang berbeda dan kota pilihan mereka. Anda dapat mencapai ini menggunakan backend Back4app sebagai layanan.

Untuk membuat bot Anda melacak pengguna yang berbeda dan kota pilihan mereka, simpan kota pilihan pengguna bot menggunakan backend Back4app sebagai layanan.

Membuat Backend Back4app

Untuk menggunakan backend Back4app sebagai layanan, Anda memerlukan akun Back4app. Jika Anda belum memilikinya, Anda dapat mendaftar secara gratis.

Masuk ke akun Anda dan klik tombol “APLIKASI BARU” di pojok kanan atas. Beri nama aplikasi Anda dan klik tombol “BUAT”.

Setelah mengklik tombol “BUAT”, Back4app akan membuat aplikasi Anda dan mengarahkan Anda ke dasbor aplikasi.

Menghubungkan ke instance aplikasi Anda di Back4App dari proyek Node.js mengharuskan Anda untuk menginisialisasi parse SDK yang Anda instal dengan kredensial aplikasi Back4app: ID Aplikasi dan Javascript KEY.

Dapatkan ID Aplikasi dan Kunci JavaScript dari Back4app dengan menavigasi ke bagian “Keamanan & Kunci” dengan mengklik “Pengaturan Aplikasi” di bilah samping.

Simpan di dalam berkas .env Anda. File .env Anda saat ini seharusnya mirip dengan file di bawah ini:

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>"

Selanjutnya, Anda perlu membuat kelas “UserState” baru dengan dua field: userId (string) dan state (objek). Anda akan menggunakan agen AI Back4app untuk menyelesaikan tugas ini.

Untuk membuat kelas ini dengan bidang yang sesuai, buka tab “Agen AI” pada layar Anda dan berikan perintah di bawah ini:

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).

Anda akan mendapatkan respons yang mirip dengan gambar di bawah ini:

Jika Anda memeriksa dasbor Back4app Anda, Anda akan melihat kelas UserState berhasil dibuat.

Mengelola Status Pengguna di Bot Telegram Anda

Untuk mengelola alur interaksi antara pengguna bot dan bot, Anda perlu mendefinisikan status pengguna yang mengindikasikan perintah apa yang diharapkan bot dari pengguna.

Selain dari perintah /start, bot memahami dua perintah utama. Setiap interaksi pengguna (termasuk perintah) memicu pembaruan status pengguna, yang disimpan bersama dengan ID obrolan mereka di kelas UserState.

Manajemen status ini memungkinkan bot untuk mengingat detail tertentu untuk setiap pengguna dalam percakapan, seperti kota pilihan mereka untuk pembaruan cuaca.

Untuk mulai melacak status pengguna dengan kelas UserState yang Anda buat di basis data Back4App Anda, Anda perlu menginisialisasi Parse SDK dengan kredensial Anda.

Tambahkan blok kode di bawah ini ke stateManager.js untuk menginisialisasi Parse SDK dengan kredensial yang diperlukan untuk terhubung ke Back4app Parse Backend:

// 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/>';

Selanjutnya, tentukan objek Parse di file stateManager.js Anda untuk merepresentasikan skema kelas UserState di backend Back4app Parse, yang memungkinkan bot Anda berinteraksi dengan status pengguna yang tersimpan di database.

Sepertinya begitu:

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

Selanjutnya, Anda perlu mengaktifkan bot Anda untuk mengambil status percakapan pengguna tertentu saat ini berdasarkan ID pengguna mereka yang tersimpan di database.

Untuk mengambil status pengguna, Anda perlu menjalankan kueri pada kelas UserState dengan ID pengguna untuk menemukan status yang tersimpan dalam database.

Sepertinya begitu:

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

Blok kode di atas mendefinisikan fungsi getUserState yang secara asinkron mengambil data status pengguna.

Fungsi ini membuat kueri untuk menemukan objek status pengguna berdasarkan argumen(userId) dan mengambil status pengguna jika ditemukan.

Setelah mengambil status pengguna, Anda perlu mengaktifkan bot Anda untuk memperbarui status percakapan yang terkait dengan pengguna tersebut berdasarkan ID pengguna dan informasi status yang diberikan.

Misalnya, memperbarui status percakapan akan memungkinkan bot memperbarui kota yang disukai untuk mendapatkan pembaruan cuaca secara teratur.

Sepertinya begitu:

// 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();
}

Fungsi pada blok kode di atas membuat kueri untuk menemukan objek status pengguna berdasarkan userId, membuat objek UserState baru jika tidak ada, menetapkan atribut status, dan menyimpan objek tersebut ke database.

Selanjutnya, tentukan fungsi untuk mengatur ulang status pengguna dengan menambahkan blok kode berikut di bawah ini ke file stateManager.js Anda:

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

Fungsi resetUserState secara asinkron mengatur status pengguna ke objek kosong {} untuk mengatur ulang status pengguna dalam database.

Pastikan objek state selalu ada untuk melacak tindakan pengguna bot lama dan baru. Tambahkan blok kode berikut di bawah ini ke berkas stateManager.js:

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

Blok kode mendefinisikan fungsi ensureUserState yang mengambil objek status berdasarkan ID pengguna, memastikan bahwa data status pengguna ada untuk userId yang disediakan di kelas UserState pada backend Back4app Parse.

Fungsi ini mengambil status pengguna dengan fungsi getUserState dan, jika tidak ada status, menetapkan status ke objek kosong {} menggunakan fungsi setUserState.

Ekspor semua fungsi agar Anda dapat menggunakannya di file sumber Javascript lainnya:

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

Menangani Interaksi Pengguna dengan Bot

Agar bot Anda dapat mendengarkan perintah start, getWeather, dan setCity, Anda akan mendefinisikan pendengar peristiwa untuk mencocokkan teks dengan ketiga perintah tersebut untuk menjalankan fungsi callback.

Ini akan memungkinkan bot untuk melakukan tugas-tugas yang berkaitan dengan perintah.

Untuk berinteraksi dengan Telegram Bot API agar Anda dapat menentukan perilaku bot Anda, impor kelas TelegramBot dari pustaka node-telegram-bot-api dan buatlah instance baru dari kelas tersebut:

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

Blok kode di atas membuat instance baru dari kelas TelegramBot dengan dua argumen: token bot dan sebuah objek.

Objek tersebut menetapkan nilai polling ke true untuk memungkinkan bot terus memeriksa pesan dan pembaruan dari server Telegram.

Selanjutnya, impor modul yang Anda buat dalam proyek ini. Anda akan menggunakan modul-modul ini untuk mengimplementasikan fungsi-fungsi bot, seperti mendapatkan pembaruan cuaca, mengatur kota pilihan, dan mengelola status pengguna.

Tambahkan kode berikut di bawah ini untuk mengimpor modul yang diperlukan:

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

Blok kode di atas mengimpor fungsi-fungsi yang Anda buat di semua berkas sumber, sehingga Anda dapat memanggil fungsi-fungsi ini di berkas bot.js Anda.

Untuk menyiapkan perintah, Anda menggunakan metode onText yang tersedia pada kelas TelegramBot. Metode ini menyiapkan pendengar untuk mengimplementasikan fungsi callback untuk melakukan beberapa logika.

Tambahkan blok kode di bawah ini ke berkas bot.js Anda untuk menyiapkan penangan perintah /start yang akan secara aktif didengarkan oleh bot dengan metode 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);
});

Blok kode di atas akan memungkinkan bot menjalankan fungsi callback, mengirimkan pesan selamat datang kepada pengguna yang merinci cara kerja bot.

Bot menetapkan status awal pengguna dengan fungsi ensureUserState, memastikan catatan yang bersih untuk setiap interaksi pengguna.

Selanjutnya, tambahkan blok kode di bawah ini ke berkas bot.js Anda untuk menyiapkan penangan perintah /setCity yang akan didengarkan secara aktif oleh bot dengan metode 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?");
});

Blok kode di atas memungkinkan pengguna untuk menentukan kota yang mereka sukai untuk pembaruan cuaca dengan perintah"/setCity“.

Setelah menerima perintah ini, bot memperbarui status pengguna menjadi “SET_CITY” menggunakan fungsi setUserState dan meminta pengguna untuk memasukkan kota yang diinginkan.

Tambahkan blok kode di bawah ini ke file bot.js Anda untuk menyiapkan penangan perintah /getWeather yang akan secara aktif didengarkan oleh bot dengan metode 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?");
});

Perintah “/getWeather” memicu bot untuk memperbarui status pengguna menjadi “GET_WEATHER” dan meminta mereka untuk memberikan kota yang mereka inginkan secara instan untuk informasi cuaca.

Menangani Pesan Masuk

Untuk menangani pesan masuk untuk bot Telegram Anda, Anda perlu menyiapkan pendengar peristiwa yang memicu fungsi callback setiap kali bot menerima pesan baru.

Tambahkan blok kode di bawah ini ke berkas bot.js Anda untuk menyiapkan penangan pesan untuk mendengarkan perintah dan respons pengguna:

// 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);

Blok kode mengatur penangan pesan umum yang mendengarkan pesan teks yang dikirim kepadanya dan bertindak sebagai inti dari logika interaksi.

Jika pesan dimulai dengan garis miring (“/”), maka pesan tersebut dianggap sebagai perintah. Dalam kasus ini, penanganannya akan mengatur ulang status pengguna untuk memastikan permulaan yang baru untuk perintah baru.

Jika tidak, handler akan memeriksa status pengguna saat ini(stateManager.getUserState) untuk memahami maksud mereka.

Jika pengguna memberikan perintah “/setCity”, penangan bot menggunakan cityManager.setCity untuk menyimpan kota yang mereka pilih dan mengonfirmasi pembaruan.

Jika pengguna memberikan perintah “/getWeather“, handler akan mengambil informasi cuaca untuk kota yang disediakan menggunakan fungsi weather.getWeather dan mengirimkan respons kembali ke pengguna.

Blok kode di atas kemudian menjalankan cityManager.init(bot ) untuk menjalankan tugas terjadwal untuk mengambil pembaruan cuaca untuk kota yang diinginkan.

Setelah Anda selesai menangani logika bot Anda, siapkan server agar dapat berjalan saat Anda menerapkannya ke kontainer Back4app.

Membuat File Entri

Anda akan membuat file entri yang akan menginisialisasi seluruh aplikasi bot. Berkas ini akan melayani dua fungsi.

• File entri akan menjalankan logika bot dengan membutuhkan file JavaScript yang menangani bagaimana bot Anda berinteraksi dengan API Telegram dan merespons pesan pengguna.

• File entri juga akan menyiapkan server untuk memungkinkan bot Anda berjalan di kontainer Back4app. Kontainer Back4app membutuhkan port yang terbuka agar penerapan aplikasi Anda berhasil.

Buka berkas server.js di dalam direktori proyek Anda. Berkas ini akan menangani pembuatan server. Tambahkan blok kode di bawah ini ke dalam berkas 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}`);
  });

Blok kode di atas menyiapkan bot Telegram untuk dijalankan dengan membuat server HTTP sederhana. Server ini bertindak sebagai titik masuk, yang memungkinkan bot berfungsi di dalam lingkungan kontainer.

Skrip mengimpor logika inti bot Anda dan menentukan port Back4app untuk memungkinkan bot Anda diterapkan pada kontainer Back4app.

Setelah membuat file entri, Anda dapat menguji bot Telegram secara lokal sebelum menerapkannya ke kontainer Back4app.

Menguji Bot Telegram

Mulai bot Telegram Anda dengan menjalankan perintah di bawah ini:

node server.js

Untuk berinteraksi dengan bot Anda, buka aplikasi Telegram dan cari nama bot Anda di bilah pencarian. Masuk ke obrolan dengan bot Anda dan kirimkan perintah /start.

Bot akan merespons dengan pesan selamat datang dan daftar perintah. Kirimkan perintah kepada bot.

Bot ini memungkinkan Anda untuk mengatur kota pilihan Anda dan menerima pembaruan cuaca secara teratur dengan perintah /setCity.

Perintah /getWeather, seperti yang ditunjukkan pada gambar di atas, dapat langsung mendapatkan informasi cuaca untuk kota tertentu.

Bot harus berperilaku serupa dengan apa yang ditunjukkan pada gambar di atas, merespons perintah Anda dan berinteraksi dengan Anda sebagaimana mestinya.

Menerapkan Bot Telegram ke Wadah Back4App

Setelah menguji bot Anda dan memastikannya berfungsi dengan baik, Anda dapat menerapkannya pada kontainer Back4app. Untuk melakukannya, pertama-tama, Anda perlu membuat Dockerfile untuk proyek Anda.

Di direktori root proyek Anda, buat berkas Dockerfile dan tambahkan blok kode di bawah ini ke dalamnya:

# 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"]

Setelah membuat Dockerfile, dorong repositori lokal Anda ke GitHub agar dapat diakses untuk digunakan pada kontainer Back4app.

Selanjutnya, instal Aplikasi GitHub Back4App Containers di akun GitHub Anda dan berikan izin yang diperlukan untuk mengakses repositori kode aplikasi Anda.

Setelah Anda selesai dengan konfigurasi GitHub Anda, buka beranda Back4app dan klik tombol “Aplikasi Baru” di sudut kanan atas layar Anda.

Ini akan membawa Anda ke layar inisialisasi, di mana Anda harus memilih jenis aplikasi yang ingin Anda buat. Pilih opsi agen Back4app, seperti yang ditunjukkan pada gambar di bawah ini.

Ketika Anda memilih opsi Agen Back4app, Anda akan diarahkan ke halaman agen AI Back4app.

Masukkan perintah di bawah ini untuk menerapkan aplikasi Anda pada kontainer 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"

Ganti placeholder dengan nilai aktualnya. Perintah di atas akan memulai proses penerapan Anda. Setelah selesai, agen AI akan merespons, yang mengindikasikan keberhasilan atau penerapan yang tertunda.

Anda akan mendapatkan respons yang serupa dengan yang di bawah ini:

Jika Anda mendapatkan pending deployment, Anda dapat memantau status deployment aplikasi Anda di dasbor kontainer Back4app. Atau, Anda dapat men-deploy aplikasi Anda secara manual di kontainer Back4app.

Kesimpulan

Pada artikel ini, Anda telah mempelajari cara membuat bot Telegram dengan Node.js. Anda telah menjelajahi cara membuat akun bot Telegram, menangani perintah bot, dan menangani interaksi pengguna.

Anda juga membuat backend untuk bot Anda dengan bantuan agen AI Back4app, yang memungkinkan Anda mengelola status pengguna secara efektif dan menyimpan informasi dalam percakapan, seperti kota pilihan pengguna untuk menerima pembaruan cuaca secara teratur.

Anda dapat menemukan kode lengkapnya di repositori GitHub ini.