์ฝ˜ํ…์ธ  ๋Œ€ํ‘œ ์ด๋ฏธ์ง€ - ๐Ÿš€ Go์–ธ์–ด๋กœ ์‹œ์ž‘ํ•˜๋Š” ๋ฉ”์‹œ์ง• ์„ธ๊ณ„: NATS, RabbitMQ, Kafka๋ฅผ ํ™œ์šฉํ•œ ์ด๋ฒคํŠธ ์ŠคํŠธ๋ฆฌ๋ฐ ์™„๋ฒฝ ๊ฐ€์ด๋“œ

๐Ÿš€ Go์–ธ์–ด๋กœ ์‹œ์ž‘ํ•˜๋Š” ๋ฉ”์‹œ์ง• ์„ธ๊ณ„: NATS, RabbitMQ, Kafka๋ฅผ ํ™œ์šฉํ•œ ์ด๋ฒคํŠธ ์ŠคํŠธ๋ฆฌ๋ฐ ์™„๋ฒฝ ๊ฐ€์ด๋“œ

์•ˆ๋…•, ์นœ๊ตฌ! ๐Ÿ‘‹ ์˜ค๋Š˜์€ ์ •๋ง ํฅ๋ฏธ์ง„์ง„ํ•œ ์ฃผ์ œ๋ฅผ ๊ฐ€์ง€๊ณ  ์™”์–ด. ๋ฐ”๋กœ Go์–ธ์–ด๋กœ ๋ฉ”์‹œ์ง• ์‹œ์Šคํ…œ์„ ๋‹ค๋ฃจ๋Š” ๋ฐฉ๋ฒ•์ด์•ผ. ์š”์ฆ˜ ๋งˆ์ดํฌ๋กœ์„œ๋น„์Šค ์•„ํ‚คํ…์ฒ˜๊ฐ€ ๋Œ€์„ธ์ž–์•„? ๊ทธ๋Ÿฌ๋ฉด์„œ ์„œ๋น„์Šค ๊ฐ„ ํ†ต์‹ ์ด ์—„์ฒญ ์ค‘์š”ํ•ด์กŒ๋Š”๋ฐ, ์ด๋•Œ ๋“ฑ์žฅํ•˜๋Š” ๊ฒŒ ๋ฐ”๋กœ ๋ฉ”์‹œ์ง• ์‹œ์Šคํ…œ์ด์ง€. NATS, RabbitMQ, Kafka ๊ฐ™์€ ๋…€์„๋“ค ๋ง์ด์•ผ. ๐Ÿ˜Ž

์ด ๊ธ€์—์„œ๋Š” Go์–ธ์–ด๋กœ ์ด ์„ธ ๊ฐ€์ง€ ๋ฉ”์‹œ์ง• ์‹œ์Šคํ…œ์„ ์–ด๋–ป๊ฒŒ ํ™œ์šฉํ•˜๋Š”์ง€, ๊ฐ๊ฐ์˜ ํŠน์ง•์€ ๋ญ”์ง€, ๊ทธ๋ฆฌ๊ณ  ์‹ค์ œ๋กœ ์–ด๋–ป๊ฒŒ ์ฝ”๋“œ๋ฅผ ์งœ๋Š”์ง€๊นŒ์ง€ ์นœ๊ตฌ์ฒ˜๋Ÿผ ํŽธํ•˜๊ฒŒ ์„ค๋ช…ํ•ด์ค„๊ฒŒ. ์ปคํ”ผ ํ•œ ์ž” โ˜• ์ค€๋น„ํ•˜๊ณ  ํŽธํ•˜๊ฒŒ ์ฝ์–ด๋ด!

NATS Fast RabbitMQ Reliable Kafka Scalable Go Language Event Streaming Message Queue Pub/Sub Pattern

๐ŸŽฏ ๋ฉ”์‹œ์ง• ์‹œ์Šคํ…œ์ด ๋ญ๊ธธ๋ž˜?

๋จผ์ € ๊ธฐ๋ณธ๋ถ€ํ„ฐ ์งš๊ณ  ๋„˜์–ด๊ฐ€์ž. ๋ฉ”์‹œ์ง• ์‹œ์Šคํ…œ์ด ๋ญ๋ƒ๊ณ ? ๊ฐ„๋‹จํ•˜๊ฒŒ ๋งํ•˜๋ฉด ์„œ๋น„์Šค๋“ค ์‚ฌ์ด์—์„œ ๋ฉ”์‹œ์ง€๋ฅผ ์ฃผ๊ณ ๋ฐ›๋Š” ์šฐ์ฒด๊ตญ ๊ฐ™์€ ๊ฑฐ์•ผ. ๐Ÿ“ฌ

์˜ˆ์ „์—๋Š” ์„œ๋น„์Šค A๊ฐ€ ์„œ๋น„์Šค Bํ•œํ…Œ ๋ญ”๊ฐ€ ์ „๋‹ฌํ•˜๋ ค๋ฉด ์ง์ ‘ HTTP ์š”์ฒญ์„ ๋ณด๋‚ด๊ฑฐ๋‚˜ ํ–ˆ์ž–์•„? ๊ทผ๋ฐ ์ด๊ฒŒ ๋ฌธ์ œ๊ฐ€ ๋ญ๋ƒ๋ฉด:

๐Ÿ”ด ์ง์ ‘ ํ†ต์‹ ์˜ ๋ฌธ์ œ์ ๋“ค

โ€ข ์„œ๋น„์Šค B๊ฐ€ ๋‹ค์šด๋˜๋ฉด? A๋„ ๊ฐ™์ด ๋ฉˆ์ถฐ๋ฒ„๋ฆผ
โ€ข ํŠธ๋ž˜ํ”ฝ์ด ๊ฐ‘์ž๊ธฐ ๋ชฐ๋ฆฌ๋ฉด? ์‹œ์Šคํ…œ ์ „์ฒด๊ฐ€ ๊ณผ๋ถ€ํ•˜
โ€ข ์ƒˆ๋กœ์šด ์„œ๋น„์Šค C๋ฅผ ์ถ”๊ฐ€ํ•˜๋ ค๋ฉด? ๊ธฐ์กด ์ฝ”๋“œ ๋‹ค ์ˆ˜์ •ํ•ด์•ผ ํ•จ
โ€ข ์ˆœ๊ฐ„์ ์œผ๋กœ ๋งŽ์€ ์š”์ฒญ์ด ๋“ค์–ด์˜ค๋ฉด? ์ฒ˜๋ฆฌ ๋ชปํ•˜๊ณ  ๋‚ ์•„๊ฐ

์ด๋Ÿฐ ๋ฌธ์ œ๋“ค์„ ํ•ด๊ฒฐํ•˜๊ธฐ ์œ„ํ•ด ๋“ฑ์žฅํ•œ ๊ฒŒ ๋ฐ”๋กœ ๋ฉ”์‹œ์ง• ์‹œ์Šคํ…œ์ด์•ผ. ์ค‘๊ฐ„์— ๋ฉ”์‹œ์ง€ ๋ธŒ๋กœ์ปค๋ฅผ ๋‘๊ณ , ์„œ๋น„์Šค๋“ค์€ ์ด ๋ธŒ๋กœ์ปค๋ฅผ ํ†ตํ•ด์„œ๋งŒ ํ†ต์‹ ํ•˜๋Š” ๊ฑฐ์ง€. ์ด๋ ‡๊ฒŒ ํ•˜๋ฉด ๋А์Šจํ•œ ๊ฒฐํ•ฉ(Loose Coupling)์ด ๊ฐ€๋Šฅํ•ด์ ธ์„œ ์‹œ์Šคํ…œ์ด ํ›จ์”ฌ ์œ ์—ฐํ•ด์ ธ! ๐ŸŽช

๐Ÿน ์™œ Go์–ธ์–ด์ธ๊ฐ€?

์ž, ๊ทธ๋Ÿผ ์™œ ํ•˜ํ•„ Go์–ธ์–ด๋กœ ๋ฉ”์‹œ์ง• ์‹œ์Šคํ…œ์„ ๋‹ค๋ฃจ๋Š” ๊ฑธ๊นŒ? Go์–ธ์–ด๋Š” ๋ฉ”์‹œ์ง• ์‹œ์Šคํ…œ๊ณผ ์ฐฐ๋–ก๊ถํ•ฉ์ด์•ผ. ์ด์œ ๋ฅผ ์•Œ๋ ค์ค„๊ฒŒ:

โšก ๋™์‹œ์„ฑ ์ฒ˜๋ฆฌ์˜ ์™•

๊ณ ๋ฃจํ‹ด(Goroutine)๊ณผ ์ฑ„๋„(Channel)๋กœ ์ˆ˜์ฒœ ๊ฐœ์˜ ๋™์‹œ ์—ฐ๊ฒฐ์„ ๊ฐ€๋ณ๊ฒŒ ์ฒ˜๋ฆฌํ•ด. ๋ฉ”์‹œ์ง• ์‹œ์Šคํ…œ์€ ๋™์‹œ์— ์—ฌ๋Ÿฌ ๋ฉ”์‹œ์ง€๋ฅผ ์ฒ˜๋ฆฌํ•ด์•ผ ํ•˜๋Š”๋ฐ, Go๋Š” ์ด๊ฒŒ ๊ธฐ๋ณธ ํƒ‘์žฌ์•ผ!

๐Ÿš€ ๋น ๋ฅธ ์„ฑ๋Šฅ

์ปดํŒŒ์ผ ์–ธ์–ด๋ผ์„œ ์‹คํ–‰ ์†๋„๊ฐ€ ๋นจ๋ผ. ๋ฉ”์‹œ์ง€ ์ฒ˜๋ฆฌ๋Ÿ‰์ด ์ค‘์š”ํ•œ ์‹œ์Šคํ…œ์—์„œ๋Š” ์ด๊ฒŒ ์—„์ฒญ๋‚œ ์žฅ์ ์ด์ง€. Python์ด๋‚˜ Node.js๋ณด๋‹ค ํ›จ์”ฌ ๋น ๋ฅด๊ฑฐ๋“ !

๐Ÿ“ฆ ๊ฐ„๊ฒฐํ•œ ๋ฌธ๋ฒ•

์ฝ”๋“œ๊ฐ€ ์ฝ๊ธฐ ์‰ฝ๊ณ  ์œ ์ง€๋ณด์ˆ˜ํ•˜๊ธฐ ์ข‹์•„. ๋ณต์žกํ•œ ๋ฉ”์‹œ์ง• ๋กœ์ง๋„ ๊น”๋”ํ•˜๊ฒŒ ํ‘œํ˜„ํ•  ์ˆ˜ ์žˆ์–ด์„œ ํŒ€ ํ˜‘์—…ํ•  ๋•Œ ์ตœ๊ณ ์•ผ.

๐Ÿ› ๏ธ ํ’๋ถ€ํ•œ ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ

NATS, RabbitMQ, Kafka ๋ชจ๋‘ ๊ณต์‹ ๋˜๋Š” ์ปค๋ฎค๋‹ˆํ‹ฐ์—์„œ ์ž˜ ๊ด€๋ฆฌ๋˜๋Š” Go ํด๋ผ์ด์–ธํŠธ๊ฐ€ ์žˆ์–ด. ๋ฐ”๋กœ ๊ฐ€์ ธ๋‹ค ์“ฐ๋ฉด ๋ผ!

