streamalism.org

1. Úvod

Kong je otvorená brána API a vrstva správy mikroslužieb.

Vďaka zásuvnej architektúre Kong je Nginx a modul lua-nginx (konkrétne OpenResty) flexibilný a výkonný.

2. Kľúčové pojmy

Predtým, ako sa ponoríme do ukážok kódu, pozrime sa na kľúčové koncepty v Kongu:

• Objekt API - zabalí vlastnosti ľubovoľného koncového bodu HTTP, ktorý dokončí konkrétnu úlohu alebo poskytne nejakú službu. Konfigurácie zahŕňajú metódy HTTP, identifikátory URI koncového bodu, adresu URL na výstupe, ktorá smeruje na naše servery API a použije sa na žiadosti o proxy server, maximálny počet vyradených súborov, limity rýchlosti, časové limity atď.
• Spotrebiteľský objekt - zabalí vlastnosti kohokoľvek, kto používa naše koncové body API. Bude slúžiť na sledovanie, kontrolu prístupu a ďalšie
• Predradený objekt - popisuje, ako budú prichádzajúce požiadavky proxy alebo vyrovnávané zaťaženie, predstavované virtuálnym názvom hostiteľa
• Cieľový objekt - predstavuje služby, ktoré sú implementované a poskytované, identifikované názvom hostiteľa (alebo IP adresou) a portom. Upozorňujeme, že ciele každého upstream je možné iba pridať alebo zakázať. História cieľových zmien je udržiavaná proti prúdu
• Objekt doplnku - zásuvné funkcie na obohatenie funkcií našej aplikácie počas životného cyklu požiadaviek a odpovedí. Napríklad je možné pridať funkcie autentifikácie API a obmedzovania rýchlosti povolením príslušných doplnkov. Spoločnosť Kong poskytuje vo svojej galérii doplnkov veľmi výkonné doplnky
• Admin API - Koncové body RESTful API používané na správu konfigurácií Konga, koncových bodov, spotrebiteľov, doplnkov atď

Obrázok nižšie zobrazuje, ako sa Kong líši od staršej architektúry, čo by nám mohlo pomôcť pochopiť, prečo zaviedol tieto koncepty:

(zdroj: //getkong.org/)

3. Inštalácia

Oficiálna dokumentácia obsahuje podrobné pokyny pre rôzne prostredia.

4. Správa API

Po lokálnom nastavení Kongu si poďme zahryznúť do jeho výkonných funkcií prostredníctvom proxy servera nášho koncového bodu jednoduchého dotazu na akcie:

@RestController @RequestMapping ("/ stock") verejná trieda QueryController {@GetMapping ("/ {code}") verejný reťazec getStockPrice (@PathVariable kód reťazca) {návrat "BTC" .equalsIgnoreCase (kód)? "10 000": "0"; }}

4.1. Pridanie API

Ďalej pridajme naše dopytovacie API do Kongu.

Správcovské API sú prístupné cez // localhost: 8001, takže všetky naše operácie správy API sa budú robiť s týmto základným URI:

APIObject stockAPI = nový APIObject ("stock-api", "stock.api", "// localhost: 8080", "/"); HttpEntity apiEntity = nový HttpEntity (stockAPI); ResponseEntity addAPIResp = restTemplate.postForEntity ("// localhost: 8001 / apis", apiEntity, String.class); assertEquals (HttpStatus.CREATED, addAPIResp.getStatusCode ());

Tu sme pridali API s nasledujúcou konfiguráciou:

{"name": "stock-api", "hosts": "stock.api", "upstream_url": "// localhost: 8080", "uris": "/"}

• "názov" je identifikátor API, ktorý sa používa pri manipulácii s jeho správaním
• „Hostitelia“ sa použije na smerovanie prichádzajúcich požiadaviek na dané „Upstream_url“ zhodou s "Hostiteľ" hlavička
• Relatívne cesty budú priradené nakonfigurovanému „uris“

V prípade, že chceme zastarať API alebo je nesprávna konfigurácia, môžeme ho jednoducho odstrániť:

restTemplate.delete ("// localhost: 8001 / apis / stock-api");

Po pridaní API budú k dispozícii na spotrebu prostredníctvom // localhost: 8000:

Reťazec apiListResp = restTemplate.getForObject ("// localhost: 8001 / apis /", String.class); assertTrue (apiListResp.contains ("stock-api")); Hlavičky HttpHeaders = nové HttpHeaders (); headers.set ("Hostiteľ", "stock.api"); RequestEntity requestEntity = new RequestEntity (headers, HttpMethod.GET, new URI ("// localhost: 8000 / stock / btc")); ResponseEntity stockPriceResp = restTemplate.exchange (requestEntity, String.class); assertEquals ("10 000", stockPriceResp.getBody ());

Vo vyššie uvedenej ukážke kódu sa pokúsime zistiť cenu akcií pomocou API, ktoré sme práve pridali do Kongu.

Vyžiadaním // localhost: 8000 / stock / BTC, dostaneme rovnakú službu ako dopytovanie priamo z // localhost: 8080 / stock / BTC.

4.2. Pridanie spotrebiteľa API

Poďme teraz k bezpečnosti - konkrétnejšie k autentifikácii používateľov, ktorí pristupujú k nášmu API.

Pridajme spotrebiteľa do nášho API dotazu na zásoby, aby sme mohli neskôr povoliť funkciu autentifikácie.

Pridanie spotrebiteľa pre API je rovnako jednoduché ako pridanie API. Meno (alebo ID) spotrebiteľa je jediné povinné pole vo všetkých jeho vlastnostiach:

ConsumerObject consumer = new ConsumerObject ("eugenp"); HttpEntity addConsumerEntity = nový HttpEntity (spotrebiteľ); ResponseEntity addConsumerResp = restTemplate.postForEntity ("// localhost: 8001 / consumer /", addConsumerEntity, String.class); assertEquals (HttpStatus.CREATED, addConsumerResp.getStatusCode ());

Tu sme pridali „eugenp“ ako nového spotrebiteľa:

{"používateľské meno": "eugenp"}

4.3. Povolenie autentifikácie

Prichádza najvýkonnejšia funkcia Konga, pluginy.

Teraz použijeme doplnok auth na naše API s požiadavkami na proxy servery:

PluginObject authPlugin = nový PluginObject ("key-auth"); ResponseEntity enableAuthResp = restTemplate.postForEntity ("// localhost: 8001 / apis / stock-api / plugins", nový HttpEntity (authPlugin), String.class); assertEquals (HttpStatus.CREATED, enableAuthResp.getStatusCode ());

Ak sa pokúsime zistiť cenu akcie prostredníctvom proxy servera URI, žiadosť bude zamietnutá:

Hlavičky HttpHeaders = nové HttpHeaders (); headers.set ("Hostiteľ", "stock.api"); RequestEntity requestEntity = new RequestEntity (headers, HttpMethod.GET, new URI ("// localhost: 8000 / stock / btc")); ResponseEntity stockPriceResp = restTemplate .exchange (requestEntity, String.class); assertEquals (HttpStatus.UNAUTHORIZED, stockPriceResp.getStatusCode ());

Zapamätaj si to Eugen je jedným z našich spotrebiteľov API, takže by sme mu mali umožniť používať toto API pridaním autentifikačného kľúča:

Reťazec consumerKey = "eugenp.pass"; KeyAuthObject keyAuth = nový KeyAuthObject (consumerKey); ResponseEntity keyAuthResp = restTemplate.postForEntity ("// localhost: 8001 / consumer / eugenp / key-auth", nový HttpEntity (keyAuth), String.class); assertTrue (HttpStatus.CREATED == keyAuthResp.getStatusCode ());

Potom Eugen môže toto API používať ako predtým:

Hlavičky HttpHeaders = nové HttpHeaders (); headers.set ("Hostiteľ", "stock.api"); headers.set ("apikey", consumerKey); RequestEntity requestEntity = new RequestEntity (headers, HttpMethod.GET, new URI ("// localhost: 8000 / stock / btc")); ResponseEntity stockPriceResp = restTemplate .exchange (requestEntity, String.class); assertEquals ("10 000", stockPriceResp.getBody ());

5. Pokročilé funkcie

Okrem základného proxy servera a správy API Kong podporuje aj vyvažovanie záťaže API, klastrovanie, kontrolu stavu a monitorovanie atď.

V tejto časti sa pozrieme na to, ako načítať požiadavky na vyváženie pomocou protokolu Kong a ako zabezpečiť administrátorské rozhrania API.

5.1. Rozdelenie výkonu

Kong poskytuje dve stratégie požiadaviek na vyrovnávanie zaťaženia back-endových služieb: dynamický ring-balancer a priama metóda založená na DNS. Kvôli jednoduchosti použijeme vyvažovač krúžkov.

Ako sme už spomenuli, upstream sa používa na vyvažovanie záťaže a každý upstream môže mať viac cieľov.

Kong podporuje vyvažovacie algoritmy založené na váženom opakovaní a na hashe. Predvolene sa používa schéma váženého princípu každý s každým - kde sa žiadosti doručujú každému cieľu podľa jeho váhy.

Najprv si pripravme protiprúdový prúd:

UpstreamObject upstream = nový UpstreamObject ("stock.api.service"); ResponseEntity addUpstreamResp = restTemplate.postForEntity ("// localhost: 8001 / upstreams", nový HttpEntity (upstream), String.class); assertEquals (HttpStatus.CREATED, addUpstreamResp.getStatusCode ());

Potom pridajte dva ciele pre upstream, testovaciu verziu s hmotnosť = 10a vydaná verzia s hmotnosť = 40:

TargetObject testTarget = nový TargetObject ("localhost: 8080", 10); ResponseEntity addTargetResp = restTemplate.postForEntity ("//localhost:8001/upstreams/stock.api.service/targets", nový HttpEntity (testTarget), String.class); assertEquals (HttpStatus.CREATED, ddTargetResp.getStatusCode ()); TargetObject releaseTarget = nový TargetObject ("localhost: 9090", 40); addTargetResp = restTemplate.postForEntity ("//localhost:8001/upstreams/stock.api.service/targets", nový HttpEntity (releaseTarget), String.class); assertEquals (HttpStatus.CREATED, addTargetResp.getStatusCode ());

Pri konfigurácii vyššie môžeme predpokladať, že 1/5 požiadaviek prejde na testovaciu verziu a 4/5 na vydanú verziu:

APIObject stockAPI = nový APIObject ("vyvážený-sklad-api", "vyvážený.stock.api", "//stock.api.service", "/"); HttpEntity apiEntity = nový HttpEntity (stockAPI); ResponseEntity addAPIResp = restTemplate.postForEntity ("// localhost: 8001 / apis", apiEntity, String.class); assertEquals (HttpStatus.CREATED, addAPIResp.getStatusCode ()); Hlavičky HttpHeaders = nové HttpHeaders (); headers.set ("Hostiteľ", "vyvážený.stock.api"); for (int i = 0; i <1000; i ++) {RequestEntity requestEntity = new RequestEntity (headers, HttpMethod.GET, new URI ("// localhost: 8000 / stock / btc")); ResponseEntity stockPriceResp = restTemplate.exchange (requestEntity, String.class); assertEquals ("10 000", stockPriceResp.getBody ()); } int releaseCount = restTemplate.getForObject ("// localhost: 9090 / stock / reqcount", Integer.class); int testCount = restTemplate.getForObject ("// localhost: 8080 / stock / reqcount", Integer.class); assertTrue (Math.round (releaseCount * 1,0 / testCount) == 4);

Upozorňujeme, že schéma váženého princípu opakovania vyvažuje požiadavky na back-endové služby približne do hmotnostného pomeru, takže je možné overiť iba približnú hodnotu pomeru, ktorá sa odráža v poslednom riadku vyššie uvedeného kódu.

5.2. Zabezpečenie správcovského rozhrania API

V predvolenom nastavení prijíma server Kong iba požiadavky správcov z miestneho rozhrania, čo je vo väčšine prípadov dostatočne dobré obmedzenie. Ale ak to chceme spravovať cez iné sieťové rozhrania, môžeme zmeniť admin_listen hodnota v kong.confa nakonfigurovať pravidlá brány firewall.

Prípadne môžeme nastaviť, aby Kong slúžil ako proxy pre samotné API správcu. Povedzme, že chceme spravovať API pomocou cesty „/ admin-api“, môžeme pridať API takto:

APIObject stockAPI = nový APIObject ("admin-api", "admin.api", "// localhost: 8001", "/ admin-api"); HttpEntity apiEntity = nový HttpEntity (stockAPI); ResponseEntity addAPIResp = restTemplate.postForEntity ("// localhost: 8001 / apis", apiEntity, String.class); assertEquals (HttpStatus.CREATED, addAPIResp.getStatusCode ());

Teraz môžeme na správu API používať proxy proxy administrátora:

Hlavičky HttpHeaders = nové HttpHeaders (); headers.set ("Hostiteľ", "admin.api"); APIObject baeldungAPI = nový APIObject ("baeldung-api", "baeldung.com", "//ww.baeldung.com", "/"); RequestEntity requestEntity = new RequestEntity (baeldungAPI, headers, HttpMethod.POST, new URI ("// localhost: 8000 / admin-api / apis")); ResponseEntity addAPIResp = restTemplate .exchange (requestEntity, String.class); assertEquals (HttpStatus.CREATED, addAPIResp.getStatusCode ());

Iste, chceme, aby bolo proxy server zabezpečené. To sa dá ľahko dosiahnuť povolením overovacieho pluginu pre proxy servera admin.

6. Zhrnutie

V tomto článku sme predstavili Kong - platformu pre mikroslužobnú bránu API a zamerali sme sa na jej základné funkcie - správu rozhraní API a požiadaviek na smerovanie na nadradené servery, ako aj na niektoré pokročilejšie funkcie, ako napríklad vyrovnávanie zaťaženia.

Existuje však ešte veľa solídnych funkcií, ktoré môžeme preskúmať, a v prípade potreby môžeme vyvinúť naše vlastné doplnky - tu môžete ďalej skúmať oficiálnu dokumentáciu.

Celú implementáciu nájdete ako vždy na Githube.