Nếu bạn đang chạy các dịch vụ nên có thể xử lý một lượng lớn lưu lượng truy cập, bạn có thể tải cân bằng rất nhiều lưu lượng truy cập đó giữa các máy chủ backend của bạn. Có rất nhiều chất cân bằng tải cấp sản xuất trên thị trường (NGINX, HAProxy, v.v.) nhưng biết làm thế nào họ làm việc đằng sau cảnh là kiến thức tốt. A Simple HTTP Load Balancer in Go Using Standard Library, Trong thực hiện này, chúng tôi sẽ sử dụng thuật toán round-robin để phân phối đồng đều các yêu cầu đến giữa một tập hợp các máy chủ backend. Cấu trúc cơ bản Đầu tiên, chúng ta cần xác định cấu trúc dữ liệu cốt lõi của chúng tôi. bộ cân bằng tải của chúng tôi sẽ theo dõi nhiều máy chủ backend và tình trạng của chúng: package main

import (
	"flag"
	"fmt"
	"log"
	"net"
	"net/http"
	"net/http/httputil"
	"net/url"
	"sync"
	"sync/atomic"
	"time"
)

// Backend represents a backend server
type Backend struct {
	URL          *url.URL
	Alive        bool
	mux          sync.RWMutex
	ReverseProxy *httputil.ReverseProxy
}

// SetAlive updates the alive status of backend
func (b *Backend) SetAlive(alive bool) {
	b.mux.Lock()
	b.Alive = alive
	b.mux.Unlock()
}

// IsAlive returns true when backend is alive
func (b *Backend) IsAlive() (alive bool) {
	b.mux.RLock()
	alive = b.Alive
	b.mux.RUnlock()
	return
}

// LoadBalancer represents a load balancer
type LoadBalancer struct {
	backends []*Backend
	current  uint64
}

// NextBackend returns the next available backend to handle the request
func (lb *LoadBalancer) NextBackend() *Backend {
	// Simple round-robin
	next := atomic.AddUint64(&lb.current, uint64(1)) % uint64(len(lb.backends))
	
	// Find the next available backend
	for i := 0; i < len(lb.backends); i++ {
		idx := (int(next) + i) % len(lb.backends)
		if lb.backends[idx].IsAlive() {
			return lb.backends[idx]
		}
	}
	return nil
}
 Bây giờ một vài điểm chính ở đây để ghi nhớ: 
 
 
 
 
 
 Backend struct đại diện cho một máy chủ backend duy nhất với URL và trạng thái sống của nó. Chúng tôi đang sử dụng một mutex để cập nhật an toàn và kiểm tra trạng thái sống của mỗi backend trong một môi trường đồng thời. LoadBalancer theo dõi một danh sách các backend và duy trì một bộ đếm cho thuật toán round-robin. Chúng tôi sử dụng các hoạt động nguyên tử để tăng số liệu an toàn trong một môi trường đồng thời. Phương pháp NextBackend thực hiện thuật toán round-robin, bỏ qua các backend không lành mạnh. Kiểm tra sức khỏe Phát hiện sự không sẵn có của backend là một trong những chức năng quan trọng của bất kỳ bộ cân bằng tải nào. Hãy thực hiện một cơ chế kiểm tra sức khỏe rất đơn giản: // isBackendAlive checks whether a backend is alive by establishing a TCP connection
func isBackendAlive(u *url.URL) bool {
	timeout := 2 * time.Second
	conn, err := net.DialTimeout("tcp", u.Host, timeout)
	if err != nil {
		log.Printf("Site unreachable: %s", err)
		return false
	}
	defer conn.Close()
	return true
}

// HealthCheck pings the backends and updates their status
func (lb *LoadBalancer) HealthCheck() {
	for _, b := range lb.backends {
		status := isBackendAlive(b.URL)
		b.SetAlive(status)
		if status {
			log.Printf("Backend %s is alive", b.URL)
		} else {
			log.Printf("Backend %s is dead", b.URL)
		}
	}
}

