Píšeme API v Pythone (s Flask a RapidAPI)

Ak čítate tento článok, pravdepodobne už poznáte možnosti, ktoré sa otvárajú použitím API (Application Programming Interface).

Pridaním jedného z mnohých otvorených API do svojho aplikácie môžete rozšíriť funkčnosť tejto aplikácie alebo ju doplniť potrebnými dátami. Ale čo ak ste vyvinuli jedinečnú funkciu, ktorú chcete zdieľať s komunitou?

Odpoveď je jednoduchá: musíte vytvoriť vlastné API..

Aj keď sa to spočiatku zdá ako zložitá úloha, v skutočnosti je to jednoduché. Povieme vám, ako to urobiť pomocou Pythonu.

Čo potrebujete na začiatok

Na vývoj API potrebujete:

• Python 3;
• Flask — jednoduchý a ľahko použiteľný rámec na vytváranie webových aplikácií;
• Flask-RESTful — rozšírenie pre Flask, ktoré umožňuje rýchlo a s minimálnym nastavením vyvinúť REST API.

Inštaláciu vykonáte príkazom:

pip install flask-restful

Odporúčame bezplatný intenzívny kurz programovania pre začiatočníkov:
Vývoj telegram-bota na C# — 26.–28. augusta. Bezplatný intenzívny kurz, ktorý vám umožní zorientovať sa v tom, ako fungujú boti-pomocníci, a v špecifikách práce s API Telegram a iných nuansách. Traja najlepší účastníci získajú od Skillbox 30 000 rubľov..

Predtým, ako začneme

Chystáme sa vyvinúť RESTful API so základnou CRUID-funkcionalitou..

Aby sme úplne pochopili úlohu, poďme si objasniť dva vyššie uvedené pojmy.

Čo je to REST?

REST API (Representational State Transfer) je API, ktoré používa HTTP požiadavky na výmenu dát.

REST API musia spĺňať určité kritériá:

• Architektúra klient-server: klient interaguje s používateľským rozhraním, zatiaľ čo server s backendom a úložiskom dát. Klient a server sú nezávislé, každý z nich môže byť nahradený samostatne od druhého.
• Stateless — žiadne klientské dáta sa neuchovávajú na serveri. Stav relácie sa uchováva na strane klienta.
• Cacheable — klienti môžu ukladať odpovede servera do cache na zlepšenie celkového výkonu.

Čo je to CRUD?

CRUD — koncept programovania, ktorý popisuje štyri základné akcie (create, read, update a delete).

V REST API zodpovedajú typy požiadaviek a metódy požiadaviek za také akcie, ako sú post, get, put, delete.

Teraz, keď sme rozobrali základné pojmy, môžeme pristúpiť k vytvoreniu API.

Vývoj

Vytvorme repozitár citátov o umelej inteligencii. Umelecká inteligencia je jednou z najrýchlejšie sa vyvíjajúcich technológií dnes a Python je obľúbeným nástrojom na prácu s umelou inteligenciou.

S týmto API bude môcť vývojár Pythonu rýchlo získavať informácie o umelej inteligencii a inšpirovať sa novými úspechmi. Ak má vývojár cenné myšlienky na túto tému, môže ich pridať do repozitára.

Začnime importovaním potrebných modulov a nastavením Flask:

from flask import Flask
from flask_restful import Api, Resource, reqparse
import random
app = Flask(__name__)
api = Api(app)

V tomto úryvku Flask, Api a Resource sú triedy, ktoré potrebujeme.

Reqparse je rozhranie na analýzu požiadaviek Flask-RESTful… Budeme tiež potrebovať modul random na zobrazenie náhodného citátu.

Teraz vytvoríme repozitár citátov o umelej inteligencii.

Každý záznam v repozitári bude obsahovať:

• digitálny ID;
• meno autora citátu;
• citát.

Keďže ide len o vzor na učenie, uložíme všetky záznamy v zozname Pythonu. V reálnom aplikácii by sme však pravdepodobne použili databázu.

