Menggunakan Kong untuk pengurusan get laluan API dalam Beego

Dengan populariti seni bina perkhidmatan mikro, get laluan API semakin menarik perhatian. Sebagai salah satu komponen penting dalam seni bina perkhidmatan mikro, gerbang API ialah aplikasi yang bertanggungjawab untuk mengedarkan permintaan, penghalaan permintaan dan permintaan penapisan. Kong telah menjadi salah satu gerbang API paling popular di kalangan banyak perusahaan kerana fleksibiliti, skalabiliti dan kemudahan penggunaannya.

Beego ialah rangka kerja untuk pembangunan pesat aplikasi Go yang boleh memberikan sokongan untuk pembangunan API RESTful. Dalam artikel ini, kami akan meneroka cara menggunakan Kong untuk pengurusan get laluan API di Beego.

1. Pasang Kong

Mula-mula, kita perlu memasang Kong. Kong boleh berjalan pada platform yang berbeza, termasuk Windows, Linux, Docker, dll. Di sini kami mengambil memasang Kong pada Linux sebagai contoh.

Gunakan yum untuk memasang 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

Selepas pemasangan selesai, jalankan kong untuk memulakan perkhidmatan Kong.

2. Buat API

Laksanakan API dalam Beego dan daftarkannya di Kong untuk menjadikannya API yang boleh diakses oleh dunia luar.

Melaksanakan API dalam Beego agak mudah, jadi saya tidak akan menerangkan terlalu banyak butiran di sini. Perlu diingatkan bahawa anda perlu menggunakan API Pentadbiran Kong dalam Beego, jadi anda perlu memasang pelanggan Go rasmi Kong: kong-go-sdk.

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

Sebelum mencipta API, kita perlu mempunyai objek klien Kong Admin API, seperti yang ditunjukkan di bawah:

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

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

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

Kemudian, kita boleh mendaftarkan API melalui kod. Berikut ialah contoh mudah:

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
}

Dalam kod di atas, kami mula-mula mencipta objek klien Kong Admin API, dan kemudian menggunakan kong.API untuk mencipta objek API, seperti nama API, API yang sepadan dengan Hulu URL, nama domain yang diminta, sama ada untuk mendayakan pengalihan keluar URI, sama ada untuk mendayakan pemotongan URI dan pilihan lain. Akhir sekali, kami mencipta API menggunakan klien Kong Admin API.

Seterusnya, kita perlu mengkonfigurasi Kong, menambah pemalam dan laluan untuk menentukan pemprosesan permintaan dan respons.

3. Mengkonfigurasi Kong

Kong menyokong banyak pemalam yang membolehkan kami melakukan pemprosesan yang lebih lanjut pada permintaan dan respons. Pemalam yang biasa digunakan termasuk rate-limiting, key-auth dan oauth2, dsb. Di sini, kami akan menggunakan pemalam rate-limiting untuk mengehadkan kelajuan akses 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
}

Dalam kod di atas, kami menggunakan panggilan berantai untuk melaksanakan pemalam dan penghalaan Kong.

Untuk kemudahan demonstrasi, kami hanya menambah pemalam pengehad semasa. Dengan menjalankan fungsi CreateRateLimiting, kami akan membuat pemalam bernama "rate-limiting" dalam get laluan Kong dan menggunakannya pada API bernama "api-name". Dalam kod, 10 mewakili had pada bilangan permintaan serentak.

Apabila menjalankan kaedah, anda perlu menghantar nama API terlebih dahulu Kita perlu mencipta API dalam get laluan menggunakan nama api. Panggil fungsi RegisterAPI untuk mendaftarkan API yang kami laksanakan dalam aplikasi Beego dengan get laluan Kong.

Selepas menjalankan fungsi AddPlugin dan fungsi AddRoute, API kami telah didaftarkan dalam gerbang Kong.

Di sini kami menggunakan kaedah pendaftaran terus API dengan gerbang API Kong dalam aplikasi Beego Malah, Kong turut menyokong penggunaan fail konfigurasi atau kaedah lain untuk mendaftarkan API melalui Kong Manager atau Kong Dashboard . Walau bagaimanapun, kaedah ini memerlukan kami untuk beroperasi secara manual dalam latar belakang gerbang API Kong, yang menyusahkan dan memakan masa.

Akhir sekali, kami hanya perlu mengakses API yang kami laksanakan di Beego melalui get laluan API Kong. Kami boleh menggunakan Posmen atau pelanggan REST lain untuk ujian.

4. Ringkasan:

Dalam artikel ini, kami memperkenalkan cara menggunakan Kong untuk pengurusan get laluan API, termasuk pendaftaran API, penambahan pemalam dan spesifikasi laluan. Menggunakan Kong sebagai gerbang API boleh mencapai pengurusan dan pemantauan API yang lebih fleksibel, cekap dan selamat.

Atas ialah kandungan terperinci Menggunakan Kong untuk pengurusan get laluan API dalam Beego. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!