Le framework Golang ultime pour les microservices : GoFr-Golang-php.cn

GoFr: The Ultimate Golang Framework for Microservices

Go est un langage de programmation multiparadigme, typé statiquement et compilé, conçu par Google. De nombreux développeurs ont adopté Go en raison de son système de récupération de place, de la sécurité de sa mémoire et de son système de typage structurel. Les frameworks Web Go ont été créés pour faciliter les processus de développement Web Go sans se soucier des configurations et en se concentrant davantage sur les fonctionnalités d'un projet. Lors de la création de petites applications, les frameworks ne sont peut-être pas nécessaires, mais pour les logiciels de niveau production, ils sont cruciaux. Les frameworks fournissent des fonctionnalités et des services supplémentaires qui peuvent être utilisés par d'autres développeurs qui souhaitent ajouter des fonctionnalités similaires à leur logiciel plutôt que d'écrire eux-mêmes le logiciel à part entière.

Choisir le framework adapté à vos besoins peut permettre des cycles de développement plus rapides et une maintenance plus facile à long terme. Dans cet article, nous parlerons de GoFr, un framework Golang avisé pour le développement accéléré de microservices. Et nous découvrirons pourquoi c'est votre choix ultime lors de la création de microservices dans Go !

GoFr & It est un riche ensemble de fonctionnalités :

Ce qui fait vraiment qu'un framework est bon ou mauvais, c'est la facilité de développement qu'il offre à son utilisateur ainsi que la gamme de fonctionnalités qu'il offre afin que l'utilisateur puisse se concentrer uniquement sur la mise en œuvre de la logique métier. GoFr a été conçu pour aider les développeurs à écrire des API rapides, évolutives et efficaces. Le framework offre un riche ensemble de fonctionnalités qui aident les développeurs à écrire facilement des microservices de qualité production. Explorons certaines de ces fonctionnalités :

1. Gestion efficace des configurations

Les variables d'environnement constituent le meilleur moyen de définir les valeurs de configuration de votre application logicielle, car elles peuvent être définies au niveau du système, indépendamment du logiciel. C'est l'un des principes de la méthodologie Twelve-Factor App et permet de créer des applications avec portabilité.

GoFr dispose de variables d'environnement prédéfinies à diverses fins, telles que la modification des niveaux de journalisation, la connexion à des bases de données, la définition du nom et de la version de l'application, la configuration des ports http, etc. L'utilisateur doit simplement les définir dans un fichier .env dans le répertoire de configuration du l'application et GoFr en lit automatiquement les valeurs.

Voici la liste complète des variables d'environnement prises en charge par GoFr

2. Interactions transparentes avec les bases de données

La gestion des connexions et des interactions avec les bases de données peut devenir mouvementée, en particulier lorsque vous travaillez avec plusieurs bases de données. GoFr gère les connexions à la base de données de manière transparente à l'aide de variables de configuration. Non seulement il gère les connexions, mais il fournit également un accès direct aux objets de la base de données en utilisant le contexte GoFr au sein des gestionnaires. Cette approche simplifie le travail avec plusieurs bases de données. GoFr prend actuellement en charge toutes les bases de données SQL Dialects, Redis, MongoDB, Cassandra et ClickHouse.

Exemple d'utilisation de MySQL et Redis DB dans le gestionnaire.

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
}

Copier après la connexion

3. Implémenter facilement l'architecture éditeur-abonné :

GoFr simplifie Pub/Sub en offrant une prise en charge intégrée pour les clients populaires tels que Kafka, Google Pub/Sub et MQTT. Cela élimine le besoin de configuration manuelle ou de gestion de bibliothèque, vous permettant ainsi de vous concentrer sur votre architecture basée sur les événements. La publication et l'abonnement aux événements sont rationalisés grâce au contexte GoFr. La publication d'événements peut être effectuée à l'intérieur du gestionnaire en utilisant le contexte, et pour vous abonner à un événement, il vous suffit d'utiliser le gestionnaire Subscribe de GoFr. Cette approche favorise un code propre et réduit le passe-partout par rapport à l'implémentation du modèle Pub/Sub à partir de zéro.

Exemple d'utilisation de Publisher et Subscriber dans une application 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
}

Copier après la connexion

4. Observabilité prête à l'emploi :

Une surveillance efficace est cruciale pour maintenir des microservices performants. GoFr vous soulage du fardeau en fournissant des fonctionnalités d'observabilité intégrées. Cela élimine le besoin de configuration manuelle des bibliothèques de traçage, de métriques et de journalisation.

Journalisation détaillée : GoFr propose une journalisation structurée avec différents niveaux de journalisation (INFO, DEBUG, WARN, ERROR, FATAL) pour capturer les événements d'application à différentes granularités. Cela vous permet d'analyser le flux des applications, d'identifier les problèmes potentiels et de rationaliser le débogage.
Mesures exploitables : GoFr collecte et expose automatiquement les métriques des applications, vous permettant de surveiller les indicateurs de performance clés. Grâce aux métriques facilement disponibles, vous pouvez identifier rapidement les goulots d'étranglement et optimiser les performances des applications.
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
}

Copier après la connexion

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()
}

Copier après la connexion

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.

---

Rendu automatique de l'interface utilisateur Swagger :

Fournir une documentation API claire et interactive est essentiel pour l'adoption par les utilisateurs et des flux de travail de développement efficaces. Les spécifications de l'API peuvent être écrites en YAML ou JSON. Le format est facile à apprendre et lisible aussi bien par les humains que par les machines. La spécification OpenAPI complète peut être trouvée sur le site officiel de Swagger.

GoFr prend en charge le rendu automatique de la documentation OpenAPI (également connue sous le nom de Swagger). Cette fonctionnalité vous permet de fournir facilement une documentation API interactive à vos utilisateurs. Pour permettre à GoFr de restituer votre documentation OpenAPI, placez simplement votre fichier openapi.json dans le répertoire statique de votre projet. GoFr restituera automatiquement la documentation Swagger au point de terminaison /.well-known/swagger.

Conclusion

Tout au long de cet article, nous avons exploré les riches fonctionnalités de GoFr, un framework Golang avisé spécialement conçu pour accélérer le développement de microservices. Nous avons vu comment GoFr simplifie les tâches courantes telles que la gestion de la configuration, les interactions avec les bases de données, l'intégration Pub/Sub, l'observabilité automatique, la communication interservices, l'utilisation du middleware et l'authentification. De plus, GoFr offre une prise en charge intégrée des migrations de données, des sockets Web, des tâches cron et des modifications du niveau de journalisation à distance, rationalisant ainsi davantage votre processus de développement.

Nous avons comparé GoFr à d'autres frameworks Go populaires tels que Gin, Chi, Echo et Fiber, et avons constaté que GoFr fonctionnait de manière optimale, même avec son ensemble complet de fonctionnalités. Cela signifie que vous pouvez exploiter toutes ses fonctionnalités puissantes sans compromettre les performances.

Nous vous encourageons à explorer GoFr par vous-même. La documentation complète, les didacticiels et la communauté active du framework sont des ressources précieuses pour vous guider dans votre voyage. Avec GoFr, vous pouvez vous concentrer sur la création de microservices robustes, évolutifs et gérés efficacement, vous permettant ainsi de consacrer plus de temps aux fonctionnalités principales de votre application.

Commencez avec GoFr dès aujourd'hui !

Voici quelques ressources utiles :