Senior

/* Il y a une application avec une architecture de microservices. Un microservice peut être abstrait à l'aide de l'interface Backend. Pour accéder à une instance de 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. C'est pourquoi 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

Для реализации client-side балансировщика нагрузки, который выбирает наименее нагруженный экземпляр Backend, можно сделать следующее:

В структуре Balancer хранить срез BackendImpl и счётчики текущей нагрузки (например, количество активных запросов) для каждого экземпляра.
При вызове Invoke выбирать Backend с минимальной нагрузкой.
Перед вызовом 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
}

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

Précédent Suivant