<div class="medium-feed-item">
<a href="https://medium.com/@nbenliogludev/facatory-design-pattern-sade-anlat%C4%B1m-kod-%C3%B6rnekleri-d19d65d616e8?source=rss-796737a1c483------2"><img src="https://cdn-images-1.medium.com/max/929/1*LBEVg4DbLQUrv1EQsk6rVQ.png" width="929"></a>
Factory Method, varoluşsal (Creational) bir tasarım desenidir.
<a href="https://medium.com/@nbenliogludev/facatory-design-pattern-sade-anlat%C4%B1m-kod-%C3%B6rnekleri-d19d65d616e8?source=rss-796737a1c483------2">Continue reading on Medium »</a>
</div>

Facatory Design Pattern: Sade Anlatım + Kod Örnekleri

<div class="medium-feed-item">
<a href="https://medium.com/@nbenliogludev/singleton-design-pattern-sade-anlat%C4%B1m-kod-%C3%B6rnekleri-abf3f56bdf28?source=rss-796737a1c483------2"><img src="https://cdn-images-1.medium.com/max/1110/0*thP5FvrHbNbvVuD9.png" width="1110"></a>
Singleton
<a href="https://medium.com/@nbenliogludev/singleton-design-pattern-sade-anlat%C4%B1m-kod-%C3%B6rnekleri-abf3f56bdf28?source=rss-796737a1c483------2">Continue reading on Medium »</a>
</div>

Singleton Design Pattern: Sade Anlatım + Kod Örnekleri

