/* Es gibt eine Anwendung mit einer Microservice-Architektur. Ein Microservice kann durch die Schnittstelle Backend abstrahiert werden. Um auf eine Instanz des Microservice zuzugreifen, kann man den Typ BackendImpl verwenden, der bereits implementiert ist. Jeder Microservice hat mehrere Dutzend laufende Instanzen, die jeweils unter ihrer eigenen Adresse addr erreichbar sind. Allerdings sind einzelne Instanzen des Microservice nicht zuverlässig: sie können ausfallen, nicht erreichbar sein oder überlastet sein. Daher müssen Sie den Typ Balancer implementieren, der ebenfalls die Schnittstelle Backend implementiert und das Load-Balancing auf der Client-Seite durchführt, indem er bei den Instanzen des Microservice jedes Mal die **am wenigsten belastete** auswählt. */ type Request interface{} type Response interface{} type Backend interface { Invoke(ctx context.Context, req Request) (Response, error) } var _ Backend = &BackendImpl{} // addr enthält ip:port einer bestimmten Instanz func NewBackend(addr string) *BackendImpl type Balancer struct { //TODO } var _ Backend = &Balancer{} // addrs enthalten die Adressen aller balancierten Instanzen 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
}

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