Change the redis client in goproxy from radix.v2 to redigo.
Reason：
There is a potential issue in the connection pool of radix.v2 which generates new connection to redis even though the current number of connections exceeds the maximum size of radix.v2 pool and this implementation may led to the redis cluster collapse.
I had tried to submit a PR to radix.v2 expecting to fix it but the author from radix.v2 rejected that PR saying that logic in radix.v2 pool was intended..., well, he is the author of radix.v2 so he got the right to determine what radix.v2 should be. However, based on the conflicting ideas from us, I'm afraid I have to change the redis client in goproxy from radix.v2 to redigo whose connection pool will restrict the size of connections severely.
Managing configurations in goproxy with viper which supports eager loading and means it will take effect immediately right after you update the configuration file.
- Round Robin Algorithm
- Weight Round Robin Algorithm
- Power of Two Choices (P2C) Algorithm
- Consistent Hashing with Bounded Loads Algorithm
goproxy is a load-balancing, reverse-proxy server implemented in go, supporting cache( by redis). As a load-balancing server, it supports 4 algorithms: Randomized Algorithm, Weight Round Robin Algorithm, Power of Two Choices (P2C) Algorithm, IP Hash Algorithm, Consistent Hashing with Bounded Loads Algorithm, besides, goproxy can dominate the http requests: filtering and blocking specific requests and even rewriting them.
Sometimes your program needs to call some third party API and wants to customize the responses from it, in that case, goproxy will be your great choice.
- GET/POST/PUT/DELETE methods in http and CONNECT method in https are supported in goproxy
- Http authentication was also supported
- Weight can be assigned to every single back-end server
- Filtering and blocking specific http requests and even rewriting them
- Customizing responses from third-party API
3.Responses can be cached in redis to speed up the responding and the expired time of caches is configurable
- Clone source of goproxy from github, goproxy
- git clone https://github.com/panjf2000/goproxy.git
- logrus (structured, pluggable logging for Go)
radix.v2 (lightweight redis client for Go)- redigo（Go client for Redis）
- cron（a cron library for go）
Install logrus：go get github.com/Sirupsen/logrus
Install radix.v2：go get github.com/mediocregopher/radix.v2/…
Install redigo：go get github.com/gomodule/redigo/redis
Besides, you also need a redis to support caching responses in goproxy.
- cd $GOPATH/src/github.com/panjf2000/goproxy
- go build
goproxy uses cfg.toml as its configurations file which is located in /etc/proxy/cfg.toml of your server, you should create a cfg.toml in there previously, here is a typical example:
# toml file for goproxy
title = "TOML config for goproxy"
[server]
port = ":8080"
reverse = true
proxy_pass = ["127.0.0.1:6000"]
# 0 - random, 1 - loop, 2 - power of two choices(p2c), 3 - hash, 4 - consistent hashing
inverse_mode = 2
auth = false
cache = true
cache_timeout = 60
cache_type = "redis"
log = 1
log_path = "./logs"
user = { agent = "proxy" }
http_read_timeout = 10
http_write_timeout = 10
[redis]
redis_host = "localhost:6379"
redis_pass = ""
max_idle = 5
idle_timeout = 10
max_active = 10
[mem]
capacity = 1000
cache_replacement_policy = "LRU"- port：the port goroxy will listen to
- reverse：enable the reverse-proxy feature or not
- proxy_pass：back-end servers that actually provide services, like ["127.0.0.1:80^10","127.0.0.1:88^5","127.0.0.1:8088^2","127.0.0.1:8888"], weight can be assigned to every single server
- inverse_mode：load-balancing algoritms：0 for Randomized Algorithm； 1 for Weight Round Robin Algorithm； 2 for Power of Two Choices (P2C) Algorithm； 3 for IP Hash Algorithm； 4 for Consistent Hashing with Bounded Loads Algorithm
- auth：enable http authentication or not
- cache：enable responses caching or not
- cache_timeout：expired time of responses caching, in seconds
- cache_type: redis or memory
- log：log level, 1 for Debug，0 for info
- log_path：the path of log files
- user：user name from http authentication
- http_read_timeout：duration for waiting response from the back-end server, if goproxy don't get the response after this duration, it will throw an exception
- http_write_timeout：duration for back-end server writing response to goproxy, if back-end server takes a longer time than this duration to write its response into goproxy, goproxy will throw an exception
- redis_host：redis host
- redis_pass：redis password
- max_idle：the maximum idle connections of redis connection pool
- idle_timeout：duration for idle redis connection to close
- max_active：maximum size of redis connection pool
- capacity: cache capacity of items
- cache_replacement_policy: LRU or LFU
You will get a binary file named goproxy as the same of project name after executing the go build command and that binary file can be run directly to start a goproxy server.
The started goproxy server will listen in the port set in cfg.toml file and you can just forward your http requests to the back-end servers set in cfg.toml by going through that port in goproxy.
Up to present, goproxy has implemented all basic functionalities like reverse-proxy, load-blancing, http caching, http requests controlling, etc and if you want to customize the responses more accurately, you can implement a new handler by inheriting (not a strict statement as there is no OO in golang) from the ProxyServer struct located in handlers/proxy.go and overriding its method named ServeHTTP, then you are allowed to write your own logic into it.
React
Typescript
Django
Laravel
Facebook
Microsoft
Google
Alibaba
D3
Tencent