์‹ค์ œ๋กœ ๋งŽ์€ ํด๋ผ์šฐ๋“œ ๋„ค์ดํ‹ฐ๋ธŒ ํ”„๋กœ์ ํŠธ๋“ค(Docker, Kubernetes, Prometheus ๋“ฑ)์ด Go๋กœ ์ž‘์„ฑ๋˜์–ด ์žˆ์–ด. ์ด๋Ÿฐ ํ”„๋กœ์ ํŠธ๋“ค์ด ๋ฉ”์‹œ์ง• ์‹œ์Šคํ…œ์„ ๋งŽ์ด ์‚ฌ์šฉํ•˜๋Š” ๊ฑธ ๋ณด๋ฉด, Go์™€ ๋ฉ”์‹œ์ง•์˜ ๊ถํ•ฉ์ด ์–ผ๋งˆ๋‚˜ ์ข‹์€์ง€ ์•Œ ์ˆ˜ ์žˆ์ง€? ๐Ÿ˜‰

๐Ÿ’จ NATS: ๊ฐ€๋ณ๊ณ  ๋น ๋ฅธ ๋ฉ”์‹œ์ง•์˜ ์ •์„

์ž, ์ด์ œ ๋ณธ๊ฒฉ์ ์œผ๋กœ ๊ฐ ๋ฉ”์‹œ์ง• ์‹œ์Šคํ…œ์„ ํŒŒํ—ค์ณ๋ณด์ž! ์ฒซ ๋ฒˆ์งธ ์ฃผ์ž๋Š” NATS์•ผ. ๐Ÿƒโ€โ™‚๏ธ

NATS๋Š” ๋ญ์•ผ?

NATS๋Š” Cloud Native Computing Foundation(CNCF)์˜ ํ”„๋กœ์ ํŠธ๋กœ, ์ดˆ๊ฒฝ๋Ÿ‰ ๊ณ ์„ฑ๋Šฅ ๋ฉ”์‹œ์ง• ์‹œ์Šคํ…œ์ด์•ผ. "Simple, Secure, and Scalable"์ด ๋ชจํ† ์ธ๋ฐ, ์ •๋ง ๊ทธ ๋ง ๊ทธ๋Œ€๋กœ์•ผ.

๐ŸŒŸ NATS์˜ ํŠน์ง•

1. ์—„์ฒญ๋‚˜๊ฒŒ ๋น ๋ฆ„ - ์ดˆ๋‹น ์ˆ˜๋ฐฑ๋งŒ ๊ฐœ์˜ ๋ฉ”์‹œ์ง€ ์ฒ˜๋ฆฌ ๊ฐ€๋Šฅ
2. ๊ฐ€๋ฒผ์›€ - ๋ฐ”์ด๋„ˆ๋ฆฌ ํฌ๊ธฐ๊ฐ€ 10MB๋„ ์•ˆ ๋ผ
3. ๊ฐ„๋‹จํ•จ - ์„ค์ •์ด ๊ฑฐ์˜ ํ•„์š” ์—†์–ด
4. At-Most-Once ์ „๋‹ฌ - ๋ฉ”์‹œ์ง€๋ฅผ ์ตœ๋Œ€ ํ•œ ๋ฒˆ ์ „๋‹ฌ (๊ธฐ๋ณธ ๋ชจ๋“œ)
5. Pub/Sub ํŒจํ„ด - ๋ฐœํ–‰-๊ตฌ๋… ๋ชจ๋ธ ์ง€์›

์–ธ์ œ NATS๋ฅผ ์“ธ๊นŒ?

NATS๋Š” ์†๋„๊ฐ€ ์ƒ๋ช…์ธ ์ƒํ™ฉ์—์„œ ๋น›์„ ๋ฐœํ•ด. ์˜ˆ๋ฅผ ๋“ค์–ด:

โ€ข ์‹ค์‹œ๊ฐ„ ์•Œ๋ฆผ ์‹œ์Šคํ…œ ๐Ÿ“ฑ
โ€ข IoT ์„ผ์„œ ๋ฐ์ดํ„ฐ ์ˆ˜์ง‘ ๐ŸŒก๏ธ
โ€ข ๋งˆ์ดํฌ๋กœ์„œ๋น„์Šค ๊ฐ„ ๋น ๋ฅธ ํ†ต์‹  ๐Ÿ”„
โ€ข ๊ฒŒ์ž„ ์„œ๋ฒ„์˜ ์‹ค์‹œ๊ฐ„ ์ด๋ฒคํŠธ ๐ŸŽฎ

Go๋กœ NATS ์‚ฌ์šฉํ•˜๊ธฐ

์ž, ์ด์ œ ์‹ค์ œ ์ฝ”๋“œ๋ฅผ ๋ณผ ์‹œ๊ฐ„์ด์•ผ! Go์—์„œ NATS๋ฅผ ์‚ฌ์šฉํ•˜๋Š” ๊ฑด ์ •๋ง ์‰ฌ์›Œ. ๋จผ์ € ํŒจํ‚ค์ง€๋ฅผ ์„ค์น˜ํ•˜์ž:

go get github.com/nats-io/nats.go

Publisher ์˜ˆ์ œ (๋ฉ”์‹œ์ง€ ๋ฐœํ–‰ํ•˜๊ธฐ)

package main

import (
    "fmt"
    "log"
    "time"
    
    "github.com/nats-io/nats.go"
)

func main() {
    // NATS ์„œ๋ฒ„์— ์—ฐ๊ฒฐ
    nc, err := nats.Connect(nats.DefaultURL)
    if err != nil {
        log.Fatal(err)
    }
    defer nc.Close()
    
    // ๋ฉ”์‹œ์ง€ ๋ฐœํ–‰
    subject := "user.signup"
    message := "์ƒˆ๋กœ์šด ์‚ฌ์šฉ์ž๊ฐ€ ๊ฐ€์ž…ํ–ˆ์Šต๋‹ˆ๋‹ค!"
    
    err = nc.Publish(subject, []byte(message))
    if err != nil {
        log.Fatal(err)
    }
    
    fmt.Println("๋ฉ”์‹œ์ง€ ๋ฐœํ–‰ ์™„๋ฃŒ:", message)
    
    // ๋ฉ”์‹œ์ง€๊ฐ€ ์ „์†ก๋  ์‹œ๊ฐ„์„ ์คŒ
    nc.Flush()
    
    if err := nc.LastError(); err != nil {
        log.Fatal(err)
    }
}

๋ณด๋‹ค์‹œํ”ผ ์—„์ฒญ ๊ฐ„๋‹จํ•˜์ง€? ์—ฐ๊ฒฐํ•˜๊ณ , Publish ๋ฉ”์„œ๋“œ ํ˜ธ์ถœํ•˜๋ฉด ๋! ๐ŸŽ‰

Subscriber ์˜ˆ์ œ (๋ฉ”์‹œ์ง€ ๊ตฌ๋…ํ•˜๊ธฐ)

package main

import (
    "fmt"
    "log"
    "runtime"
    "time"
    
    "github.com/nats-io/nats.go"
)

func main() {
    // NATS ์„œ๋ฒ„์— ์—ฐ๊ฒฐ
    nc, err := nats.Connect(nats.DefaultURL)
    if err != nil {
        log.Fatal(err)
    }
    defer nc.Close()
    
    // ๋ฉ”์‹œ์ง€ ๊ตฌ๋…
    subject := "user.signup"
    
    // ๋™๊ธฐ ๊ตฌ๋…
    sub, err := nc.SubscribeSync(subject)
    if err != nil {
        log.Fatal(err)
    }
    
    fmt.Println("๋ฉ”์‹œ์ง€ ๋Œ€๊ธฐ ์ค‘...")
    
    // ๋ฉ”์‹œ์ง€ ์ˆ˜์‹  (ํƒ€์ž„์•„์›ƒ 5์ดˆ)
    msg, err := sub.NextMsg(5 * time.Second)
    if err != nil {
        log.Fatal(err)
    }
    
    fmt.Printf("๋ฐ›์€ ๋ฉ”์‹œ์ง€: %s\n", string(msg.Data))
    
    // ๋น„๋™๊ธฐ ๊ตฌ๋… ์˜ˆ์ œ
    nc.Subscribe(subject, func(msg *nats.Msg) {
        fmt.Printf("๋น„๋™๊ธฐ๋กœ ๋ฐ›์€ ๋ฉ”์‹œ์ง€: %s\n", string(msg.Data))
    })
    
    // ํ”„๋กœ๊ทธ๋žจ์ด ์ข…๋ฃŒ๋˜์ง€ ์•Š๋„๋ก ๋Œ€๊ธฐ
    runtime.Goexit()
}

๐Ÿ’ก ํŒ: NATS๋Š” ๊ธฐ๋ณธ์ ์œผ๋กœ ๋ฉ”์‹œ์ง€๋ฅผ ๋ฉ”๋ชจ๋ฆฌ์—๋งŒ ์ €์žฅํ•ด. ๊ทธ๋ž˜์„œ ๊ตฌ๋…์ž๊ฐ€ ์—†์œผ๋ฉด ๋ฉ”์‹œ์ง€๊ฐ€ ์‚ฌ๋ผ์ ธ. ๋ฉ”์‹œ์ง€ ์ง€์†์„ฑ์ด ํ•„์š”ํ•˜๋ฉด NATS Streaming์ด๋‚˜ JetStream์„ ์‚ฌ์šฉํ•ด์•ผ ํ•ด!

NATS JetStream์œผ๋กœ ์—…๊ทธ๋ ˆ์ด๋“œ

NATS์˜ ์ตœ์‹  ๋ฒ„์ „์—๋Š” JetStream์ด๋ผ๋Š” ๊ธฐ๋Šฅ์ด ์ถ”๊ฐ€๋์–ด. ์ด๊ฑด ๋ฉ”์‹œ์ง€ ์ง€์†์„ฑ, At-Least-Once ์ „๋‹ฌ, ๋ฉ”์‹œ์ง€ ์žฌ์ƒ ๊ฐ™์€ ๊ณ ๊ธ‰ ๊ธฐ๋Šฅ์„ ์ œ๊ณตํ•ด. ์ฝ”๋“œ๋ฅผ ๋ณผ๊นŒ?

package main

import (
    "fmt"
    "log"
    
    "github.com/nats-io/nats.go"
)

func main() {
    // JetStream ํ™œ์„ฑํ™”๋œ NATS ์„œ๋ฒ„์— ์—ฐ๊ฒฐ
    nc, err := nats.Connect(nats.DefaultURL)
    if err != nil {
        log.Fatal(err)
    }
    defer nc.Close()
    
    // JetStream ์ปจํ…์ŠคํŠธ ์ƒ์„ฑ
    js, err := nc.JetStream()
    if err != nil {
        log.Fatal(err)
    }
    
    // ์ŠคํŠธ๋ฆผ ์ƒ์„ฑ
    streamName := "ORDERS"
    js.AddStream(&nats.StreamConfig{
        Name:     streamName,
        Subjects: []string{"orders.*"},
    })
    
    // ๋ฉ”์‹œ์ง€ ๋ฐœํ–‰ (์ง€์†์„ฑ ๋ณด์žฅ)
    ack, err := js.Publish("orders.new", []byte("์ฃผ๋ฌธ๋ฒˆํ˜ธ 12345"))
    if err != nil {
        log.Fatal(err)
    }
    
    fmt.Printf("๋ฉ”์‹œ์ง€ ๋ฐœํ–‰ ์™„๋ฃŒ! ์‹œํ€€์Šค: %d\n", ack.Sequence)
    
    // ๋ฉ”์‹œ์ง€ ๊ตฌ๋…
    js.Subscribe("orders.*", func(msg *nats.Msg) {
        fmt.Printf("์ฃผ๋ฌธ ๋ฐ›์Œ: %s\n", string(msg.Data))
        msg.Ack() // ๋ฉ”์‹œ์ง€ ์ฒ˜๋ฆฌ ์™„๋ฃŒ ํ™•์ธ
    })
}

JetStream์„ ์‚ฌ์šฉํ•˜๋ฉด ๋ฉ”์‹œ์ง€๊ฐ€ ๋””์Šคํฌ์— ์ €์žฅ๋˜๊ณ , ๊ตฌ๋…์ž๊ฐ€ ์ฒ˜๋ฆฌ๋ฅผ ํ™•์ธ(Ack)ํ•  ๋•Œ๊นŒ์ง€ ์žฌ์ „์†ก๋ผ. ํ›จ์”ฌ ์•ˆ์ •์ ์ด์ง€? ๐Ÿ’ช

