transfert de proxy Golang

Avec le développement rapide d'Internet, de plus en plus d'applications doivent obtenir des données de différents serveurs, et ces demandes de données peuvent devoir passer par plusieurs serveurs intermédiaires. Par conséquent, lors du développement d'applications, il est souvent nécessaire d'utiliser un proxy pour l'envoi. les requêtes au serveur distant jusqu'à ce que les données requises soient obtenues.

Cet article expliquera comment utiliser le langage Go pour créer un serveur proxy simple qui transmet les requêtes des clients à un autre serveur et renvoie une réponse. Les serveurs proxy peuvent gérer efficacement plusieurs demandes de clients, réduisant ainsi la pression sur les serveurs back-end et améliorant les performances et l'évolutivité des applications.

Vue d'ensemble

Dans cet article, nous apprendrons comment créer un serveur proxy basé sur Golang qui envoie les requêtes entrantes aux clients et transmet les réponses au serveur cible. Nous utiliserons l'implémentation de la bibliothèque standard net/http, qui fournit un moyen simple et efficace de gérer les requêtes et les réponses HTTP.

Préparation

Avant de commencer à écrire le serveur proxy, nous devons d'abord installer l'environnement Go. Nous pouvons télécharger et installer Go depuis le site officiel https://golang.org/.

Comment fonctionne le serveur proxy

Dans le serveur proxy, nous devons utiliser le package net/http du langage Go pour écrire du code permettant d'intercepter les requêtes des clients. Ce package fournit de nombreuses fonctions et structures utiles pour le traitement et le décodage des requêtes et réponses HTTP. Dans notre serveur proxy, nous utiliserons la fonction http.Handle() pour intercepter les requêtes des clients et les rediriger vers le serveur distant. Nous utilisons ensuite la structure http.Client() pour envoyer une requête au serveur distant et renvoyer la réponse au client.

Le pseudocode suivant montre le fonctionnement d'un serveur proxy :

Lorsqu'un client fait une requête :

• Le client se connecte au serveur proxy et envoie une requête HTTP.
• Le serveur proxy intercepte la demande du client et analyse l'en-tête et le corps de la demande.
• Le serveur proxy vérifie si le serveur cible défini existe et renvoie une erreur s'il n'existe pas.
• Le serveur proxy crée une nouvelle requête HTTP, y copie la requête du client et l'envoie au serveur cible.
• Le serveur cible reçoit la requête du serveur proxy et traite la requête.
• Le serveur cible crée et renvoie une réponse HTTP.
• Le serveur proxy reçoit la réponse du serveur cible et renvoie les données de réponse au client.

Écriture du serveur proxy

Commençons maintenant à écrire l'implémentation du serveur proxy. Nous devons créer un serveur HTTP et définir son adresse d'écoute, son port et le temps d'attente du client. Nous devons également ajouter des règles de routage afin que différents gestionnaires soient sélectionnés en fonction des demandes des clients. Dans notre cas, nous utiliserons la fonction http.Handle() pour ajouter une route, et lorsque l'URL demandée par le client est /proxy, nous redirigerons la requête vers le serveur spécifié. Voici l'extrait de code :

package main

import (
    "log"
    "net/http"
)

func main() {
    // 创建 http 服务器
    proxy := &Proxy{}

    // 添加路由规则
    http.Handle("/proxy", proxy)

    // 监听地址及端口
    log.Fatal(http.ListenAndServe(":8080", nil))
}

// 代理服务器结构体
type Proxy struct {
}

// 实现 http.Handler 接口的 ServeHTTP 方法
func (p *Proxy) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    // 处理代理请求
}

Dans le code ci-dessus, nous avons créé une structure nommée Proxy et implémenté la méthode ServeHTTP() dans l'interface http.Handler. La méthode ServeHTTP() reçoit deux paramètres : les objets http.ResponseWriter et *http.Request. Le premier représente les données renvoyées par le serveur au client, et le second représente l'en-tête de la requête HTTP et le corps de la requête demandés par le client.

Nous avons ensuite configuré en ajoutant une règle de routage à définir lorsqu'un client demande /proxy dans l'URL, la demande sera redirigée vers notre gestionnaire.

Ensuite, nous devons écrire le code pour gérer les demandes de proxy. Nous devons vérifier que le serveur cible existe et que les données demandées par le client sont correctes. Ici, nous pouvons utiliser la fonction http.NewRequest() pour créer un nouvel objet de requête HTTP. Nous utilisons ensuite la méthode Do() dans http.Client() pour envoyer la requête et attendre la réponse. Enfin, nous renvoyons la réponse au client.

Ce qui suit est le code complet :

package main

import (

"io/ioutil"
"log"
"net/http"

)

func main() {

// 创建 http 服务器
proxy := &Proxy{}

// 添加路由规则
http.Handle("/proxy", proxy)

// 监听地址及端口
log.Fatal(http.ListenAndServe(":8080", nil))

}

// Structure du serveur proxy
type Proxy struct {
}

// Implémentez la méthode ServeHTTP de l'interface net/http.Handler
func (p Proxy) ServeHTTP(w http.ResponseWriter, r http.Request) {

// 检查目标服务器是否存在
targetUrl := "http://localhost:8888"
if len(targetUrl) == 0 {
    w.WriteHeader(http.StatusBadGateway)
    return
}

// 检查客户端请求的数据是否正确
if r.Method != "GET" {
    w.WriteHeader(http.StatusMethodNotAllowed)
    return
}

// 创建一个新的 HTTP 请求对象
req, err := http.NewRequest("GET", targetUrl, nil)
if err != nil {
    log.Fatal("请求创建失败", err)
}

// 使用 http.Client() 发送请求
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
    log.Fatal("请求发送失败", err)
}

defer resp.Body.Close()

// 读取响应的数据
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
    log.Fatal("读取响应数据失败", err)
}

// 将响应数据返回给客户端
w.Write(body)

}

运行代理服务器

现在我们已经完成了代理服务器的编写，请使用以下命令在命令行中运行该服务器，其中 targetUrl 是我们要转发的目标服务器的 IP 地址和端口。

$ go run main.go -targetUrl=http://localhost:8888

接下来，在浏览器中输入以下 URL，将客户端请求发送到代理服务器中：

http://localhost:8080/proxy

此时，代理服务器将转发该请求到目标服务器，并等待响应。当目标服务器返回响应时，代理服务器将响应数据返回给客户端。我们可以在代码中设置超时时间来控制客户端请求的等待时间，以及设置日志记录来实时查看代理服务器的运行情况。

结论

本文介绍了如何使用 Go 语言构建代理服务器，并演示了代理服务器的操作流程。虽然我们实现的代理服务器比较简单，但可以轻松扩展它来处理更复杂的请求。如果您有进一步的需求，可以使用类似的方法来扩展该服务器，以更好地满足您的需求。

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!