Middle

/* Il existe une application avec une architecture de microservices. Un microservice peut être abstrait via une interface Backend. Pour accéder à une instance du microservice, on peut utiliser le type BackendImpl, qui est déjà implémenté. Chaque microservice a plusieurs dizaines d'instances en cours d'exécution, chacune accessible par sa propre adresse addr. Cependant, les instances individuelles du microservice ne sont pas fiables : elles peuvent échouer, être inaccessibles ou surchargées. Par conséquent, vous devez implémenter le type Balancer, qui implémente également l'interface Backend et effectue un équilibrage de charge côté client entre les instances du microservice, en choisissant à chaque fois l'instance la moins chargée. / type Request interface{} type Response interface{} type Backend interface { Invoke(ctx context.Context, req Request) (Response, error) } var _ Backend = &BackendImpl{} // addr contient ip:port d'une instance spécifique func NewBackend(addr string) BackendImpl type Balancer struct { // TODO } var _ Backend = &Balancer{} // addrs contiennent les adresses de toutes les instances équilibrées func NewBalancer(addrs []string) *Balancer { // TODO }

sobes.tech IA

Réponse de l'IA

Для реализации 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 балансировку нагрузки.

Précédent Suivant