๐Ÿฐ RabbitMQ: ์‹ ๋ขฐ์„ฑ์˜ ๋Œ€๋ช…์‚ฌ

๋‘ ๋ฒˆ์งธ ์ฃผ์ž๋Š” RabbitMQ์•ผ! ํ† ๋ผ์ฒ˜๋Ÿผ ๊ท€์—ฝ์ง€๋งŒ ์„ฑ๋Šฅ์€ ๋งน์ˆ˜๊ธ‰์ด์ง€. ๐Ÿฐโšก

RabbitMQ๋Š” ๋ญ์•ผ?

RabbitMQ๋Š” AMQP(Advanced Message Queuing Protocol)๋ฅผ ๊ตฌํ˜„ํ•œ ์˜คํ”ˆ์†Œ์Šค ๋ฉ”์‹œ์ง€ ๋ธŒ๋กœ์ปค์•ผ. 2007๋…„๋ถ€ํ„ฐ ์žˆ์—ˆ์œผ๋‹ˆ๊นŒ ์—ญ์‚ฌ๋„ ๊นŠ๊ณ , ๊ฒ€์ฆ๋„ ๋งŽ์ด ๋œ ๋…€์„์ด์ง€.

๐ŸŒŸ RabbitMQ์˜ ํŠน์ง•

1. ์‹ ๋ขฐ์„ฑ - ๋ฉ”์‹œ์ง€ ์†์‹ค ๋ฐฉ์ง€ ๋ฉ”์ปค๋‹ˆ์ฆ˜์ด ๊ฐ•๋ ฅํ•จ
2. ์œ ์—ฐํ•œ ๋ผ์šฐํŒ… - Exchange์™€ Queue๋กœ ๋ณต์žกํ•œ ๋ผ์šฐํŒ… ๊ฐ€๋Šฅ
3. ๋‹ค์–‘ํ•œ ํ”„๋กœํ† ์ฝœ - AMQP, MQTT, STOMP ๋“ฑ ์ง€์›
4. ๊ด€๋ฆฌ UI - ์›น ๊ธฐ๋ฐ˜ ๊ด€๋ฆฌ ์ธํ„ฐํŽ˜์ด์Šค ์ œ๊ณต
5. ํ”Œ๋Ÿฌ๊ทธ์ธ ์ƒํƒœ๊ณ„ - ๋‹ค์–‘ํ•œ ํ”Œ๋Ÿฌ๊ทธ์ธ์œผ๋กœ ๊ธฐ๋Šฅ ํ™•์žฅ ๊ฐ€๋Šฅ

RabbitMQ์˜ ํ•ต์‹ฌ ๊ฐœ๋…

RabbitMQ๋ฅผ ์ดํ•ดํ•˜๋ ค๋ฉด ๋ช‡ ๊ฐ€์ง€ ๊ฐœ๋…์„ ์•Œ์•„์•ผ ํ•ด:

โ€ข Producer (์ƒ์‚ฐ์ž) - ๋ฉ”์‹œ์ง€๋ฅผ ๋ณด๋‚ด๋Š” ์• ํ”Œ๋ฆฌ์ผ€์ด์…˜
โ€ข Queue (ํ) - ๋ฉ”์‹œ์ง€๊ฐ€ ์ €์žฅ๋˜๋Š” ๋ฒ„ํผ
โ€ข Consumer (์†Œ๋น„์ž) - ๋ฉ”์‹œ์ง€๋ฅผ ๋ฐ›๋Š” ์• ํ”Œ๋ฆฌ์ผ€์ด์…˜
โ€ข Exchange (๊ตํ™˜๊ธฐ) - ๋ฉ”์‹œ์ง€๋ฅผ ์–ด๋А ํ๋กœ ๋ณด๋‚ผ์ง€ ๊ฒฐ์ •ํ•˜๋Š” ๋ผ์šฐํ„ฐ
โ€ข Binding (๋ฐ”์ธ๋”ฉ) - Exchange์™€ Queue๋ฅผ ์—ฐ๊ฒฐํ•˜๋Š” ๊ทœ์น™

Exchange ํƒ€์ž…๋“ค

RabbitMQ์˜ Exchange๋Š” 4๊ฐ€์ง€ ํƒ€์ž…์ด ์žˆ์–ด:

๐Ÿ“ข Direct

๋ผ์šฐํŒ… ํ‚ค๊ฐ€ ์ •ํ™•ํžˆ ์ผ์น˜ํ•˜๋Š” ํ๋กœ๋งŒ ์ „๋‹ฌ. ๊ฐ„๋‹จํ•˜๊ณ  ๋ช…ํ™•ํ•ด!

๐Ÿ“ฃ Fanout

์—ฐ๊ฒฐ๋œ ๋ชจ๋“  ํ์— ๋ฉ”์‹œ์ง€ ๋ธŒ๋กœ๋“œ์บ์ŠคํŠธ. ๋ฐฉ์†ก๊ตญ ๊ฐ™์€ ๋А๋‚Œ!

๐ŸŽฏ Topic

ํŒจํ„ด ๋งค์นญ์œผ๋กœ ๋ผ์šฐํŒ…. ์œ ์—ฐํ•˜๊ณ  ๊ฐ•๋ ฅํ•ด!

๐ŸŽช Headers

๋ฉ”์‹œ์ง€ ํ—ค๋” ์†์„ฑ์œผ๋กœ ๋ผ์šฐํŒ…. ๋ณต์žกํ•œ ์กฐ๊ฑด ์ฒ˜๋ฆฌ ๊ฐ€๋Šฅ!

Go๋กœ RabbitMQ ์‚ฌ์šฉํ•˜๊ธฐ

Go์—์„œ RabbitMQ๋ฅผ ์‚ฌ์šฉํ•˜๋ ค๋ฉด ๊ณต์‹ AMQP ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ๋ฅผ ์„ค์น˜ํ•ด์•ผ ํ•ด:

go get github.com/rabbitmq/amqp091-go

Producer ์˜ˆ์ œ (๋ฉ”์‹œ์ง€ ๋ฐœํ–‰)

package main

import (
    "context"
    "fmt"
    "log"
    "time"
    
    amqp "github.com/rabbitmq/amqp091-go"
)

func main() {
    // RabbitMQ ์—ฐ๊ฒฐ
    conn, err := amqp.Dial("amqp://guest:guest@localhost:5672/")
    if err != nil {
        log.Fatal(err)
    }
    defer conn.Close()
    
    // ์ฑ„๋„ ์ƒ์„ฑ
    ch, err := conn.Channel()
    if err != nil {
        log.Fatal(err)
    }
    defer ch.Close()
    
    // ํ ์„ ์–ธ
    queueName := "hello"
    q, err := ch.QueueDeclare(
        queueName, // ํ ์ด๋ฆ„
        true,      // durable (์„œ๋ฒ„ ์žฌ์‹œ์ž‘ ์‹œ์—๋„ ์œ ์ง€)
        false,     // auto-delete
        false,     // exclusive
        false,     // no-wait
        nil,       // arguments
    )
    if err != nil {
        log.Fatal(err)
    }
    
    // ๋ฉ”์‹œ์ง€ ๋ฐœํ–‰
    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    defer cancel()
    
    body := "์•ˆ๋…•ํ•˜์„ธ์š”, RabbitMQ!"
    err = ch.PublishWithContext(
        ctx,
        "",     // exchange
        q.Name, // routing key
        false,  // mandatory
        false,  // immediate
        amqp.Publishing{
            DeliveryMode: amqp.Persistent, // ๋ฉ”์‹œ์ง€ ์ง€์†์„ฑ
            ContentType:  "text/plain",
            Body:         []byte(body),
        },
    )
    if err != nil {
        log.Fatal(err)
    }
    
    fmt.Println("๋ฉ”์‹œ์ง€ ๋ฐœํ–‰ ์™„๋ฃŒ:", body)
}

Consumer ์˜ˆ์ œ (๋ฉ”์‹œ์ง€ ์†Œ๋น„)

package main

import (
    "fmt"
    "log"
    
    amqp "github.com/rabbitmq/amqp091-go"
)

func main() {
    // RabbitMQ ์—ฐ๊ฒฐ
    conn, err := amqp.Dial("amqp://guest:guest@localhost:5672/")
    if err != nil {
        log.Fatal(err)
    }
    defer conn.Close()
    
    // ์ฑ„๋„ ์ƒ์„ฑ
    ch, err := conn.Channel()
    if err != nil {
        log.Fatal(err)
    }
    defer ch.Close()
    
    // ํ ์„ ์–ธ (Producer์™€ ๋™์ผํ•˜๊ฒŒ)
    queueName := "hello"
    q, err := ch.QueueDeclare(
        queueName,
        true,
        false,
        false,
        false,
        nil,
    )
    if err != nil {
        log.Fatal(err)
    }
    
    // QoS ์„ค์ • (ํ•œ ๋ฒˆ์— ํ•˜๋‚˜์˜ ๋ฉ”์‹œ์ง€๋งŒ ์ฒ˜๋ฆฌ)
    err = ch.Qos(
        1,     // prefetch count
        0,     // prefetch size
        false, // global
    )
    if err != nil {
        log.Fatal(err)
    }
    
    // ๋ฉ”์‹œ์ง€ ์†Œ๋น„ ์‹œ์ž‘
    msgs, err := ch.Consume(
        q.Name, // queue
        "",     // consumer
        false,  // auto-ack (์ˆ˜๋™ ํ™•์ธ ๋ชจ๋“œ)
        false,  // exclusive
        false,  // no-local
        false,  // no-wait
        nil,    // args
    )
    if err != nil {
        log.Fatal(err)
    }
    
    fmt.Println("๋ฉ”์‹œ์ง€ ๋Œ€๊ธฐ ์ค‘...")
    
    // ๋ฉ”์‹œ์ง€ ์ฒ˜๋ฆฌ
    forever := make(chan bool)
    
    go func() {
        for msg := range msgs {
            fmt.Printf("๋ฐ›์€ ๋ฉ”์‹œ์ง€: %s\n", msg.Body)
            
            // ๋ฉ”์‹œ์ง€ ์ฒ˜๋ฆฌ ๋กœ์ง
            // ...
            
            // ์ฒ˜๋ฆฌ ์™„๋ฃŒ ํ™•์ธ
            msg.Ack(false)
        }
    }()
    
    <-forever
}

Topic Exchange ํ™œ์šฉ ์˜ˆ์ œ

์ด์ œ ์ข€ ๋” ๊ณ ๊ธ‰ ๊ธฐ๋Šฅ์„ ์จ๋ณผ๊นŒ? Topic Exchange๋ฅผ ์‚ฌ์šฉํ•˜๋ฉด ํŒจํ„ด ๋งค์นญ์œผ๋กœ ๋ฉ”์‹œ์ง€๋ฅผ ๋ผ์šฐํŒ…ํ•  ์ˆ˜ ์žˆ์–ด:

package main

import (
    "context"
    "fmt"
    "log"
    "time"
    
    amqp "github.com/rabbitmq/amqp091-go"
)

