golang melaksanakan pintu masuk api

Dengan populariti seni bina perkhidmatan mikro, komunikasi antara perkhidmatan yang berbeza telah menjadi isu yang sangat penting. Untuk memastikan operasi yang stabil bagi seni bina perkhidmatan mikro, cara yang baik diperlukan untuk mengawal dan mengurus komunikasi antara mereka. Gerbang API ialah komponen penting yang digunakan untuk mengawal dan mengurus komunikasi antara perkhidmatan mikro.

Gerbang API ialah corak dalam seni bina perkhidmatan mikro, yang mencapai pendedahan fungsi perkhidmatan dan kawalan komunikasi dengan menghalakan semua permintaan API kepada kejadian perkhidmatan mikro yang sepadan. Gerbang API juga boleh meningkatkan keselamatan dan kebolehpercayaan seni bina perkhidmatan mikro dengan menambahkan keselamatan, penukaran protokol, pengimbangan beban, kawalan akses dan fungsi lain pada permintaan dan respons. Dalam aplikasi praktikal, get laluan API biasanya digunakan pada awan dan merupakan alat penting untuk membina sistem teragih.

Golang ialah bahasa pengaturcaraan yang sangat baik dengan ciri-ciri prestasi tinggi, konkurensi tinggi, kecekapan tinggi dan penyelenggaraan yang mudah. Di bawah seni bina perkhidmatan mikro, model pengaturcaraan golang adalah konsisten dengan komunikasi antara perkhidmatan, jadi semakin banyak syarikat mula menggunakan golang untuk melaksanakan get laluan API mereka sendiri. Artikel ini akan memperkenalkan cara menggunakan golang untuk melaksanakan get laluan API mudah.

1. Fahami seni bina get laluan API

Sebelum melaksanakan get laluan API, kita perlu memahami seni bina asas get laluan API. Seni bina asas get laluan API adalah seperti berikut:

Gerbang API termasuk komponen berikut:

• Penghala: Bertanggungjawab untuk menghalakan permintaan masuk Laluan ke contoh perkhidmatan mikro yang berbeza.
• Pengimbang beban: Bertanggungjawab untuk mengedarkan permintaan pada contoh perkhidmatan mikro yang berbeza.
• Pengurus keselamatan: Bertanggungjawab mengurus keselamatan get laluan API untuk memastikan sumber rangkaian tidak diakses oleh unit yang tidak dibenarkan.
• Pengesah: Bertanggungjawab untuk mengesahkan identiti pemanggil API.
• Pengurus cache: Bertanggungjawab mengurus cache respons API dan mengurangkan tekanan pada perkhidmatan mikro.
• Panel pentadbir: Menyediakan pentadbir dengan panel kawalan visual untuk get laluan API dan perkhidmatan mikro.

2. Kod untuk melaksanakan get laluan API

Sekarang mari kita lihat cara menggunakan golang untuk melaksanakan kod get laluan API. Kami akan menggunakan rangka kerja gin untuk melaksanakan fungsi asas get laluan API. Mula-mula, kita perlu memasang rangka kerja gin:

go get -u github.com/gin-gonic/gin

Seterusnya, kita boleh menulis kod sampel pertama untuk melaksanakan kawalan penghalaan asas get laluan API melalui rangka kerja gin:

package main

import (
    "net/http"

    "github.com/gin-gonic/gin"
)

func main() {
    router := gin.Default()

    router.GET("/", func(c *gin.Context) {
        c.JSON(http.StatusOK, gin.H{
            "message": "Hello, world!",
        })
    })

    router.Run(":8080") 
}

Kita boleh menjalankan kod Dan lawati http://localhost:8080/ untuk mengesahkan bahawa kod kami berfungsi dengan baik. Sekarang mari kita tulis kod yang lebih kompleks untuk melaksanakan kawalan penghalaan get laluan API. Dalam contoh ini, kami menunjukkan cara untuk menghalakan permintaan masuk ke contoh perkhidmatan mikro yang berbeza.

package main

import (
    "net/http"
    "net/http/httputil"
    "net/url"

    "github.com/gin-gonic/gin"
)

func main() {
    router := gin.Default()

    api1 := router.Group("/api1")
    api1.GET("/user/:id", func(c *gin.Context) {
        director := func(req *http.Request) {
            url, _ := url.Parse("http://user-service:8080")
            req.URL.Scheme = url.Scheme
            req.URL.Host = url.Host
            req.URL.Path = "/user/" + c.Param("id")
        }

        proxy := &httputil.ReverseProxy{Director: director}
        proxy.ServeHTTP(c.Writer, c.Request)
    })

    api2 := router.Group("/api2")
    api2.GET("/order/:id", func(c *gin.Context) {
        director := func(req *http.Request) {
            url, _ := url.Parse("http://order-service:8080")
            req.URL.Scheme = url.Scheme
            req.URL.Host = url.Host
            req.URL.Path = "/order/" + c.Param("id")
        }

        proxy := &httputil.ReverseProxy{Director: director}
        proxy.ServeHTTP(c.Writer, c.Request)
    })

    router.Run(":8080") 
}

