transfert TCP Golang

Transfert TCP Golang : implémentation des bases et des scénarios d'application

Le transfert TCP est une technologie couramment utilisée dans la transmission de données. Sa fonction principale est de transmettre les demandes de connexion TCP reçues par le serveur vers d'autres serveurs pour traitement, afin que le trafic de données puisse être dispersé. à plusieurs sur un serveur pour améliorer la capacité de charge du système. Cet article présentera en détail la base de mise en œuvre et les scénarios d'application du transfert Golang TCP.

1. Base de mise en œuvre

Avant de présenter la base de mise en œuvre du transfert TCP de Golang, présentons brièvement la programmation réseau TCP de Golang. Le langage Go fournit un ensemble de bibliothèques standard, qui contiennent des fonctions et des interfaces liées à la programmation réseau TCP. Grâce à ces fonctions et interfaces, la fonction de transfert TCP Golang peut être implémentée. Voici un exemple de code simple :

package main

import (
    "fmt"
    "net"
)

func main() {
    ln, err := net.Listen("tcp", ":8080")
    if err != nil {
        fmt.Println(err)
        return
    }
    defer ln.Close()

    for {
        conn, err := ln.Accept()
        if err != nil {
            fmt.Println(err)
            continue
        }
        go handleConnection(conn)
    }
}

func handleConnection(conn net.Conn) {
    defer conn.Close()

    buf := make([]byte, 4096)
    for {
        n, err := conn.Read(buf)
        if err != nil {
            fmt.Println(err)
            return
        }
        fmt.Println(string(buf[:n]))
    }
}

Le code ci-dessus crée un serveur TCP écoutant le port 8080 via la fonction net.Listen, reçoit la demande de connexion TCP via la fonction ln.Accept, puis permet à goroutine de traiter la connexion. Lorsqu'il y a des données dans la connexion Lors de la lecture, les données sont lues via la fonction conn.Read et sorties vers la console. Bien entendu, cela est loin d’être suffisant pour implémenter la fonction de transfert TCP. Nous verrons ci-dessous en détail comment implémenter la fonction de transfert TCP.

Le transfert TCP Golang peut être implémenté des deux manières suivantes :

Méthode 1 : transfert TCP d'origine

La mise en œuvre du transfert TCP d'origine est très simple, principalement grâce aux fonctions fournies par le package net, en utilisant net.ListenTCP avec ip spécifié La fonction crée un serveur TCP qui écoute l'adresse IP et le port, puis reçoit les demandes du client via la méthode AcceptTCP. Une fois la demande reçue, une nouvelle connexion TCP sera immédiatement établie, puis les données envoyées par le client seront transmises de manière transparente au serveur cible, réalisant ainsi le transfert des données TCP.

package main

import (
    "fmt"
    "io"
    "net"
)

func main() {
    listener, err := net.ListenTCP("tcp", &net.TCPAddr{
        IP:   net.ParseIP("0.0.0.0"),
        Port: 8888,
    })
    if err != nil {
        panic(err.Error())
    }
    defer listener.Close()

    targetTcpAddr, err := net.ResolveTCPAddr("tcp", "172.16.100.101:80")
    if err != nil {
        panic(err.Error())
    }

    for {
        clientConn, err := listener.AcceptTCP()
        if err != nil {
            fmt.Println(err)
            continue
        }
        go handleConnection(clientConn, targetTcpAddr)
    }
}

func handleConnection(clientConn *net.TCPConn, targetAddr *net.TCPAddr) {
    defer clientConn.Close()

    targetConn, err := net.DialTCP("tcp", nil, targetAddr)
    if err != nil {
        fmt.Println(err)
        return
    }
    defer targetConn.Close()

    io.Copy(targetConn, clientConn)
    io.Copy(clientConn, targetConn)
}

Méthode 2 : transfert TCP basé sur un proxy HTTP

Le proxy HTTP est un protocole de transmission réseau courant, qui peut transmettre la demande du client au serveur cible via le serveur proxy. Utiliser l'idée du proxy pour implémenter le transfert TCP consiste à encapsuler le paquet de données TCP dans une requête HTTP, à utiliser le serveur proxy HTTP pour transmettre la requête au serveur cible, puis à encapsuler les données renvoyées par le serveur cible dans une réponse HTTP et à renvoyer au client.