func main() {
    conn, err := amqp.Dial("amqp://guest:guest@localhost:5672/")
    if err != nil {
        log.Fatal(err)
    }
    defer conn.Close()
    
    ch, err := conn.Channel()
    if err != nil {
        log.Fatal(err)
    }
    defer ch.Close()
    
    // Topic Exchange ์„ ์–ธ
    exchangeName := "logs_topic"
    err = ch.ExchangeDeclare(
        exchangeName,
        "topic", // exchange type
        true,
        false,
        false,
        false,
        nil,
    )
    if err != nil {
        log.Fatal(err)
    }
    
    // ๋ฉ”์‹œ์ง€ ๋ฐœํ–‰
    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    defer cancel()
    
    // ๋‹ค์–‘ํ•œ ๋ผ์šฐํŒ… ํ‚ค๋กœ ๋ฉ”์‹œ์ง€ ๋ฐœํ–‰
    routingKeys := []string{
        "user.signup.email",
        "user.login.web",
        "order.created.payment",
    }
    
    for _, key := range routingKeys {
        body := fmt.Sprintf("์ด๋ฒคํŠธ: %s", key)
        err = ch.PublishWithContext(
            ctx,
            exchangeName,
            key,
            false,
            false,
            amqp.Publishing{
                ContentType: "text/plain",
                Body:        []byte(body),
            },
        )
        if err != nil {
            log.Fatal(err)
        }
        fmt.Printf("๋ฐœํ–‰: %s -> %s\n", key, body)
    }
}

๊ตฌ๋…์ž๋Š” ํŒจํ„ด์„ ์‚ฌ์šฉํ•ด์„œ ์›ํ•˜๋Š” ๋ฉ”์‹œ์ง€๋งŒ ๋ฐ›์„ ์ˆ˜ ์žˆ์–ด:

// "user.*" ํŒจํ„ด์œผ๋กœ ๊ตฌ๋…ํ•˜๋ฉด user ๊ด€๋ จ ๋ฉ”์‹œ์ง€๋งŒ ๋ฐ›์Œ
// "*.signup.*" ํŒจํ„ด์œผ๋กœ ๊ตฌ๋…ํ•˜๋ฉด ๋ชจ๋“  signup ์ด๋ฒคํŠธ๋ฅผ ๋ฐ›์Œ
// "#" ๋Š” ๋ชจ๋“  ๋ฉ”์‹œ์ง€๋ฅผ ๋ฐ›์Œ

๐Ÿ’ก ์‹ค์ „ ํŒ: RabbitMQ๋Š” ๋ฉ”์‹œ์ง€ ํ™•์ธ(Acknowledgement) ๋ฉ”์ปค๋‹ˆ์ฆ˜์ด ๊ฐ•๋ ฅํ•ด. ๋ฉ”์‹œ์ง€ ์ฒ˜๋ฆฌ ์ค‘ ์—๋Ÿฌ๊ฐ€ ๋‚˜๋ฉด Nack()๋ฅผ ํ˜ธ์ถœํ•ด์„œ ๋‹ค์‹œ ํ์— ๋„ฃ์„ ์ˆ˜ ์žˆ์–ด. ์ด๋ ‡๊ฒŒ ํ•˜๋ฉด ๋ฉ”์‹œ์ง€ ์†์‹ค์„ ๋ฐฉ์ง€ํ•  ์ˆ˜ ์žˆ์ง€!

๐ŸŒŠ Kafka: ๋Œ€์šฉ๋Ÿ‰ ์ŠคํŠธ๋ฆฌ๋ฐ์˜ ์ œ์™•

๋งˆ์ง€๋ง‰ ์ฃผ์ž๋Š” Kafka์•ผ! LinkedIn์—์„œ ๋งŒ๋“  ์ด ๋…€์„์€ ์ง„์งœ ๊ดด๋ฌผ์ด์•ผ. ๐Ÿฆ–

Kafka๋Š” ๋ญ์•ผ?

Apache Kafka๋Š” ๋ถ„์‚ฐ ์ด๋ฒคํŠธ ์ŠคํŠธ๋ฆฌ๋ฐ ํ”Œ๋žซํผ์ด์•ผ. ๋ฉ”์‹œ์ง• ์‹œ์Šคํ…œ์ด๋ผ๊ธฐ๋ณด๋‹ค๋Š” "๋ถ„์‚ฐ ์ปค๋ฐ‹ ๋กœ๊ทธ"์— ๊ฐ€๊นŒ์›Œ. ์—„์ฒญ๋‚œ ์–‘์˜ ๋ฐ์ดํ„ฐ๋ฅผ ์‹ค์‹œ๊ฐ„์œผ๋กœ ์ฒ˜๋ฆฌํ•  ์ˆ˜ ์žˆ์ง€.

๐ŸŒŸ Kafka์˜ ํŠน์ง•

1. ์—„์ฒญ๋‚œ ์ฒ˜๋ฆฌ๋Ÿ‰ - ์ดˆ๋‹น ์ˆ˜๋ฐฑ๋งŒ ๊ฐœ์˜ ๋ฉ”์‹œ์ง€ ์ฒ˜๋ฆฌ
2. ์ˆ˜ํ‰ ํ™•์žฅ์„ฑ - ์„œ๋ฒ„๋ฅผ ์ถ”๊ฐ€ํ•˜๋ฉด ์„ฑ๋Šฅ์ด ์„ ํ˜•์ ์œผ๋กœ ์ฆ๊ฐ€
3. ๋ฉ”์‹œ์ง€ ์˜์†์„ฑ - ๋””์Šคํฌ์— ์ €์žฅ๋˜์–ด ์˜ค๋ž˜ ๋ณด๊ด€ ๊ฐ€๋Šฅ
4. ๋ฉ”์‹œ์ง€ ์žฌ์ƒ - ๊ณผ๊ฑฐ ๋ฉ”์‹œ์ง€๋ฅผ ๋‹ค์‹œ ์ฝ์„ ์ˆ˜ ์žˆ์Œ
5. ๋ถ„์‚ฐ ์•„ํ‚คํ…์ฒ˜ - ์—ฌ๋Ÿฌ ์„œ๋ฒ„์— ๋ฐ์ดํ„ฐ ๋ณต์ œ๋กœ ๊ณ ๊ฐ€์šฉ์„ฑ ๋ณด์žฅ

Kafka์˜ ํ•ต์‹ฌ ๊ฐœ๋…

Kafka๋ฅผ ์ดํ•ดํ•˜๋ ค๋ฉด ์ด ๊ฐœ๋…๋“ค์„ ์•Œ์•„์•ผ ํ•ด:

โ€ข Topic (ํ† ํ”ฝ) - ๋ฉ”์‹œ์ง€๊ฐ€ ์ €์žฅ๋˜๋Š” ์นดํ…Œ๊ณ ๋ฆฌ. ๋ฐ์ดํ„ฐ๋ฒ ์ด์Šค์˜ ํ…Œ์ด๋ธ” ๊ฐ™์€ ๊ฑฐ
โ€ข Partition (ํŒŒํ‹ฐ์…˜) - ํ† ํ”ฝ์„ ๋‚˜๋ˆˆ ์กฐ๊ฐ. ๋ณ‘๋ ฌ ์ฒ˜๋ฆฌ์˜ ํ•ต์‹ฌ!
โ€ข Producer (ํ”„๋กœ๋“€์„œ) - ๋ฉ”์‹œ์ง€๋ฅผ ํ† ํ”ฝ์— ์“ฐ๋Š” ์• ํ”Œ๋ฆฌ์ผ€์ด์…˜
โ€ข Consumer (์ปจ์Šˆ๋จธ) - ํ† ํ”ฝ์—์„œ ๋ฉ”์‹œ์ง€๋ฅผ ์ฝ๋Š” ์• ํ”Œ๋ฆฌ์ผ€์ด์…˜
โ€ข Consumer Group (์ปจ์Šˆ๋จธ ๊ทธ๋ฃน) - ์—ฌ๋Ÿฌ ์ปจ์Šˆ๋จธ๊ฐ€ ํ˜‘๋ ฅํ•ด์„œ ๋ฉ”์‹œ์ง€ ์ฒ˜๋ฆฌ
โ€ข Broker (๋ธŒ๋กœ์ปค) - Kafka ์„œ๋ฒ„
โ€ข Offset (์˜คํ”„์…‹) - ํŒŒํ‹ฐ์…˜ ๋‚ด ๋ฉ”์‹œ์ง€์˜ ์œ„์น˜

Kafka Architecture Producer Kafka Cluster Topic: orders Part 0 Part 1 Part 2 Topic: users Consumer Group A Consumer Group B

์–ธ์ œ Kafka๋ฅผ ์“ธ๊นŒ?

Kafka๋Š” ์ด๋Ÿฐ ์ƒํ™ฉ์—์„œ ์ตœ๊ณ ์•ผ:

โ€ข ์‹ค์‹œ๊ฐ„ ๋กœ๊ทธ ์ˆ˜์ง‘ ๋ฐ ๋ถ„์„ ๐Ÿ“Š
โ€ข ์ด๋ฒคํŠธ ์†Œ์‹ฑ ์•„ํ‚คํ…์ฒ˜ ๐Ÿ—๏ธ
โ€ข ๋Œ€์šฉ๋Ÿ‰ ๋ฐ์ดํ„ฐ ํŒŒ์ดํ”„๋ผ์ธ ๐Ÿšฐ
โ€ข ์‹ค์‹œ๊ฐ„ ์ถ”์ฒœ ์‹œ์Šคํ…œ ๐ŸŽฏ
โ€ข ๊ธˆ์œต ๊ฑฐ๋ž˜ ์ฒ˜๋ฆฌ ๐Ÿ’ฐ

โš ๏ธ ์ฃผ์˜: Kafka๋Š” ๊ฐ•๋ ฅํ•˜์ง€๋งŒ ๋ณต์žกํ•ด. ์ž‘์€ ํ”„๋กœ์ ํŠธ์—๋Š” ์˜ค๋ฒ„์—”์ง€๋‹ˆ์–ด๋ง์ผ ์ˆ˜ ์žˆ์–ด. ์ •๋ง ๋Œ€์šฉ๋Ÿ‰ ๋ฐ์ดํ„ฐ๋ฅผ ๋‹ค๋ฃจ๊ฑฐ๋‚˜ ๋ฉ”์‹œ์ง€ ์žฌ์ƒ์ด ํ•„์š”ํ•œ ๊ฒฝ์šฐ์— ์‚ฌ์šฉํ•˜๋Š” ๊ฒŒ ์ข‹์•„!

Go๋กœ Kafka ์‚ฌ์šฉํ•˜๊ธฐ

Go์—์„œ Kafka๋ฅผ ์‚ฌ์šฉํ•  ๋•Œ๋Š” ์ฃผ๋กœ ๋‘ ๊ฐ€์ง€ ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ๋ฅผ ์จ:

1. Sarama - ์ˆœ์ˆ˜ Go๋กœ ์ž‘์„ฑ๋œ ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ
2. confluent-kafka-go - Confluent์˜ ๊ณต์‹ ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ (librdkafka ๊ธฐ๋ฐ˜)

์—ฌ๊ธฐ์„œ๋Š” Sarama๋ฅผ ์‚ฌ์šฉํ•ด๋ณผ๊ฒŒ. ์„ค์น˜๋ถ€ํ„ฐ:

go get github.com/IBM/sarama

Producer ์˜ˆ์ œ (๋ฉ”์‹œ์ง€ ๋ฐœํ–‰)

package main

import (
    "fmt"
    "log"
    
    "github.com/IBM/sarama"
)

