go-lb

go-lb provides a general load balancers library.

Features

The stocked algorithm are:

• random
• round-robin
• weighted round-robin
• consistent hash
• weighted random
• weighted versioning

Use Register(...)/Unregister(...) to add the balancer with your algorithm and use it with our New(algorithm, opts...).

History

• v0.5.1

  • upgrade deps

• v0.5.0

  • a tiny logger interface has been embedded. So

    • we removed the dep to hedzr/log and free you from it

    • you may still enable internal logging sentences in hedzr/lb by setting up a custom Logger

      import "github.com/hedzr/lb/pkg/logger"
      logger.SetLogger(yoursLogger)

  • all codes reviewed

• v0.3.3

  • needs go modules 1.17 and higher
  • upgraded deps
  • remove unecessary deps
  • remove the nest go.mod since it cannot work any more
  • fix gin vuln report

• v0.3.1, v0.3.0 : work for below go1.17

Usages

Simple

package main

import (
    "fmt"
    lb "github.com/hedzr/lb"
    "github.com/hedzr/lb/lbapi"
)

func main() {
    b := lb.New(lb.RoundRobin)

    b.Add(exP("172.16.0.7:3500"), exP("172.16.0.8:3500"), exP("172.16.0.9:3500"))
    sum := make(map[lbapi.Peer]int)
    for i := 0; i < 300; i++ {
        p, _ := b.Next(lbapi.DummyFactor)
        sum[p]++
    }

    for k, v := range sum {
        fmt.Printf("%v: %v\n", k, v)
    }
}

type exP string

func (s exP) String() string { return string(s) }

About Weighted versioning

With the Weighted versioning algorithm, a set of version constraints and weights can be put as the basic rule. Such as:

1. "<= 1.1.x", weight: 2,
2. "^1.2.x", weight: 4,
3. "^2.x", weight: 11,
4. ^3.x", weight: 3,

the peers will be picked out by its version. And, all versioning peers will be picked with weights specified in constraints totally.

The partial codes:

var testConstraints = []lbapi.Constrainable{
    version.NewConstrainablePeer("<= 1.1.x", 2),
    version.NewConstrainablePeer("^1.2.x", 4),
    version.NewConstrainablePeer("^2.x", 11),
    version.NewConstrainablePeer("^3.x", 3),
}

func TestVersionWRR2(t *testing.T) {
    lb := version.New(version.WithConstrainedPeers(testConstraints...))

    sum := make(map[lbapi.Peer]int)
    hits := make(map[lbapi.Peer]map[lbapi.Constrainable]bool)

    factor := initFactors()

    for i := 0; i < 500; i++ {
        peer, c := lb.Next(factor)

        sum[peer]++
        if ps, ok := hits[peer]; ok {
            if _, ok := ps[c]; !ok {
                ps[c] = true
            }
        } else {
            hits[peer] = make(map[lbapi.Constrainable]bool)
            hits[peer][c] = true
        }
    }

    // results
    total := 0
    for _, v := range sum {
        total += v
    }
    for peer, v := range sum {
        var keys []string
        var w int
        for c := range hits[peer] {
            if kk, ok := c.(fmt.Stringer); ok {
                keys = append(keys, kk.String())
            }
            if ww, ok := c.(lbapi.Weighted); ok {
                w = ww.Weight()
            }
        }
        // ex := findC(peer)
        t.Logf("%v: %v/%0.2f%%/w:%v. [%v => weight: %v]",
            peer, v, (float32(v)/float32(total))*100.0, w,
            strings.Join(keys, ","), w)
    }
}

See the full codes at version/new_test.go,

For the full document of version constraints: Masterminds/semver .

API GW demo

Please check out the source codes:

• gw-small
• svc-small

And the command line to test its:

go run ./_examples/svc-small -port 8111 &
go run ./_examples/svc-small -port 8112 &
go run ./_examples/svc-small -port 8113 &

go run ./_examples/gw-lb-aware/main.go 8111 8112 8113 &

for ((i=0;i<5;i++)); do curl http://localhost:8103/ ; done

License

MIT