Vytváříme API v Pythonu (s Flask a RapidAPI)

Pokud čtete tento článek, pravděpodobně již znáte možnosti, které se otevírají při používání API (rozhraní pro programování aplikací).

Přidáním jednoho z mnoha otevřených API do vaší aplikace můžete rozšířit její funkčnost nebo ji doplnit potřebnými daty. Co však dělat, pokud jste vyvinuli unikátní funkci, kterou chcete sdílet s komunitou?

Odpověď je jednoduchá: musíte vytvořit vlastní API.

I když to zpočátku vypadá jako složitý úkol, ve skutečnosti je vše jednoduché. Povědíme vám, jak to udělat pomocí Pythonu.

Co potřebujete pro začátek

Pro vývoj API potřebujete:

• Python 3;
• Flask — jednoduchý a snadno použitelný framework pro vytváření webových aplikací;
• Flask-RESTful — rozšíření pro Flask, které umožňuje rychlý vývoj REST API s minimální konfigurací.

Instalaci provedete příkazem:

pip install flask-restful

Doporučujeme bezplatný intenzivní kurz programování pro začátečníky:
Vývoj telegramového bota v C# — 26–28 srpna. Bezplatný kurz, který vám pomůže porozumět tomu, jak fungují pomocníci, jak pracovat s API Telegram a dalšími nuancemi. Tři nejlepší účastníci získají od Skillboxu 30 000 rublů..

Předtím, než začnete

Chystáme se vyvinout RESTful API se základní funkcionalitou CRUID.

Abychom plně pochopili úkol, podívejme se na dva termíny, které byly zmíněny výše.

Co je REST?

REST API (Representational State Transfer) je API, které využívá HTTP požadavky pro výměnu dat.

REST API by měla splňovat určité kritéria:

• Architektura klient-server: klient interaguje s uživatelským rozhraním, zatímco server s backendem a datovým úložištěm. Klient a server jsou nezávislé, lze je vyměnit odděleně.
• Stateless — žádná data klienta nejsou uchovávána na serveru. Stav relace je uchováván na straně klienta.
• Caching — klienti mohou ukládat odpovědi serveru do mezipaměti pro zlepšení celkové výkonnosti.

Co je CRUD?

CRUD — koncept programování, který popisuje čtyři základní akce (create, read, update a delete).

V REST API typy požadavků a metody požadavků odpovídají za akce, jako jsou post, get, put, delete.

Teď, když jsme si osvojili základní termíny, můžeme se pustit do vytváření API.

Vývoj

Vytvořme repozitář citátů o umělé inteligenci. AI je jednou z nejrychleji se rozvíjejících technologií současnosti a Python je populárním nástrojem pro práci s AI.

S tímto API bude moci vývojář Pythonu rychle získávat informace o AI a inspirovat se novými úspěchy. Pokud má vývojář cenné myšlenky na toto téma, může je do repozitáře přidat.

Začněme importem potřebných modulů a nastavením Flasku:

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

V tomto úryvku jsou Flask, Api a Resource třídy, které potřebujeme.

Reqparse je rozhraní pro zpracování požadavků Flask-RESTful... Také budeme potřebovat modul random pro zobrazení náhodného citátu.

Nyní vytvoříme repozitář citátů o AI.

Každý záznam v repozitáři bude obsahovat:

• digitální ID;
• jméno autora citátu;
• citát.

Protože se jedná pouze o příklad pro výuku, uchováme všechny záznamy v seznamu Pythonu. V reálné aplikaci bychom pravděpodobně místo toho použili databázi.