ai_quotes = [
    {
        "id": 0,
        "author": "Kevin Kelly",
        "quote": "Obchodné plány ďalších 10 000 startupov sa dajú ľahko predpokladať: " +
                 "Zoberte X a pridajte AI."
    },
    {
        "id": 1,
        "author": "Stephen Hawking",
        "quote": "Rozvoj plnej umelej inteligencie by mohol " +
                 "znamenáť koniec ľudskej rasy... " +
                 "Bola by schopná sama vzlietnuť a prekonštruovať " +
                 "sama seba čoraz rýchlejšie. " +
                 "Ľudia, obmedzení pomalou biologickou evolúciou, " +
                 "by sa nemohli konkurencii prispôsobiť a boli by nahradení."
    },
    {
        "id": 2,
        "author": "Claude Shannon",
        "quote": "Predstavujem si čas, keď budeme robotom tým, čím " +
                 "sú psy pre ľudí, " +
                 "a držím palce strojom."
    },
    {
        "id": 3,
        "author": "Elon Musk",
        "quote": "Rýchlosť pokroku v umetnej inteligencii " +
                 "(nemyslím tým úzku AI) " +
                 "je neuveriteľne rýchla. Pokiaľ nemáte priamu " +
                 "expozíciu skupinám ako Deepmind, " +
                 "nemáte predstavu, ako rýchlo — rastie " +
                 "dynamikou blízkou exponenciálnemu rastu. " +
                 "Riziko, že sa v niečom vážne nebezpečnom " +
                 "stane niečo, je v horizonte piatich rokov. " +
                 "Najviac 10 rokov."
    },
    {
        "id": 4,
        "author": "Geoffrey Hinton",
        "quote": "Vždy som bol presvedčený, že jediný spôsob, " +
                 "ako dosiahnuť, aby umelá inteligencia fungovala, " +
                 "je robiť výpočty spôsobom podobným ľudskému mozgu. " +
                 "To je cieľ, ktorý sledujem. Dosahujeme pokrok, " +
                 "aj keď ešte máme veľa na učenie sa o " +
                 "tom, ako mozog skutočne funguje."
    },
    {
        "id": 5,
        "author": "Pedro Domingos",
        "quote": "Ľudia sa obávajú, že počítače sa " +
                 "stanú príliš inteligentné a ovládnu svet, " +
                 "ale skutočný problém je, že sú príliš hlúpe " +
                 "a už ovládli svet."
    },
    {
        "id": 6,
        "author": "Alan Turing",
        "quote": "Zdá sa pravdepodobné, že akonáhle začne " +
                 "metóda myslenia strojov, nebude trvať dlho, " +
                 "aby prekonali naše slabé schopnosti... " +
                 "Budú schopní medzi sebou konverzovať „+" +
                 "aby si ostreli vtipy. " +
                 "V nejakom štádiu sa preto musíme " +
                 "očakávať, že stroje prevezmú kontrolu."
    },
    {
        "id": 7,
        "author": "Ray Kurzweil",
        "quote": "Umelej inteligencie dosiahne " +
                 "ľudské úrovne okolo roku 2029. " +
                 "Ak sa pozrieme ďalej, povedzme na rok 2045, " +
                 "násobíme inteligenciu, " +
                 "inteligenciu našej ľudskej biologickej mašiny " +
                 "našej civilizácie miliardakrát."
    },
    {
        "id": 8,
        "author": "Sebastian Thrun",
        "quote": "Nikto to takto neformuluje, ale myslím si, " +
                 "že umelá inteligencia " +
                 "je takmer disciplínou humanitných vied. Je to naozaj pokus " +
                 "pochopiť ľudskú inteligenciu a ľudské kognície."
    },
    {
        "id": 9,
        "author": "Andrew Ng",
        "quote": "Robíme túto analógiu, že AI je nová elektrina." +
                 "Elektřina transformovala odvetvia: poľnohospodárstvo, " +
                 "dopravu, komunikáciu, výrobu."
    }
]

Teraz je potrebné vytvoriť triedu Quote, ktorá bude definovať operácie koncových bodov nášho API. V triede je potrebné deklarovať štyri metódy: get, post, put, delete.

Začneme metódou GET

Umožňuje získať konkrétny citát určením jeho ID, alebo náhodný citát, ak ID nie je zadané.