package main

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

func main() {
    http.HandleFunc("/", handleRequest)
    http.ListenAndServe(":8080", nil)
}

func handleRequest(w http.ResponseWriter, req *http.Request) {
    if req.Method != "CONNECT" {
        http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
        return
    }

    targetAddr := req.Host
    targetConn, err := net.Dial("tcp", targetAddr)
    if err != nil {
        fmt.Println(err)
        http.Error(w, "Internal server error", http.StatusInternalServerError)
        return
    }
    defer targetConn.Close()

    w.WriteHeader(http.StatusOK)
    hijacker, ok := w.(http.Hijacker)
    if !ok {
        http.Error(w, "Internal server error", http.StatusInternalServerError)
        return
    }

    clientConn, _, err := hijacker.Hijack()
    if err != nil {
        return
    }
    defer clientConn.Close()

    go func() {
        io.Copy(targetConn, clientConn)
    }()
    io.Copy(clientConn, targetConn)
}

Le code ci-dessus implémente un simple serveur proxy HTTP. Lorsque le client se connecte au serveur proxy, le serveur proxy analysera l'adresse du serveur cible à partir de l'en-tête de la requête HTTP, établira une connexion TCP avec le serveur cible, puis établir une connexion avec le client. La connexion TCP transmet la requête HTTP du client au serveur cible. Lorsque le serveur cible renvoie des données, il renvoie également les données au client via une réponse HTTP.

2. Scénarios d'application

Le transfert TCP est une technologie réseau très pratique et est souvent utilisé dans l'équilibrage de charge, la haute disponibilité, l'accélération des données et d'autres scénarios. Ce qui suit présentera plusieurs scénarios de transfert TCP dans des applications pratiques.

Scénario 1 : Équilibrage de charge HTTP

Dans un site Web ou une application, lorsque le volume de requêtes des utilisateurs devient important, un serveur ne peut souvent pas résister à une pression aussi importante. À l'heure actuelle, la technologie de transfert TCP doit être utilisée pour distribuer les requêtes. sur plusieurs serveurs pour être traités sur un serveur afin d'équilibrer la charge. Le protocole HTTP est basé sur le protocole TCP, vous pouvez donc envisager d'utiliser le transfert TCP en conjonction avec le protocole HTTP et l'implémenter à l'aide de l'équilibrage de charge HTTP.

Scénario 2 : Service TCP hautement disponible

Dans un système distribué, il est souvent nécessaire de démarrer des programmes qui fournissent le même service sur plusieurs serveurs en même temps pour atteindre une haute disponibilité. Si le protocole TCP traditionnel est utilisé, les adresses IP et les numéros de port de tous les serveurs doivent être codés en dur dans le programme client. Cependant, lorsqu'un serveur tombe en panne, une nouvelle machine doit être remise en ligne et le logiciel doit le faire. être redéployé. Pour une application à grande échelle, il est très difficile. Grâce à la technologie de transfert TCP, vous pouvez obtenir des services TCP transparents et hautement disponibles. Il vous suffit de connecter le client TCP au serveur de transfert. Le serveur de transfert transmet la demande de connexion à un serveur disponible et renvoie les données renvoyées par le serveur au client. . Obtenez une haute disponibilité transparente.

Scénario 3 : Transmission de données accélérée

La transmission TCP est effectuée par segments. L'envoi de données par segments peut augmenter considérablement le taux de transmission des données. Cependant, la taille des segments de données TCP est automatiquement contrôlée par la pile de protocoles sous-jacente, qui ne peut souvent pas répondre aux besoins des utilisateurs. Grâce à la technologie de transfert TCP, vous pouvez personnaliser la taille du segment TCP et transférer les données de manière transparente vers le serveur cible après la segmentation, augmentant ainsi le taux de transmission des données.

3. Résumé

Cet article présente en détail la base de mise en œuvre et les scénarios d'application du transfert Golang TCP. Le transfert Golang TCP est une technologie réseau très pratique qui est souvent utilisée dans l'équilibrage de charge, la haute disponibilité, l'accélération des données et d'autres scénarios. En comprenant le transfert TCP, nous pouvons mieux comprendre le mécanisme de transmission de données dans le réseau et fournir plus d'idées et de solutions pour le développement de nos applications et de nos systèmes.

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!