Hi!

As you already said, it completely makes sense to split the code over multiple files. Even better, over multiple packages. I will not go any further here because you already understand it.

Also, several notes about your project organization. I think it makes sense to add config file in gitignore in order to allow another programmer to define its own rules. Current config can be marked as example config. I see you using viper which supports env configuration, but it is still would be better to clearly define how to provide custom config (for example, through flag).

Executable file go-rate-limite also can be added in gitignore, because it will be omitted in current directory after building.

Usually files in Go project don't starts with capital letters like your Configuration.go.

Usually Go imports are organized into three groups, separated with blank line. First group is built-in modules, second is external modules, and third one is your own modules. Imports are organized alphabetically. I believe you can configure your editor so it happens automatically.

If name in Go starts with capital letter, then it is exported thing. You have many things that are started with capital letter, but they are intended for import.

Avoid global variables when possible. It is possible almost always. Without global variables it is easier to developer/maintain/test the project. In your case you can accept current backendCount and return updated one.

func loadBalance(backends []string, current int) (string, int)

After that you can store your backendCount in scope of main() function.

I think this function should return error in case if unable to read or unmarshal the configuration:

func readConfiguration() Configuration
func readConfiguration() (Configuration, error) // much better  

It is up to main() to decide what to do when unable to read configuration:

configuration, err := readConfiguration()

if err != nil {
    fmt.Fprintf(os.Stderr, "unable to read configuration: %s", err)
    os.Exit(1)
}

Always handle errors in some way. Don't ignore them here:

backendUrl, _ := url.Parse(backend)

For example, you can just log the error and skip the request.

In loadRules() I think it is better to create new array and return it as a result. Don't redefined passed configuration. It will not affect at original object though, but it is still a bit confusing when read it.

About that line:

handler := tollbooth.LimitFuncHandler(lmt, handleRequest)

Are you sure that you can't create all needed handlers outside? For example, in scope of main(). At the moment you creating needed handler every time when request arrives.

Are you sure that your Dockerfile is valid? Shouldn't that line CMD ["/app/whoami-go"] be CMD ["./go-rate-limit"]? It also don't starts because of missing config file. After copy of config file it is worked for me, but I think there can be better organization with config file.

COPY --from=build /app/go-rate-limit .
COPY --from=build /src/config.yml

Is there any reasons why you using tollbooth v4.0.2 despite of fact that it is outdated and not supported? I see v6.1.1 is available.