🥇Kirjutame API Pythonis (Flaski ja RapidAPI abil)

Kui loete seda artiklit, olete tõenäoliselt juba tuttav API (rakenduste programmeerimise liidese) võimalustega.

Lisades oma rakendusele ühe paljusid avatud API-sid, saate selle funktsionaalsust laiendada või täiendavate andmetega täiendada. Aga mis juhtub, kui olete arendanud unikaalse funktsiooni, millest soovite kogukonnaga jagada?

Vastus on lihtne: peate looma oma API.

Kuigi see võib alguses tunduda keeruline ülesanne, on tegelikult kõik lihtne. Räägime, kuidas seda Pythoniga teha.

Mida on vaja projekti alustamiseks

API arendamiseks on vajalik:

Python 3;
Flask — lihtne ja kasutajasõbralik raamistik veebirakenduste loomiseks;
Flask-RESTful — Flaski laiendus, mis võimaldab kiiresti ja minimaalse konfigureerimisega arendada REST API-d.

Installimine toimub käsuga:

pip install flask-restful

Soovitame tasuta intensiivkursust programmeerimises algajatele:
C# telegrammi roboti arendamine — 26.-28. august. Tasuta intensiivkursus, mis aitab mõista, kuidas abibotid töötavad, tutvuda Telegrami API eripäradega ja muude nüanssidega. Kolm parimat osalejat saavad Skillboxilt 30 000 rubla..

Enne alustamist

Kavandame arendada RESTful API põhifunktsionaalsusega CRUD-funktsioonid.

Küsimuse täielikuks mõistmiseks vaatleme kaht eelnevalt mainitud mõistet.

Mis on REST?

REST API (Representational State Transfer) on API, mis kasutab andmete vahetamiseks HTTP-päringuid.

REST API-d peavad vastama teatud kriteeriumidele:

Kliendi-serveri arhitektuur: klient suhtleb kasutajaliidesega, server aga tagab andmebaasi ja andmete talletamise. Klient ja server on sõltumatud, mõlemat võib asendada eraldi.
Stateless — serveris ei hoita ühtegi kliendiandmeid. Seansi seisund säilitatakse kliendi külge.
Vahemälu — kliendid saavad serveri vastuseid vahemälu salvestada, et parandada üldist jõudlust.

Mis on CRUD?

CRUD — programmeerimise mõisted, mis kirjeldavad nelja põhilist toimingut (create, read, update ja delete).

REST API-s vastutavad päringute tüübid ja päringumeetodid selliste toimingute eest nagu post, get, put, delete.

Nüüd, kui oleme põhimõisted selgeks saanud, saame alustada API loomist.

Arendus

Loome tsitaatide repot tehisintellekti kohta. AI on tänapäeval üks kiiremini arenevaid tehnoloogiaid ning Python on populaarne tööriist AI-ga töötamiseks.

Selle API abil saab Python arendaja kiiresti teavet AI kohta ja ammutada inspiratsiooni uutest saavutustest. Kui arendajal on selle teema kohta väärt mõtteid, saab ta need repo lisada.

Alustame vajalike moodulite importimise ja Flaski seadistamisega:

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

Selles Flaski snippetis on Api ja Resource klassid, mida meil vaja on.

Reqparse on Flask-RESTful'i päringute parsimise liides… Samuti on meil vajalik random moodul, et näidata juhuslikku tsitaati.

Nüüd loome tehisintellekti tsitaatide repo.

Iga repo kirje sisaldab:

numbrilist ID-d;
tsitaadi autori nime;
tsitaati.

Kuna see on lihtsalt õppe näide, salvestame kõik kirjed Pythonis nimekirja. Reaalses rakenduses kasutaksime tõenäoliselt andmebaasi.

