Reverse Proxy

How to use Echo as a reverse proxy server?

This recipe demonstrates how you can use Echo as a reverse proxy server and load balancer in front of your favorite applications like WordPress, Node.js, Java, Python, Ruby or even Go. For simplicity, I will use Go upstream servers with WebSocket.

Step 1: Identify upstream target URLs

  1. url1, err := url.Parse("http://localhost:8081")
  2. if err != nil {
  3.   e.Logger.Fatal(err)
  4. }
  5. url2, err := url.Parse("http://localhost:8082")
  6. if err != nil {
  7.   e.Logger.Fatal(err)
  8. }

Step 2: Setup proxy middleware with upstream targets

In the following code snippet we are using round-robin load balancing technique. You may also use middleware.RandomBalancer.

  1. e.Use(middleware.Proxy(&middleware.RoundRobinBalancer{
  2.   Targets: []*middleware.ProxyTarget{
  3.     &middleware.ProxyTarget{
  4.       URL: url1,
  5.     },
  6.     &middleware.ProxyTarget{
  7.       URL: url2,
  8.     },
  9.   },
  10. }))

To setup proxy for a sub-route use Echo#Group().

  1. g := e.Group("/blog")
  2. g.Use(middleware.Proxy(...))

Step 3: Start upstream servers

  • cd upstream
  • go run server.go server1 :8081
  • go run server.go server2 :8082

Step 3: Start the proxy server

  1. go run server.go

Step 4: Browse to http://localhost:1323

You should see a webpage with HTTP request being served from “server 1” and WebSocket request from “server 2”.

  1. HTTP
  3. Hello from upstream server server1
  5. WebSocket
  7. Hello from upstream server server2!
  8. Hello from upstream server server2!
  9. Hello from upstream server server2!

Source Code

upstream/server.go

  1. package main
  3. import (
  4.     "fmt"
  5.     "net/http"
  6.     "os"
  7.     "time"
  9.     "github.com/labstack/echo"
  10.     "github.com/labstack/echo/middleware"
  11.     "golang.org/x/net/websocket"
  12. )
  14. var index = `
  15.     <!DOCTYPE html>
  16.     <html lang="en">
  17.     <head>
  18.         <meta charset="UTF-8">
  19.         <meta name="viewport" content="width=device-width, initial-scale=1.0">
  20.         <meta http-equiv="X-UA-Compatible" content="ie=edge">
  21.         <title>Upstream Server</title>
  22.         <style>
  23.             h1, p {
  24.                 font-weight: 300;
  25.             }
  26.         </style>
  27.     </head>
  28.     <body>
  29.         <h1>HTTP</h1>
  30.         <p>
  31.             Hello from upstream server %s
  32.         </p>
  33.         <h1>WebSocket</h1>
  34.         <p id="output"></p>
  35.         <script>
  36.             var ws = new WebSocket('ws://localhost:1323/ws')
  38.             ws.onmessage = function(evt) {
  39.                 var out = document.getElementById('output');
  40.                 out.innerHTML += evt.data + '<br>';
  41.             }
  42.         </script>
  43.     </body>
  44.     </html
  45. `
  47. func main() {
  48.     name := os.Args[1]
  49.     port := os.Args[2]
  50.     e := echo.New()
  51.     e.Use(middleware.Recover())
  52.     e.Use(middleware.Logger())
  53.     e.GET("/", func(c echo.Context) error {
  54.         return c.HTML(http.StatusOK, fmt.Sprintf(index, name))
  55.     })
  57.     // WebSocket handler
  58.     e.GET("/ws", func(c echo.Context) error {
  59.         websocket.Handler(func(ws *websocket.Conn) {
  60.             defer ws.Close()
  61.             for {
  62.                 // Write
  63.                 err := websocket.Message.Send(ws, fmt.Sprintf("Hello from upstream server %s!", name))
  64.                 if err != nil {
  65.                     e.Logger.Error(err)
  66.                 }
  67.                 time.Sleep(1 * time.Second)
  68.             }
  69.         }).ServeHTTP(c.Response(), c.Request())
  70.         return nil
  71.     })
  73.     e.Logger.Fatal(e.Start(port))
  74. }

server.go

  1. package main
  3. import (
  4.     "net/url"
  6.     "github.com/labstack/echo"
  7.     "github.com/labstack/echo/middleware"
  8. )
  10. func main() {
  11.     e := echo.New()
  12.     e.Use(middleware.Recover())
  13.     e.Use(middleware.Logger())
  15.     // Setup proxy
  16.     url1, err := url.Parse("http://localhost:8081")
  17.     if err != nil {
  18.         e.Logger.Fatal(err)
  19.     }
  20.     url2, err := url.Parse("http://localhost:8082")
  21.     if err != nil {
  22.         e.Logger.Fatal(err)
  23.     }
  24.     e.Use(middleware.Proxy(&middleware.RoundRobinBalancer{
  25.         Targets: []*middleware.ProxyTarget{
  26.             &middleware.ProxyTarget{
  27.                 URL: url1,
  28.             },
  29.             &middleware.ProxyTarget{
  30.                 URL: url2,
  31.             },
  32.         },
  33.     }))
  35.     e.Logger.Fatal(e.Start(":1323"))
  36. }

Maintainers