Go ist eine multiparadigmatische, statisch typisierte und kompilierte Programmiersprache, die von Google entwickelt wurde. Viele Entwickler haben Go wegen seiner Speicherbereinigung, Speichersicherheit und seinem strukturellen Typisierungssystem angenommen. Go-Web-Frameworks wurden entwickelt, um Go-Web-Entwicklungsprozesse zu vereinfachen, ohne sich um die Einrichtung kümmern zu müssen und sich mehr auf die Funktionalitäten eines Projekts zu konzentrieren. Beim Erstellen kleiner Anwendungen sind Frameworks möglicherweise nicht erforderlich, für Software auf Produktionsebene sind sie jedoch von entscheidender Bedeutung. Frameworks bieten zusätzliche Funktionalitäten und Dienste, die von anderen Entwicklern genutzt werden können, die ihrer Software ähnliche Funktionalitäten hinzufügen möchten, anstatt die vollständige Software selbst zu schreiben.
Die Auswahl des richtigen Frameworks für Ihre Anforderungen kann zu schnelleren Entwicklungszyklen und einer einfacheren späteren Wartung führen. In diesem Artikel werden wir über GoFr sprechen, ein eigenwilliges Golang-Framework für die beschleunigte Entwicklung von Microservices. Und wir werden herausfinden, warum es Ihre ultimative Wahl beim Aufbau von Microservices in Go!
ist
GoFr und seine umfangreichen Funktionen:
Was ein Framework wirklich gut oder schlecht macht, ist die einfache Entwicklung, die es dem Benutzer ermöglicht, sowie die Bandbreite an Funktionen, die es bietet, sodass sich der Benutzer ausschließlich auf die Implementierung der Geschäftslogik konzentrieren kann. GoFr wurde entwickelt, um Entwicklern beim Schreiben schneller, skalierbarer und effizienter APIs zu helfen. Das Framework bietet zahlreiche Funktionen, die Entwicklern dabei helfen, problemlos Microservices in Produktionsqualität zu schreiben. Lassen Sie uns einige dieser Funktionen erkunden:
1. Effizientes Konfigurationsmanagement
Umgebungsvariablen sind die beste Möglichkeit, Konfigurationswerte für Ihre Softwareanwendung festzulegen, da sie unabhängig von der Software auf Systemebene definiert werden können. Dies ist eines der Prinzipien der Zwölf-Faktor-App-Methodik und ermöglicht die Erstellung von Anwendungen mit Portabilität.
GoFr verfügt über einige vordefinierte Umgebungsvariablen für verschiedene Zwecke wie das Ändern von Protokollebenen, das Herstellen einer Verbindung zu Datenbanken, das Festlegen von Anwendungsnamen und -version, das Festlegen von http-Ports usw. Der Benutzer muss diese lediglich in einer .env-Datei im Konfigurationsverzeichnis des festlegen Anwendung und GoFr liest automatisch die Werte daraus.
Hier ist die vollständige Liste der von GoFr unterstützten Umgebungsvariablen
2. Nahtlose Datenbankinteraktionen
Die Verwaltung von Datenbankverbindungen und -interaktionen kann hektisch werden, insbesondere wenn Sie mit mehreren Datenbanken arbeiten. GoFr verwaltet Datenbankverbindungen nahtlos mithilfe von Konfigurationsvariablen. Es verwaltet nicht nur die Verbindungen, sondern bietet auch direkten Zugriff auf Datenbankobjekte mithilfe des GoFr-Kontexts in Handlern. Dieser Ansatz vereinfacht die Arbeit mit mehreren Datenbanken. GoFr unterstützt derzeit alle SQL-Dialekte, Redis-, MongoDB-, Cassandra- und ClickHouse-Datenbanken.
Beispiel für die Verwendung von MySQL und Redis DB im Handler.
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
}
Nach dem Login kopieren
3. Einfache Implementierung der Publisher-Subscriber-Architektur:
GoFr vereinfacht Pub/Sub, indem es integrierte Unterstützung für beliebte Clients wie Kafka, Google Pub/Sub und MQTT bietet. Dadurch entfällt die Notwendigkeit einer manuellen Konfiguration oder Bibliotheksverwaltung, sodass Sie sich auf Ihre ereignisgesteuerte Architektur konzentrieren können. Das Veröffentlichen und Abonnieren von Veranstaltungen wird mithilfe des GoFr-Kontexts optimiert. Das Veröffentlichen von Ereignissen kann innerhalb des Handlers mithilfe des Kontexts erfolgen. Um ein Ereignis zu abonnieren, müssen Sie lediglich den Subscribe-Handler von GoFr verwenden. Dieser Ansatz fördert sauberen Code und reduziert den Boilerplate im Vergleich zur Implementierung des Pub/Sub-Musters von Grund auf.
Beispiel für die Verwendung von Publisher und Subscriber in einer GoFr-Anwendung:
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
}
Nach dem Login kopieren
4. Out-of-the-Box-Beobachtbarkeit:
Eine effektive Überwachung ist entscheidend für die Aufrechterhaltung leistungsstarker Microservices. GoFr entlastet Sie durch die Bereitstellung integrierter Observability-Funktionen. Dadurch entfällt die Notwendigkeit einer manuellen Konfiguration von Tracing-, Metrik- und Protokollierungsbibliotheken.
Detaillierte Protokollierung: GoFr bietet eine strukturierte Protokollierung mit verschiedenen Protokollebenen (INFO, DEBUG, WARN, ERROR, FATAL), um Anwendungsereignisse mit unterschiedlichen Granularitäten zu erfassen. Dadurch können Sie den Anwendungsfluss analysieren, potenzielle Probleme identifizieren und das Debuggen optimieren.
Umsetzbare Metriken: GoFr erfasst und stellt automatisch Anwendungsmetriken bereit, sodass Sie wichtige Leistungsindikatoren überwachen können. Mit leicht verfügbaren Metriken können Sie Engpässe schnell erkennen und die Anwendungsleistung optimieren.
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.
5. Effortless Interservice HTTP Communication:
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
}
Nach dem Login kopieren
6. Flexible Middleware Support for Enhanced Control:
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()
}
Nach dem Login kopieren
7. Integrated Authentication Mechanisms:
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 : within the standard Authorization header. GoFr offers two ways to implement basic authentication i.e. using pre-defined credentials as well as defining a custom validation function.
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.
---
- Automatisches Swagger-UI-Rendering:
Die Bereitstellung einer klaren und interaktiven API-Dokumentation ist für die Benutzerakzeptanz und effiziente Entwicklungsworkflows von entscheidender Bedeutung. API-Spezifikationen können in YAML oder JSON geschrieben werden. Das Format ist leicht zu erlernen und sowohl für Menschen als auch für Maschinen lesbar. Die vollständige OpenAPI-Spezifikation finden Sie auf der offiziellen Swagger-Website.
GoFr unterstützt das automatische Rendern der OpenAPI-Dokumentation (auch bekannt als Swagger). Mit dieser Funktion können Sie Ihren Benutzern auf einfache Weise interaktive API-Dokumentation bereitstellen. Damit GoFr Ihre OpenAPI-Dokumentation rendern kann, platzieren Sie einfach Ihre openapi.json-Datei im statischen Verzeichnis Ihres Projekts. GoFr rendert die Swagger-Dokumentation automatisch am Endpunkt /.well-known/swagger.
Abschluss
In diesem Artikel haben wir die umfangreichen Funktionen von GoFr untersucht, einem eigenständigen Golang-Framework, das speziell zur Beschleunigung der Microservice-Entwicklung entwickelt wurde. Wir haben gesehen, wie GoFr allgemeine Aufgaben wie Konfigurationsmanagement, Datenbankinteraktionen, Pub/Sub-Integration, automatische Beobachtbarkeit, Kommunikation zwischen Diensten, Middleware-Nutzung und Authentifizierung vereinfacht. Darüber hinaus bietet GoFr integrierte Unterstützung für Datenmigrationen, Web-Sockets, Cron-Jobs und Änderungen der Remote-Protokollebene, wodurch Ihr Entwicklungsprozess weiter optimiert wird.
Wir haben GoFr mit anderen beliebten Go-Frameworks wie Gin, Chi, Echo und Fiber verglichen und festgestellt, dass GoFr trotz seines umfangreichen Funktionsumfangs eine optimale Leistung erbringt. Das bedeutet, dass Sie alle leistungsstarken Funktionen nutzen können, ohne Kompromisse bei der Leistung einzugehen.
Wir ermutigen Sie, GoFr selbst zu erkunden. Die umfassende Dokumentation, die Tutorials und die aktive Community des Frameworks sind wertvolle Ressourcen, die Sie auf Ihrer Reise begleiten. Mit GoFr können Sie sich auf den Aufbau robuster, skalierbarer und effizient verwalteter Microservices konzentrieren und haben so mehr Zeit für die Kernfunktionen Ihrer Anwendung.
Beginnen Sie noch heute mit GoFr!
Hier sind einige hilfreiche Ressourcen:
GoFr-Website: https://gofr.dev
GoFr GitHub-Repository: https://github.com/gofr-dev/gofr
GoFr Discord Server: https://discord.gg/zyJkVhps
Das obige ist der detaillierte Inhalt vonDas ultimative Golang-Framework für Microservices: GoFr. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