ai_quotes = [
    {
        "id": 0,
        "author": "Kevin Kelly",
        "quote": "Järgmise 10 000 idufirma äri plaanid on kergesti ennustatavad: " +
                 "Võta X ja lisa AI."
    },
    {
        "id": 1,
        "author": "Stephen Hawking",
        "quote": "Täieliku tehisintellekti arendamine võib " +
                 "tähendada inimkonna lõppu… " +
                 "See tõuseb iseseisvalt ja projekteerib " +
                 "ennast pidevalt suureneva kiirusel. " +
                 "Inimesed, kelle areng on piiratud aeglase bioloogilise evolutsiooniga, " +
                 "ei suuda konkureerida ja jäävad tahaplaanile."
    },
    {
        "id": 2,
        "author": "Claude Shannon",
        "quote": "Ma kujutan ette aega, mil me oleme robotitele nagu " +
                 "koerad inimestele, " +
                 "ja ma toetan masinaid."
    },
    {
        "id": 3,
        "author": "Elon Musk",
        "quote": "Tehisintellekti arengutempo " +
                 "(ma ei räägi kitsast AI-st) " +
                 "on äärmiselt kiire. Kui teil ei ole otsest " +
                 "kokkupuudet rühmadega nagu Deepmind, " +
                 "siis ei tead saa, kui kiiresti see — kasvab " +
                 "lähedal eksponentsiaalsele kiirus. " +
                 "Oht, et midagi tõeliselt ohtlikku " +
                 "juhtuda, on viie aasta perspektiivis." +
                 "10 aastat maksimaalselt."
    },
    {
        "id": 4,
        "author": "Geoffrey Hinton",
        "quote": "Ma olen alati olnud veendunud, et ainus viis " +
                 "tehisintellekti tõhusaks töötamiseks on " +
                 "laske arvutustel toimuda sarnaselt inimaju tööle. " +
                 "See on eesmärk, mille poole olen püüelnud. Me teeme edusamme, " +
                 "kuigi me peame endiselt palju õppima, " +
                 "kuidas aju tegelikult töötab."
    },
    {
        "id": 5,
        "author": "Pedro Domingos",
        "quote": "Inimesed muretsevad, et arvutid saavad " +
                 "liialt nutikaks ja võtavad üle maailma, " +
                 "aga tegelik probleem on see, et nad on liiga lollid " +
                 "ja nad on juba maailma üle võtnud."
    },
    {
        "id": 6,
        "author": "Alan Turing",
        "quote": "Tundub, et on tõenäoline, et kui masin mõtlemise " +
                 "meetod on alustatud, ei möödu kaua, " +
                 "kui nad ületavad meie nõrgad võimed… " +
                 "Nad oleksid võimelised omavahel rääkima " +
                 "oma arusaamise teravdamiseks. " +
                 "Mõnes etapis peaksime siis " +
                 "ootama, et masinad võtavad kontrolli."
    },
    {
        "id": 7,
        "author": "Ray Kurzweil",
        "quote": "Tehisintellekt saavutab " +
                 "inimtaseme umbes 2029. aastaks. " +
                 "Jätkates seda edasi, ütleme, 2045, " +
                 "oleme paljundanud intellekti, " +
                 "meie tsivilisatsiooni inimbioloogilise masina intellekti " +
                 "ühe miljardi kordselt."
    },
    {
        "id": 8,
        "author": "Sebastian Thrun",
        "quote": "Keegi ei väljenda seda nii, kuid ma arvan, " +
                 "et tehisintellekt " +
                 "on peaaegu humanitaarteaduse distsipliin. See on tegelikult katse " +
                 "mõista inimintellekti ja inimkognitsiooni."
    },
    {
        "id": 9,
        "author": "Andrew Ng",
        "quote": "Me teeme seda analoogiat, et AI on uus elekter." +
                 "Elekter muutis tööstusharusid: põllumajandus, " +
                 "transport, kommunikatsioon, tootmine."
    }
]

