/* Mikroservis memarlığına malik bir tətbiq var. Bir mikroservis Backend interfeysi ilə abstraksiya edilə bilər. Bir mikroservis nümunəsinə giriş üçün artıq tətbiq edilmiş olan BackendImpl tipindən istifadə edə bilərsiniz. Hər mikroservis üçün onlarla işləyən nümunə var, hər biri öz ünvanı addr ilə əlçatandır. Ancaq, mikroservisin ayrı-ayrı nümunələri etibarlı deyil: onlar çökməyə, əlçatmaz olmağa və ya yüklənməyə bilər. Buna görə, siz Balancer tipini tətbiq etməlisiniz, bu da Backend interfeysini də həyata keçirir və müştəri tərəfdən yük balanslaşdırmasını həyata keçirir mikroservis nümunələri arasında, hər dəfə ən az yüklü nümunəni seçərək. */ type Request interface{} type Response interface{} type Backend interface { Invoke(ctx context.Context, req Request) (Response, error) } var _ Backend = &BackendImpl{} // addr müəyyən nümunənin ip:port ünvanını ehtiva edir func NewBackend(addr string) *BackendImpl type Balancer struct { //TODO } var _ Backend = &Balancer{} // addrs bütün balanslaşdırılmış nümunələrin ünvanlarını ehtiva edir 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
}

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