redirection de nom de domaine golang

Golang est un langage de programmation puissant couramment utilisé dans le développement Web, la programmation réseau et d'autres domaines. En programmation réseau, la redirection de nom de domaine est une fonction importante. Cet article explique comment utiliser Golang pour implémenter le transfert de nom de domaine.

1. Résolution du nom de domaine

Avant de transférer le nom de domaine, nous devons d'abord effectuer une résolution du nom de domaine. La résolution de noms de domaine fait référence au processus de conversion des noms de domaine en adresses IP. Golang fournit le package net, qui contient des fonctions liées à la résolution DNS. Voici un exemple simple de résolution de nom de domaine :

package main

import (
    "fmt"
    "net"
)

func main() {
    ips, err := net.LookupIP("www.baidu.com")
    if err != nil {
        fmt.Println("域名解析失败：", err)
        return
    }

    for _, ip := range ips {
        fmt.Println(ip.String())
    }
}

L'exécution du code ci-dessus affichera l'adresse IP de Baidu. Il est à noter que la résolution de nom de domaine nécessitant un accès au serveur DNS, il faut s'assurer que la connexion réseau est normale.

2. Redirection HTTP de base

Lors du transfert de noms de domaine, nous devons mapper le nom de domaine à une adresse IP, puis transmettre la demande à l'adresse IP. Ceci peut être réalisé avec un simple transfert HTTP. Voici un exemple de redirecteur HTTP très basique :

package main

import (
    "log"
    "net/http"
)

func main() {
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        log.Printf("收到请求：%v
", r.URL)

        // 创建并发送请求
        resp, err := http.Get("http://127.0.0.1:8080" + r.URL.Path)
        if err != nil {
            log.Printf("请求失败：%v
", err)
            w.WriteHeader(http.StatusInternalServerError)
            w.Write([]byte(err.Error()))
            return
        }
        defer resp.Body.Close()

        // 复制响应头
        for k, v := range resp.Header {
            w.Header().Set(k, v[0])
        }

        // 发送响应体
        w.WriteHeader(resp.StatusCode)
        _, err = io.Copy(w, resp.Body)
        if err != nil {
            log.Printf("响应失败：%v
", err)
        }
    })

    log.Println("开始监听：127.0.0.1:80")
    err := http.ListenAndServe(":80", nil)
    if err != nil {
        log.Fatal("监听失败：", err)
    }
}

Le code ci-dessus transmettra toutes les requêtes au port local 8080. Il convient de noter que ce redirecteur est très simple et ne peut pas gérer les requêtes HTTP complexes. Si vous devez gérer des requêtes plus complexes, vous pouvez utiliser une bibliothèque HTTP tierce, telle que Gin ou Echo.

3. Redirection dynamique de nom de domaine

Dans l'exemple ci-dessus, nous transmettons toutes les demandes vers la même adresse IP. Voyons maintenant comment mapper plusieurs noms de domaine à différentes adresses IP. Ceci peut être réalisé via un fichier de configuration. Voici un exemple simple de fichier de configuration :

www.example.com=192.168.0.1
api.example.com=192.168.0.2

Nous pouvons lire ce fichier de configuration au démarrage du programme et enregistrer ces relations de mappage de nom de domaine et d'adresse IP dans une carte. Ensuite, lorsqu'une demande est reçue, l'adresse IP correspondante est trouvée en fonction du nom de domaine demandé et la demande est transmise à l'adresse IP. Voici un exemple :

package main

import (
    "bufio"
    "io"
    "log"
    "net"
    "net/http"
    "os"
    "strings"
    "sync"
)

var mu sync.RWMutex
var addrMap = make(map[string]string)

func main() {
    // 读取配置文件
    f, err := os.Open("config.txt")
    if err != nil {
        log.Fatal("读取配置文件失败：", err)
    }
    defer f.Close()

    reader := bufio.NewReader(f)
    for {
        line, _, err := reader.ReadLine()
        if err == io.EOF {
            break
        } else if err != nil {
            log.Fatal("读取配置文件失败：", err)
        }
        parts := strings.Split(string(line), "=")
        if len(parts) != 2 {
            continue
        }
        addrMap[parts[0]] = parts[1]
    }

    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        log.Printf("收到请求：%v
", r.URL)
        var addr string

        // 解析域名
        host := strings.Split(r.Host, ":")[0]
        mu.RLock()
        addr, ok := addrMap[host]
        mu.RUnlock()
        if !ok {
            http.NotFound(w, r)
            return
        }

        // 创建并发送请求
        resp, err := http.Get("http://" + addr + r.URL.Path)
        if err != nil {
            log.Printf("请求失败：%v
", err)
            w.WriteHeader(http.StatusInternalServerError)
            w.Write([]byte(err.Error()))
            return
        }
        defer resp.Body.Close()

        // 复制响应头
        for k, v := range resp.Header {
            w.Header().Set(k, v[0])
        }

        // 发送响应体
        w.WriteHeader(resp.StatusCode)
        _, err = io.Copy(w, resp.Body)
        if err != nil {
            log.Printf("响应失败：%v
", err)
        }
    })

    log.Println("开始监听：127.0.0.1:80")
    err = http.ListenAndServe(":80", nil)
    if err != nil {
        log.Fatal("监听失败：", err)
    }
}

Dans l'exemple ci-dessus, nous utilisons une carte pour enregistrer la relation de mappage entre les noms de domaine et les adresses IP. Lors de la réception d'une demande, nous trouverons l'adresse IP correspondante à partir de cette carte et transmettrons la demande à l'adresse IP. Étant donné que plusieurs requêtes peuvent accéder à cette relation de mappage en même temps, un verrou en lecture-écriture doit être utilisé pour protéger cette relation.

Résumé

Dans cet article, nous avons présenté comment utiliser Golang pour mettre en œuvre le transfert de nom de domaine. Nous avons d'abord présenté comment effectuer la résolution de nom de domaine, puis avons introduit le transfert HTTP simple et le transfert de nom de domaine dynamique. Il convient de noter que les exemples de cet article ne représentent que les implémentations les plus élémentaires. Dans le développement réel, davantage de facteurs doivent être pris en compte, tels que la mise en cache, l'équilibrage de charge, etc.

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!