<a href="https://www.nginx.com/">Nginx</a> is a web server that can also be used as a reverse proxy, load balancer, mail proxy, and HTTP cache.
<h3>Implementation</h3>
The first thing we need to do is to install <a href="https://openresty.org/en/">OpenResty</a>. OpenResty is a modified version of nginx with LuaJIT compiled in and many nginx options that can be controlled or modified via Lua. It is very commonly used in content delivery networks for it’s configurability.
Once installed, you should navigate to your browser and type <a href="http://localhost./">http://localhost.</a> If everything goes well, you will see the below screenshot:
<figure><img alt="" src="https://cdn-images-1.medium.com/max/966/1*zeY_GdpUw8DniBQ5Q4a2AA.png"></figure>With this, you have successfully installed OpenResty along with Nginx.
Now, we need to edit the nginx.conf file. You can find the nginx.conf file in the below locations:
<ul>
<li>Ubuntu : /usr/local/openresty/nginx/nginx.conf
</li>
<li>Windows: /openresty-VERSION/conf/nginx.conf</li>
<li>Mac: /usr/local/Cellar/openresty/nginx/nginx.conf (using homebrew)
</li>
</ul>
For a basic Load Balancer with dynamic backends, there are two important operations that it should perform:
<ol>
<li>API for adding hosts</li>
<li>Load Balancer</li>
<li>Reverse proxy server</li>
</ol>
<h4>Full Code of nginx.conf:</h4>
<pre>worker_processes 1; #pid logs/nginx.pid; events { worker_connections 1024; } http { include mime.types; default_type application/octet-stream; sendfile on; keepalive_timeout 65; -- Creating dict for hosts lua_shared_dict hosts 10m; upstream backend { server 0.0.0.1; balancer_by_lua_block { -- Import nginx balancer package local balancer = require "ngx.balancer" -- Getting hosts keys local hosts = ngx.shared.hosts local hosts_keys = hosts:get_keys() -- Getting total weight of all hosts local total_weight = 0 for i, key in ipairs(hosts_keys) do total_weight = total_weight + hosts:get(key) end -- Generating random number between 1 and total_weight local random_num = math.random(1, total_weight) total_weight = 0 -- Apply weight random algorithm for i, key in ipairs(hosts_keys) do total_weight = total_weight + hosts:get(key) if random_num &lt; total_weight then local host, port = string.match(key, "^(.-):(.*)$") ok, err = balancer.set_current_peer(host, port) if not ok then return ngx.exit(500) end break end end } keepalive_timeout 10ms; } server { listen 8081; server_name localhost; location = /add-peer { content_by_lua_block { -- Getting post request body ngx.req.read_body() -- Import library to work with json local cjson = require "cjson" -- Getting post request's args local post_args = ngx.req.get_post_args() local json_str = next(post_args) local json_obj = cjson.decode(json_str) local host = json_obj.host local weight = json_obj.weight -- Setting new host to hosts dict in (host, weight) format local hosts = ngx.shared.hosts hosts:set(host, weight) -- Return host and weight ngx.say(host) ngx.say(hosts:get(host)) } } } server { listen 8080; server_name localhost; location / { proxy_pass http://backend; } } }</pre>
<h3>API</h3>
<ol>
<li>The server directive sets up an NGINX server block listening on port 8081 with the server name "localhost".</li>
<li>The location = /add-host directive specifies that this location block will be used only for requests with the exact path "/add-host".</li>
<li>The content_by_lua_block directive allows you to execute custom Lua code to handle the request.</li>
<li>The Lua code begins by reading the request body using ngx.req.read_body(). This ensures that the request body is read and available for further processing.</li>
<li>The code then imports the “cjson” library, which provides functions to work with JSON data in Lua.</li>
<li>The ngx.req.get_post_args() function is used to retrieve the POST request arguments. It returns a table containing the key-value pairs of the arguments.</li>
<li>Since there is only one argument expected, next(post_args) retrieves the first (and only) key from the table.</li>
<li>The received JSON string is then decoded into a Lua table using cjson.decode(json_str). This converts the JSON data into a Lua object that can be easily accessed.</li>
<li>Next, it accesses the ngx.shared.hosts shared memory dictionary and sets the host as the key and weight as the corresponding value usin hosts:set(host, weight).</li>
<li>The code uses ngx.say() to return the host and its corresponding weight as the response body. These values are sent back to the client.</li>
</ol>
In summary, this code sets up an NGINX server block that listens on port 8081. It handles a POST request to the “/add-host” endpoint, which expects a JSON payload containing the properties “host” and “weight”. It then stores the host and weight in the ngx.shared.hosts shared memory dictionary and returns the host and its weight as the response.
<pre>server { listen 8081; server_name localhost; location = /add-host { content_by_lua_block { -- Getting post request body ngx.req.read_body() -- Import library which provides functions to work with JSON local cjson = require "cjson" -- Retrieving the POST request arguments. local post_args = ngx.req.get_post_args() local json_str = next(post_args) local json_ obj = cjson.decode(json_str) local host = json_obj.host local weight = json_obj.weight -- Setting new host to hosts dict in (host, weight) format local hosts = ngx.shared.hosts hosts:set(host, weight) -- Return host and weight ngx.say(host) ngx.say(hosts:get(host)) } } }</pre>
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*O3PmXV34fAvuYm4fVutORw.png"></figure><h3>Load Balancer</h3>
Load balancer in OpenResty with a dynamic set of backends requires using balancer_by_lua_block or balancer_by_lua_file.
<ol>
<li>The upstream directive is used to define a group of servers that will be used as the backend for processing requests.</li>
<li>The server 0.0.0.1 line specifies a dummy server IP address. This server will not actually be used, but it is required for the configuration to be valid.</li>
<li>The balancer_by_lua_block directive allows you to execute custom Lua code to implement the load balancing logic.</li>
<li>The code starts by importing the NGINX balancer package with local balancer = require "ngx.balancer". This package provides functions to interact with the load balancer module.</li>
<li>It retrieves the list of host keys from the ngx.shared.hosts shared memory dictionary using local hosts = ngx.shared.hosts and local hosts_keys = hosts:get_keys().</li>
<li>The variable total_weight is initialized as 0. It will be used to calculate the total weight of all hosts.</li>
<li>The code then iterates over each host key in the hosts_keys list. For each host, it retrieves its weight using hosts:get(key) and adds it to total_weight.</li>
<li>After calculating the total weight, the code generates a random number between 1 and total_weight using math.random(1, total_weight).</li>
<li>Another loop iterates over the host keys again, this time performing the weighted random algorithm. The algorithm checks if the randomly generated number is less than the cumulative weight. If it is, it selects that host as the current peer.</li>
<li>When a host is selected, the key is split into host and port using string.match(key, "^(.-):(.*)$"). The balancer.set_current_peer function is then called with host and port to set the current peer for load balancing.</li>
<li>Once a host is selected and set as the current peer, the loop breaks, and the load balancing process is complete.</li>
<li>The keepalive_timeout directive sets the maximum time in milliseconds that the connection to the backend server should be kept alive for subsequent requests.</li>
</ol>
In summary, this code implements a weighted random load balancing algorithm using Lua scripting within NGINX. It selects a backend server from a pool of servers based on their weights defined in the ngx.shared.hosts shared memory dictionary.
<pre>upstream backend { server 0.0.0.1; balancer_by_lua_block { -- Import nginx balancer package local balancer = require "ngx.balancer" -- Getting hosts keys local hosts = ngx.shared.hosts local hosts_keys = hosts:get_keys() -- Getting total weight of all hosts local total_weight = 0 for i, key in ipairs(hosts_keys) do total_weight = total_weight + hosts:get(key) end -- Generating random number between 1 and total_weight local random_num = math.random(1, total_weight) total_weight = 0 -- Apply weight random algorithm for i, key in ipairs(hosts_keys) do total_weight = total_weight + hosts:get(key) if random_num &lt; total_weight then local host, port = string.match(key, "^(.-):(.*)$") ok, err = balancer.set_current_peer(host, port) if not ok then return ngx.exit(500) end break end end } keepalive_timeout 10ms; }</pre>
<h3>Reverse proxy server</h3>
<pre>server { listen 8080; server_name localhost; location / { proxy_pass http://backend; } }</pre>
proxy_pass http://backend;: This line is the key part of this configuration. It instructs NGINX to act as a reverse proxy and forward all requests to the backend server specified by the URL "<a href="http://backend/">http://backend</a>". NGINX will pass the requests it receives to the backend server, receive the response, and return it to the original client.
<h3>Testing</h3>
To test the load balancer, I launched 3 three servers. The first one runs on port 8091. The second one runs on port 8092 and the third one runs on port 8093. Then I added them to Load Balancer using /add-host . The weight of the first server is 2. The weight of the second server is 6 and the weight of the third server is 10. To test the Load Balancer we need to send request to localhost:8080/ . So, I sent 10 requests to see how the load balancer would distribute them across three servers.
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Y7xcyBia4iktWinidsKvGQ.png"></figure>As a result, No request was sent to the server with weight 2.
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*aYbedMdEXdQmBRqHFnUu4g.png"></figure>Two requests was sent to the server with weight 6.
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MCyqYDNBKRkN5lisGHdAEg.png"></figure>Eight requests was sent to the server with weight 10.
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*b-wgX3WCXfBI7jQSJmiqrg.png"></figure>Congrats, your Load Balancer is ready! 🔥
<h3>At Last:</h3>
If you like this article, please follow or subscribe to receive high-quality content in time. Thank you for your support ;)
<img src="https://medium.com/_/stat?event=post.clientViewed&amp;referrerSource=full_rss&amp;postId=da5d3cc77b52" width="1" height="1" alt="">

Building Basic Load Balancer with Dynamic Backends with Nginx + Lua.

<h3>Introduction</h3>
The previous post (<a href="https://medium.com/@nikbenlioglu/how-to-build-a-to-do-list-telegram-bot-with-the-golang-postgresql-database-b77b1ec014ba">https://medium.com/@nikbenlioglu/how-to-build-a-to-do-list-telegram-bot-with-the-golang-postgresql-database-b77b1ec014ba</a>), I built a Telegram bot using Golang and Postgresql. So, in this post, I will show you how to Dockerize this project.
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*-NUbnqNzOEEj3aR6.png"></figure>To Dockerize the Golang project we first need to write Dockerfile.
<pre>FROM golang:1.19.3-alpine3.16 as builder WORKDIR /app COPY /. ./ #apk add nano \ &amp;&amp; RUN go mod download \ &amp;&amp; go build -o /telegram-todolist . FROM alpine:3.16.2 WORKDIR /app COPY --from=builder telegram-todolist . COPY .env . CMD ["./telegram-todolist"]</pre>
Then we need to build an image from this Dockerfile. To build an image run the “docker build .” command in the terminal.
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*sTyQL3EHJ7qwLo-3RWzekA.png"></figure>Let's list our Docker images. Run the “docker image ls” command.
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*caLDDELVb-0r3IxYhxR87w.png"></figure>To change the name of the image run “docker tag ‘IMAGE ID’ ‘new_name’ ” command.
<figure><img alt="" src="https://cdn-images-1.medium.com/max/746/1*2bcoGwWqxW7tNcCI9hdTcw.png"></figure>Your image is now displayed in Docker.
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HhnqxFAVfRZvnnPrmrl9Ow.png"></figure>Now let's push this image to dockerhub. To do this, we first need to log in dockerhub. Run “docker login” command to authorize.
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WJ8noHPqZF_Z65pJGkMpPg.png"></figure>Then we need to change the actual image's name to “dockerhub_nickname/image_name:tag”.
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1001/1*2npi8Ea2rk_WRQg2cgCLAg.png"></figure>Now we can push our image by running “docker push ‘image_name’” command.
<figure><img alt="" src="https://cdn-images-1.medium.com/max/836/1*_w1wV1g4vaqjQl3ODP4d8Q.png"></figure>Now you can find your image on dockerhub.
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xe-Q3xA-NMESBESTKFtiIQ.png"></figure>Now to combine the project image and database image into one container we need to create docker-compose file. There are two services in the file below. The first one is the Golang project’s image. The second one is PostgreSQL’s image.
<figure><img alt="" src="https://cdn-images-1.medium.com/max/667/1*YSJyEr1n6BmFxORgnzSUSw.png"></figure>After creating the docker-compose file run it by running “file_name up” command.
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6oOp1lCjQCXqERxugBobDA.png"></figure>As a result, you will find a ready container in docker.
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LWRWodJfiVGjmOZrCsVj4w.png"></figure>Congrats, your container is running! 🔥
<h3>At Last:</h3>
If you like this article, please follow or subscribe to receive high-quality content in time. Thank you for your support ;)
<img src="https://medium.com/_/stat?event=post.clientViewed&amp;referrerSource=full_rss&amp;postId=e68a149e31c1" width="1" height="1" alt="">

How to Dockerize your Golang application

Github: <a href="https://github.com/nikben08/todolist-telegram_bot-medium">https://github.com/nikben08/todolist-telegram_bot-medium</a>
<h3>Register your bot on Telegram</h3>
<figure><img alt="" src="https://cdn-images-1.medium.com/max/811/1*AiYemKIiRyo3doCWtW_uOQ.png"></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/738/1*2J5U0lOqf-c-vW08B2d1tA.png"></figure><h3>Let’s create a project</h3>
There are 3 layers in my project.
<ol>
<li>The handlers layer is the layer that processes incoming commands.</li>
<li>The services layer is the layer that implements business logic.</li>
<li>The repositories layer is the layer that we use to perform operations with the database.</li>
</ol>
The picture below shows the structure of the project
<figure><img alt="" src="https://cdn-images-1.medium.com/max/364/1*njujmtxGYVIw39nf2F3GFQ.png"></figure><ol><li>Create .env file.</li></ol>
First of all, we need to create .env file where we will store the environment variables like the Telegram API token, Project’s port, DBHost, etc.
<pre>TELEGRAM_APITOKEN= #your telegram api toke PORT=83 POSTGRES_HOST=127.0.0.1 POSTGRES_USER=postgres POSTGRES_PASSWORD=0811 POSTGRES_DATABASE_NAME=todolist POSTGRES_PORT=5432 SSL_MODE="disable"</pre>
2. Create config file (config &gt; config.go).
Then we need to create config.go file. In that file we need to write a function that gets the environment variable from .env file.
<pre>package config import ( "fmt" "os" "github.com/joho/godotenv" ) // Config func to get env value from key --- func Config(key string) string { // load .env file err := godotenv.Load(".env") if err != nil { fmt.Print("Error loading .env file") } return os.Getenv(key) }</pre>
3. Create a telegram client file (clients &gt; telegram.go).
Then we need to create a Telegram client file. In that file, I wrote a function that creates a connection with the Telegram bot and returns the connection as a pointer. As a telegram library, I use go-telegram-bot-api.
<pre>package clients import ( "log" "telegram-todolist/config" tgbotapi "github.com/go-telegram-bot-api/telegram-bot-api/v5" ) func Init() *tgbotapi.BotAPI { bot, err := tgbotapi.NewBotAPI(config.Config("TELEGRAM_APITOKEN")) if err != nil { log.Panic(err) } bot.Debug = true return bot }</pre>
4. Create a database connection file (database &gt; database.go)
Next, we need to create database.go file. In that file, I wrote a function that creates a connection with PostgreSQL. Then that function recreates the database by dropping todolist database if it exists and creating the new one. Then the function creates a connection to the database it previously created. Then the Init function makes migration and returns the database connection as a pointer.
<pre>package database import ( "fmt" "log" "telegram-todolist/config" "telegram-todolist/models" _ "github.com/lib/pq" "gorm.io/driver/postgres" "gorm.io/gorm" ) func Init() *gorm.DB { //Connect to database dsn := fmt.Sprintf("host=%s user=%s password=%s port=%s, dbname=%s", config.Config("POSTGRES_HOST"), config.Config("POSTGRES_USER"), config.Config("POSTGRES_PASSWORD"), config.Config("POSTGRES_PORT"), "postgres") DB, err := gorm.Open(postgres.Open(dsn), &amp;gorm.Config{}) if err != nil { log.Fatal(err) } if err := DB.Exec("DROP DATABASE IF EXISTS todolist;").Error; err != nil { panic(err) } if err := DB.Exec("CREATE DATABASE todolist").Error; err != nil { panic(err) } dsn = fmt.Sprintf("host=%s user=%s password=%s dbname=%s port=%s", config.Config("POSTGRES_HOST"), config.Config("POSTGRES_USER"), config.Config("POSTGRES_PASSWORD"), config.Config("POSTGRES_DATABASE_NAME"), config.Config("POSTGRES_PORT")) DB, err = gorm.Open(postgres.Open(dsn), &amp;gorm.Config{}) if err != nil { log.Fatal(err) } // Migrate tables DB.AutoMigrate(&amp;models.Task{}) return DB }</pre>
5. Create model Task (models &gt; task.go)
Next, we need to create a model that we will use to create todos. I created the model by creating a Task struct. Task struct has an ID that automatically generates. As an ID I use uuid from Google. The task also has ChatId that we will use as a user identifier and Task containing text with the todo.
<pre>package models import ( "github.com/google/uuid" ) type Task struct { ID uuid.UUID `gorm:"type:uuid;default:gen_random_uuid();"` ChatId int64 `gorm:"chat_id"` Task string `gorm:"task"` }</pre>
6. Create handler functions (handlers &gt; init.go, commands.go, callbacks.go, messages.go)
init.go
The Init function checks updates and determines the type of update.
<pre>package handlers import ( tgbotapi "github.com/go-telegram-bot-api/telegram-bot-api/v5" ) func Init(bot *tgbotapi.BotAPI) { u := tgbotapi.NewUpdate(0) u.Timeout = 60 updates := bot.GetUpdatesChan(u) // Loop through each update. for update := range updates { if update.CallbackQuery != nil { Callbacks(bot, update) } else if update.Message.IsCommand() { Commands(bot, update) } else { Messages(bot, update) } } }</pre>
commands.go
The Commands function handles commands that come from Init function.
<pre>package handlers import ( "telegram-todolist/services" tgbotapi "github.com/go-telegram-bot-api/telegram-bot-api/v5" ) func Commands(bot *tgbotapi.BotAPI, update tgbotapi.Update) { switch update.Message.Command() { case "start": services.Start(bot, update) case "set_todo": services.SetTask(bot, update) case "delete_todo": services.DeleteTask(bot, update) case "show_all_todos": services.ShowAllTasks(bot, update) } }</pre>
callbacks.go
The Сallbacks function handles callbacks. At the beginning of the function, we split update.CallbackQuery.Data to get command and taskId (todo ID).
<pre>package handlers import ( "telegram-todolist/services" "telegram-todolist/utils" tgbotapi "github.com/go-telegram-bot-api/telegram-bot-api/v5" ) func Callbacks(bot *tgbotapi.BotAPI, update tgbotapi.Update) { cmd, taskId := utils.GetKeyValue(update.CallbackQuery.Data) switch { case cmd == "delete_task": services.DeleteTaskCallback(bot, update, taskId) } }</pre>
messages.go
The messages function handles received messages. As a message we send only Todo’s text, that's why we don't need to use a case switch here.
<pre>package handlers import ( "telegram-todolist/services" tgbotapi "github.com/go-telegram-bot-api/telegram-bot-api/v5" ) func Messages(bot *tgbotapi.BotAPI, update tgbotapi.Update) { services.SetTaskCallback(bot, update) }</pre>
7. Create the services layer (services &gt; tasks.go)
In the services layer, I implement the business logic of the project. DeleteTask function creates a markup keyboard of todos so that the user can select the todo to be deleted.
<pre>package services import ( "fmt" "telegram-todolist/keyboards" "telegram-todolist/repositories" tgbotapi "github.com/go-telegram-bot-api/telegram-bot-api/v5" ) func Start(bot *tgbotapi.BotAPI, update tgbotapi.Update) { text := "Hi, here you can create todos for your todolist." msg := tgbotapi.NewMessage(update.Message.Chat.ID, text) msg.ReplyMarkup = keyboards.CmdKeyboard() if _, err := bot.Send(msg); err != nil { panic(err) } } func SetTask(bot *tgbotapi.BotAPI, update tgbotapi.Update) { text := "Please, write todo." msg := tgbotapi.NewMessage(update.Message.Chat.ID, text) if _, err := bot.Send(msg); err != nil { panic(err) } } func SetTaskCallback(bot *tgbotapi.BotAPI, update tgbotapi.Update) { text := "Todo successfully created" err := repositories.SetTask(update) if err != nil { text = "Couldnt set task" } msg := tgbotapi.NewMessage(update.Message.Chat.ID, text) if _, err := bot.Send(msg); err != nil { panic(err) } } func DeleteTask(bot *tgbotapi.BotAPI, update tgbotapi.Update) { data, _ := repositories.GetAllTasks(update.Message.Chat.ID) var btns []tgbotapi.InlineKeyboardButton for i := 0; i &lt; len(data); i++ { btn := tgbotapi.NewInlineKeyboardButtonData(data[i].Task, "delete_task="+data[i].ID.String()) btns = append(btns, btn) } var rows [][]tgbotapi.InlineKeyboardButton for i := 0; i &lt; len(btns); i += 2 { if i &lt; len(btns) &amp;&amp; i+1 &lt; len(btns) { row := tgbotapi.NewInlineKeyboardRow(btns[i], btns[i+1]) rows = append(rows, row) } else if i &lt; len(btns) { row := tgbotapi.NewInlineKeyboardRow(btns[i]) rows = append(rows, row) } } fmt.Println(len(rows)) var keyboard = tgbotapi.InlineKeyboardMarkup{InlineKeyboard: rows} //keyboard.InlineKeyboard = rows text := "Please, select todo you want to delete" msg := tgbotapi.NewMessage(update.Message.Chat.ID, text) msg.ReplyMarkup = keyboard if _, err := bot.Send(msg); err != nil { panic(err) } } func DeleteTaskCallback(bot *tgbotapi.BotAPI, update tgbotapi.Update, taskId string) { text := "Task successfully deleted" err := repositories.DeleteTask(taskId) if err != nil { text = "Couldnt delete task" } msg := tgbotapi.NewMessage(update.CallbackQuery.Message.Chat.ID, text) if _, err := bot.Send(msg); err != nil { panic(err) } } func ShowAllTasks(bot *tgbotapi.BotAPI, update tgbotapi.Update) { text := "Tasks: \n" tasks, err := repositories.GetAllTasks(update.Message.Chat.ID) if err != nil { text = "Couldnt get tasks" } for i := 0; i &lt; len(tasks); i++ { text += tasks[i].Task + " \n" } msg := tgbotapi.NewMessage(update.Message.Chat.ID, text) if _, err := bot.Send(msg); err != nil { panic(err) } }</pre>
8. Create repositories layer (repositories &gt; repository.go, tasks.go)
repository.go
In the repository file, we create a connection to the database.
<pre>package repositories import ( "telegram-todolist/database" "gorm.io/gorm" ) var DB *gorm.DB = database.Init()</pre>
tasks.go
In task.go file we create functions that we use in the services layer. These functions we use to perform operations with the database.
<pre>package repositories import ( "telegram-todolist/models" tgbotapi "github.com/go-telegram-bot-api/telegram-bot-api/v5" ) func SetTask(update tgbotapi.Update) error { task := models.Task{ ChatId: update.Message.Chat.ID, Task: update.Message.Text, } if result := DB.Create(&amp;task); result.Error != nil { return result.Error } return nil } func DeleteTask(taskId string) error { if result := DB.Where("id = ?", taskId).Delete(&amp;models.Task{}); result.Error != nil { return result.Error } return nil } func GetAllTasks(chatId int64) ([]models.Task, error) { var tasks []models.Task if result := DB.Where("chat_id = ?", chatId).Find(&amp;tasks); result.Error != nil { return tasks, result.Error } return tasks, nil }</pre>
9. Create commands keyboard file (keyboards &gt; cmd_keyboard.go)
CmdKeyaboard creates a keyboard of commands.
<pre>package keyboards import ( tgbotapi "github.com/go-telegram-bot-api/telegram-bot-api/v5" ) func CmdKeyboard() tgbotapi.ReplyKeyboardMarkup { var cmdKeyboard = tgbotapi.NewReplyKeyboard( tgbotapi.NewKeyboardButtonRow( tgbotapi.NewKeyboardButton("/set_todo"), ), tgbotapi.NewKeyboardButtonRow( tgbotapi.NewKeyboardButton("/delete_todo"), ), tgbotapi.NewKeyboardButtonRow( tgbotapi.NewKeyboardButton("/show_all_todos"), ), ) return cmdKeyboard }</pre>
10. Create main.go file
Main function sets the app variable, telegram client, and calls handlers.Init() function.
<pre>package main import ( "log" "telegram-todolist/clients" "telegram-todolist/config" "telegram-todolist/handlers" "github.com/gofiber/fiber/v2" "github.com/gofiber/fiber/v2/middleware/cors" ) func main() { app := fiber.New() app.Use(cors.New(cors.Config{ AllowOrigins: "*", AllowHeaders: "*", })) bot := clients.Init() handlers.Init(bot) log.Fatal(app.Listen(":" + config.Config("PORT"))) }</pre>
11. Run “go mod init project_name” and “go mod tidy” commands in terminal. Then run “go run main.go” command.
Congrats, your bot is now live! 🔥
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xvlJeAHSHD5EDFL_MIAi7w.png"></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rC52Gy97SlhSoWWBKHdq0g.png"></figure><h3>At Last:</h3>
If you like this article, please follow or subscribe to receive high-quality content in time. Thank you for your support ;)
<img src="https://medium.com/_/stat?event=post.clientViewed&amp;referrerSource=full_rss&amp;postId=b77b1ec014ba" width="1" height="1" alt="">

Hey! 👋

My name is Nikolay and I'm a Full Stack Developer specializing in backend development with Java Spring Boot and frontend development with TypeScript Next.js.

This is my digital garden, where I write about the things I'm working on and share what I've learned. 😊

Articles

Building Basic Load Balancer with Dynamic Backends with Nginx + Lua.

How to Dockerize your Golang application

How to build a Telegram Bot with the GOLANG (PostgreSQL)

.css-b3pn3b{display:inline-block;position:relative;}Hey!.css-1c50u9e{display:block;position:absolute;background:var(--chakra-colors-gray-200);width:100%;height:1px;bottom:calc(var(--chakra-space-2) * -1);} 👋

My name is .css-35ezg3{font-weight:600;}Nikolay and I'm a .css-w00cnv{white-space:pre-line;}Full Stack Developer specializing in backend development with Java Spring Boot and frontend development with TypeScript Next.js.

This is my digital garden, where I write about the things I'm working on and share what I've learned. 😊

Articles

How to Dockerize your Golang application

How to build a Telegram Bot with the GOLANG (PostgreSQL)

Hey! 👋

My name is Nikolay and I'm a Full Stack Developer specializing in backend development with Java Spring Boot and frontend development with TypeScript Next.js.