Golang implémente la passerelle API

Avec la popularité de l'architecture des microservices, la communication entre les différents services est devenue un enjeu très important. Afin de garantir le fonctionnement stable de l'architecture des microservices, un bon moyen est nécessaire pour contrôler et gérer la communication entre eux. La passerelle API est un composant important utilisé pour contrôler et gérer la communication entre les microservices.

La passerelle API est un modèle de l'architecture du microservice, qui permet d'exposer les fonctions de service et de contrôler la communication en acheminant toutes les requêtes API vers les instances de microservice correspondantes. Les passerelles API peuvent également améliorer la sécurité et la fiabilité de l'architecture des microservices en ajoutant la sécurité, la conversion de protocole, l'équilibrage de charge, le contrôle d'accès et d'autres fonctions aux demandes et réponses. Dans les applications pratiques, les passerelles API sont généralement déployées sur le cloud et constituent un outil important pour la création de systèmes distribués.

golang est un excellent langage de programmation présentant les caractéristiques de hautes performances, de haute concurrence, de haute efficacité et de maintenance facile. Dans le cadre de l'architecture des microservices, le modèle de programmation de Golang est cohérent avec la communication entre les services, de sorte que de plus en plus d'entreprises commencent à utiliser Golang pour implémenter leurs propres passerelles API. Cet article explique comment utiliser Golang pour implémenter une passerelle API simple.

1. Comprendre l'architecture de la passerelle API

Avant de mettre en œuvre la passerelle API, nous devons comprendre l'architecture de base de la passerelle API. L'architecture de base de la passerelle API est la suivante :

La passerelle API comprend les composants suivants :

• Router (routeur) : responsable du routage des requêtes entrantes vers différentes instances de microservice.
• Équilibreur de charge : responsable de la distribution des requêtes sur différentes instances de microservices.
• Gestionnaire de sécurité (responsable de la sécurité) : Responsable de la gestion de la sécurité de la passerelle API pour garantir que les ressources réseau ne sont pas accessibles par des unités non autorisées.
• Validateur : Responsable de la vérification de l'identité des appelants de l'API.
• Cache manager (caching manager) : Responsable de la gestion du cache des réponses API et de la réduction de la pression sur les microservices.
• Panneau d'administration (panneau d'administration) : fournit aux administrateurs un panneau de contrôle visuel pour les passerelles API et les microservices.

2. Code pour implémenter la passerelle API

Voyons maintenant comment utiliser Golang pour implémenter le code de la passerelle API. Nous utiliserons le framework gin pour implémenter les fonctions de base de la passerelle API. Tout d'abord, nous devons installer le framework gin :

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

Ensuite, le premier exemple de code que nous pouvons écrire pour implémenter le contrôle de routage de base de la passerelle API via le framework 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") 
}

Nous pouvons exécuter le code et accéder à http:// localhost : 8080/ pour vérifier que notre code fonctionne correctement. Écrivons maintenant du code plus complexe pour implémenter le contrôle de routage de la passerelle API. Dans cet exemple, nous montrons comment acheminer les requêtes entrantes vers différentes instances de microservice.

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

Dans cet exemple, nous avons créé deux routeurs, chacun correspondant à des requêtes API différentes. Dans chaque routeur, nous définissons une requête GET avec des paramètres. Lorsque ces requêtes seront appelées, elles seront d’abord acheminées dans le routeur puis redirigées vers l’instance de microservice correspondante. Notez que nous devons utiliser ReverseProxy pour rediriger l'URL de la requête vers l'URL de l'instance de microservice avant d'effectuer la redirection.

3. Ajouter une fonction d'équilibrage de charge

Un autre composant très important de la passerelle API est l'équilibreur de charge. Les équilibreurs de charge peuvent distribuer des requêtes à plusieurs instances de microservices, améliorant ainsi la fiabilité et les performances de l'ensemble du système. Vous trouverez ci-dessous un exemple de code montrant comment nous pouvons implémenter un équilibreur de charge simple à l'aide de Golang.

Tout d'abord, nous devons installer l'API Consul et Consul :

go get github.com/hashicorp/consul/api

Nous pouvons maintenant utiliser l'API Consul et Consul pour créer un client Consul qui vérifiera périodiquement l'état de toutes les instances de microservice et sélectionnera dynamiquement en fonction des conditions de charge l'équilibreur de charge. Voici un exemple de code pour créer un client à l'aide de l'API Consul et Consul :

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

Dans cet exemple, nous utilisons d'abord l'API Consul pour obtenir périodiquement l'état de toutes les instances de microservice dans le constructeur et entre elles via la fonction NextEndpoint dans LoadBalance À tour de rôle pour répartir la charge. Notez que nous définissons une structure LoadBalance et ses fonctions associées en tant que module indépendant à partager entre différentes routes de la passerelle API. Dans le routage de l'API, nous redirigeons la requête vers l'URL renvoyée dans la structure LoadBalance.

Résumé

Grâce à cet article, vous devriez déjà comprendre l'application de base de golang dans la passerelle API. Nous avons commencé par l'infrastructure et avons démontré du code Golang simple, montrant le contrôle du routage, l'équilibrage de charge, la gestion de la sécurité et d'autres fonctions de la passerelle API. J'espère que ce contenu pourra vous aider à mieux comprendre l'application de Golang dans l'architecture des microservices et vous aider dans vos projets.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!