paramètres nginx golang

Dans des scénarios d'application réels, l'utilisation de la combinaison de Nginx et Golang peut fournir des services Web avec de bonnes performances et une haute disponibilité. Cet article explique comment inverser les services proxy Golang via Nginx et comment utiliser Nginx pour l'équilibrage de charge dans Golang.

1. Service Golang de proxy inverse Nginx

Le proxy inverse est une architecture de serveur courante qui peut améliorer les performances et la fiabilité. Il fonctionne en envoyant une requête du client à un serveur proxy inverse, qui transmet ensuite la requête au serveur réel du cluster de serveurs et renvoie la réponse au client. Le proxy inverse Nginx est une excellente solution qui est non seulement très performante, mais peut facilement gérer des milliers de connexions simultanées.

Dans les applications pratiques, il existe deux méthodes principales de proxy inverse : l'une est un hôte virtuel basé sur le nom de domaine et l'autre est basée sur le chemin de l'URL.

1. Proxy inverse basé sur un nom de domaine

Supposons que votre nom de domaine soit example.com et qu'il y ait deux sous-domaines sous ce nom de domaine, l'un est blog.example.com et l'autre est api.example.com. Vous souhaitez que les deux sous-domaines pointent vers des serveurs différents. Ensuite, votre Nginx peut être configuré comme ceci :

server {
    server_name blog.example.com;
    location / {
         proxy_pass http://your.blog.server;
    }
}

server {
    server_name api.example.com;
    location / {
         proxy_pass http://your.api.server;
    }
}

2. Proxy inverse basé sur une URL

Supposons que vous souhaitiez transmettre les demandes de /blog et /api à différents serveurs pour traitement. Ensuite, votre Nginx peut être configuré comme ceci :

location /blog/ {
    proxy_pass http://your.blog.server;
}

location /api/ {
    proxy_pass http://your.api.server;
}

De cette façon, lorsqu'un client demande du contenu sur example.com/blog/, Nginx transmettra la demande à votre.blog.server au lieu de renvoyer le contenu local.

2. Golang utilise Nginx pour l'équilibrage de charge

1. Configuration Nginx

Avant d'utiliser le client Golang et Nginx pour l'équilibrage de charge, vous devez installer Nginx et le configurer.

La commande pour installer Nginx sur Ubuntu est la suivante :

sudo apt-get update 
sudo apt-get install nginx

Une fois l'installation terminée, ajoutez le contenu suivant dans le fichier de configuration :

events {
    worker_connections  1024;
}

http {
    upstream your_go_server {
        server 127.0.0.1:8080;
        server 127.0.0.1:8081;
    }

    server {
        listen 80;
        server_name localhost;
        location / {
            proxy_pass http://your_go_server;
        }
    }
}

Le module en amont définit ici le serveur dont la charge est équilibrée, et plusieurs serveurs peuvent être configuré pour une charge équilibrée. Le module serveur définit le port à charge équilibrée Nginx. Le chemin / dans le module de localisation indique que Nginx transmettra toutes les requêtes.

2. Code client Golang

Pour équilibrer la charge, vous devez utiliser une bibliothèque client HTTP Golang côté client et écrire une fonction "trouver" qui sélectionne un serveur dans la liste des serveurs d'équilibrage de charge.

func findServer() string {
    servers := []string{"http://127.0.0.1:8080", "http://127.0.0.1:8081"}   //要进行负载均衡的服务器列表
    n := len(servers)
    rand.Seed(time.Now().UnixNano())  //定义随机种子
    index := rand.Intn(n)  //生成随机数
    return servers[index]   //返回随机选择的服务器
}

Ensuite, lorsque vous faites une requête HTTP, il vous suffit d'ajouter "findServer()" devant l'URL de la ressource :

client := &http.Client{}
req, err := http.NewRequest("GET", findServer()+"/example", nil)
response, err := client.Do(req)

De cette façon, le code du client Golang peut être bien distribué via le système d'équilibrage de charge de Nginx.

Résumé

La mise en œuvre du proxy inverse et de l'équilibrage de charge grâce à la combinaison de Nginx et Golang peut améliorer les performances et la haute disponibilité des applications. Le proxy inverse peut transmettre les requêtes des clients au serveur réel pour traitement, tandis que l'équilibrage de charge peut équilibrer la charge des requêtes pour éviter une charge excessive sur un serveur donné. J'espère que l'introduction et les exemples de cet article pourront vous aider à mieux utiliser Nginx et Golang.

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!