Golang en avant http

Avec le développement rapide et la popularité d'Internet, l'importance des applications réseau continue de croître. Et tout cela est indissociable du protocole HTTP, car c’est l’une des pierres angulaires du World Wide Web. Dans le processus de développement d'applications réseau, nous rencontrons souvent des situations où le transfert de requêtes HTTP est requis. Cet article explique comment utiliser Golang pour implémenter le transfert de requêtes HTTP.

1. Le principe du transfert de requêtes HTTP

Le transfert de requêtes HTTP, comme son nom l'indique, consiste à transmettre certaines requêtes client à d'autres serveurs pour traitement. Ce processus nécessite plusieurs interactions de protocole HTTP, vous devez donc comprendre le principe du transfert de requête HTTP.

Le principe du transfert de requête HTTP se décompose principalement en les étapes suivantes :

1. Le client envoie une requête HTTP au serveur de transfert.

2. Une fois que le serveur de transfert a reçu la demande, il détermine si la demande doit être transmise à d'autres serveurs pour être traitée selon certaines règles. Si tel est le cas, passez à la troisième étape, sinon il renvoie directement une réponse au client.

3. Le serveur de transfert transmet la requête au serveur cible. Après plusieurs interactions du protocole HTTP (y compris les requêtes et les réponses), le serveur cible renvoie finalement le résultat de la réponse au serveur de transfert.

4. Le serveur de transfert renvoie le résultat de la réponse au client.

2. Utilisez Golang pour implémenter le transfert de requêtes HTTP

Dans Golang, vous pouvez utiliser le type ReverseProxy fourni par le package net/http pour implémenter le transfert de requêtes HTTP. ReverseProxy est un type de structure qui peut transmettre par proxy un ensemble de requêtes HTTP à un autre serveur et renvoyer les résultats de réponse correspondants. La méthode principale de ReverseProxy est la méthode ServeHTTP, qui accepte deux paramètres, l'un est le type Writer du résultat de la réponse et l'autre est le type de pointeur de la requête HTTP.

Le code permettant d'utiliser Golang pour implémenter le transfert de requêtes HTTP est le suivant :

package main

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

func main() {
    targetUrl, _ := url.Parse("http://www.example.com/")
    proxy := httputil.NewSingleHostReverseProxy(targetUrl)
    http.ListenAndServe(":8080", proxy)
}

Le code ci-dessus définit d'abord une URL cible et l'analyse dans un objet URL ; utilise ensuite la méthode NewSingleHostReverseProxy pour créer une instance ReverseProxy et transmet l'URL cible. en paramètre ; Enfin, utilisez la méthode ListenAndServe pour démarrer un serveur HTTP et transmettez l'instance ReverseProxy créée ci-dessus.

3. Configurations facultatives de ReverseProxy

En plus d'utiliser la configuration par défaut, ReverseProxy prend également en charge certaines configurations facultatives, telles que :

1 Modifier le corps de la demande ou le corps de la réponse : ReverseProxy fournit la fonction de modifier le corps de la demande ou. corps de la réponse. Ceci peut être réalisé en modifiant les méthodes Director et ModifyResponse.

2. Modifier l'URL demandée : Ceci peut être réalisé en modifiant la méthode Director.

3. Gestion personnalisée des erreurs : une gestion personnalisée des erreurs peut être implémentée en modifiant le champ ErrorLog.

Voici quelques exemples de codes :

package main

import (
    "log"
    "net/http"
    "net/http/httputil"
    "net/url"
)

func main() {
    targetUrl, _ := url.Parse("http://www.example.com/")
    proxy := httputil.NewSingleHostReverseProxy(targetUrl)

    // 修改请求体或者响应体
    proxy.Director = func(req *http.Request) {
        req.Header.Set("Content-Type", "application/json")
    }
    proxy.ModifyResponse = func(response *http.Response) error {
        response.Header.Set("Content-Type", "application/json")
        return nil
    }

    // 修改请求的URL
    proxy.Director = func(req *http.Request) {
        req.Host = "www.anotherexample.com"
        req.URL.Scheme = "https"
    }

    // 自定义错误处理
    logFile, _ := os.OpenFile("access.log", os.O_WRONLY|os.O_CREATE, 0755)
    errorLog := log.New(logFile, "proxy error: ", log.LstdFlags)
    proxy.ErrorLog = errorLog

    http.ListenAndServe(":8080", proxy)
}

4. Cas pratique de transfert de requêtes HTTP

Un scénario d'application de transfert de requêtes HTTP courant est l'équilibrage de charge. L'équilibrage de charge est une technologie importante dans les systèmes informatiques distribués. Son objectif est de traiter les demandes via plusieurs serveurs pour obtenir une haute disponibilité et un débit élevé des services. Les stratégies courantes d'équilibrage de charge incluent le round robin, le round robin pondéré, le nombre minimum de connexions, etc.

Ce qui suit est un équilibreur de charge simple implémenté à l'aide de Golang :

package main

import (
    "fmt"
    "log"
    "math/rand"
    "net/http"
    "net/http/httputil"
    "net/url"
    "strconv"
    "strings"
    "time"
)

func main() {
    targetUrls := []string{"http://localhost:8001/", "http://localhost:8002/", "http://localhost:8003/"}

    // 随机数生成器
    rand.Seed(time.Now().Unix())

    balancedHandler := func(rw http.ResponseWriter, req *http.Request) {
        // 随机选择一个目标URL
        targetUrl := targetUrls[rand.Intn(len(targetUrls))]

        // 创建ReverseProxy
        target, _ := url.Parse(targetUrl)
        proxy := httputil.NewSingleHostReverseProxy(target)

        // 修改请求的Host
        req.URL.Host = target.Host
        req.URL.Scheme = target.Scheme
        req.Header.Set("X-Forwarded-Host", req.Header.Get("Host"))
        req.Host = target.Host

        // 记录日志
        log.Printf("%s %s %s
", req.RemoteAddr, req.Method, req.URL)
        proxy.ServeHTTP(rw, req)
    }

    http.HandleFunc("/", balancedHandler)
    if err := http.ListenAndServe(":8080", nil); err != nil {
        fmt.Println(err)
    }
}

func getBalance(targetUrls []string) func() string {
    var last int32 = -1
    return func() string {
        if len(targetUrls) == 0 {
            return ""
        }
        if len(targetUrls) == 1 {
            return targetUrls[0]
        }
        next := last
        for next == last {
            next = rand.Int31n(int32(len(targetUrls)))
        }
        last = next
        return targetUrls[last]
    }
}

Le code ci-dessus définit d'abord le tableau d'URL cible, puis utilise le générateur de nombres aléatoires fourni par le package rand pour sélectionner aléatoirement une URL cible, puis crée une instance ReverseProxy et ; utilise La méthode Director modifie l'hôte et d'autres paramètres de la requête ; enregistre enfin le journal de la requête et appelle la méthode ServeHTTP de ReverseProxy pour transmettre la requête.

5. Résumé

Grâce à l'introduction de cet article, vous avez une compréhension préliminaire des principes de base du transfert de requêtes HTTP et de sa mise en œuvre dans Golang. Dans le même temps, nous avons donné un exemple simple d’équilibrage de charge, dans l’espoir d’être utile à votre travail de développement.

Pour mettre en œuvre un programme de transfert de requêtes HTTP efficace, flexible et robuste, de nombreux aspects doivent être pris en compte, notamment le contrôle de flux, la gestion des erreurs, la sécurité, etc. Nous pouvons répondre à différents besoins en utilisant les configurations facultatives fournies par ReverseProxy.

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!