// HealthCheckPeriodically runs a routine health check every interval
func (lb *LoadBalancer) HealthCheckPeriodically(interval time.Duration) {
	t := time.NewTicker(interval)
	for {
		select {
		case <-t.C:
			lb.HealthCheck()
		}
	}
}
 Kiểm tra sức khỏe này rất đơn giản: 
 
 
 
 Chúng tôi cố gắng bắt đầu một kết nối TCP với backend. Nếu kết nối này thành công, thì backend vẫn còn sống; nếu không thì nó đã chết. Kiểm tra được thực hiện ở một khoảng thời gian được chỉ định trong hàm HealthCheckPeriodically. Trong một môi trường sản xuất, bạn có thể muốn một kiểm tra sức khỏe tiên tiến hơn thực sự thực hiện một yêu cầu HTTP đến một số điểm cuối được chỉ định, nhưng điều này bắt đầu. Bộ xử lý HTTP Hãy tiếp tục và triển khai trình xử lý HTTP sẽ nhận được yêu cầu và định tuyến chúng đến các backend của chúng tôi: // ServeHTTP implements the http.Handler interface for the LoadBalancer
func (lb *LoadBalancer) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	backend := lb.NextBackend()
	if backend == nil {
		http.Error(w, "Service Unavailable", http.StatusServiceUnavailable)
		return
	}
	
	// Forward the request to the backend
	backend.ReverseProxy.ServeHTTP(w, r)
}
 Và đây là nơi mà phép thuật xảy ra: 
 
 
 
 Thuật toán round-robin của chúng tôi cung cấp cho chúng tôi backend tiếp theo có sẵn. Nếu không có backend nào có sẵn, chúng tôi sẽ trả về lỗi 503 Service Unavailable. Nếu không, chúng tôi proxy yêu cầu đến backend được chọn thông qua proxy ngược nội bộ của Go. Lưu ý cách các Gói cung cấp các loại, mà xử lý tất cả các phức tạp của proxy HTTP yêu cầu cho chúng tôi. net/http/httputil ReverseProxy Đặt tất cả cùng nhau Cuối cùng, chúng ta hãy thực hiện chức năng để cấu hình và khởi động bộ cân bằng tải của chúng tôi: main func main() {
	// Parse command line flags
	port := flag.Int("port", 8080, "Port to serve on")
	flag.Parse()

	// Configure backends
	serverList := []string{
		"http://localhost:8081",
		"http://localhost:8082",
		"http://localhost:8083",
	}

	// Create load balancer
	lb := LoadBalancer{}

	// Initialize backends
	for _, serverURL := range serverList {
		url, err := url.Parse(serverURL)
		if err != nil {
			log.Fatal(err)
		}

		proxy := httputil.NewSingleHostReverseProxy(url)
		proxy.ErrorHandler = func(w http.ResponseWriter, r *http.Request, err error) {
			log.Printf("Error: %v", err)
			http.Error(w, "Service Unavailable", http.StatusServiceUnavailable)
		}

		lb.backends = append(lb.backends, &Backend{
			URL:          url,
			Alive:        true,
			ReverseProxy: proxy,
		})
		log.Printf("Configured backend: %s", url)
	}

	// Initial health check
	lb.HealthCheck()

	// Start periodic health check
	go lb.HealthCheckPeriodically(time.Minute)

	// Start server
	server := http.Server{
		Addr:    fmt.Sprintf(":%d", *port),
		Handler: &lb,
	}

	log.Printf("Load Balancer started at :%d\n", *port)
	if err := server.ListenAndServe(); err != nil {
		log.Fatal(err)
	}
}
 Bây giờ, đây là những gì đang xảy ra trong chức năng chính: 
 
 
 
 
 
 
 Chúng tôi cấu hình cổng dựa trên các cờ dòng lệnh mà chúng tôi phân tích. Chúng tôi đã thiết lập một danh sách các máy chủ backend. For each backend server, we:
 
 
 
 
 
 
 Parse the URL Create a reverse proxy for that backend Add error handling for when a backend fails Add the backend to our load balancer Chúng tôi thực hiện kiểm tra sức khỏe ban đầu. Chúng tôi bắt đầu một goroutine cho kiểm tra sức khỏe định kỳ. Cuối cùng, chúng tôi bắt đầu máy chủ HTTP với bộ cân bằng tải của chúng tôi với tư cách là bộ xử lý. Thử nghiệm Load Balancer Vì vậy, một lần nữa để kiểm tra trình cân bằng tải của chúng tôi, chúng tôi cần một số máy chủ backend. // Save this to backend.go