ai_quotes = [
    {
        "id": 0,
        "author": "Kevin Kelly",
        "quote": "Podnikatelské plány dalších 10 000 startupů se snadno předpovídají: " +
                 "Vezměte X a přidejte AI."
    },
    {
        "id": 1,
        "author": "Stephen Hawking",
        "quote": "Rozvoj plnohodnotné umělé inteligence by mohl " +
                 "znamenat konec lidského druhu… " +
                 "Odstartovala by sama a přepracovala " +
                 "se stále rychlejším tempem. " +
                 "Lidé, kteří jsou omezeni pomalou biologickou evolucí, " +
                 "by nemohli konkurovat a byli by překonáni."
    },
    {
        "id": 2,
        "author": "Claude Shannon",
        "quote": "Představuji si dobu, kdy budeme pro roboty tím, co " +
                 "psi jsou pro lidi, " +
                 "a fandím strojům."
    },
    {
        "id": 3,
        "author": "Elon Musk",
        "quote": "Tempo pokroku v umělé inteligenci " +
                 "(nemluvím o úzké AI) " +
                 "je neuvěřitelně rychlé. Pokud nemáte přímou " +
                 "expozici skupinám jako Deepmind, " +
                 "nemáte ponětí, jak rychle — roste " +
                 "tempem blízkým exponenciálnímu. " +
                 "Riziko něčeho skutečně nebezpečného " +
                 "se vyskytuje v časovém rámci pěti let." +
                 "10 let maximálně."
    },
    {
        "id": 4,
        "author": "Geoffrey Hinton",
        "quote": "Vždy jsem byl přesvědčen, že jediný způsob, " +
                 "jak přimět umělou inteligenci fungovat, " +
                 "je provádět výpočty způsobem podobným lidskému mozku. " +
                 "To je cíl, který jsem si stanovil. Postupujeme kupředu, " +
                 "i když se stále musíme mnoho naučit o tom, " +
                 "jak mozek skutečně funguje."
    },
    {
        "id": 5,
        "author": "Pedro Domingos",
        "quote": "Lidé se obávají, že počítače se stanou " +
                 "příliš chytrými a ovládnou svět, " +
                 "ale skutečný problém je, že jsou příliš hloupé " +
                 "a už svět ovládly."
    },
    {
        "id": 6,
        "author": "Alan Turing",
        "quote": "Zdá se pravděpodobné, že jakmile začne myšlení stroje, " +
                 "nebude trvat dlouho, " +
                 "než překonají naše slabé schopnosti… " +
                 "Budou schopni si mezi sebou povídat " +
                 "a ostřit své vtipy. " +
                 "V určitém okamžiku bychom tedy " +
                 "měli očekávat, že stroje převezmou kontrolu."
    },
    {
        "id": 7,
        "author": "Ray Kurzweil",
        "quote": "Umělá inteligence dosáhne " +
                 "lidské úrovně přibližně do roku 2029. " +
                 "Pokud se na to podíváme dál, řekněme, do roku 2045, " +
                 "mnohonásobíme inteligenci, " +
                 "inteligenci lidského biologického stroje " +
                 "naší civilizace miliardkrát."
    },
    {
        "id": 8,
        "author": "Sebastian Thrun",
        "quote": "Nikdo to takto neformuluje, ale myslím, " +
                 "že umělá inteligence " +
                 "je téměř oborem humanitních věd. Je to opravdu pokus " +
                 "pochopit lidskou inteligenci a lidské kognice."
    },
    {
        "id": 9,
        "author": "Andrew Ng",
        "quote": "Děláme tuto analogii, že AI je nová elektrická energie." +
                 "Elektrická energie transformovala průmysly: zemědělství, " +
                 "dopravu, komunikaci, výrobu."
    }
]

Nyní je třeba vytvořit zdrojovou třídu Quote, která bude definovat operace koncových bodů našeho API. V rámci třídy je potřeba deklarovat čtyři metody: get, post, put, delete.

Začneme s metodou GET

Ta umožňuje získat určitou citaci na základě jejího ID, nebo náhodnou citaci, pokud ID není uvedeno.

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 "Citace nenalezena", 404

Metoda GET vrací náhodnou citaci, pokud ID obsahuje výchozí hodnotu, tj. při vyvolání metody ID nebylo zadáno.

Pokud je ID zadáno, metoda hledá mezi citacemi a najde tu, která obsahuje zadané ID. Pokud se nic nenajde, zobrazí se zpráva "Citace nenalezena, 404".

Pamatujte: metoda vrací HTTP stav 200 v případě úspěšného požadavku a 404, pokud záznam není nalezen.

Nyní vytvořme POST metodu pro přidání nové citace do repozitáře

Ta přijme identifikátor každé nové citace při zadání. Kromě toho POST použije reqparse pro analýzu parametrů, které budou přicházet v těle požadavku (autor a text citace).

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"Citace s id {id} již existuje", 400
      quote = {
          "id": int(id),
          "author": params["author"],
          "quote": params["quote"]
      }
      ai_quotes.append(quote)
      return quote, 201

Ve výše uvedeném kódu POST metoda přijala ID citace. Poté, pomocí reqparse, získala autora a citaci z požadavku, a uložila je do slovníku params.

Pokud citace s uvedeným ID již existuje, metoda zobrazí odpovídající zprávu a kód 400.

Pokud citace s uvedeným ID ještě nebyla vytvořena, metoda vytvoří nový záznam s uvedeným ID a autorem, stejně jako dalšími parametry. Poté přidá záznam do seznamu ai_quotes a vrátí záznam s novou citací spolu s kódem 201.

Nyní vytvoříme PUT metodu pro změnu existující citace v repozitáři

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

Metoda PUT, podobně jako v předchozím příkladu, bere ID a vstup a parsuje parametry citace pomocí reqparse.

Pokud citace s uvedeným ID existuje, metoda ji aktualizuje s novými parametry a poté zobrazí aktualizovanou citaci s kódem 200. Pokud citace s uvedeným ID ještě neexistuje, bude vytvořena nový záznam s kódem 201.

Nakonec vytvoříme metodu DELETE pro odstranění citace, která nás již neinspiruje.

