Comment implémenter le proxy inverse, l'équilibrage de charge et la mise en cache dans Golang

Ces dernières années, Golang est devenu un langage de programmation qui a attiré beaucoup d'attention. Il est apprécié par de plus en plus de développeurs en raison de son efficacité, de sa stabilité et de sa facilité de maintenance. Dans le développement Web traditionnel, nous utilisons généralement Nginx comme serveur proxy inverse, qui peut implémenter de nombreuses fonctions, telles que l'équilibrage de charge, le proxy inverse, la mise en cache, la sécurité, etc.

Cependant, avec le développement et l'amélioration continus de Golang, de plus en plus de personnes commencent à se demander s'il est possible de créer des services Web hautes performances sans utiliser Nginx. Cet article expliquera comment implémenter le proxy inverse, l'équilibrage de charge et la mise en cache dans Golang, et comment utiliser Golang pour obtenir toutes ces fonctionnalités sans utiliser Nginx.

1. Proxy inverse

Le proxy inverse est généralement utilisé pour apporter des modifications à la requête ou ajouter un traitement supplémentaire avant de transmettre la requête au serveur backend. Si nous utilisons Nginx, nous pouvons facilement implémenter un proxy inverse, mais dans Golang, comment devons-nous procéder ?

En utilisant le package "net/http/httputil" dans la bibliothèque standard, nous pouvons implémenter un proxy inverse très simplement. Le code suivant montre comment proxy la requête vers le port local 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)
}

Nous pouvons voir que dans le code ci-dessus, nous instancions un proxy inverse (proxy) via la fonction httputil.NewSingleHostReverseProxy(), et le définissons pour gérer tout requêtes par défaut ("/") Ensuite, il nous suffit d'appeler http.ListenAndServe() pour démarrer notre service.

2. Équilibrage de charge

L'équilibrage de charge peut distribuer les requêtes à plusieurs serveurs pour améliorer les performances et l'évolutivité du système. Dans Nginx, l'équilibrage de charge peut être facilement réalisé via la configuration, alors comment pouvons-nous y parvenir dans Golang ?

Nous pouvons utiliser la structure Balancer dans le package github.com/valyala/fasthttp pour implémenter la fonction d'équilibrage de charge. Comme indiqué ci-dessous :

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)
}

Nous pouvons d'abord définir une liste de serveurs (serveurs), puis l'envelopper avec une structure HostBalancer afin de pouvoir sélectionner facilement un serveur. Ensuite, nous définissons un gestionnaire de requêtes HTTP qui sélectionne un serveur dans l'équilibreur de charge et envoie la requête à ce serveur. Enfin, nous démarrons notre service en utilisant la fonction fasthttp.ListenAndServe().

3. Mise en cache

La mise en cache peut accélérer le temps de réponse et réduire la consommation des ressources du serveur. Dans Nginx, la mise en cache est une fonction très courante, alors comment l'implémenter dans Golang ?

Nous pouvons utiliser "http-cache" dans la bibliothèque standard Golang, qui est un cache HTTP basé sur la mémoire utilisé pour stocker les données de réponse de la requête. Le code suivant montre comment utiliser http-cache pour implémenter la mise en cache :

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()
}

Dans le code ci-dessus, nous définissons deux caches : l'un est le cache mémoire et l'autre est le cache disque, puis nous créons un client de mise en cache (cachingTransport) , utilisé pour obtenir des réponses du cache mémoire et du cache disque. Ensuite, nous définissons un proxy inverse (proxy) et le transmettons au client de cache afin que nous puissions utiliser le cache pendant le processus de proxy. Enfin, nous utilisons la fonction http.ListenAndServe() pour démarrer notre service.

Résumé

Maintenant, vous avez appris comment implémenter le proxy inverse, l'équilibrage de charge et la mise en cache dans Golang. Ces technologies sont généralement implémentées à l'aide de Nginx. Cependant, ces fonctions peuvent également être facilement implémentées à l’aide de Golang. Non seulement cela rend votre code plus simple et plus facile à maintenir, mais cela améliore également les performances et la réactivité de votre système.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!