Cara menggunakan Go untuk melaksanakan perkhidmatan pemajuan berprestasi tinggi

Go ialah bahasa pengaturcaraan yang sangat popular yang bukan sahaja mudah dipelajari dan digunakan, tetapi juga menyediakan keupayaan pembangunan pelayan berprestasi tinggi. Dalam aplikasi rangkaian, pemajuan adalah salah satu tugas biasa. Go menyediakan satu siri perpustakaan berkaitan HTTP yang boleh membantu kami melaksanakan perkhidmatan pemajuan berprestasi tinggi. Artikel ini akan memperkenalkan cara menggunakan Go untuk melaksanakan perkhidmatan pemajuan berprestasi tinggi.

1. Pengenalan

Pengiriman semula merujuk kepada pemajuan permintaan daripada klien ke pelayan lain. Dalam aplikasi Internet, disebabkan bilangan lawatan yang banyak, adalah sukar bagi satu pelayan untuk memenuhi keperluan pengguna, jadi berbilang pelayan perlu digunakan untuk mengendalikan permintaan. Pada ketika ini, kaedah yang berkesan diperlukan untuk mengedarkan permintaan kepada berbilang pelayan.

Dalam aplikasi web moden, pelayan proksi sering digunakan untuk melaksanakan pemajuan. Pelayan proksi boleh menapis, cache, mempercepatkan dan memajukan permintaan HTTP. Dalam artikel ini, kami akan melaksanakan pelayan proksi mudah menggunakan Go dan membandingkannya dengan pelayan proksi lain melalui ujian prestasi.

2. Pelaksanaan

Kami akan menggunakan pakej net/http Go untuk melaksanakan pelayan proksi. Pakej ini menyediakan pelayan dan klien HTTP yang ringkas tetapi berkuasa yang memudahkan untuk melaksanakan pelayan proksi.

Berikut ialah pelaksanaan asas pelayan proksi:

package main

import (
    "log"
    "net/http"
)

func main() {
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        resp, err := http.DefaultTransport.RoundTrip(r)
        if err != nil {
            http.Error(w, err.Error(), http.StatusServiceUnavailable)
            return
        }
        defer resp.Body.Close()

        // 将其他服务器返回的 Header 添加到响应中 
        for key, values := range resp.Header {
            for _, value := range values {
                w.Header().Add(key, value)
            }
        }

        // 将其他服务器返回的状态码添加到响应中 
        w.WriteHeader(resp.StatusCode)

        //将其他服务器返回的 Body 添加到响应中 
        _, err = io.Copy(w, resp.Body)
        if err != nil {
            log.Println("failed to copy response:", err)
        }
    })

    log.Println("starting server...")
    log.Fatal(http.ListenAndServe(":8000", nil))
}

Kod ini menggunakan fungsi http.HandlerFunc yang disediakan oleh pakej net/http, yang boleh menerima fungsi pemprosesan dan menggabungkan semua Permintaan dihantar ke fungsi ini. Dalam fungsi ini, kami menggunakan fungsi http.DefaultTransport.RoundTrip untuk menghantar permintaan ke pelayan lain dan menambah respons yang dikembalikan oleh pelayan lain kepada respons kami sebelum menghantarnya kepada klien.

3. Ujian Prestasi

Untuk menguji prestasi pelayan proksi kami, kami akan menggunakan alat Apache Bench untuk ujian penanda aras. Anda boleh mengetahui lebih lanjut tentang alatan Apache Bench di https://httpd.apache.org/docs/current/programs/ab.html. Kami akan menjalankan penanda aras menggunakan arahan berikut:

ab -n 1000000 -c 100 http://localhost:8000/

Arahan ini akan menghantar 100 permintaan serentak ke http://localhost:8000/ dan diulang 1,000,000 kali. Berikut ialah keputusan ujian:

Server Software:        
Server Hostname:        localhost
Server Port:            8000

Document Path:          /
Document Length:        844 bytes

Concurrency Level:      100
Time taken for tests:   22.679 seconds
Complete requests:      1000000
Failed requests:        0
Total transferred:      926000000 bytes
HTML transferred:       844000000 bytes
Requests per second:    44107.20 [#/sec] (mean)
Time per request:       2.268 [ms] (mean)
Time per request:       0.023 [ms] (mean, across all concurrent requests)
Transfer rate:          39832.25 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:        0    0   0.4      0      26
Processing:     0    2   0.9      2      39
Waiting:        0    2   0.9      2      39
Total:          0    2   0.9      2      39

Keputusan di atas menunjukkan bahawa pelayan proksi kami boleh menyampaikan 44107.20 permintaan sesaat (purata), dengan masa pemprosesan 2.268 ms setiap permintaan (purata).

4. Kesimpulan

Kami melaksanakan pelayan proksi yang mudah tetapi berprestasi tinggi menggunakan Go dan menjalankan ujian penanda aras menggunakan alat Apache Bench. Keputusan ujian menunjukkan bahawa pelayan proksi kami boleh mengendalikan 44107.20 permintaan sesaat dengan purata masa tindak balas 2.268 milisaat. Ini menunjukkan bahawa Go boleh digunakan untuk membina aplikasi web berprestasi tinggi dan berskala.

Perlu diambil perhatian bahawa artikel ini hanya memperkenalkan cara menggunakan Go untuk melaksanakan pelayan proksi mudah dan menjalankan ujian prestasi padanya. Melaksanakan pelayan proksi yang lebih kompleks mungkin memerlukan lebih banyak kod dan fungsi yang lebih lengkap. Oleh itu, apabila membangunkan aplikasi anda untuk pengeluaran, pertimbangkan faktor berikut:

• Bilangan serentak permintaan untuk dikendalikan
• Pengendalian muat naik dan muat turun fail besar
• Pengimbangan beban dan failover
• Caching dan penapisan
• Uji dan ukur menggunakan alatan prestasi lain

Atas ialah kandungan terperinci Cara menggunakan Go untuk melaksanakan perkhidmatan pemajuan berprestasi tinggi. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!