func main() {
    // Kafka ์„ค์ •
    config := sarama.NewConfig()
    config.Producer.Return.Successes = true
    config.Producer.RequiredAcks = sarama.WaitForAll // ๋ชจ๋“  ๋ณต์ œ๋ณธ ํ™•์ธ
    config.Producer.Retry.Max = 5
    
    // ํ”„๋กœ๋“€์„œ ์ƒ์„ฑ
    brokers := []string{"localhost:9092"}
    producer, err := sarama.NewSyncProducer(brokers, config)
    if err != nil {
        log.Fatal(err)
    }
    defer producer.Close()
    
    // ๋ฉ”์‹œ์ง€ ๋ฐœํ–‰
    topic := "user-events"
    message := &sarama.ProducerMessage{
        Topic: topic,
        Key:   sarama.StringEncoder("user123"), // ํ‚ค๋กœ ํŒŒํ‹ฐ์…˜ ๊ฒฐ์ •
        Value: sarama.StringEncoder("์‚ฌ์šฉ์ž๊ฐ€ ๋กœ๊ทธ์ธํ–ˆ์Šต๋‹ˆ๋‹ค"),
    }
    
    partition, offset, err := producer.SendMessage(message)
    if err != nil {
        log.Fatal(err)
    }
    
    fmt.Printf("๋ฉ”์‹œ์ง€ ๋ฐœํ–‰ ์™„๋ฃŒ! ํŒŒํ‹ฐ์…˜: %d, ์˜คํ”„์…‹: %d\n", partition, offset)
}

Consumer ์˜ˆ์ œ (๋ฉ”์‹œ์ง€ ์†Œ๋น„)

package main

import (
    "context"
    "fmt"
    "log"
    "os"
    "os/signal"
    "syscall"
    
    "github.com/IBM/sarama"
)

func main() {
    // Kafka ์„ค์ •
    config := sarama.NewConfig()
    config.Consumer.Return.Errors = true
    config.Consumer.Offsets.Initial = sarama.OffsetNewest
    
    // ์ปจ์Šˆ๋จธ ๊ทธ๋ฃน ์ƒ์„ฑ
    brokers := []string{"localhost:9092"}
    group := "my-consumer-group"
    topics := []string{"user-events"}
    
    consumerGroup, err := sarama.NewConsumerGroup(brokers, group, config)
    if err != nil {
        log.Fatal(err)
    }
    defer consumerGroup.Close()
    
    // ์ปจํ…์ŠคํŠธ ์„ค์ •
    ctx, cancel := context.WithCancel(context.Background())
    defer cancel()
    
    // ์‹œ๊ทธ๋„ ์ฒ˜๋ฆฌ
    signals := make(chan os.Signal, 1)
    signal.Notify(signals, syscall.SIGINT, syscall.SIGTERM)
    
    // ์ปจ์Šˆ๋จธ ํ•ธ๋“ค๋Ÿฌ
    handler := &ConsumerHandler{}
    
    // ๋ฉ”์‹œ์ง€ ์†Œ๋น„ ์‹œ์ž‘
    go func() {
        for {
            if err := consumerGroup.Consume(ctx, topics, handler); err != nil {
                log.Printf("์—๋Ÿฌ: %v", err)
            }
            
            if ctx.Err() != nil {
                return
            }
        }
    }()
    
    fmt.Println("์ปจ์Šˆ๋จธ ์‹œ์ž‘๋จ. Ctrl+C๋กœ ์ข…๋ฃŒ...")
    <-signals
    fmt.Println("์ข…๋ฃŒ ์ค‘...")
}

// ConsumerHandler๋Š” ๋ฉ”์‹œ์ง€ ์ฒ˜๋ฆฌ ํ•ธ๋“ค๋Ÿฌ
type ConsumerHandler struct{}

func (h *ConsumerHandler) Setup(sarama.ConsumerGroupSession) error {
    return nil
}

func (h *ConsumerHandler) Cleanup(sarama.ConsumerGroupSession) error {
    return nil
}

func (h *ConsumerHandler) ConsumeClaim(session sarama.ConsumerGroupSession, claim sarama.ConsumerGroupClaim) error {
    for message := range claim.Messages() {
        fmt.Printf("๋ฉ”์‹œ์ง€ ๋ฐ›์Œ [%s:%d:%d]: %s\n",
            message.Topic,
            message.Partition,
            message.Offset,
            string(message.Value),
        )
        
        // ๋ฉ”์‹œ์ง€ ์ฒ˜๋ฆฌ ๋กœ์ง
        // ...
        
        // ์˜คํ”„์…‹ ์ปค๋ฐ‹
        session.MarkMessage(message, "")
    }
    return nil
}

๊ณ ๊ธ‰ ๊ธฐ๋Šฅ: ํŠธ๋žœ์žญ์…˜ ํ”„๋กœ๋“€์„œ

Kafka๋Š” ํŠธ๋žœ์žญ์…˜์„ ์ง€์›ํ•ด์„œ ์—ฌ๋Ÿฌ ๋ฉ”์‹œ์ง€๋ฅผ ์›์ž์ ์œผ๋กœ ๋ฐœํ–‰ํ•  ์ˆ˜ ์žˆ์–ด:

package main

import (
    "fmt"
    "log"
    
    "github.com/IBM/sarama"
)

func main() {
    config := sarama.NewConfig()
    config.Producer.Idempotent = true // ์ค‘๋ณต ๋ฐฉ์ง€
    config.Producer.RequiredAcks = sarama.WaitForAll
    config.Producer.Return.Successes = true
    config.Producer.Transaction.ID = "my-transaction-id"
    config.Net.MaxOpenRequests = 1
    
    brokers := []string{"localhost:9092"}
    producer, err := sarama.NewSyncProducer(brokers, config)
    if err != nil {
        log.Fatal(err)
    }
    defer producer.Close()
    
    // ํŠธ๋žœ์žญ์…˜ ์‹œ์ž‘
    err = producer.BeginTxn()
    if err != nil {
        log.Fatal(err)
    }
    
    // ์—ฌ๋Ÿฌ ๋ฉ”์‹œ์ง€ ๋ฐœํ–‰
    messages := []*sarama.ProducerMessage{
        {
            Topic: "orders",
            Value: sarama.StringEncoder("์ฃผ๋ฌธ ์ƒ์„ฑ"),
        },
        {
            Topic: "inventory",
            Value: sarama.StringEncoder("์žฌ๊ณ  ๊ฐ์†Œ"),
        },
        {
            Topic: "payments",
            Value: sarama.StringEncoder("๊ฒฐ์ œ ์ฒ˜๋ฆฌ"),
        },
    }
    
    for _, msg := range messages {
        _, _, err := producer.SendMessage(msg)
        if err != nil {
            // ์—๋Ÿฌ ๋ฐœ์ƒ ์‹œ ๋กค๋ฐฑ
            producer.AbortTxn()
            log.Fatal(err)
        }
    }
    
    // ํŠธ๋žœ์žญ์…˜ ์ปค๋ฐ‹
    err = producer.CommitTxn()
    if err != nil {
        log.Fatal(err)
    }
    
    fmt.Println("ํŠธ๋žœ์žญ์…˜ ์™„๋ฃŒ!")
}

๐Ÿ’ก ์„ฑ๋Šฅ ํŒ: Kafka์—์„œ ์„ฑ๋Šฅ์„ ์ตœ๋Œ€๋กœ ๋ฝ‘์œผ๋ ค๋ฉด:
1. ๋ฐฐ์น˜ ํฌ๊ธฐ๋ฅผ ๋Š˜๋ ค๋ผ (config.Producer.Flush.Messages)
2. ์••์ถ•์„ ์‚ฌ์šฉํ•ด๋ผ (config.Producer.Compression)
3. ํŒŒํ‹ฐ์…˜์„ ์ ์ ˆํžˆ ๋‚˜๋ˆ ๋ผ (๋ณ‘๋ ฌ ์ฒ˜๋ฆฌ)
4. ์ปจ์Šˆ๋จธ ๊ทธ๋ฃน์„ ํ™œ์šฉํ•ด๋ผ (๋ถ€ํ•˜ ๋ถ„์‚ฐ)

โš–๏ธ ๋น„๊ต: NATS vs RabbitMQ vs Kafka

์ž, ์ด์ œ ์„ธ ๋…€์„์„ ๋น„๊ตํ•ด๋ณผ ์‹œ๊ฐ„์ด์•ผ! ๊ฐ์ž ์žฅ๋‹จ์ ์ด ์žˆ์œผ๋‹ˆ๊นŒ ์ƒํ™ฉ์— ๋งž๊ฒŒ ์„ ํƒํ•˜๋Š” ๊ฒŒ ์ค‘์š”ํ•ด. ๐ŸŽฏ

๐Ÿš€ ์„ฑ๋Šฅ & ์ฒ˜๋ฆฌ๋Ÿ‰

NATS: ์ดˆ๊ณ ์†, ๋‚ฎ์€ ๋ ˆ์ดํ„ด์‹œ
RabbitMQ: ์ค‘๊ฐ„ ์ˆ˜์ค€
Kafka: ์ตœ๊ณ  ์ฒ˜๋ฆฌ๋Ÿ‰, ๋ฐฐ์น˜ ์ฒ˜๋ฆฌ์— ๊ฐ•ํ•จ

๐Ÿ’พ ๋ฉ”์‹œ์ง€ ์ง€์†์„ฑ

NATS: ๊ธฐ๋ณธ์€ ๋ฉ”๋ชจ๋ฆฌ (JetStream์œผ๋กœ ์ง€์†์„ฑ ๊ฐ€๋Šฅ)
RabbitMQ: ๋””์Šคํฌ ์ €์žฅ ๊ฐ€๋Šฅ
Kafka: ๊ธฐ๋ณธ์ ์œผ๋กœ ๋””์Šคํฌ์— ์ €์žฅ

๐Ÿ”„ ๋ฉ”์‹œ์ง€ ์žฌ์ƒ

NATS: JetStream์—์„œ ๊ฐ€๋Šฅ
RabbitMQ: ๋ถˆ๊ฐ€๋Šฅ (ํ•œ ๋ฒˆ ์†Œ๋น„ํ•˜๋ฉด ์‚ญ์ œ)
Kafka: ์™„๋ฒฝ ์ง€์› (์˜คํ”„์…‹ ์กฐ์ •)

๐Ÿ“ˆ ํ™•์žฅ์„ฑ

NATS: ์ˆ˜ํ‰ ํ™•์žฅ ์‰ฌ์›€
RabbitMQ: ํด๋Ÿฌ์Šคํ„ฐ๋ง ๊ฐ€๋Šฅํ•˜์ง€๋งŒ ๋ณต์žก
Kafka: ์ˆ˜ํ‰ ํ™•์žฅ ์ตœ๊ณ  (ํŒŒํ‹ฐ์…”๋‹)

๐Ÿ› ๏ธ ์šด์˜ ๋ณต์žก๋„

NATS: ๋งค์šฐ ๊ฐ„๋‹จ
RabbitMQ: ์ค‘๊ฐ„
Kafka: ๋ณต์žก (ZooKeeper ํ•„์š”, ์ตœ์‹  ๋ฒ„์ „์€ KRaft ๋ชจ๋“œ)

๐Ÿ’ฐ ๋ฆฌ์†Œ์Šค ์‚ฌ์šฉ

NATS: ๋งค์šฐ ๊ฐ€๋ฒผ์›€
RabbitMQ: ์ค‘๊ฐ„
Kafka: ๋งŽ์€ ๋ฉ”๋ชจ๋ฆฌ์™€ ๋””์Šคํฌ ํ•„์š”

์„ ํƒ ๊ฐ€์ด๋“œ

๐ŸŽฏ NATS๋ฅผ ์„ ํƒํ•ด์•ผ ํ•  ๋•Œ:

โ€ข ์ดˆ์ €์ง€์—ฐ์ด ํ•„์š”ํ•œ ์‹ค์‹œ๊ฐ„ ์‹œ์Šคํ…œ
โ€ข ๊ฐ„๋‹จํ•˜๊ณ  ๊ฐ€๋ฒผ์šด ๋ฉ”์‹œ์ง•์ด ํ•„์š”ํ•  ๋•Œ
โ€ข ๋งˆ์ดํฌ๋กœ์„œ๋น„์Šค ๊ฐ„ ๋น ๋ฅธ ํ†ต์‹ 
โ€ข IoT ๋””๋ฐ”์ด์Šค ํ†ต์‹ 
โ€ข ๋ฉ”์‹œ์ง€ ์†์‹ค์ด ํฌ๊ฒŒ ๋ฌธ์ œ๋˜์ง€ ์•Š๋Š” ๊ฒฝ์šฐ