Nüüd tuleb luua ressursside klass Quote, mis määratleb meie API lõpp-punktide toimingud. Klassis tuleb deklareerida neli meetodit: get, post, put, delete.

Alustame GET-meetodist

See võimaldab saada kindlat tsitaati, näidates selle ID-d, või juhusliku tsitaadi, kui ID-d ei ole esitatud.

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 "Tsitaati ei leitud", 404

GET-meetod tagastab juhusliku tsitaadi, kui ID on vaikimisi väärtus, st kui meetodit kutsutakse, ei ole ID-d määratud.

Kui see on määratud, otsib meetod tsitaatide hulgast ja leiab selle, mis vastab määratud ID-le. Kui midagi ei leita, kuvatakse teade “Tsitaati ei leitud, 404”.

Pidage meeles: meetod tagastab HTTP-staatuse 200 edukate päringute korral ja 404, kui kirjet ei leita.

Nüüd loome POST-meetodi, et lisada uus tsitaat registrisse

See saab iga uue tsitaadi ID sisendina. Lisaks kasutab POST reqparse'i, et analüüsida parameetreid, mis lähevad päringu kehas (autor ja tsitaadi tekst).

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"Tsitaat id-ga {id} juba eksisteerib", 400
      quote = {
          "id": int(id),
          "author": params["author"],
          "quote": params["quote"]
      }
      ai_quotes.append(quote)
      return quote, 201

Ülaltoodud koodis võttis POST-meetod tsitaadi ID. Seejärel kasutas ta reqparse'i, et saada autor ja tsitaat päringust, salvestades need sõnastikku params.

Kui tsitaat määratud ID-ga juba eksisteerib, siis kuvab meetod sobiva teadete ja koodi 400.

Kui tsitaat määratud ID-ga veel ei olnud loodud, loob meetod uue kirje määratud ID ja autoriga, samuti teiste parameetritega. Seejärel lisab see kirje ai_quotes loendisse ja tagastab uue tsitaadi kirje koos koodiga 201.

Nüüd loome PUT-meetodi olemasoleva tsitaadi muutmiseks registris

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

PUT meetod, sarnaselt eelnevale näitele, võtab ID ja sisendi ning parsetab tsiteeringu parameetrid, kasutades reqparse'i.

Kui tsiteering, mille ID on määratud, eksisteerib, uuendab meetod seda uute parameetritega ja kuvab seejärel uuendatud tsiteeringu koodiga 200. Kui tsiteeringut määratud ID-ga pole, luuakse uus kirje koodiga 201.

Lõpuks loome DELETE meetodi tsiteeringu kustutamiseks, mis enam ei inspireeri.

def delete(self, id):
      global ai_quotes
      ai_quotes = [quote for quote in ai_quotes if quote["id"] != id]
      return f"Quote with id {id} is deleted.", 200

See meetod saab tsiteeringu ID sisendi ja uuendab ai_quotes loendit, kasutades globaalset loendit.

Nüüd, kui oleme kõik meetodid loonud, peame lihtsalt lisama ressursi API-le, määrama tee ja käivitama Flaski.

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

Meie REST API teenus on valmis!

Edasi saame koodi salvestada faili app.py, käivitades selle terminalis käsuga:

python3 app.py

Kui kõik on hästi, saame midagi sellist:

* Debug režiim: sisse lülitatud
* Jooksul 127.0.0.1:5000\/ (T9 CTRL+C, et lõpetada)
* Taaskäivitamine staatilise andmetega
* Siluri tööriist on aktiivne!
* Siluri PIN: XXXXXXX

Testime API-d

Pärast API loomist tuleb see testida.

Seda saab teha kas käsurea tööriista curl või Insomnia REST kliendiga, või avaldades API Rapid API-s.

Avaldame meie API

RapidAPI on maailma suurim turuplats, kus on rohkem kui 10 000 API (ja umbes 1 miljon arendajat).