class Quote(Resource):
    def get(self, id=0):
        if id == 0:
            return random.choice(ai_quotes), 200
        for quote in ai_quotes:
            if(quote["id"] == id):
                return quote, 200
        return "Citát nenájdený", 404

Metóda GET vracia náhodný citát, ak ID obsahuje predvolenú hodnotu, t.j. ak pri volaní metódy ID nebolo zadané.

Ak je zadané, metóda hľadá medzi citátmi a nájde ten, ktorý má zadané ID. Ak sa nič nenájde, zobrazí sa správa "Citát nenájdený, 404".

Pamätajte: Metóda vracia HTTP status 200 v prípade úspešného požiadavku a 404, ak záznam nebol nájdený.

Teraz vytvoríme POST metódu na pridanie nového citátu do repozitára

Bude prijímať identifikátor každého nového citátu pri vstupe. Okrem toho bude POST používať reqparse na parsovanie parametrov, ktoré pôjdu v tele požiadavku (autor a text citátu).

def post(self, id):
      parser = reqparse.RequestParser()
      parser.add_argument("author")
      parser.add_argument("quote")
      params = parser.parse_args()
      for quote in ai_quotes:
          if(id == quote["id"]):
              return f"Citát s ID {id} už existuje", 400
      quote = {
          "id": int(id),
          "author": params["author"],
          "quote": params["quote"]
      }
      ai_quotes.append(quote)
      return quote, 201

V uvedenom kóde POST metóda prijala ID citátu. Potom, pomocou reqparse, získala autora a citát z požiadavku, pričom ich uložila do slovníka params.

Ak citát s uvedeným ID už existuje, metóda zobrazí príslušnú správu a kód 400.

Ak citát s uvedeným ID ešte nebol vytvorený, metóda vytvorí nový záznam s uvedeným ID a autorom, ako aj ďalšími parametrami. Potom pridá záznam do zoznamu ai_quotes a vráti záznam s novým citátom spolu s kódom 201.

Teraz vytvárame PUT metódu na zmenu existujúceho citátu v repozitári

def put(self, id):
      parser = reqparse.RequestParser()
      parser.add_argument("author")
      parser.add_argument("quote")
      params = parser.parse_args()
      for quote in ai_quotes:
          if(id == quote["id"]):
              quote["author"] = params["author"]
              quote["quote"] = params["quote"]
              return quote, 200
      
      quote = {
          "id": id,
          "author": params["author"],
          "quote": params["quote"]
      }
      
      ai_quotes.append(quote)
      return quote, 201

Metóda PUT, podobne ako v predchádzajúcom príklade, berie ID a vstup a parsuje parametre citácie pomocou reqparse.

Ak citácia so zadaným ID existuje, metóda ju aktualizuje s novými parametrami a potom vráti aktualizovanú citáciu s kódom 200. Ak citácia so zadaným ID ešte neexistuje, bude vytvorený nový záznam s kódom 201.

Nakoniec vytvorme metódu DELETE na odstránenie citácie, ktorá už inšpiruje.

def delete(self, id):
      global ai_quotes
      ai_quotes = [quote for quote in ai_quotes if quote["id"] != id]
      return f"Citácia s id {id} bola odstránená.", 200

Táto metóda prijíma ID citácie pri vstupe a aktualizuje zoznam ai_quotes pomocou globálneho zoznamu.

Teraz, keď sme vytvorili všetky metódy, všetko, čo potrebujeme, je jednoducho pridať resource k API, nastaviť cestu a spustiť Flask.

api.add_resource(Quote, "\/ai-quotes", "\/ai-quotes\/", "\/ai-quotes\/")
if __name__ == '__main__':
    app.run(debug=True)

Náš REST API služba je pripravená!

Ďalej môžeme uložiť kód do súboru app.py a spustiť ho v konzole pomocou príkazu:

python3 app.py

Ak je všetko v poriadku, dostaneme niečo takéto:

* Debug mode: zapnuté
* Beží na 127.0.0.1:5000\/ (Stlačte CTRL+C na ukončenie)
* Reštartovanie so stat
* Debugger je aktívny!
* Debugger PIN: XXXXXXX

Testujeme API

Po tom, ako API bolo vytvorené, je potrebné ho otestovať.