Dalam contoh ini, kami mencipta dua penghala, setiap satu sepadan dengan permintaan API yang berbeza. Dalam setiap penghala, kami mentakrifkan permintaan GET dengan parameter. Apabila permintaan ini dipanggil, mereka akan dihalakan terlebih dahulu dalam penghala dan kemudian diubah hala ke contoh perkhidmatan mikro yang sepadan. Ambil perhatian bahawa kita perlu menggunakan ReverseProxy untuk mengubah hala URL dalam permintaan ke URL contoh perkhidmatan mikro sebelum melakukan ubah hala.

3. Tambah fungsi pengimbangan beban

Satu lagi komponen get laluan API yang sangat penting ialah pengimbang beban. Pengimbang beban boleh mengedarkan permintaan kepada berbilang contoh perkhidmatan mikro, dengan itu meningkatkan kebolehpercayaan dan prestasi keseluruhan sistem. Di bawah ialah contoh kod bagaimana kita boleh melaksanakan pengimbang beban mudah menggunakan golang.

Pertama, kita perlu memasang Consul dan Consul API:

go get github.com/hashicorp/consul/api

Kini kita boleh menggunakan Consul dan Consul API untuk mencipta pelanggan Konsul yang akan menyemak status semua contoh perkhidmatan mikro secara berkala, dan secara dinamik pilih pengimbang beban berdasarkan keadaan beban. Berikut ialah contoh kod untuk mencipta pelanggan menggunakan Consul dan Consul API:

package main

import (
    "fmt"
    "log"
    "net/http"
    "net/http/httputil"
    "net/url"
    "sync"

    "github.com/gin-gonic/gin"
    "github.com/hashicorp/consul/api"
)

type ServiceEndpoints struct {
    Urls []string
}

type LoadBalance struct {
    Services map[string]ServiceEndpoints
    Current  map[string]int
    Mutex    sync.Mutex
}

func NewLoadBalance(consulAddress string) (*LoadBalance, error) {
    lb := &LoadBalance{
        Services: make(map[string]ServiceEndpoints),
        Current:  make(map[string]int),
    }

    conf := api.DefaultConfig()
    conf.Address = consulAddress
    client, err := api.NewClient(conf)
    if err != nil {
        return nil, err
    }

    services, _, err := client.Health().Service("user-service", "", true, nil)
    if err != nil {
        return nil, err
    }

    for _, svc := range services {
        serviceUrl := fmt.Sprintf("%v:%v", svc.Service.Address, svc.Service.Port)
        lb.Services["user-service"] = ServiceEndpoints{
            Urls: append(lb.Services["user-service"].Urls, serviceUrl),
        }
    }

    return lb, nil
}

func (lb *LoadBalance) NextEndpoint(serviceName string) string {
    lb.Mutex.Lock()
    defer lb.Mutex.Unlock()

    endpoints := lb.Services[serviceName]
    currentIndex := lb.Current[serviceName]
    nextIndex := (currentIndex + 1) % len(endpoints.Urls)
    lb.Current[serviceName] = nextIndex
    return endpoints.Urls[nextIndex]
}

func main() {
    router := gin.Default()

    lb, err := NewLoadBalance("localhost:8500")
    if err != nil {
        log.Fatal(err)
    }

    api1 := router.Group("/api1")
    api1.GET("/user/:id", func(c *gin.Context) {
        director := func(req *http.Request) {
            urlStr := lb.NextEndpoint("user-service")
            url, _ := url.Parse(urlStr)
            req.URL.Scheme = url.Scheme
            req.URL.Host = url.Host
            req.URL.Path = "/user/" + c.Param("id")
        }

        proxy := &httputil.ReverseProxy{Director: director}
        proxy.ServeHTTP(c.Writer, c.Request)
    })

    router.Run(":8080") 
}

Dalam contoh ini, kami mula-mula menggunakan Consul API untuk secara berkala mendapatkan status semua kejadian mikroperkhidmatan dalam pembina dan melalui fungsi NextEndpoint dalam LoadBalance Agihkan beban di antara mereka secara bergilir-gilir. Ambil perhatian bahawa kami mentakrifkan struktur LoadBalance dan fungsi berkaitannya sebagai modul bebas untuk dikongsi di antara laluan get laluan API yang berbeza. Dalam penghalaan API, kami mengubah hala permintaan ke URL yang dikembalikan dalam struktur LoadBalance.

Ringkasan

Melalui artikel ini, anda sepatutnya sudah memahami aplikasi asas golang dalam get laluan API. Kami bermula dengan infrastruktur dan menunjukkan beberapa kod golang mudah, menunjukkan kawalan penghalaan, pengimbangan beban, pengurusan keselamatan dan fungsi lain get laluan API. Saya harap kandungan ini dapat membantu anda lebih memahami aplikasi golang dalam seni bina perkhidmatan mikro dan membantu anda dalam projek anda.

Atas ialah kandungan terperinci golang melaksanakan pintu masuk api. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!