package main

import (
	"flag"
	"fmt"
	"log"
	"net/http"
	"os"
)

func main() {
	port := flag.Int("port", 8081, "Port to serve on")
	flag.Parse()

	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
		hostname, _ := os.Hostname()
		fmt.Fprintf(w, "Backend server on port %d, host: %s, Request path: %s\n", *port, hostname, r.URL.Path)
	})

	log.Printf("Backend started at :%d\n", *port)
	if err := http.ListenAndServe(fmt.Sprintf(":%d", *port), nil); err != nil {
		log.Fatal(err)
	}
}
 Chạy nhiều trường hợp của backend này trên các cổng khác nhau: go build -o backend backend.go
./backend -port 8081 &
./backend -port 8082 &
./backend -port 8083 &
 Sau đó xây dựng và chạy Balancer tải: go build -o load-balancer main.go
./load-balancer
 Bây giờ, thực hiện một số yêu cầu để kiểm tra nó: curl http://localhost:8080/test
 Thực hiện nhiều yêu cầu và bạn sẽ thấy chúng được phân phối trên các máy chủ backend của bạn theo cách round-robin. Những cải tiến tiềm năng Đây là một thực hiện tối thiểu, nhưng có rất nhiều điều bạn có thể làm để cải thiện nó: 
 
 
 
 
 
 
 
 
 : Implement weighted round-robin, least connections, or IP hash-based selection. Different balancing algorithms 
 
 : Make full HTTP requests to a health endpoint instead of just checking TCP connectivity. Better health checking 
 
 : Track request counts, response times, and error rates for each backend. Metrics collection 
 
 : Ensure requests from the same client always go to the same backend. Sticky sessions 
 
 : Add HTTPS for secure connections. TLS support 
 
 : Allow updating the backend list without restarting. Dynamic configuration Chúng tôi đã xây dựng một trình cân bằng tải HTTP đơn giản nhưng hiệu quả, sử dụng không có gì ngoài thư viện tiêu chuẩn của Go. ví dụ này minh họa các khái niệm quan trọng trong lập trình mạng và sức mạnh của các tính năng kết nối mạng tích hợp của Go. Mặc dù đây không phải là sản xuất sẵn sàng, nhưng nó cung cấp một nền tảng vững chắc để hiểu làm thế nào tải cân bằng hoạt động. giải pháp hoàn chỉnh là khoảng 150 dòng mã - một bằng chứng cho sự biểu cảm của Go và sức mạnh của thư viện tiêu chuẩn của nó. Đối với việc sử dụng sản xuất, bạn muốn xây dựng thêm các tính năng và thêm xử lý lỗi mạnh mẽ, nhưng các khái niệm cốt lõi đều giống nhau. Một sự hiểu biết về các nguyên tắc cơ bản này sẽ chuẩn bị cho bạn để cấu hình và xử lý tốt hơn bất kỳ bộ cân bằng tải nào bạn sẽ sử dụng trên đường. Bạn có thể tìm thấy mã nguồn tại đây https://github.com/rezmoss/simple-load-balancer

Read My Stories

Nghe bài viết này bằng Tiếng Anh, đọc bởi robot thông minh của HackerNoon

dài quá đọc không nổi

Make resilience your competitive advantage

Kịch bản 150-Line Go này thực sự là một bộ cân bằng tải đầy đủ

About Author

BÌNH LUẬN

chuyên mục

BÀI VIẾT NÀY CŨNG CÓ MẶT TẠI

Related Stories

287 Stories To Learn About Blockchain Development

61 Stories To Learn About Polotical Philosophy

147 Stories To Learn About Reading Books Online

85 Stories To Learn About Travel

287 Stories To Learn About Blockchain Development

61 Stories To Learn About Polotical Philosophy

147 Stories To Learn About Reading Books Online

85 Stories To Learn About Travel

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps