/* Es gibt eine Anwendung mit einer Microservice-Architektur. Ein Microservice kann durch eine Backend-Schnittstelle abstrahiert werden. Um auf eine Instanz des Microservice zuzugreifen, kann der Typ BackendImpl verwendet werden, 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 abstürzen, nicht erreichbar sein oder überlastet sein. Daher müssen Sie den Typ Balancer implementieren, der ebenfalls die Backend-Schnittstelle implementiert und das Client-seitige Load-Balancing zwischen den Instanzen des Microservice durchführt, wobei jedes Mal die **am wenigsten belastete** Instanz ausgewählt wird. */ 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 }

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

Примерный подход:

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

Пример кода:

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
}

Таким образом, каждый запрос направляется на наименее загруженный экземпляр, что обеспечивает client-side балансировку нагрузки.