Môžete to urobiť pomocou konzolového nástroja curl alebo klienta Insomnia REST, alebo zverejnením API na Rapid API.

Zverejňujeme naše API

RapidAPI je najväčšie na svete trhovisko s viac ako 10 000 API (a okolo 1 milióna vývojárov).

RapidAPI nielenže poskytuje jednotné rozhranie na prácu s externými API, ale aj umožňuje rýchlo a bez problémov zverejniť vaše vlastné API.

Aby ste aby ste to mohli urobiť, najskôr je potrebné zverejniť ho na nejakom serveri v sieti. V našom prípade využijeme Heroku. Práca s ním by nemala vyvolať žiadne ťažkosti, (viac informácií o ňom sa môžete dozvedieť tu).

Ako zverejniť vaše API na Heroku

1. Nainštalujeme Heroku.

Najprv sa musíte zaregistrovať a nainštalovať Heroku Command Line Interface (CLI). To funguje na Ubuntu 16+.

sudo snap install heroku --classic

Potom sa prihlásime:

heroku login

2. Pridáme potrebné súbory.

Teraz musíme pridať súbory na zverejnenie do priečinka v našej aplikácii:

• requirements.txt so zoznamom potrebných Python modulov;
• Procfile, ktorý určuje, aké príkazy sa majú vykonať na spustenie aplikácie;
• .gitignore — na vylúčenie súborov, ktoré nie sú potrebné na serveri.

Súbor requirements.txt bude obsahovať nasledujúce riadky:

• flask
• flask-restful
• gunicorn

Prosím, vezmite na vedomie: pridali sme gunicorn (Python WSGI HTTP Server) do zoznamu, pretože je potrebné spustiť našu aplikáciu na serveri.

Procfile bude obsahovať:

web: gunicorn app:app

Obsah .gitignore:

*.pyc
__pycache__/

Teraz, keď sú súbory vytvorené, inicializujme git-repo a urobme commit:

git init
git add
git commit -m "Prvý API commit"

3. Vytvoríme novú aplikáciu Heroku.

heroku create

Odosielame master branch do vzdialeného repo Heroku:

git push heroku master

Teraz môžeme začať otvorením API servisu pomocou príkazov:

heroku ps:scale web=1
heroku open
 

API bude dostupné na adrese your-random-heroku-name.herokuapp.com/ai-quotes.

Ako pridať váš Python API na trh RapidAPI

Po tom, čo je API servis publikovaný na Heroku, ho môžeme pridať k Rapid API. Tu nájdete podrobnú dokumentáciu k tejto téme.

1. Vytvorte účet RapidAPI.

Zaregistrujte si bezplatný účet - to je možné urobiť pomocou Facebooku, Google, GitHub.

2. Pridajte API do ovládacieho panela.

3. Potom zadajte základné informácie o svojom API.

4. Po kliknutí na „Add API“ sa objaví nová stránka, kde môžete zadať informácie o našom API.

5. Teraz môžete buď manuálne zadať koncové body API, alebo nahrať swagger-file pomocou OpenAPI.

A teraz je potrebné určiť koncové body nášho API na stránke Endpoints. V našom prípade koncové body zodpovedajú konceptu CRUD (get, post, put, delete).

Potom je potrebné vytvoriť koncový bod GET AI Quote, ktorý vracia náhodný citát (v prípade, že ID je predvolené) alebo citát pre zadané ID.

Na vytvorenie koncového bodu je potrebné stlačiť tlačidlo „Create Endpoint“.

Tento proces opakujeme pre všetky ostatné koncové body API. To je všetko! Blahoželám, publikovali ste svoje API!

Ak je všetko v poriadku, stránka API bude vyzerať nejako takto:

Záver

V tomto článku sme si prešli proces vytvárania vlastného RESTful API Servisu v Pythone, spolu s procesom publikovania API v cloudovom prostredí Heroku a jeho pridaním do katalógu RapidAPI.

Ale v testovacej verzii boli ukázané iba základné princípy vývoja API — také nuansy, ako sú bezpečnosť, odolnosť a škálovateľnosť, neboli zohľadnené.

Pri vývoji reálneho API je potrebné na to myslieť.

Zdroj: habr.com