Verwendung von Kong für die API-Gateway-Verwaltung in Beego

Mit der Popularität der Microservice-Architektur ziehen API-Gateways immer mehr Aufmerksamkeit auf sich. Als eine der wichtigen Komponenten in der Microservice-Architektur ist das API-Gateway eine Anwendung, die für die Verteilung von Anforderungen, das Weiterleiten von Anforderungen und das Filtern von Anforderungen verantwortlich ist. Aufgrund seiner Flexibilität, Skalierbarkeit und Benutzerfreundlichkeit ist Kong bei vielen Unternehmen zu einem der beliebtesten API-Gateways geworden.

Beego ist ein Framework für die schnelle Entwicklung von Go-Anwendungen, das Unterstützung für die RESTful-API-Entwicklung bieten kann. In diesem Artikel erfahren Sie, wie Sie Kong für die API-Gateway-Verwaltung in Beego verwenden.

1. Kong installieren

Zuerst müssen wir Kong installieren. Kong kann auf verschiedenen Plattformen ausgeführt werden, darunter Windows, Linux, Docker usw. Hier nehmen wir als Beispiel die Installation von Kong unter Linux.

Verwenden Sie yum, um Kong zu installieren:

$ 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

Nach Abschluss der Installation führen Sie kong aus, um den Kong-Dienst zu starten.

2. API erstellen

Implementieren Sie die API in Beego und registrieren Sie sie bei Kong, um sie zu einer extern zugänglichen API zu machen.

Die Implementierung der API in Beego ist relativ einfach, daher werde ich hier nicht zu sehr ins Detail gehen. Es ist zu beachten, dass Sie die Admin-API von Kong in Beego verwenden müssen, also müssen Sie den offiziellen Go-Client von Kong installieren: kong-go-sdk.

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

Bevor wir die API erstellen, benötigen wir ein Client-Objekt der Kong Admin API, wie unten gezeigt:

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

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

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

Dann können wir die Registrierung der API über Code implementieren. Hier ist ein einfaches Beispiel:

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
}

Im obigen Code erstellen wir zunächst ein Clientobjekt der Kong Admin API und verwenden dann kong.API, um ein API-Objekt zu erstellen, z. B. den API-Namen Upstream URL, die der API entspricht, angeforderter Domänenname, ob die URI-Entfernung aktiviert werden soll, ob die URI-Kürzung aktiviert werden soll und andere Optionen. Schließlich erstellen wir die API mithilfe des Clients der Kong Admin API. 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

Als nächstes müssen wir Kong konfigurieren, Plug-Ins und Routen hinzufügen, um die Verarbeitung von Anfragen und Antworten festzulegen.

Konfigurieren von Kong

Kong unterstützt viele Plugins, die es uns ermöglichen, eine erweiterte Verarbeitung von Anfragen und Antworten durchzuführen. Zu den häufig verwendeten Plug-ins gehören rate-limiting, key-auth und oauth2 usw. Hier verwenden wir das Plugin rate-limiting, um die API-Zugriffsgeschwindigkeit zu begrenzen.

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
}

Im obigen Code implementieren wir Kongs Plug-Ins und Routing mithilfe von Kettenaufrufen.

Zur Vereinfachung der Demonstration haben wir nur ein Strombegrenzungs-Plug-in hinzugefügt. Durch Ausführen der CreateRateLimiting-Funktion erstellen wir ein Plug-in mit dem Namen „rate-limiting“ im Kong-Gateway und wenden es auf die API mit dem Namen „api-name“ an. Im Code stellt 10 die Begrenzung der Anzahl gleichzeitiger Anforderungen dar.

Sie müssen beim Ausführen der Methode den Namen der API übergeben. Wir müssen zunächst eine API im Gateway erstellen, die den API-Namen verwendet. Rufen Sie die RegisterAPI-Funktion auf, um die API, die wir in der Beego-Anwendung implementiert haben, beim Kong-Gateway zu registrieren.

Nachdem die AddPlugin-Funktion und die AddRoute-Funktion ausgeführt wurden, wurde unsere API im Kong-Gateway registriert.
4. Hier verwenden wir die Methode der direkten Registrierung der API beim Kong API-Gateway in der Beego-Anwendung. Tatsächlich unterstützt Kong auch die Verwendung von Konfigurationsdateien oder anderen Methoden zur Registrierung der API über Kong Manager oder Kong Dashboard. Bei diesen Methoden müssen wir jedoch manuell im Hintergrund des Kong-API-Gateways arbeiten, was umständlich und zeitaufwändig ist.

Schließlich müssen wir nur noch über Kongs API-Gateway auf die API zugreifen, die wir in Beego implementiert haben. Zum Testen können wir Postman oder andere REST-Clients verwenden.

🎜🎜Zusammenfassung: 🎜🎜🎜In diesem Artikel haben wir vorgestellt, wie Sie Kong für die API-Gateway-Verwaltung verwenden, einschließlich API-Registrierung, Plug-in-Hinzufügung und Routenspezifikation. Durch die Verwendung von Kong als API-Gateway kann eine flexiblere, effizientere und sicherere API-Verwaltung und -Überwachung erreicht werden. 🎜

Das obige ist der detaillierte Inhalt vonVerwendung von Kong für die API-Gateway-Verwaltung in Beego. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!