RapidAPI pakub mitte ainult ühte liidese töötamiseks kolmandate osapoolte API-dega, vaid ka võimalust kiiresti ja probleemideta avaldada oma API.

Selleks et selleks, peate esmalt avaldama selle mõnes serveris võrgus. Me kasutame selles kontekstis Heroku. Töösel ei tohiks tekkida mingeid keerukusi, (seda saab rohkem teada siit).

Kuidas avaldada oma API Heroku-s

1. Paigaldame Heroku.

Esmalt tuleb registreeruda ja paigaldada Heroku käsurealiidese (CLI). See töötab Ubuntu 16+ peal.

sudo snap install heroku —classic

Seejärel logime sisse:

heroku login

2. Lisame vajalikud failid.

Nüüd tuleb lisada failid avaldamiseks meie rakenduse kausta:

requirements.txt koos vajalike Python moodulite nimekirjaga;
Procfile, mis näitab, milliseid käske tuleb rakenduse käivitamiseks täita;
.gitignore — faile, mida serveris pole vaja, ignoreerimiseks.

Fail requirements.txt sisaldab järgmisi ridu:

flask
flask-restful
gunicorn

Palun pange tähele: oleme gunicorn'i (Python WSGI HTTP Server) nimekirja lisanud, kuna peame meie rakenduse serveris käivitama.

Procfile sisaldab:

web: gunicorn app:app

.gitignore sisu:

*.pyc
__pycache__/

Nüüd, kui failid on loodud, algatame git-repo ja teeme commit'i:

git init
git add
git commit -m "Esimene API commit"

3. Loome uue Heroku rakenduse.

heroku create

Saadame master haru kaugservisse Heroku:

git push heroku master

Nüüd on võimalik alustada, avades API teenuse käsku:

heroku ps:scale web=1
heroku open

API on saadaval aadressil your-random-heroku-name.herokuapp.com/ai-quotes.

Kuidas lisada oma Python API RapidAPI turule

Pärast seda, kui API teenus on Herokusse avaldatud, saab selle lisada Rapid API-sse. Siin on detailne dokumentatsioon selle teema kohta.

1. Loome RapidAPI konto.

Registreerige tasuta konto - seda saab teha Facebooki, Google'i või GitHubi abil.

2. Lisame API juhtpaneelile.

3. Sisestame üldteabe oma API kohta.

4. Pärast nuppu "Lisa API" avaneb uus leht, kus saab sisestada teavet meie API kohta.

5. Nüüd saab kas käsitsi sisestada API lõpp-punkte või laadida swagger-faili OpenAPI abil.

Nüüd tuleb määrata meie API lõpp-punktid lehel Lõpp-punktid. Meie puhul vastavad lõpp-punktid CRUD kontseptsioonile (get, post, put, delete).

Järgmiseks tuleb luua GET AI Quote lõpp-punkt, mis väljendab juhuslikku tsitaati (kui ID on vaikimisi) või tsitaati antud ID jaoks.

Lõpp-punkti loomiseks tuleb vajutada nuppu "Loo lõpp-punkt".

Korrake seda protsessi kõigi teiste API lõpp-punktide jaoks. Sellega on kõik! Palju õnne, olete oma API avaldanud!

Kui kõik on hästi, näeb API leht välja umbes selline:

Kokkuvõte

Selles artiklis uurisime, kuidas luua oma RESTful API teenus Pythonis, koos API avaldamise protsessiga cloud Herokus ja selle lisamisega RapidAPI katalooge.

Kuid testimisversioonis näidati ainult API arendamise põhialuseid - sellised nüansid nagu turvalisus, tõrke taluvus ja skaleeritavus ei olnud käsitletud.

Reaalse API arendamisel tuleb kõike seda arvesse võtta.

Allikas: habr.com

Kirjutame API Pythonis (Flaski ja RapidAPI-ga)

Mida on vaja projekti alustamiseks

Arendus

Kokkuvõte