/* მიკროსერვისების არქიტექტურით შექმნილი აპლიკაცია არსებობს. მიკროსერვისი შეიძლება აბსტრაქტულად იყოს წარმოდგენილი `Backend` ინტერფეისის საშუალებით. მიკროსერვისის ერთ ეგზემპლარის მისაღებად, შეგიძლიათ გამოიყენოთ `BackendImpl` ტიპი, რომელიც უკვე განხორციელებულია. ყოველი მიკროსერვისი აქვს რამდენიმე ათეული ამუშავებული ეგზემპლარი, რომელიც ხელმისაწვდომია თავისი მისამართით `addr`. თუმცა, მიკროსერვისის ინდივიდუალური ეგზემპლარები არ არის საიმედო: შეგვიძლია, რომ მათმა ჩავარდნამ, მიუწვდომლობამ ან გადატვირთვამ გამოიწვიოს პრობლემები. ამიტომ, თქვენ უნდა განახორციელოთ `Balancer` ტიპის რეალიზაცია, რომელიც ასევე რეალიზებს `Backend` ინტერფეისს და ახორციელებს დატვირთვის ბალანსირებას მიკროსერვისის ეგზემპლარებს შორის, ყოველ ჯერზე არჩევს **მცირეწლოვან** ეგზემპლარს. */ type Request interface{} type Response interface{} type Backend interface { Invoke(ctx context.Context, req Request) (Response, error) } var _ Backend = &BackendImpl{} // addr შეიცავს კონკრეტული ეგზემპლარის ip:port-ს func NewBackend(addr string) *BackendImpl type Balancer struct { //TODO } var _ Backend = &Balancer{} // addrs შეიცავს ყველა ბალანსირებულ ეგზემპლარის მისამართებს func NewBalancer(addrs []string) *Balancer { //TODO }

Для реализации client-side балансировщика нагрузки, который выбирает наименее нагруженный экземпляр Backend, можно сделать следующее:

1. В структуре Balancer хранить срез BackendImpl и счётчики текущей нагрузки (например, количество активных запросов) для каждого экземпляра.
2. При вызове Invoke выбирать Backend с минимальной нагрузкой.
3. Перед вызовом Invoke увеличивать счётчик нагрузки, после завершения — уменьшать.

Пример реализации на Go:

import (
    "context"
    "sync"
)

type Balancer struct {
    backends []*BackendImpl
    mu       sync.Mutex
    loads    []int // количество активных запросов на каждый backend
}

func NewBalancer(addrs []string) *Balancer {
    b := &Balancer{
        backends: make([]*BackendImpl, len(addrs)),
        loads:    make([]int, len(addrs)),
    }
    for i, addr := range addrs {
        b.backends[i] = NewBackend(addr)
    }
    return b
}

func (b *Balancer) Invoke(ctx context.Context, req Request) (Response, error) {
    b.mu.Lock()
    // Найти индекс с минимальной нагрузкой
    minIdx := 0
    minLoad := b.loads[0]
    for i, load := range b.loads {
        if load < minLoad {
            minLoad = load
            minIdx = i
        }
    }
    b.loads[minIdx]++
    b.mu.Unlock()

    // Вызов backend
    resp, err := b.backends[minIdx].Invoke(ctx, req)

    b.mu.Lock()
    b.loads[minIdx]--
    b.mu.Unlock()

    return resp, err
}

Такой подход обеспечивает выбор наименее загруженного экземпляра в момент вызова, учитывая текущую активную нагрузку. Для более точного учёта можно использовать атомарные операции или более сложные метрики нагрузки.