Utiliser Kong pour la gestion de la passerelle API dans Beego

Avec la popularité de l'architecture des microservices, les passerelles API attirent de plus en plus l'attention. En tant que l'un des composants importants de l'architecture des microservices, la passerelle API est une application responsable de la distribution des requêtes, du routage des requêtes et du filtrage des requêtes. Kong est devenue l'une des passerelles API les plus populaires parmi de nombreuses entreprises en raison de sa flexibilité, de son évolutivité et de sa facilité d'utilisation.

Beego est un framework de développement rapide d'applications Go qui peut prendre en charge le développement d'API RESTful. Dans cet article, nous explorerons comment utiliser Kong pour la gestion des passerelles API dans Beego.

1. Installer Kong

Tout d'abord, nous devons installer Kong. Kong peut fonctionner sur différentes plates-formes, notamment Windows, Linux, Docker, etc. Ici, nous prenons l'exemple de l'installation de Kong sur Linux.

Utilisez yum pour installer Kong :

$ echo '[bintray--kong-kong-rpm]
name=bintray--kong-kong-rpm
baseurl=https://kong.bintray.com/kong-community-edition-rpm/centos/$releasever/$basearch/
gpgcheck=0
repo_gpgcheck=0
enabled=1' | sudo tee /etc/yum.repos.d/bintray-kong-kong-rpm.repo
$ sudo yum install -y kong

Une fois l'installation terminée, exécutez kong pour démarrer le service Kong.

2. Créer une API

Implémentez l'API dans Beego et enregistrez-la auprès de Kong pour en faire une API accessible en externe.

La mise en œuvre de l'API dans Beego est relativement simple, je n'entrerai donc pas trop dans les détails ici. Il convient de noter que vous devez utiliser l'API Admin de Kong dans Beego, vous devez donc installer le client Go officiel de Kong : kong-go-sdk.

$ go get github.com/Kong/go-kong/kong

Avant de créer l'API, nous devons disposer d'un objet client de l'API Kong Admin, comme indiqué ci-dessous :

import "github.com/Kong/go-kong/kong"

const KongAdminURL = "http://localhost:8001"

func NewKongClient() (*kong.Client, error) {
    return kong.NewClient(kong.String(KongAdminURL))
}

Ensuite, nous pouvons implémenter l'enregistrement de l'API via le code. Voici un exemple simple :

func RegisterAPI(name, upstreamURL, requestHost, stripPath string) error {
    kongClient, err := NewKongClient()
    if err != nil {
        return fmt.Errorf("create kong client error: %v", err)
    }

    targetURL, err := url.Parse(upstreamURL)
    if err != nil {
        return fmt.Errorf("parse target url error: %v", err)
    }

    api := &kong.API{
        Name:        kong.String(name),
        Uris:        kong.StringSlice("/" + name),
        UpstreamURL: kong.String(targetURL.String()),
        RequestHost: kong.String(requestHost),
        StripUri:    kong.Bool(true),
        StripPath:   kong.Bool(stripPath),
    }

    _, err = kongClient.APIs().Create(kongContext.Background(), api)
    if err != nil {
        return fmt.Errorf("register api to kong error: %v", err)
    }

    return nil
}

Dans le code ci-dessus, nous créons d'abord un objet client de l'API Kong Admin, puis utilisons kong.API pour créer un objet API, tel que le nom de l'API, en amont. URL correspondant à l'API, nom de domaine demandé, s'il faut activer la suppression de l'URI, s'il faut activer la troncature de l'URI et d'autres options. Enfin, nous créons l'API en utilisant le client de l'API Kong Admin. kong.API 创建一个 API 对象，如API名称、API对应的 Upstream URL、请求的域名、是否启用URI去除、是否启用URI截断等选项。最后，我们使用Kong Admin API 的 client 创建API。

接下来，我们需要配置Kong，增加插件和路由来指定请求和响应的处理。

3. 配置Kong

Kong支持许多插件，使我们可以在请求和响应时进行更高级的处理。常用的插件包括rate-limiting、key-auth和oauth2等。在这里，我们将使用rate-limiting

