Cara melaksanakan proksi terbalik, pengimbangan beban dan caching di Golang

Dalam beberapa tahun kebelakangan ini, Golang telah menjadi bahasa pengaturcaraan yang telah menarik perhatian lebih ramai pembangun kerana kecekapan, kestabilan dan penyelenggaraan yang mudah. Dalam pembangunan web tradisional, kami biasanya menggunakan Nginx sebagai pelayan proksi terbalik, yang boleh melaksanakan banyak fungsi, seperti pengimbangan beban, proksi terbalik, caching, keselamatan, dll.

Namun, dengan pembangunan dan penambahbaikan berterusan Golang, semakin ramai orang mula meneroka sama ada boleh membina perkhidmatan web berprestasi tinggi tanpa menggunakan Nginx. Artikel ini akan memperkenalkan cara melaksanakan proksi terbalik, pengimbangan beban dan caching dalam Golang, dan cara menggunakan Golang untuk mencapai semua ciri ini tanpa menggunakan Nginx.

1. Proksi songsang

Proksi songsang biasanya digunakan untuk membuat beberapa perubahan pada permintaan atau menambah beberapa pemprosesan tambahan sebelum menghantar permintaan kepada pelayan bahagian belakang. Jika kita menggunakan Nginx, kita boleh melaksanakan proksi terbalik dengan mudah, tetapi di Golang, bagaimana kita harus melakukannya?

Dengan menggunakan pakej "net/http/httputil" dalam perpustakaan standard, kami boleh melaksanakan proksi terbalik dengan sangat mudah. Kod berikut menunjukkan cara untuk memproksi permintaan ke port tempatan 80:

package main

import (
    "fmt"
    "net/http"
    "net/http/httputil"
)

func main() {
    localPort := ":80"
    proxyPort := ":8080" 
    proxy := httputil.NewSingleHostReverseProxy(&url.URL{
        Scheme: "http",
        Host:   "localhost" + proxyPort,
    })
    http.Handle("/", proxy)
    fmt.Println("Server started on port" + localPort)
    http.ListenAndServe(localPort, nil)
}

Kita dapat melihat bahawa dalam kod di atas, kita membuat instantiate proksi terbalik melalui proksi fungsi httputil.NewSingleHostReverseProxy() dan menetapkannya untuk mengendalikan semua permintaan secara lalai ("/"). Seterusnya, kami hanya perlu memanggil http.ListenAndServe() untuk memulakan perkhidmatan kami.

2. Pengimbangan Beban

Pengimbangan beban boleh mengedarkan permintaan kepada berbilang pelayan untuk meningkatkan prestasi dan kebolehskalaan sistem. Dalam Nginx, pengimbangan beban boleh dicapai dengan mudah melalui konfigurasi, jadi bagaimana kita boleh mencapainya di Golang?

Kita boleh menggunakan struktur Pengimbang dalam pakej github.com/valyala/fasthttp untuk melaksanakan fungsi pengimbangan beban. Seperti yang ditunjukkan di bawah:

package main

import (
    "fmt"

    "github.com/valyala/fasthttp"
)

func main() {
    servers := []string{"http://localhost:8080", "http://localhost:8081"}

    balancer := &fasthttp.HostBalancer{Hosts: servers}

    handler := func(ctx *fasthttp.RequestCtx) {
        realServerAddr := balancer.PickServerAddr()

        proxy := &fasthttp.HostClient{
            Addr: realServerAddr,
        }

        proxy.Do(&ctx.Request, &ctx.Response)
    }

    fmt.Println("Server started on port 80")
    fasthttp.ListenAndServe(":80", handler)
}

Kita boleh mentakrifkan senarai pelayan (pelayan) dahulu dan kemudian membungkusnya dengan struktur HostBalancer supaya kita boleh memilih pelayan dengan mudah. Seterusnya, kami mentakrifkan pengendali permintaan HTTP yang memilih pelayan daripada pengimbang beban dan menghantar permintaan kepada pelayan tersebut. Akhir sekali, kami memulakan perkhidmatan kami menggunakan fungsi fasthttp.ListenAndServe().

3. Caching

Caching boleh mempercepatkan masa tindak balas dan mengurangkan penggunaan sumber pelayan Dalam Nginx, caching adalah fungsi yang sangat biasa, jadi bagaimana untuk melaksanakannya di Golang?

Kami boleh menggunakan "http-cache" dalam pustaka standard Golang, iaitu cache HTTP berasaskan memori yang digunakan untuk menyimpan data respons permintaan. Kod berikut menunjukkan cara menggunakan http-cache untuk melaksanakan caching:

package main

import (
    "fmt"
    "net/http"
    "net/http/httptest"
    "net/http/httputil"
    "time"

    "github.com/gregjones/httpcache"
    "github.com/gregjones/httpcache/diskcache"
    "github.com/gregjones/httpcache/memory"
)

func main() {
    //创建一个HTTP缓存
    inMemoryCache := memory.NewTransport()

    //创建一个磁盘缓存，它将缓存存储在/tmp目录下，有效期为1小时
    diskCache := diskcache.New("/tmp", time.Hour)

    //创建一个缓存客户端，它将首先尝试从内存缓存中获取结果，然后再尝试从磁盘缓存中获取
    cachingTransport := httpcache.NewTransport(inMemoryCache, diskCache)

    //创建一个反向代理，它会代理到http://localhost:8080，使用缓存客户端
    proxy := httputil.NewSingleHostReverseProxy(&url.URL{
        Scheme: "http",
        Host:   "localhost:8080",
    })
    proxy.Transport = cachingTransport

    //使用缓存的反向代理处理所有请求
    http.Handle("/", proxy)

    //开启我们的服务
    server := httptest.NewServer(http.DefaultServeMux)
    fmt.Println("Server started on address:", server.URL)
    server.Close()
}

Dalam kod di atas, kami mentakrifkan dua cache: satu ialah cache memori dan satu ialah cache cakera, dan kemudian kami mencipta Pelanggan caching (cachingTransport), digunakan untuk mendapatkan respons daripada cache memori dan cache cakera. Seterusnya, kami mentakrifkan proksi terbalik (proksi) dan menyerahkannya kepada klien cache supaya kami boleh menggunakan cache semasa proses proksi. Akhir sekali, kami menggunakan fungsi http.ListenAndServe() untuk memulakan perkhidmatan kami.

Ringkasan

Kini, anda telah mempelajari cara melaksanakan proksi terbalik, pengimbangan beban dan caching dalam Golang Teknologi ini biasanya dilaksanakan menggunakan Nginx. Walau bagaimanapun, fungsi ini juga boleh dilaksanakan dengan mudah menggunakan Golang. Ini bukan sahaja menjadikan kod anda lebih mudah dan lebih mudah untuk diselenggara, ia juga meningkatkan prestasi dan responsif sistem anda.

Atas ialah kandungan terperinci Cara melaksanakan proksi terbalik, pengimbangan beban dan caching di Golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!