def delete(self, id):
      global ai_quotes
      ai_quotes = [qoute for qoute in ai_quotes if qoute["id"] != id]
      return f"Citace s id {id} byla odstraněna.", 200

Tato metoda získává ID citace při vstupu a aktualizuje seznam ai_quotes pomocí globálního seznamu.

Teď, když jsme vytvořili všechny metody, všechno, co musíme udělat, je jednoduše přidat resource k API, nastavit cestu a spustit Flask.

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

Naše REST API služba je hotová!

Dále můžeme uložit kód do souboru app.py a spustit ho v konzoli pomocí příkazu:

python3 app.py

Pokud je vše v pořádku, dostaneme něco jako toto:

* Debug mode: zapnuto
* Běží na 127.0.0.1:5000\/ (Stiskněte CTRL+C pro ukončení)
* Restartuje se se stat
* Debugger je aktivní!
* Debugger PIN: XXXXXXX

Testujeme API

Poté, co je API vytvořeno, je třeba ho otestovat.

Můžeme to udělat pomocí konzolového nástroje curl nebo klienta Insomnia REST, nebo ho publikovat na Rapid API.

Publikujeme naše API

RapidAPI je největší trh na světě s více než 10 000 API (a přibližně 1 milionem vývojářů).

RapidAPI nejenže poskytuje jednotné rozhraní pro práci s externími API, ale také umožňuje rychle a bez problémů publikovat vaše vlastní API.

Abychom udělat to, nejprve je třeba ho publikovat na nějakém serveru v síti. V našem případě použijeme Heroku. Práce s tím by neměla přinášet žádné komplikace, (více o něm se můžete dozvědět zde).

Jak publikovat vaše API na Heroku

1. Nainstalujeme Heroku.

Nejdříve se musíte zaregistrovat a nainstalovat Heroku Command Line Interface (CLI). Funguje to na Ubuntu 16 a vyšším.

sudo snap install heroku —classic

Poté se přihlásíme:

heroku login

2. Přidáváme potřebné soubory.

Teď je třeba přidat soubory pro publikaci do složky v našem aplikaci:

• requirements.txt se seznamem potřebných Python modulů;
• Procfile, který určuje, jaké příkazy mají být provedeny pro spuštění aplikace;
• .gitignore – pro vyloučení souborů, které na serveru nejsou potřeba.

Soubor requirements.txt bude obsahovat následující řádky:

• flask
• flask-restful
• gunicorn

Upozorňujeme, že jsme do seznamu přidali gunicorn (Python WSGI HTTP Server), protože je třeba spustit naši aplikaci na serveru.

Procfile bude obsahovat:

web: gunicorn app:app

Obsah .gitignore:

*.pyc
__pycache__/

Nyní, když byly soubory vytvořeny, inicializujme git repo a zcommitujme:

git init
git add
git commit -m "První API commit"

3. Vytvoříme novou aplikaci Heroku.

heroku create

Odesíláme master branch do vzdáleného repo Heroku:

git push heroku master

Nyní můžeme začít tím, že otevřeme API Service pomocí příkazů:

heroku ps:scale web=1
heroku open
 

API bude zpřístupněno na adrese your-random-heroku-name.herokuapp.com/ai-quotes.

Jak přidat váš Python API do tržiště RapidAPI

Jakmile je API Service publikováno na Heroku, můžete jej přidat k Rapid API. Tady najdete podrobnou dokumentaci k tomuto tématu.

1. Vytvoříme účet RapidAPI.

Zaregistrujte si bezplatný účet — to můžete udělat pomocí Facebooku, Googlu, GitHubu.

2. Přidáme API do panelu správy.

3. Poté zadáme základní informace o našem API.

4. Po kliknutí na Add API se objeví nová stránka, kde můžete zadat informace o našem API.

5. Nyní můžete buď ručně zadat koncové body API, nebo nahrát swagger-file pomocí OpenAPI.

Teď je třeba nastavit koncové body našeho API na stránce Endpoints. V našem případě koncové body odpovídají konceptu CRUD (get, post, put, delete).

Dále je třeba vytvořit GET AI Quote koncový bod, který vrací náhodný citát (pokud je ID výchozí) nebo citát pro zadané ID.

Pro vytvoření koncového bodu je třeba stisknout tlačítko Create Endpoint.

Tento proces opakujeme pro všechny ostatní koncové body API. A to je vše! Gratuluji, publikovali jste své API!

Pokud vše proběhne v pořádku, stránka API bude vypadat přibližně takto:

Závěr

V tomto článku jsme prozkoumali proces vytváření vlastního RESTful API Service v Pythonu, spolu s procesem publikace API v cloudu Heroku a přidáním do katalogu RapidAPI.

V testovací variantě byly ukázány pouze základní principy vývoje API — takové detaily jako zabezpečení, odolnost a škálovatelnost nebyly zohledněny.

Při vývoji skutečného API je třeba to vše zohlednit.

Zdroj: habr.com