Ensuite, nous devons configurer Kong, ajouter des plug-ins et des routes pour spécifier le traitement des requêtes et des réponses.

Configuration de Kong

Kong prend en charge de nombreux plugins qui nous permettent d'effectuer un traitement plus avancé sur les requêtes et les réponses. Les plug-ins couramment utilisés incluent rate-limiting, key-auth et oauth2, etc. Ici, nous utiliserons le plugin rate-limiting pour limiter la vitesse d'accès de l'API.

func AddPlugin(apiName string) error {
    kongClient, err := NewKongClient()
    if err != nil {
        return fmt.Errorf("create kong client error: %v", err)
    }

    api, err := kongClient.APIs().Get(kongContext.Background(), &apiName)
    if err != nil {
        return fmt.Errorf("get api error: %v", err)
    }

    plugin := &kong.RateLimiting{
        Name:       kong.String("rate-limiting"),
        ConsumerID: nil,
        Limit:      kong.Int(10),
        Policy:     kong.String("local"),
    }

    _, err = kongClient.Plugins().Create(kongContext.Background(), &kong.Plugin{
        APIID: api.ID,
        Name:  plugin.Name,
        Config: kong.Configuration{
            kong.String("consumer_id"): plugin.ConsumerID,
            kong.String("limit"):       plugin.Limit,
            kong.String("policy"):      plugin.Policy,
        },
    })

    if err != nil {
        return fmt.Errorf("add rate-limiting plugin error: %v", err)
    }

    return nil
}

func AddRoute(apiName string) error {
    kongClient, err := NewKongClient()
    if err != nil {
        return fmt.Errorf("create kong client error: %v", err)
    }

    route := &kong.Route{
        Name:   kong.String(apiName),
        Paths:  kong.StringSlice(fmt.Sprintf("/%s", apiName)),
        StripPath: kong.Bool(true),
        PreserveHost: kong.Bool(false),
        RegexPriority: kong.Int(0),
        Service: &kong.Service{
            ID: kong.String(apiName),
        },
    }

    _, err = kongClient.Routes().Create(kongContext.Background(), route)
    if err != nil {
        return fmt.Errorf("add route error: %v", err)
    }

    return nil
}

Dans le code ci-dessus, nous implémentons les plug-ins et le routage de Kong à l'aide d'appels en chaîne.

Pour faciliter la démonstration, nous avons uniquement ajouté un plug-in de limitation de courant. En exécutant la fonction CreateRateLimiting, nous allons créer un plug-in nommé « rate-limiting » dans la passerelle Kong et l'appliquer à l'API nommée « api-name ». Dans le code, 10 représente la limite du nombre de requêtes simultanées.

Vous devez transmettre le nom de l'API lors de l'exécution de la méthode. Nous devons d'abord créer une API dans la passerelle en utilisant le nom de l'API. Appelez la fonction RegisterAPI pour enregistrer l'API que nous avons implémentée dans l'application Beego auprès de la passerelle Kong.

Après avoir exécuté les fonctions AddPlugin et AddRoute, notre API a été enregistrée dans la passerelle Kong.
4. Ici, nous utilisons la méthode d'enregistrement direct de l'API auprès de la passerelle API Kong dans l'application Beego. En fait, Kong prend également en charge l'utilisation de fichiers de configuration ou d'autres méthodes pour enregistrer l'API via Kong Manager ou Kong Dashboard. Cependant, ces méthodes nous obligent à opérer manuellement en arrière-plan de la passerelle API Kong, ce qui est fastidieux et prend du temps.

Enfin, il nous suffit d'accéder à l'API que nous avons implémentée dans Beego via la passerelle API de Kong. Nous pouvons utiliser Postman ou d'autres clients REST pour les tests.

🎜🎜Résumé : 🎜🎜🎜Dans cet article, nous avons présenté comment utiliser Kong pour la gestion de la passerelle API, y compris l'enregistrement de l'API, l'ajout de plug-ins et la spécification de l'itinéraire. L'utilisation de Kong comme passerelle API peut permettre une gestion et une surveillance des API plus flexibles, efficaces et sécurisées. 🎜

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!