Ver3.0 ๐ Go์ธ์ด๋ก ์์ํ๋ ๋ฉ์์ง ์ธ๊ณ: NATS, RabbitMQ, Kafka๋ฅผ ํ์ฉํ ์ด๋ฒคํธ ์คํธ๋ฆฌ๋ฐ ์๋ฒฝ ๊ฐ์ด๋

๐ Go์ธ์ด๋ก ์์ํ๋ ๋ฉ์์ง ์ธ๊ณ: NATS, RabbitMQ, Kafka๋ฅผ ํ์ฉํ ์ด๋ฒคํธ ์คํธ๋ฆฌ๋ฐ ์๋ฒฝ ๊ฐ์ด๋
์๋ , ์น๊ตฌ! ๐ ์ค๋์ ์ ๋ง ํฅ๋ฏธ์ง์งํ ์ฃผ์ ๋ฅผ ๊ฐ์ง๊ณ ์์ด. ๋ฐ๋ก Go์ธ์ด๋ก ๋ฉ์์ง ์์คํ ์ ๋ค๋ฃจ๋ ๋ฐฉ๋ฒ์ด์ผ. ์์ฆ ๋ง์ดํฌ๋ก์๋น์ค ์ํคํ ์ฒ๊ฐ ๋์ธ์์? ๊ทธ๋ฌ๋ฉด์ ์๋น์ค ๊ฐ ํต์ ์ด ์์ฒญ ์ค์ํด์ก๋๋ฐ, ์ด๋ ๋ฑ์ฅํ๋ ๊ฒ ๋ฐ๋ก ๋ฉ์์ง ์์คํ ์ด์ง. NATS, RabbitMQ, Kafka ๊ฐ์ ๋ ์๋ค ๋ง์ด์ผ. ๐
์ด ๊ธ์์๋ Go์ธ์ด๋ก ์ด ์ธ ๊ฐ์ง ๋ฉ์์ง ์์คํ ์ ์ด๋ป๊ฒ ํ์ฉํ๋์ง, ๊ฐ๊ฐ์ ํน์ง์ ๋ญ์ง, ๊ทธ๋ฆฌ๊ณ ์ค์ ๋ก ์ด๋ป๊ฒ ์ฝ๋๋ฅผ ์ง๋์ง๊น์ง ์น๊ตฌ์ฒ๋ผ ํธํ๊ฒ ์ค๋ช ํด์ค๊ฒ. ์ปคํผ ํ ์ โ ์ค๋นํ๊ณ ํธํ๊ฒ ์ฝ์ด๋ด!
๐ฏ ๋ฉ์์ง ์์คํ ์ด ๋ญ๊ธธ๋?
๋จผ์ ๊ธฐ๋ณธ๋ถํฐ ์ง๊ณ ๋์ด๊ฐ์. ๋ฉ์์ง ์์คํ ์ด ๋ญ๋๊ณ ? ๊ฐ๋จํ๊ฒ ๋งํ๋ฉด ์๋น์ค๋ค ์ฌ์ด์์ ๋ฉ์์ง๋ฅผ ์ฃผ๊ณ ๋ฐ๋ ์ฐ์ฒด๊ตญ ๊ฐ์ ๊ฑฐ์ผ. ๐ฌ
์์ ์๋ ์๋น์ค 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๋ฅผ ์ธ๊น?
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
์ง์์ธ์ ์ฒ - ์ง์ ์ฌ์ฐ๊ถ ๋ณดํธ ๊ณ ์ง
์ง์ ์ฌ์ฐ๊ถ ๋ณดํธ ๊ณ ์ง
- ์ ์๊ถ ๋ฐ ์์ ๊ถ: ๋ณธ ์ปจํ ์ธ ๋ ์ฌ๋ฅ๋ท์ ๋ ์ AI ๊ธฐ์ ๋ก ์์ฑ๋์์ผ๋ฉฐ, ๋ํ๋ฏผ๊ตญ ์ ์๊ถ๋ฒ ๋ฐ ๊ตญ์ ์ ์๊ถ ํ์ฝ์ ์ํด ๋ณดํธ๋ฉ๋๋ค.
- AI ์์ฑ ์ปจํ ์ธ ์ ๋ฒ์ ์ง์: ๋ณธ AI ์์ฑ ์ปจํ ์ธ ๋ ์ฌ๋ฅ๋ท์ ์ง์ ์ฐฝ์๋ฌผ๋ก ์ธ์ ๋๋ฉฐ, ๊ด๋ จ ๋ฒ๊ท์ ๋ฐ๋ผ ์ ์๊ถ ๋ณดํธ๋ฅผ ๋ฐ์ต๋๋ค.
- ์ฌ์ฉ ์ ํ: ์ฌ๋ฅ๋ท์ ๋ช ์์ ์๋ฉด ๋์ ์์ด ๋ณธ ์ปจํ ์ธ ๋ฅผ ๋ณต์ , ์์ , ๋ฐฐํฌ, ๋๋ ์์ ์ ์ผ๋ก ํ์ฉํ๋ ํ์๋ ์๊ฒฉํ ๊ธ์ง๋ฉ๋๋ค.
- ๋ฐ์ดํฐ ์์ง ๊ธ์ง: ๋ณธ ์ปจํ ์ธ ์ ๋ํ ๋ฌด๋จ ์คํฌ๋ํ, ํฌ๋กค๋ง, ๋ฐ ์๋ํ๋ ๋ฐ์ดํฐ ์์ง์ ๋ฒ์ ์ ์ฌ์ ๋์์ด ๋ฉ๋๋ค.
- AI ํ์ต ์ ํ: ์ฌ๋ฅ๋ท์ AI ์์ฑ ์ปจํ ์ธ ๋ฅผ ํ AI ๋ชจ๋ธ ํ์ต์ ๋ฌด๋จ ์ฌ์ฉํ๋ ํ์๋ ๊ธ์ง๋๋ฉฐ, ์ด๋ ์ง์ ์ฌ์ฐ๊ถ ์นจํด๋ก ๊ฐ์ฃผ๋ฉ๋๋ค.
์์ง ๋๊ธ์ด ์์ต๋๋ค.