๐Ÿฐ RabbitMQ๋ฅผ ์„ ํƒํ•ด์•ผ ํ•  ๋•Œ:

โ€ข ๋ฉ”์‹œ์ง€ ์‹ ๋ขฐ์„ฑ์ด ์ตœ์šฐ์„ 
โ€ข ๋ณต์žกํ•œ ๋ผ์šฐํŒ… ๋กœ์ง์ด ํ•„์š”ํ•  ๋•Œ
โ€ข ๋‹ค์–‘ํ•œ ๋ฉ”์‹œ์ง• ํŒจํ„ด ์‚ฌ์šฉ
โ€ข ๊ธฐ์กด AMQP ์‹œ์Šคํ…œ๊ณผ ํ†ตํ•ฉ
โ€ข ์ค‘์†Œ๊ทœ๋ชจ ์‹œ์Šคํ…œ

๐ŸŒŠ Kafka๋ฅผ ์„ ํƒํ•ด์•ผ ํ•  ๋•Œ:

โ€ข ๋Œ€์šฉ๋Ÿ‰ ๋ฐ์ดํ„ฐ ์ŠคํŠธ๋ฆฌ๋ฐ
โ€ข ์ด๋ฒคํŠธ ์†Œ์‹ฑ ์•„ํ‚คํ…์ฒ˜
โ€ข ๋ฉ”์‹œ์ง€ ์žฌ์ƒ์ด ํ•„์š”ํ•  ๋•Œ
โ€ข ๋กœ๊ทธ ์ˆ˜์ง‘ ๋ฐ ๋ถ„์„
โ€ข ์‹ค์‹œ๊ฐ„ ๋ฐ์ดํ„ฐ ํŒŒ์ดํ”„๋ผ์ธ
โ€ข ๋†’์€ ์ฒ˜๋ฆฌ๋Ÿ‰์ด ํ•„์š”ํ•œ ๊ฒฝ์šฐ

๐ŸŽจ ์‹ค์ „ ํŒจํ„ด๊ณผ ๋ฒ ์ŠคํŠธ ํ”„๋ž™ํ‹ฐ์Šค

์ด๋ก ์€ ์ถฉ๋ถ„ํžˆ ๋ฐฐ์› ์œผ๋‹ˆ, ์ด์ œ ์‹ค์ „์—์„œ ์–ด๋–ป๊ฒŒ ์“ฐ๋Š”์ง€ ์•Œ์•„๋ณด์ž! ๐Ÿ’ช

1. ์—๋Ÿฌ ์ฒ˜๋ฆฌ ํŒจํ„ด

๋ฉ”์‹œ์ง• ์‹œ์Šคํ…œ์—์„œ ์—๋Ÿฌ ์ฒ˜๋ฆฌ๋Š” ์ •๋ง ์ค‘์š”ํ•ด. ๋ฉ”์‹œ์ง€๊ฐ€ ๋‚ ์•„๊ฐ€๋ฉด ํฐ์ผ์ด์ž–์•„?

package main

import (
    "fmt"
    "log"
    "time"
    
    "github.com/IBM/sarama"
)

// ์žฌ์‹œ๋„ ๋กœ์ง์ด ํฌํ•จ๋œ ํ”„๋กœ๋“€์„œ
type RetryProducer struct {
    producer    sarama.SyncProducer
    maxRetries  int
    retryDelay  time.Duration
}

func (rp *RetryProducer) SendWithRetry(msg *sarama.ProducerMessage) error {
    var err error
    
    for i := 0; i < rp.maxRetries; i++ {
        _, _, err = rp.producer.SendMessage(msg)
        if err == nil {
            return nil
        }
        
        log.Printf("์ „์†ก ์‹คํŒจ (์‹œ๋„ %d/%d): %v", i+1, rp.maxRetries, err)
        time.Sleep(rp.retryDelay)
    }
    
    return fmt.Errorf("์ตœ๋Œ€ ์žฌ์‹œ๋„ ํšŸ์ˆ˜ ์ดˆ๊ณผ: %w", err)
}

// Dead Letter Queue ํŒจํ„ด
func handleFailedMessage(msg *sarama.ConsumerMessage, err error) {
    // ์‹คํŒจํ•œ ๋ฉ”์‹œ์ง€๋ฅผ ๋ณ„๋„์˜ ํ† ํ”ฝ์œผ๋กœ ์ „์†ก
    dlqTopic := "failed-messages"
    
    // DLQ์— ๋ฉ”์‹œ์ง€ ์ €์žฅ ๋กœ์ง
    log.Printf("๋ฉ”์‹œ์ง€๋ฅผ DLQ๋กœ ์ „์†ก: %s, ์—๋Ÿฌ: %v", string(msg.Value), err)
}

2. ๋ฉฑ๋“ฑ์„ฑ(Idempotency) ๋ณด์žฅ

๊ฐ™์€ ๋ฉ”์‹œ์ง€๊ฐ€ ์—ฌ๋Ÿฌ ๋ฒˆ ์ฒ˜๋ฆฌ๋˜์–ด๋„ ๊ฒฐ๊ณผ๊ฐ€ ๊ฐ™์•„์•ผ ํ•ด. ์ด๊ฑธ ๋ฉฑ๋“ฑ์„ฑ์ด๋ผ๊ณ  ํ•ด:

package main

import (
    "sync"
)

// ๋ฉ”์‹œ์ง€ ์ค‘๋ณต ์ฒ˜๋ฆฌ ๋ฐฉ์ง€
type MessageDeduplicator struct {
    processed map[string]bool
    mu        sync.RWMutex
}

func NewMessageDeduplicator() *MessageDeduplicator {
    return &MessageDeduplicator{
        processed: make(map[string]bool),
    }
}

func (md *MessageDeduplicator) IsProcessed(messageID string) bool {
    md.mu.RLock()
    defer md.mu.RUnlock()
    return md.processed[messageID]
}

func (md *MessageDeduplicator) MarkProcessed(messageID string) {
    md.mu.Lock()
    defer md.mu.Unlock()
    md.processed[messageID] = true
}

// ์‚ฌ์šฉ ์˜ˆ์‹œ
func processMessage(msg Message, dedup *MessageDeduplicator) {
    if dedup.IsProcessed(msg.ID) {
        // ์ด๋ฏธ ์ฒ˜๋ฆฌ๋œ ๋ฉ”์‹œ์ง€
        return
    }
    
    // ๋ฉ”์‹œ์ง€ ์ฒ˜๋ฆฌ ๋กœ์ง
    // ...
    
    dedup.MarkProcessed(msg.ID)
}

type Message struct {
    ID   string
    Data string
}

3. ์„œํ‚ท ๋ธŒ๋ ˆ์ด์ปค ํŒจํ„ด

๋ฉ”์‹œ์ง• ์‹œ์Šคํ…œ์ด ๋‹ค์šด๋˜์—ˆ์„ ๋•Œ ๊ณ„์† ์žฌ์‹œ๋„ํ•˜๋ฉด ๋ฆฌ์†Œ์Šค๋งŒ ๋‚ญ๋น„๋ผ. ์„œํ‚ท ๋ธŒ๋ ˆ์ด์ปค๋กœ ํ•ด๊ฒฐํ•˜์ž:

package main

import (
    "errors"
    "sync"
    "time"
)

type CircuitBreaker struct {
    maxFailures  int
    resetTimeout time.Duration
    
    failures    int
    lastFailure time.Time
    state       string // "closed", "open", "half-open"
    mu          sync.RWMutex
}

func NewCircuitBreaker(maxFailures int, resetTimeout time.Duration) *CircuitBreaker {
    return &CircuitBreaker{
        maxFailures:  maxFailures,
        resetTimeout: resetTimeout,
        state:        "closed",
    }
}

func (cb *CircuitBreaker) Call(fn func() error) error {
    cb.mu.Lock()
    defer cb.mu.Unlock()
    
    // ์„œํ‚ท์ด ์—ด๋ ค์žˆ์œผ๋ฉด ์š”์ฒญ ๊ฑฐ๋ถ€
    if cb.state == "open" {
        if time.Since(cb.lastFailure) > cb.resetTimeout {
            cb.state = "half-open"
            cb.failures = 0
        } else {
            return errors.New("circuit breaker is open")
        }
    }
    
    // ํ•จ์ˆ˜ ์‹คํ–‰
    err := fn()
    
    if err != nil {
        cb.failures++
        cb.lastFailure = time.Now()
        
        if cb.failures >= cb.maxFailures {
            cb.state = "open"
        }
        return err
    }
    
    // ์„ฑ๊ณตํ•˜๋ฉด ๋ฆฌ์…‹
    cb.failures = 0
    cb.state = "closed"
    return nil
}

4. ๋ฉ”์‹œ์ง€ ๋ฐฐ์น˜ ์ฒ˜๋ฆฌ

๋ฉ”์‹œ์ง€๋ฅผ ํ•˜๋‚˜์”ฉ ์ฒ˜๋ฆฌํ•˜๋Š” ๊ฒƒ๋ณด๋‹ค ๋ฐฐ์น˜๋กœ ์ฒ˜๋ฆฌํ•˜๋ฉด ํ›จ์”ฌ ํšจ์œจ์ ์ด์•ผ:

package main

import (
    "fmt"
    "time"
)

type MessageBatcher struct {
    batchSize    int
    flushTimeout time.Duration
    messages     []string
    processor    func([]string) error
}

func NewMessageBatcher(batchSize int, timeout time.Duration, processor func([]string) error) *MessageBatcher {
    mb := &MessageBatcher{
        batchSize:    batchSize,
        flushTimeout: timeout,
        messages:     make([]string, 0, batchSize),
        processor:    processor,
    }
    
    // ํƒ€์ด๋จธ๋กœ ์ฃผ๊ธฐ์  ํ”Œ๋Ÿฌ์‹œ
    go mb.autoFlush()
    
    return mb
}

func (mb *MessageBatcher) Add(msg string) error {
    mb.messages = append(mb.messages, msg)
    
    if len(mb.messages) >= mb.batchSize {
        return mb.Flush()
    }
    
    return nil
}

func (mb *MessageBatcher) Flush() error {
    if len(mb.messages) == 0 {
        return nil
    }
    
    err := mb.processor(mb.messages)
    if err != nil {
        return err
    }
    
    mb.messages = mb.messages[:0]
    return nil
}

func (mb *MessageBatcher) autoFlush() {
    ticker := time.NewTicker(mb.flushTimeout)
    defer ticker.Stop()
    
    for range ticker.C {
        mb.Flush()
    }
}

// ์‚ฌ์šฉ ์˜ˆ์‹œ
func main() {
    batcher := NewMessageBatcher(100, 5*time.Second, func(messages []string) error {
        fmt.Printf("๋ฐฐ์น˜ ์ฒ˜๋ฆฌ: %d๊ฐœ ๋ฉ”์‹œ์ง€\n", len(messages))
        // ์‹ค์ œ ์ฒ˜๋ฆฌ ๋กœ์ง
        return nil
    })
    
    // ๋ฉ”์‹œ์ง€ ์ถ”๊ฐ€
    for i := 0; i < 250; i++ {
        batcher.Add(fmt.Sprintf("๋ฉ”์‹œ์ง€ %d", i))
    }
}

๐Ÿ’ก ํ”„๋กœ ํŒ: ๋ฐฐ์น˜ ์ฒ˜๋ฆฌ๋Š” ๋ฐ์ดํ„ฐ๋ฒ ์ด์Šค ์“ฐ๊ธฐ๋‚˜ ์™ธ๋ถ€ API ํ˜ธ์ถœ ๊ฐ™์€ ๋น„์šฉ์ด ํฐ ์ž‘์—…์—์„œ ํŠนํžˆ ํšจ๊ณผ์ ์ด์•ผ. ์ฒ˜๋ฆฌ๋Ÿ‰์ด 10๋ฐฐ ์ด์ƒ ์ฆ๊ฐ€ํ•  ์ˆ˜ ์žˆ์–ด!

