/* Există o aplicație cu arhitectură de microservicii. Un microserviciu poate fi abstractizat folosind interfața Backend. Pentru a accesa o instanță de microserviciu, se poate folosi tipul BackendImpl, care este deja implementat. Pentru fiecare microserviciu, există câzeci de instanțe în execuție, fiecare accesibilă prin adresa sa addr. Cu toate acestea, instanțele individuale ale microserviciului nu sunt fiabile: pot cădea, pot fi indisponibile sau suprasolicitate. De aceea, trebuie să implementați tipul Balancer, care de asemenea implementează interfața Backend și realizează echilibrare a încărcării pe partea clientului între instanțele microserviciului, alegând de fiecare dată instanța **cu cea mai mică încărcare**. */ type Request interface{} type Response interface{} type Backend interface { Invoke(ctx context.Context, req Request) (Response, error) } var _ Backend = &BackendImpl{} // addr conține ip:portul unei instanțe specifice func NewBackend(addr string) *BackendImpl type Balancer struct { //TODO } var _ Backend = &Balancer{} // addrs conține adresele tuturor instanțelor echilibrate 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
}

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