Go ialah bahasa pengaturcaraan berbilang paradigma, ditaip secara statik dan disusun oleh Google. Ramai pembangun telah menerima Go kerana pengumpulan sampah, keselamatan memori dan sistem penaipan strukturnya. Rangka kerja web Go dicipta untuk memudahkan proses pembangunan web Go tanpa perlu risau tentang persediaan dan lebih memfokuskan pada fungsi sesuatu projek. Semasa membina aplikasi kecil, rangka kerja mungkin tidak diperlukan, tetapi untuk perisian peringkat pengeluaran, ia adalah penting. Rangka kerja menyediakan fungsi dan perkhidmatan tambahan yang boleh digunakan oleh pembangun lain yang ingin menambahkan kefungsian yang serupa pada perisian mereka dan bukannya menulis sendiri perisian lengkap itu.
Memilih rangka kerja yang sesuai untuk keperluan anda boleh mendayakan kitaran pembangunan yang lebih pantas dan penyelenggaraan yang lebih mudah di sepanjang jalan. Dalam artikel ini kita akan bercakap tentang GoFr, rangka kerja Golang yang mempunyai pendapat untuk pembangunan perkhidmatan mikro yang dipercepatkan. Dan kami akan mengetahui sebab ia adalah pilihan utama anda apabila membina perkhidmatan mikro dalam Go!
Apa yang benar-benar menjadikan rangka kerja baik atau buruk ialah kemudahan pembangunan yang disediakan untuk penggunanya bersama-sama dengan julat ciri yang ditawarkannya supaya pengguna boleh menumpukan pada pelaksanaan logik perniagaan semata-mata. GoFr telah dibina untuk membantu pembangun menulis API yang pantas, berskala dan cekap. Rangka kerja ini menawarkan set ciri yang kaya yang membantu pembangun dalam menulis perkhidmatan mikro gred pengeluaran dengan mudah. Mari terokai beberapa ciri ini:
Pembolehubah persekitaran ialah cara terbaik untuk menetapkan nilai konfigurasi untuk aplikasi perisian anda kerana ia boleh ditakrifkan pada peringkat sistem, secara bebas daripada perisian. Ini adalah salah satu prinsip metodologi Apl Dua Belas Faktor dan membolehkan aplikasi dibina dengan mudah alih.
GoFr mempunyai beberapa pembolehubah persekitaran yang dipratentukan untuk pelbagai tujuan seperti menukar tahap log, menyambung ke pangkalan data, menetapkan nama dan versi aplikasi, menetapkan port http dll. Pengguna hanya perlu menetapkannya dalam fail .env di dalam direktori konfigurasi aplikasi dan GoFr secara automatik membaca nilai daripada itu.
Berikut ialah senarai penuh pembolehubah persekitaran yang disokong oleh GoFr
Mengurus sambungan dan interaksi pangkalan data boleh menjadi sibuk, terutamanya apabila bekerja dengan berbilang pangkalan data. GoFr mengendalikan sambungan pangkalan data dengan lancar menggunakan pembolehubah konfigurasi. Ia bukan sahaja menguruskan sambungan, tetapi ia juga menyediakan akses terus kepada objek pangkalan data menggunakan konteks GoFr dalam pengendali. Pendekatan ini memudahkan kerja dengan pelbagai pangkalan data. GoFr kini menyokong semua pangkalan data Dialek SQL, Redis, MongoDB, Cassandra dan ClickHouse.
Contoh penggunaan MySQL dan Redis DB di dalam pengendali.
func DBHandler(c *gofr.Context) (interface{}, error) {
var value int
// querying a SQL db
err := c.SQL.QueryRowContext(c, "select 2+2").Scan(&value)
if err != nil {
return nil, datasource.ErrorDB{Err: err, Message: "error from sql db"}
}
// retrieving value from Redis
_, err = c.Redis.Get(c, "test").Result()
if err != nil && !errors.Is(err, redis.Nil) {
return nil, datasource.ErrorDB{Err: err, Message: "error from redis db"}
}
return value, nil
}
GoFr memudahkan Pub/Sub dengan menawarkan sokongan terbina dalam untuk pelanggan popular seperti Kafka, Google Pub/Sub dan MQTT. Ini menghapuskan keperluan untuk konfigurasi manual atau pengurusan perpustakaan, membolehkan anda menumpukan pada seni bina dipacu acara anda. Menerbitkan dan melanggan acara diperkemas menggunakan konteks GoFr. Penerbitan acara boleh dilakukan di dalam pengendali menggunakan konteks, dan untuk melanggan acara, anda hanya perlu menggunakan pengendali Langgan GoFr. Pendekatan ini menggalakkan kod bersih dan mengurangkan boilerplate berbanding dengan melaksanakan corak Pub/Sub dari awal.
Contoh penggunaan Penerbit dan Pelanggan dalam aplikasi GoFr:
package main
import (
"encoding/json"
"gofr.dev/pkg/gofr"
)
func main() {
app := gofr.New()
app.POST("/publish-product", product)
// subscribing to products topic
app.Subscribe("products", func(c *gofr.Context) error {
var productInfo struct {
ProductId string `json:"productId"`
Price string `json:"price"`
}
err := c.Bind(&productInfo)
if err != nil {
c.Logger.Error(err)
return nil
}
c.Logger.Info("Received product ", productInfo)
return nil
})
app.Run()
}
func product(ctx *gofr.Context) (interface{}, error) {
type productInfo struct {
ProductId string `json:"productId"`
Price string `json:"price"`
}
var data productInfo
// binding the request data to productInfo struct
err := ctx.Bind(&data)
if err != nil {
return nil, err
}
msg, _ := json.Marshal(data)
// publishing message to producst topic using gofr context
err = ctx.GetPublisher().Publish(ctx, "products", msg)
if err != nil {
return nil, err
}
return "Published", nil
}
Pemantauan yang berkesan adalah penting untuk mengekalkan perkhidmatan mikro berprestasi tinggi. GoFr meringankan beban anda dengan menyediakan ciri kebolehmerhatian terbina dalam. Ini menghapuskan keperluan untuk konfigurasi manual pengesanan, metrik dan perpustakaan pengelogan.
Log Terperinci: GoFr menawarkan pengelogan berstruktur dengan pelbagai peringkat log (INFO, DEBUG, WARN, ERROR, FATAL) untuk menangkap peristiwa aplikasi pada butiran yang berbeza. Ini memberi anda kuasa untuk menganalisis aliran aplikasi, mengenal pasti isu yang berpotensi dan memperkemas penyahpepijatan.
Metrik Boleh Tindakan: GoFr secara automatik mengumpul dan mendedahkan metrik aplikasi, membolehkan anda memantau penunjuk prestasi utama. Dengan metrik yang tersedia, anda boleh mengenal pasti kesesakan dan mengoptimumkan prestasi aplikasi dengan cepat.
Distributed Tracing: GoFr integrates with popular tracing backends like Zipkin and Jaeger. Distributed tracing allows you to visualize the entire request lifecycle across your microservices, making it easier to pinpoint the root cause of issues within complex systems.
These observability features help users gain detailed insights into the application's flow and performance, identify and resolve bottlenecks, and ensure smooth operation.
In a microservices architecture, efficient and reliable communication between services is crucial. GoFr simplifies this process by providing a dedicated mechanism to initialize and manage interservice HTTP communication. You can easily register downstream services at the application level using the AddHTTPService method.
Configurational Options for HTTP Services:
GoFr offers a variety of configuration options to enhance interservice communication:
Authentication: Supports APIKeyConfig, BasicAuthConfig, and OAuthConfig for secure authentication.
Default Headers: Allows setting default headers for all downstream HTTP service requests.
Circuit Breaker: Enhance service resilience with built-in circuit breaker functionality. GoFr allows you to configure thresholds and intervals to gracefully handle failures and prevent cascading outages.
Health Checks: Proactively monitor the health of your downstream services using GoFr's health check configuration. Define a health endpoint for each service, and GoFr will automatically verify their availability, allowing for early detection of potential issues.
These features ensure that interservice communication is secure, reliable, and easily manageable.
Example of connecting to a HTTP Service and sending a GET request:
func main() {
a := gofr.New()
a.AddHTTPService("cat-facts", "https://catfact.ninja",
&service.CircuitBreakerConfig{
Threshold: 4,
Interval: 1 * time.Second,
},
&service.HealthConfig{
HealthEndpoint: "breeds",
},
)
a.GET("/fact", Handler)
a.Run()
}
func Handler(c *gofr.Context) (any, error) {
var data = struct {
Fact string `json:"fact"`
Length int `json:"length"`
}{}
var catFacts = c.GetHTTPService("cat-facts")
resp, err := catFacts.Get(c, "fact", map[string]interface{}{
"max_length": 20,
})
if err != nil {
return nil, err
}
b, _ := io.ReadAll(resp.Body)
err = json.Unmarshal(b, &data)
if err != nil {
return nil, err
}
return data, nil
}
Middleware allows you intercepting and manipulating HTTP requests and responses flowing through your application's router. Middlewares can perform tasks such as authentication, authorization, caching etc. before or after the request reaches your application's handler.
GoFr empowers developers with middleware support, allowing for request/response manipulation and custom logic injection. This provides a powerful mechanism to implement cross-cutting concerns like authentication, authorization, and caching in a modular and reusable way. Middleware functions are registered using the UseMiddleware method on your GoFr application instance.
Additionally, GoFr includes built-in CORS (Cross-Origin Resource Sharing) middleware to handle CORS-related headers.
Example of adding a custom middleware to GoFr application:
import (
"net/http"
gofrHTTP "gofr.dev/pkg/gofr/http"
)
// Define your custom middleware function
func customMiddleware() gofrHTTP.Middleware {
return func(inner http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
// Your custom logic here
// For example, logging, authentication, etc.
// Call the next handler in the chain
inner.ServeHTTP(w, r)
})
}
}
func main() {
// Create a new instance of your GoFr application
app := gofr.New()
// Add your custom middleware to the application
app.UseMiddleware(customMiddleware())
// Define your application routes and handlers
// ...
// Run your GoFr application
app.Run()
}
Securing your microservices with robust authentication is crucial. GoFr streamlines this process by providing built-in support for various industry-standard authentication mechanisms. This empowers you to choose the approach that best suits your application's needs without writing complex authentication logic from scratch.
Basic Auth: Basic auth is the simplest way to authenticate your APIs. It's built on HTTP protocol authentication scheme. It involves sending the prefix Basic trailed by the Base64-encoded
API Keys Auth: API Key Authentication is an HTTP authentication scheme where a unique API key is included in the request header for validation against a store of authorized keys. GoFr offers two ways to implement API Keys authentication i.e. Framework Default Validation as well as defining a Custom Validation Function.
OAuth 2.0: OAuth 2.0 is the industry-standard protocol for authorization. It focuses on client developer simplicity while providing specific authorization flows for web applications, desktop applications, mobile phones, and living room devices. It involves sending the prefix Bearer trailed by the encoded token within the standard Authorization header. GoFr supports authenticating tokens encoded by algorithm RS256/384/512.
Refer to the GoFr's Authentication Documentation to see the examples of how to use these auth mechanisms and know more about it.
Menyediakan dokumentasi API yang jelas dan interaktif adalah penting untuk penggunaan pengguna dan aliran kerja pembangunan yang cekap. Spesifikasi API boleh ditulis dalam YAML atau JSON. Format ini mudah dipelajari dan boleh dibaca oleh manusia dan mesin. Spesifikasi OpenAPI yang lengkap boleh didapati di laman web rasmi Swagger.
GoFr menyokong pemaparan automatik dokumentasi OpenAPI (juga dikenali sebagai Swagger). Ciri ini membolehkan anda menyediakan dokumentasi API interaktif dengan mudah untuk pengguna anda. Untuk membenarkan GoFr memaparkan dokumentasi OpenAPI anda, cuma letakkan fail openapi.json anda di dalam direktori statik projek anda. GoFr akan secara automatik memaparkan dokumentasi Swagger di titik akhir /.well-known/swagger.
Sepanjang artikel ini, kami telah meneroka ciri kaya GoFr, rangka kerja Golang berpandangan yang direka khusus untuk mempercepatkan pembangunan perkhidmatan mikro. Kami telah melihat bagaimana GoFr memudahkan tugas biasa seperti pengurusan konfigurasi, interaksi pangkalan data, penyepaduan Pub/Sub, pemerhatian automatik, komunikasi antara perkhidmatan, penggunaan perisian tengah dan pengesahan. Selain itu, GoFr menawarkan sokongan terbina dalam untuk pemindahan data, soket web, kerja cron dan perubahan tahap log jauh, memperkemas lagi proses pembangunan anda.
Kami menanda aras GoFr terhadap rangka kerja Go popular lain seperti Gin, Chi, Echo dan Fiber, dan mendapati GoFr menunjukkan prestasi yang optimum, walaupun dengan set cirinya yang luas. Ini bermakna anda boleh memanfaatkan semua fungsinya yang berkuasa tanpa menjejaskan prestasi.
Kami menggalakkan anda menerokai GoFr sendiri. Dokumentasi komprehensif rangka kerja, tutorial dan komuniti aktif adalah sumber yang berharga untuk membimbing anda dalam perjalanan anda. Dengan GoFr, anda boleh menumpukan pada membina perkhidmatan mikro yang teguh, berskala dan diurus dengan cekap, membebaskan anda untuk menumpukan lebih banyak masa kepada fungsi teras aplikasi anda.
Mulakan dengan GoFr hari ini!
Berikut ialah beberapa sumber yang berguna:
Tapak Web GoFr: https://gofr.dev
Repositori GitHub GoFr: https://github.com/gofr-dev/gofr
Pelayan Discord GoFr: https://discord.gg/zyJkVhps
Atas ialah kandungan terperinci Rangka Kerja Ultimate Golang untuk Perkhidmatan Mikro: GoFr. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!
Pengenalan kepada ciri-ciri ruang maya
Penggunaan pulangan nilai pulangan Python
Cara menggunakan mata wang digital
Apakah yang perlu saya lakukan jika huruf Inggeris muncul apabila komputer dihidupkan dan komputer tidak boleh dihidupkan?
Perbezaan antara vue2.0 dan 3.0
Cara menukar bandar di Douyin
tiada penyelesaian fail sedemikian
Bagaimana untuk mengkonfigurasi gerbang lalai
![[Web front-end] Permulaan pantas Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