๐Ÿ”ง ๋ชจ๋‹ˆํ„ฐ๋ง๊ณผ ๋””๋ฒ„๊น…

๋ฉ”์‹œ์ง• ์‹œ์Šคํ…œ์„ ์šด์˜ํ•˜๋‹ค ๋ณด๋ฉด ๋ฌธ์ œ๊ฐ€ ์ƒ๊ธฐ๊ธฐ ๋งˆ๋ จ์ด์•ผ. ์–ด๋–ป๊ฒŒ ๋ชจ๋‹ˆํ„ฐ๋งํ•˜๊ณ  ๋””๋ฒ„๊น…ํ• ๊นŒ? ๐Ÿ”

1. ๋ฉ”ํŠธ๋ฆญ ์ˆ˜์ง‘

Prometheus์™€ Grafana๋ฅผ ์‚ฌ์šฉํ•ด์„œ ๋ฉ”ํŠธ๋ฆญ์„ ์ˆ˜์ง‘ํ•˜๊ณ  ์‹œ๊ฐํ™”ํ•˜์ž:

package main

import (
    "github.com/prometheus/client_golang/prometheus"
    "github.com/prometheus/client_golang/prometheus/promauto"
)

var (
    messagesProduced = promauto.NewCounter(prometheus.CounterOpts{
        Name: "messages_produced_total",
        Help: "๋ฐœํ–‰๋œ ๋ฉ”์‹œ์ง€ ์ด ๊ฐœ์ˆ˜",
    })
    
    messagesConsumed = promauto.NewCounter(prometheus.CounterOpts{
        Name: "messages_consumed_total",
        Help: "์†Œ๋น„๋œ ๋ฉ”์‹œ์ง€ ์ด ๊ฐœ์ˆ˜",
    })
    
    messageProcessingDuration = promauto.NewHistogram(prometheus.HistogramOpts{
        Name:    "message_processing_duration_seconds",
        Help:    "๋ฉ”์‹œ์ง€ ์ฒ˜๋ฆฌ ์‹œ๊ฐ„",
        Buckets: prometheus.DefBuckets,
    })
    
    messageErrors = promauto.NewCounter(prometheus.CounterOpts{
        Name: "message_errors_total",
        Help: "๋ฉ”์‹œ์ง€ ์ฒ˜๋ฆฌ ์—๋Ÿฌ ์ด ๊ฐœ์ˆ˜",
    })
)

// ๋ฉ”์‹œ์ง€ ๋ฐœํ–‰ ์‹œ
func publishMessage(msg string) error {
    messagesProduced.Inc()
    // ๋ฐœํ–‰ ๋กœ์ง
    return nil
}

// ๋ฉ”์‹œ์ง€ ์†Œ๋น„ ์‹œ
func consumeMessage(msg string) error {
    timer := prometheus.NewTimer(messageProcessingDuration)
    defer timer.ObserveDuration()
    
    messagesConsumed.Inc()
    
    // ์ฒ˜๋ฆฌ ๋กœ์ง
    err := processMessage(msg)
    if err != nil {
        messageErrors.Inc()
        return err
    }
    
    return nil
}

2. ๊ตฌ์กฐํ™”๋œ ๋กœ๊น…

๋กœ๊ทธ๋ฅผ ์ž˜ ๋‚จ๊ธฐ๋ฉด ๋ฌธ์ œ ์ถ”์ ์ด ํ›จ์”ฌ ์‰ฌ์›Œ์ ธ:

package main

import (
    "go.uber.org/zap"
)

func setupLogger() *zap.Logger {
    logger, _ := zap.NewProduction()
    return logger
}

func processMessageWithLogging(msg Message, logger *zap.Logger) error {
    logger.Info("๋ฉ”์‹œ์ง€ ์ฒ˜๋ฆฌ ์‹œ์ž‘",
        zap.String("message_id", msg.ID),
        zap.String("topic", msg.Topic),
        zap.Int("partition", msg.Partition),
        zap.Int64("offset", msg.Offset),
    )
    
    // ์ฒ˜๋ฆฌ ๋กœ์ง
    err := doProcess(msg)
    
    if err != nil {
        logger.Error("๋ฉ”์‹œ์ง€ ์ฒ˜๋ฆฌ ์‹คํŒจ",
            zap.String("message_id", msg.ID),
            zap.Error(err),
        )
        return err
    }
    
    logger.Info("๋ฉ”์‹œ์ง€ ์ฒ˜๋ฆฌ ์™„๋ฃŒ",
        zap.String("message_id", msg.ID),
        zap.Duration("duration", msg.ProcessingTime),
    )
    
    return nil
}

3. ํ—ฌ์Šค ์ฒดํฌ

๋ฉ”์‹œ์ง• ์‹œ์Šคํ…œ์˜ ์ƒํƒœ๋ฅผ ์ฃผ๊ธฐ์ ์œผ๋กœ ํ™•์ธํ•˜์ž:

package main

import (
    "context"
    "fmt"
    "time"
    
    "github.com/IBM/sarama"
)

type HealthChecker struct {
    brokers []string
}

func (hc *HealthChecker) CheckKafka() error {
    config := sarama.NewConfig()
    config.Version = sarama.V2_6_0_0
    
    client, err := sarama.NewClient(hc.brokers, config)
    if err != nil {
        return fmt.Errorf("Kafka ์—ฐ๊ฒฐ ์‹คํŒจ: %w", err)
    }
    defer client.Close()
    
    // ๋ธŒ๋กœ์ปค ์ƒํƒœ ํ™•์ธ
    brokers := client.Brokers()
    for _, broker := range brokers {
        connected, err := broker.Connected()
        if err != nil || !connected {
            return fmt.Errorf("๋ธŒ๋กœ์ปค %s ์—ฐ๊ฒฐ ์•ˆ๋จ", broker.Addr())
        }
    }
    
    return nil
}

func (hc *HealthChecker) StartHealthCheck(interval time.Duration) {
    ticker := time.NewTicker(interval)
    defer ticker.Stop()
    
    for range ticker.C {
        err := hc.CheckKafka()
        if err != nil {
            fmt.Printf("ํ—ฌ์Šค ์ฒดํฌ ์‹คํŒจ: %v\n", err)
            // ์•Œ๋ฆผ ์ „์†ก ๋กœ์ง
        } else {
            fmt.Println("ํ—ฌ์Šค ์ฒดํฌ ์„ฑ๊ณต")
        }
    }
}

๐ŸŒ ์‹ค์ œ ์‚ฌ์šฉ ์‚ฌ๋ก€

์ด๋ก ๋งŒ ๋ฐฐ์šฐ๋ฉด ์žฌ๋ฏธ์—†์ž–์•„? ์‹ค์ œ๋กœ ์–ด๋–ป๊ฒŒ ์“ฐ์ด๋Š”์ง€ ์‚ฌ๋ก€๋ฅผ ๋ณด์ž! ๐ŸŽฌ

์‚ฌ๋ก€ 1: ์ „์ž์ƒ๊ฑฐ๋ž˜ ์ฃผ๋ฌธ ์‹œ์Šคํ…œ

์˜จ๋ผ์ธ ์‡ผํ•‘๋ชฐ์—์„œ ์ฃผ๋ฌธ์ด ๋“ค์–ด์˜ค๋ฉด ์—ฌ๋Ÿฌ ์„œ๋น„์Šค๊ฐ€ ํ˜‘๋ ฅํ•ด์•ผ ํ•ด:

// ์ฃผ๋ฌธ ์„œ๋น„์Šค
func handleOrder(order Order) error {
    // 1. ์ฃผ๋ฌธ ์ƒ์„ฑ ์ด๋ฒคํŠธ ๋ฐœํ–‰
    publishEvent("order.created", order)
    
    // 2. ์žฌ๊ณ  ํ™•์ธ ์š”์ฒญ
    publishEvent("inventory.check", order)
    
    // 3. ๊ฒฐ์ œ ์ฒ˜๋ฆฌ ์š”์ฒญ
    publishEvent("payment.process", order)
    
    return nil
}

// ์žฌ๊ณ  ์„œ๋น„์Šค
func handleInventoryCheck(order Order) error {
    // ์žฌ๊ณ  ํ™•์ธ ๋กœ์ง
    if !hasStock(order) {
        publishEvent("order.failed", "์žฌ๊ณ  ๋ถ€์กฑ")
        return errors.New("์žฌ๊ณ  ๋ถ€์กฑ")
    }
    
    // ์žฌ๊ณ  ์ฐจ๊ฐ
    decreaseStock(order)
    publishEvent("inventory.reserved", order)
    
    return nil
}

// ๊ฒฐ์ œ ์„œ๋น„์Šค
func handlePayment(order Order) error {
    // ๊ฒฐ์ œ ์ฒ˜๋ฆฌ ๋กœ์ง
    err := processPayment(order)
    if err != nil {
        publishEvent("payment.failed", order)
        // ์žฌ๊ณ  ๋ณต๊ตฌ ์ด๋ฒคํŠธ ๋ฐœํ–‰
        publishEvent("inventory.restore", order)
        return err
    }
    
    publishEvent("payment.completed", order)
    return nil
}

// ์•Œ๋ฆผ ์„œ๋น„์Šค
func handleNotification(event Event) {
    switch event.Type {
    case "order.created":
        sendEmail("์ฃผ๋ฌธ์ด ์ ‘์ˆ˜๋˜์—ˆ์Šต๋‹ˆ๋‹ค")
    case "payment.completed":
        sendEmail("๊ฒฐ์ œ๊ฐ€ ์™„๋ฃŒ๋˜์—ˆ์Šต๋‹ˆ๋‹ค")
        sendSMS("๋ฐฐ์†ก ์ค€๋น„ ์ค‘์ž…๋‹ˆ๋‹ค")
    case "order.failed":
        sendEmail("์ฃผ๋ฌธ ์ฒ˜๋ฆฌ ์ค‘ ๋ฌธ์ œ๊ฐ€ ๋ฐœ์ƒํ–ˆ์Šต๋‹ˆ๋‹ค")
    }
}

์ด๋ ‡๊ฒŒ ํ•˜๋ฉด ๊ฐ ์„œ๋น„์Šค๊ฐ€ ๋…๋ฆฝ์ ์œผ๋กœ ๋™์ž‘ํ•˜๋ฉด์„œ๋„ ํ˜‘๋ ฅํ•  ์ˆ˜ ์žˆ์–ด! ๐Ÿค

์‚ฌ๋ก€ 2: ์‹ค์‹œ๊ฐ„ ๋กœ๊ทธ ๋ถ„์„ ์‹œ์Šคํ…œ

Kafka๋ฅผ ์‚ฌ์šฉํ•ด์„œ ๋Œ€์šฉ๋Ÿ‰ ๋กœ๊ทธ๋ฅผ ์‹ค์‹œ๊ฐ„์œผ๋กœ ๋ถ„์„ํ•˜๋Š” ์‹œ์Šคํ…œ:

// ๋กœ๊ทธ ์ˆ˜์ง‘๊ธฐ
func collectLogs() {
    producer := createKafkaProducer()
    
    // ์—ฌ๋Ÿฌ ์†Œ์Šค์—์„œ ๋กœ๊ทธ ์ˆ˜์ง‘
    logSources := []string{"app1", "app2", "app3"}
    
    for _, source := range logSources {
        go func(src string) {
            for log := range readLogs(src) {
                producer.SendMessage(&sarama.ProducerMessage{
                    Topic: "application-logs",
                    Key:   sarama.StringEncoder(src),
                    Value: sarama.StringEncoder(log),
                })
            }
        }(source)
    }
}