<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_LXS4yKDubQlLDyFDUHVBA.png"></figure><h3>1. @SpringBootApplication</h3>
@SpringBootApplication anotasyonu, Spring Boot uygulamalarının başlangıç noktasıdır ve üç önemli anotasyonu birleştirir: @Configuration, @EnableAutoConfiguration ve @ComponentScan. Genellikle ana sınıfa yazılır ve uygulamanın otomatik yapılandırılmasını sağlar.
<pre>package com.example.demo; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; @SpringBootApplication // @Configuration + @EnableAutoConfiguration + @ComponentScan public class DemoApplication { public static void main(String[] args) { SpringApplication.run(DemoApplication.class, args); } }</pre>
<h3>2. @Bean</h3>
@Bean anotasyonu, Spring uygulamalarında bir metot aracılığıyla özel olarak oluşturulan nesnelerin (bean'lerin) Spring konteynerine manuel olarak kaydedilmesini sağlar. Bu sayede geliştiriciler, dış kütüphanelerden gelen ya da @Component ile işaretlenemeyen sınıfları da Spring tarafından yönetilen nesneler haline getirebilir. Genellikle @Configuration sınıfı içinde tanımlanır ve singleton olarak çalışır.
<pre>@Configuration public class AppConfig { @Bean public PasswordEncoder passwordEncoder() { return new BCryptPasswordEncoder(); // Bu bean, singleton olarak context'e eklenir } }</pre>
<h3>3. @Service</h3>
@Service, Spring Framework’te bir sınıfın iş mantığı (business logic) içerdiğini belirtmek için kullanılan bir anotasyondur. Spring, bu anotasyonu gördüğünde ilgili sınıfı bir bean olarak kaydeder ve yönetmeye başlar.
<pre>@Service public class UserService { public String getWelcomeMessage() { return "Welcome to the User Service!"; } }</pre>
<h3>4. @Configuration</h3>
@Configuration anotasyonu, sınıf tabanlı bir anotasyondur ve içinde bir veya daha fazla @Bean metodunu tanımlamak için kullanılır. Bu sınıf, servisler ve diğer uygulama bileşenleri gibi yapıların Spring uygulama bağlamına (application context) ekleneceğini belirtir.
<pre>@Configuration public class AppConfig { @Bean public PasswordEncoder passwordEncoder() { return new BCryptPasswordEncoder(); } }</pre>
<pre>// @Service anotasyonu sayesinde Spring, bu sınıfı otomatik olarak // bir bean olarak tanır ve IoC konteynerine ekler. @Service public class UserService { // PasswordEncoder bağımlılığı constructor üzerinden enjekte edilir. // Spring, uygulama başlatılırken PasswordEncoder bean'ini bulur ve // otomatik olarak buraya enjekte eder. private final PasswordEncoder passwordEncoder; // Constructor Injection yöntemi kullanılmıştır. public UserService(PasswordEncoder passwordEncoder) { this.passwordEncoder = passwordEncoder; } public void registerUser(String rawPassword) { String encodedPassword = passwordEncoder.encode(rawPassword); } }</pre>
<h3>5. @Autowired</h3>
Spring Boot’ta kullanılan @Autowired anotasyonu, bir bean’in bağımlılığını başka bir bean’e enjekte etmek için kullanılır. Spring tarafından yönetilen bir nesne, ihtiyaç duyan başka bir nesneye otomatik olarak entegre edilir.
Yani, bir alanı (field), metodu veya yapıcı metodu (constructor) @Autowired ile işaretlediğinizde, Spring Boot bu bağımlılığı otomatik olarak enjekte eder ve o alana uygun olan bean’i bulur.
@Autowired üç şekilde kullanılabilir: field enjeksiyonu, setter enjeksiyonu ve constructor enjeksiyonu.
Başka bir deyişle, Spring Boot’ta @Autowired anotasyonu, bir nesnenin yaşam döngüsünün tamamını yönetir.
<pre>// @Service sayesinde Spring tarafından otomatik olarak bean olarak // Tanınır ve IoC konteynerine eklenir. @Service public class UserService { // Field Injection kullanılmıştır. // @Autowired ile Spring, uygun tipteki bean'i (UserRepository) // Otomatik olarak buraya enjekte eder. // Bu yöntem kolay olsa da test edilebilirlik ve değiştirilebilirlik // Açısından constructor injection kadar esnek değildir. @Autowired private UserRepository userRepository; public void doSomething() { userRepository.findAll(); // Repository katmanına erişim sağlanır } }</pre>
<h3>6. @Component</h3>
@Component anotasyonu, Spring uygulamalarında bir Java sınıfını işaretlemek için kullanılır. Spring’in IoC (Inversion of Control) konteyneri, bu anotasyonla işaretlenen sınıfları yönetir ve bu bileşenlerin yaşam döngüsünden (oluşturma, başlatma, yok etme gibi) sorumludur.
Bu sayede bileşenler, uygulama içindeki servisler, controller’lar veya başka nesneler olabilir. Bir sınıf @Component ile işaretlendiğinde, Spring Boot classpath taraması sayesinde bu bileşeni otomatik olarak algılar.
Ayrıca, bileşenler genellikle @Autowired ve @Qualifier anotasyonlarıyla birlikte kullanılarak bağımlılıkların otomatik olarak enjekte edilmesini sağlar.
<pre>@Component public class MyComponent { public String getMessage() { return "Merhaba, field injection örneğindesin!"; } }</pre>
<pre>@Service public class MyService { @Autowired private MyComponent myComponent; // Field injection burada public void printMessage() { System.out.println(myComponent.getMessage()); } }</pre>
<h3>7. @Entity</h3>
@Entity, Spring Data JPA’da bir Java sınıfının veritabanında bir tabloyu temsil ettiğini belirtmek için kullanılır. Bu anotasyonla işaretlenen sınıf, JPA (Java Persistence API) tarafından yönetilir ve veritabanı işlemlerine uygun hale gelir.
<pre>import jakarta.persistence.Entity; import jakarta.persistence.Id; @Entity public class User { @Id private Long id; private String username; // Getter ve Setter'lar public Long getId() { return id; } public void setId(Long id) { this.id = id; } public String getUsername() { return username; } public void setUsername(String username) { this.username = username; } }</pre>
<h3>8. @Repository</h3>
@Repository anotasyonu, NoSQL veritabanları ve ilişkisel (relational) veritabanları gibi farklı veritabanlarıyla etkileşim kurmak için kullanılır. Bir Java sınıfı @Repository ile işaretlendiğinde, Spring Boot bu sınıfı otomatik olarak algılar ve gerekli uygulama bağlamına (application context) ekler.
@Repository ile işaretlenen sınıf, veri erişim katmanının (data access layer) bir öğesidir ve veritabanıyla etkileşim sağlamak için bir API sunar. Bu sayede geliştirici daha az kod yazarak veri işlemlerini gerçekleştirebilir.
<pre>@Repository public interface UserRepository extends JpaRepository&lt;User, Long&gt; { User findByUsername(String username); }</pre>
<h3>9. @RestController</h3>
@RestController anotasyonu, @ResponseBody ve @Controller anotasyonlarının işlevlerini birleştirir. Bu anotasyon, XML, JSON ve diğer türlerde cevaplar dönen RESTful endpoint'lerin oluşturulmasını kolaylaştırır.
Spring Boot’ta @RestController, yalnızca JSON değil, düz metin (plain text), görsel (image) veya PDF gibi içerik türlerine cevap vermek için de kullanılabilir. Ayrıca, Spring Boot varsayılan olarak HTTP yanıtını ayarlasa da, @RestController sayesinde yanıtlar özelleştirilebilir.
Bir sınıf @RestController ile işaretlendiğinde, o sınıftaki tüm request mapping metotlarında ayrıca @ResponseBody yazmaya gerek kalmaz.
<pre>@RestController // @Controller + @ResponseBody @RequestMapping("/api/users") public class UserController { @GetMapping("/hello") public String sayHello() { return "Merhaba kullanıcı!"; } }</pre>
<h3>10. @RequestBody</h3>
@RequestBody, HTTP istek gövdesindeki verileri otomatik olarak bir Java nesnesine dönüştürüp controller metoduna bağlamak için kullanılır. Genellikle JSON, XML gibi formatlardaki verileri alırken kullanılır ve Spring bu verileri otomatik olarak serileştirir. Özellikle RESTful servislerde, gelen veriyi doğrudan nesneye maplemek için idealdir.
<pre>@RestController @RequestMapping("/api/users") public class UserController { @PostMapping("/create") public String createUser(@RequestBody User user) { return "Kullanıcı oluşturuldu: " + user.getName() + " (" + user.getEmail() + ")"; } }</pre>
<h3>11. @PathVariable</h3>
@PathVariable, HTTP isteğindeki URI yolundaki dinamik parametreleri alıp controller metoduna aktarır. RESTful servislerde, değişken URL parçalarını kolayca işlemenizi sağlar ve genellikle @GetMapping gibi anotasyonlarla birlikte kullanılır. Bu sayede daha okunabilir ve esnek API uç noktaları oluşturulabilir.
<pre>import org.springframework.web.bind.annotation.*; @RestController @RequestMapping("/api/users") public class UserController { @GetMapping("/{id}") public String getUserById(@PathVariable Long id) { return "Kullanıcı ID: " + id; } }</pre>
<h3>12. @EnableAutoConfiguration</h3>
Bu anotasyon, Spring Boot uygulamalarınızın otomatik olarak yapılandırılmasını sağlar. @EnableAutoConfiguration anotasyonu, gerekli Spring bileşenlerini tanımlar ve yapılandırmaları otomatik olarak gerçekleştirir.
Otomatik yapılandırılan bean’ler classpath üzerinde bulunur ve bu sayede geliştiricilerin işleri kolaylaşır. Gerekli bean’ler classpath’ten algılanarak uygulamanın çalışması için otomatik olarak yapılandırılır. Spring Boot’ta @EnableAutoConfiguration anotasyonu, bulunduğu sınıfın varsayılan paketini dikkate alır.
Ayrıca, bazı sınıfların otomatik yapılandırmaya dahil edilmesini istemiyorsanız, Spring Boot bu sınıfları manuel olarak hariç tutmanıza da olanak tanır.
<pre>@Configuration @EnableAutoConfiguration // Spring Boot bileşenlerini otomatik yapılandır @ComponentScan // Bileşenleri tara public class DemoApplication { public static void main(String[] args) { SpringApplication.run(DemoApplication.class, args); } }</pre>
<img src="https://medium.com/_/stat?event=post.clientViewed&amp;referrerSource=full_rss&amp;postId=f69d39050081" width="1" height="1" alt="">

Spring Boot’ta Yaygın Olarak Kullanılan Temel Anotasyonlar: Tanımları ve Uygulama Örnekleri

<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

Facatory Design Pattern: Sade Anlatım + Kod Örnekleri

Singleton Design Pattern: Sade Anlatım + Kod Örnekleri

Spring Boot’ta Yaygın Olarak Kullanılan Temel Anotasyonlar: Tanımları ve Uygulama Örnekleri

.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

Singleton Design Pattern: Sade Anlatım + Kod Örnekleri

Spring Boot’ta Yaygın Olarak Kullanılan Temel Anotasyonlar: Tanımları ve Uygulama Örnekleri

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.