Rumah >pembangunan bahagian belakang >Golang >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.
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:
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.
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!