// ๋กœ๊ทธ ๋ถ„์„๊ธฐ
func analyzeLogs() {
    consumer := createKafkaConsumer("log-analyzer-group")
    
    for msg := range consumer.Messages() {
        log := parseLog(msg.Value)
        
        // ์—๋Ÿฌ ๋กœ๊ทธ ๊ฐ์ง€
        if log.Level == "ERROR" {
            alertOnError(log)
        }
        
        // ๋ฉ”ํŠธ๋ฆญ ์—…๋ฐ์ดํŠธ
        updateMetrics(log)
        
        // ๊ฒ€์ƒ‰ ์ธ๋ฑ์Šค์— ์ €์žฅ
        indexLog(log)
    }
}

// ์‹ค์‹œ๊ฐ„ ๋Œ€์‹œ๋ณด๋“œ
func updateDashboard() {
    consumer := createKafkaConsumer("dashboard-group")
    
    for msg := range consumer.Messages() {
        log := parseLog(msg.Value)
        
        // WebSocket์œผ๋กœ ๋ธŒ๋ผ์šฐ์ €์— ์‹ค์‹œ๊ฐ„ ์ „์†ก
        broadcastToClients(log)
    }
}

์‚ฌ๋ก€ 3: IoT ์„ผ์„œ ๋ฐ์ดํ„ฐ ์ฒ˜๋ฆฌ

NATS๋ฅผ ์‚ฌ์šฉํ•ด์„œ ์ˆ˜์ฒœ ๊ฐœ์˜ IoT ์„ผ์„œ ๋ฐ์ดํ„ฐ๋ฅผ ์ฒ˜๋ฆฌ:

// ์„ผ์„œ ๋ฐ์ดํ„ฐ ๋ฐœํ–‰
func publishSensorData(sensorID string, data SensorData) {
    nc := connectToNATS()
    
    subject := fmt.Sprintf("sensors.%s.%s", sensorID, data.Type)
    payload, _ := json.Marshal(data)
    
    nc.Publish(subject, payload)
}

// ์˜จ๋„ ๋ชจ๋‹ˆํ„ฐ๋ง ์„œ๋น„์Šค
func monitorTemperature() {
    nc := connectToNATS()
    
    // ๋ชจ๋“  ์˜จ๋„ ์„ผ์„œ ๊ตฌ๋…
    nc.Subscribe("sensors.*.temperature", func(msg *nats.Msg) {
        var data SensorData
        json.Unmarshal(msg.Data, &data)
        
        if data.Value > 30.0 {
            sendAlert("๊ณ ์˜จ ๊ฒฝ๊ณ !", data)
        }
    })
}

// ๋ฐ์ดํ„ฐ ์ €์žฅ ์„œ๋น„์Šค
func storeSensorData() {
    nc := connectToNATS()
    
    // ๋ชจ๋“  ์„ผ์„œ ๋ฐ์ดํ„ฐ ๊ตฌ๋…
    nc.Subscribe("sensors.>", func(msg *nats.Msg) {
        var data SensorData
        json.Unmarshal(msg.Data, &data)
        
        // ์‹œ๊ณ„์—ด ๋ฐ์ดํ„ฐ๋ฒ ์ด์Šค์— ์ €์žฅ
        saveToTimeSeries(data)
    })
}

์ด๋Ÿฐ ์‹์œผ๋กœ NATS์˜ ๋น ๋ฅธ ์†๋„๋ฅผ ํ™œ์šฉํ•˜๋ฉด ์‹ค์‹œ๊ฐ„ IoT ์‹œ์Šคํ…œ์„ ์‰ฝ๊ฒŒ ๊ตฌ์ถ•ํ•  ์ˆ˜ ์žˆ์–ด! ๐ŸŒก๏ธ

๐ŸŽ“ ํ•™์Šต ๋ฆฌ์†Œ์Šค์™€ ์ปค๋ฎค๋‹ˆํ‹ฐ

๋” ๊นŠ์ด ๊ณต๋ถ€ํ•˜๊ณ  ์‹ถ๋‹ค๋ฉด? ์—ฌ๊ธฐ ์ข‹์€ ๋ฆฌ์†Œ์Šค๋“ค์„ ๋ชจ์•„๋ดค์–ด! ๐Ÿ“š

๐Ÿ“– ๊ณต์‹ ๋ฌธ์„œ

โ€ข NATS: https://docs.nats.io/
โ€ข RabbitMQ: https://www.rabbitmq.com/documentation.html
โ€ข Kafka: https://kafka.apache.org/documentation/

๐Ÿ’ป Go ํด๋ผ์ด์–ธํŠธ ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ

โ€ข NATS: github.com/nats-io/nats.go
โ€ข RabbitMQ: github.com/rabbitmq/amqp091-go
โ€ข Kafka: github.com/IBM/sarama, github.com/confluentinc/confluent-kafka-go

๐ŸŽฅ ์ถ”์ฒœ ๊ฐ•์˜

โ€ข Udemy์˜ "Apache Kafka Series"
โ€ข Pluralsight์˜ "RabbitMQ in Depth"
โ€ข YouTube์˜ NATS ๊ณต์‹ ์ฑ„๋„

๊ทธ๋ฆฌ๊ณ  ํ˜น์‹œ ๋ฉ”์‹œ์ง• ์‹œ์Šคํ…œ ๊ด€๋ จํ•ด์„œ ๋” ๋ฐฐ์šฐ๊ณ  ์‹ถ๊ฑฐ๋‚˜, ์‹ค์ œ ํ”„๋กœ์ ํŠธ์— ์ ์šฉํ•˜๋Š” ๋ฐ ๋„์›€์ด ํ•„์š”ํ•˜๋‹ค๋ฉด ์žฌ๋Šฅ๋„ท์—์„œ ์ „๋ฌธ๊ฐ€๋“ค์˜ ๋„์›€์„ ๋ฐ›์„ ์ˆ˜ ์žˆ์–ด! ํ”„๋กœ๊ทธ๋ž˜๋ฐ ๋ฉ˜ํ† ๋ง๋ถ€ํ„ฐ ์ฝ”๋“œ ๋ฆฌ๋ทฐ๊นŒ์ง€ ๋‹ค์–‘ํ•œ ์žฌ๋Šฅ์„ ๊ฑฐ๋ž˜ํ•  ์ˆ˜ ์žˆ์œผ๋‹ˆ๊นŒ ํ•œ๋ฒˆ ๋‘˜๋Ÿฌ๋ณด๋Š” ๊ฒƒ๋„ ์ข‹์„ ๊ฑฐ์•ผ. ๐Ÿ˜Š

๐Ÿš€ ๋งˆ๋ฌด๋ฆฌํ•˜๋ฉฐ

์™€, ์—ฌ๊ธฐ๊นŒ์ง€ ์ฝ์—ˆ๋‹ค๋ฉด ์ •๋ง ๋Œ€๋‹จํ•ด! ๐Ÿ‘ ์šฐ๋ฆฌ๊ฐ€ ํ•จ๊ป˜ ์‚ดํŽด๋ณธ ๋‚ด์šฉ์„ ์ •๋ฆฌํ•ด๋ณด์ž:

ํ•ต์‹ฌ ํฌ์ธํŠธ ์š”์•ฝ:

โœ… ๋ฉ”์‹œ์ง• ์‹œ์Šคํ…œ์€ ๋งˆ์ดํฌ๋กœ์„œ๋น„์Šค ์•„ํ‚คํ…์ฒ˜์˜ ํ•ต์‹ฌ์ด์•ผ
โœ… Go์–ธ์–ด๋Š” ๋™์‹œ์„ฑ ์ฒ˜๋ฆฌ์™€ ์„ฑ๋Šฅ ๋ฉด์—์„œ ๋ฉ”์‹œ์ง• ์‹œ์Šคํ…œ๊ณผ ์ฐฐ๋–ก๊ถํ•ฉ
โœ… NATS๋Š” ๊ฐ€๋ณ๊ณ  ๋น ๋ฅธ ์‹ค์‹œ๊ฐ„ ํ†ต์‹ ์— ์ตœ์ 
โœ… RabbitMQ๋Š” ์‹ ๋ขฐ์„ฑ๊ณผ ์œ ์—ฐํ•œ ๋ผ์šฐํŒ…์ด ํ•„์š”ํ•  ๋•Œ ์„ ํƒ
โœ… Kafka๋Š” ๋Œ€์šฉ๋Ÿ‰ ์ŠคํŠธ๋ฆฌ๋ฐ๊ณผ ์ด๋ฒคํŠธ ์†Œ์‹ฑ์— ๊ฐ•๋ ฅํ•จ
โœ… ์ƒํ™ฉ์— ๋งž๋Š” ๋„๊ตฌ๋ฅผ ์„ ํƒํ•˜๋Š” ๊ฒŒ ๊ฐ€์žฅ ์ค‘์š”ํ•ด

๋ฉ”์‹œ์ง• ์‹œ์Šคํ…œ์€ ์ฒ˜์Œ์—๋Š” ๋ณต์žกํ•ด ๋ณด์ผ ์ˆ˜ ์žˆ์ง€๋งŒ, ํ•˜๋‚˜์”ฉ ๋ฐฐ์›Œ๊ฐ€๋‹ค ๋ณด๋ฉด ์ •๋ง ๊ฐ•๋ ฅํ•œ ๋„๊ตฌ๋ผ๋Š” ๊ฑธ ์•Œ๊ฒŒ ๋  ๊ฑฐ์•ผ. ์‹ค์ œ๋กœ ์จ๋ณด๋ฉด์„œ ๊ฒฝํ—˜์„ ์Œ“๋Š” ๊ฒŒ ๊ฐ€์žฅ ์ค‘์š”ํ•ด! ๐Ÿ’ช

์ž‘์€ ํ”„๋กœ์ ํŠธ๋ถ€ํ„ฐ ์‹œ์ž‘ํ•ด์„œ ์ ์  ๋ณต์žกํ•œ ์‹œ์Šคํ…œ์œผ๋กœ ํ™•์žฅํ•ด๋‚˜๊ฐ€ ๋ณด์ž. ๊ทธ๋ฆฌ๊ณ  ๋ง‰ํžˆ๋Š” ๋ถ€๋ถ„์ด ์žˆ์œผ๋ฉด ์ปค๋ฎค๋‹ˆํ‹ฐ์— ์งˆ๋ฌธํ•˜๊ฑฐ๋‚˜, ์žฌ๋Šฅ๋„ท ๊ฐ™์€ ํ”Œ๋žซํผ์—์„œ ์ „๋ฌธ๊ฐ€์˜ ๋„์›€์„ ๋ฐ›๋Š” ๊ฒƒ๋„ ์ข‹์€ ๋ฐฉ๋ฒ•์ด์•ผ.

์ž, ์ด์ œ ๋‹น์‹  ์ฐจ๋ก€์•ผ! Go์–ธ์–ด๋กœ ๋ฉ‹์ง„ ๋ฉ”์‹œ์ง• ์‹œ์Šคํ…œ์„ ๋งŒ๋“ค์–ด๋ณด์ž! ๐ŸŽ‰

Happy Coding! ๐Ÿš€โœจ

๋Œ“๊ธ€ ์ž‘์„ฑ

์ด ๊ธ€์— ๋Œ€ํ•œ ์—ฌ๋Ÿฌ๋ถ„์˜ ์ƒ๊ฐ์„ ๋“ค๋ ค์ฃผ์„ธ์š”

๋Œ“๊ธ€ 0
๋Œ“๊ธ€์„ ๋ถˆ๋Ÿฌ์˜ค๋Š” ์ค‘์ž…๋‹ˆ๋‹ค.

์•„์ง ๋Œ“๊ธ€์ด ์—†์Šต๋‹ˆ๋‹ค.