🥇Kirjutame API Pythonis (Flaski ja RapidAPI abil)

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

Oma rakendusele ühe paljude avatud API-de lisamine võimaldab teil laiendada rakenduse funktsionaalsust või täiendada seda vajalike andmetega. Aga mis siis, kui olete välja töötanud ainulaadse funktsiooni, millega soovite kogukonda jagada?

Vastus on lihtne: tuleb luua oma API..

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

Mida vajate algamiseks

API arendamiseks on vajalik:

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

Installimine toimub käsuga:

pip install flask-restful

Soovitame tasuta algajate programmise intensiivkursust:
Telegrami boti arendamine C#-s — 26–28 august. Tasuta intensiivkursus, mis aitab mõista, kuidas töötavad assistentbotid, tutvustavad Telegrami API-d ja muud nüansid. Kolm parimat osalejat saavad Skillboxilt 30 000 rubla..

Enne alustamist

Kavatseme välja töötada RESTful API, millel on põhi CRUD-funktsionaalsus.

Küsimuse täielikuks mõistmiseks vaatame lähemalt kaht ülaltoodud terminit.

Mis on REST?

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

REST API-d peavad vastama teatud kriteeriumidele:

Klient-server arhitektuur: klient suhtleb kasutajaliidesega ja server tagab bäkendi ja andmete salvestamise. Klient ja server on iseseisvad, kumbki võib teineteisest sõltumatult asendada.
State-less — serveris ei salvestata kliendiandmeid. Seansi olek salvestatakse kliendi poolel.
Vahemälu — kliendid saavad serveri vastuseid vahemälus hoida, et parandada üldist jõudlust.

Mis on CRUD?

CRUD on programmeerimise kontseptsioon, mis kirjeldab nelja põhitegevust (loo, loe, uuenda ja kustuta).

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

Nüüd, kui oleme baasterminitega tutvunud, saame edasi liikuda API loomise juurde.

Arendus

Loome kunstliku intelligentsi tsitaatide reposiit. AI on üks kiiremini arenevaid tehnoloogiaid tänapäeval ja Python on populaarne tööriist AI-ga töötamiseks.

Selle API abil saavad Python arendajad kiiresti teavet AI kohta ning ammutada inspiratsiooni uutest saavutustest. Kui arendajal on teemal väärtuslikke mõtteid, saab ta lisada need repossi.

Alustame vajalike moodulite impordiga ja Flaski seadistamisega:

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

Selles Flaski koodijupis on Api ja Resource klassid, mida vajame.

Reqparse on Flask-RESTful päringute analüüsimise liides... Samuti on vajalik juhusliku tsitaadi kuvamiseks random moodul.

Nüüd loome kunstliku intelligentsi tsitaatide reposi.

Iga reposiitkande puhul sisaldab:

digitaalne ID;
tsitaadi autori nimi;
tsitaat.

Kuna see on lihtsalt õppeaine näide, hoiame me kõik kirjed Pythonis loendis. Tõelises rakenduses kasutaksime tõenäoliselt selle asemel andmebaasi.

ai_quotes = [
    {
        "id": 0,
        "author": "Kevin Kelly",
        "quote": "Järgmise 10,000 idufirma äriplaanid on kergesti ennustatavad: " +
                 "Võta X ja lisa AI."
    },
    {
        "id": 1,
        "author": "Stephen Hawking",
        "quote": "Täiusliku kunstliku intellekti areng võib " +
                 "tähendada inimrassi lõppu… " +
                 "See hakkab iseseisvalt arenema ja disainima " +
                 "ennast üha kasvu kiirusel. " +
                 "Inimesed, kes 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 olen masinate poolt."
    },
    {
        "id": 3,
        "author": "Elon Musk",
        "quote": "Kunstliku intellekti edenemise tempo " +
                 "(ma ei räägi kitsast AI-st) " +
                 "on uskumatult kiire. Kui sul ei ole otsest " +
                 "kokkupuudet selliste gruppidega nagu Deepmind, " +
                 "siis sul pole aimu, kui kiiresti — see kasvab " +
                 "peaaegu eksponentsiaalses tempos. " +
                 "Tõsise ohu nimetamise risk " +
                 "on viieaastases ajaraamis." +
                 "Kümme aastat maksimaalselt."
    },
    {
        "id": 4,
        "author": "Geoffrey Hinton",
        "quote": "Olen alati olnud veendunud, et ainus viis " +
                 "kunstliku intellekti töötamiseks " +
                 "on arvutuste tegemine sarnaselt inimeajule. " +
                 "See on eesmärk, mille nimel olen töötanud. Me teeme edusamme, " +
                 "kuigi meil on endiselt palju õppida, " +
                 "kuidas aju tegelikult töötab."
    },
    {
        "id": 5,
        "author": "Pedro Domingos",
        "quote": "Inimesed muretsevad, et arvutid saavad " +
                 "liialt targaks ja võtavad maailma üle, " +
                 "aga tõeline probleem on, et nad on liiga lollid " +
                 "ja nad on juba maailma üle võtnud."
    },
    {
        "id": 6,
        "author": "Alan Turing",
        "quote": "Tundub tõenäoline, et kui masinategemise " +
                 "meetod on alustanud, ei lähe kaua, " +
                 "kui see ületab meie nõrgad võimed… " +
                 "Nad suudavad omavahel suhelda " +
                 "oma arusaama teravdamiseks. " +
                 "Teatud hetkel peaksime seega " +
                 "oodama, et masinad võtavad kontrolli."
    },
    {
        "id": 7,
        "author": "Ray Kurzweil",
        "quote": "Kunstlik intellekt saavutab " +
                 "inimtaseme umbes 2029. aastaks. " +
                 "Viies seda edasi kuni, ütleme, 2045, " +
                 "oleme paljundanud intelligentsi, " +
                 "inimeste bioloogilise masina intelligentsuse " +
                 "meie tsivilisatsioonis miljardikordselt."
    },
    {
        "id": 8,
        "author": "Sebastian Thrun",
        "quote": "Keegi ei väljenda seda nõnda, aga ma arvan, " +
                 "et kunstlik intellekt " +
                 "on peaaegu humanitaarteaduste ala. See on tõeliselt katse " +
                 "mõista inimintellekti ja inimkognitsiooni."
    },
    {
        "id": 9,
        "author": "Andrew Ng",
        "quote": "Teeme selle analoogia, et AI on uus elekter." +
                 "Elektor on muutnud tööstusi: põllumajandust, " +
                 "transporti, kommunikatsiooni, tootmist."
    }
]

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

Alustame GET-meetodiga

See võimaldab saada konkreetset tsitaati, osutades selle ID-le, või juhuslikku tsitaati, kui ID-d ei ole antud.

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 seast ja leiab selle, millel on antud ID. Kui midagi ei leita, kuvatakse sõnum "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 reservoiri

See saab iga uue tsitaadi identifikaatori sisestamisel. Lisaks kasutab POST reqparse'i, et analüüsida parameetreid, mis tulevad 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 vastu tsitaadi ID. Seejärel, kasutades reqparse'i, sai ta autorit ja tsitaati päringust, salvestades need sõnastikku params.

Kui tsitaat, mille ID on näidatud, juba eksisteerib, väljastab meetod vastava teate ja koodi 400.

Kui tsitaat, mille ID on näidatud, ei ole veel loodud, loob meetod uue kirje näidatud ID ja autoriga, samuti teiste parameetritega. Seejärel lisab ta kirje ai_quotes'i loendisse ja tagastab kirje koos uue tsitaadiga ning koodiga 201.

Nüüd loome PUT-meetodi, et muuta olemasolevat tsitaati andmebaasis.

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, nagu eelnevas näites, võtab ID ja sisendi ning analüüsib tsitaadi parameetrid, kasutades reqparse.

Kui antud ID-ga tsitaat eksisteerib, värskendab meetod seda uute parameetritega ja seejärel väljastab värskendatud tsitaadi koodiga 200. Kui antud ID-ga tsitaati veel ei ole, luuakse uus kantud koodiga 201.

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

def delete(self, id):
      global ai_quotes
      ai_quotes = [qoute for qoute in ai_quotes if qoute["id"] != id]
      return f"Tsitaat ID-ga {id} on kustutatud.", 200

See meetod võtab tsitaadi ID sisendiks ja värskendab ai_quotes loendit, kasutades globaalsed loendit.

Nüüd, kui oleme loonud kõik meetodid, on meil vaja vaid lisada resource API-le, määrata tee ja käivitada Flask.

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

Meie REST API teenus on valmis!

Seejärel saame koodi salvestada faili app.py, käivitades selle konsoolis käsuga:

python3 app.py

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

* Silumise režiim: sisse
* Käivitamine aadressil 127.0.0.1:5000/ (vajutage CTRL+C, et väljuda)
* Taaskäivitamine statsiooniga
* Silur on aktiivne!
* Siluri PIN: XXXXXXX

Testime API-d

Pärast API loomist tuleb seda testida.

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

Avaldame oma API

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

RapidAPI mitte ainult ei paku ühtset liidest kolmandate osapoolte API-dega töötamiseks, vaid võimaldab ka kiiresti ja probleemideta avaldada omaenda API.

Selleks, et seda teha, peate kõigepealt publitseerima selle mõnel serveril võrgus. Meie puhul kasutame Heroku. Selle kasutamine ei peaks olema keeruline, (rohkem teavet selle kohta leiate siit).

Kuidas avaldada oma API Heroku-s

1. Installige Heroku.

Esiteks peate registreeruma ja installima Heroku Command Line Interface (CLI). See töötab Ubuntu 16+ peal.

sudo snap install heroku --classic

Seejärel logime sisse:

heroku login

2. Lisage vajalikud failid.

Nüüd peate lisama avaldamiseks vajalikud failid meie rakenduse kausta:

requirements.txt, kus on loetelu vajalikest Python'i moodulitest;
Procfile, mis näitab, milliseid käske tuleb rakenduse käivitamiseks täita;
.gitignore — näiteks failide väljajätmiseks, mis serveris ei ole vajalikud.

Fail requirements.txt sisaldab järgmisi ridu:

flask
flask-restful
gunicorn

Palun pange tähele: oleme lisanud gunicorni (Python WSGI HTTP Server) loetellu, kuna meie rakendus tuleb serveris käivitada.

Procfile sisaldab:

web: gunicorn app:app

Sisu .gitignore:

*.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 kaugserverisse Heroku:

git push heroku master

Nüüd saame alustada, avades API teenuse käsuga:

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 API-teenuse avaldamist Heroku kaudu saab selle lisada Rapid API-sse. Siin on detailne dokumentatsioon selle teema kohta.

1. Looge RapidAPI konto.

Registreerige tasuta konto — seda saab teha Facebooki, Google'i või GitHubi kaudu.

2. Lisage API juhtpaneelile.

3. Seejärel sisestage oma API põhiteave.

4. Pärast nuppu “Add API” ilmub uus lehekülg, kus saab sisestada teavet meie API kohta.

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

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

Seejärel tuleb luua GET AI Quote lõpp-punkt, mis tagastab juhusliku tsitaadi (kui ID on vaikimisi) või tsitaadi antud ID jaoks.

Lõpp-punkti loomiseks vajutage nuppu “Create Endpoint”.

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

Kui kõik läks hästi, näeb API leht välja umbes nii:

Kokkuvõte

Selles artiklis uurisime kohandatud RESTful API teenuse loomise protsessi Pythonis, samuti API avalikustamise protsessi Heroku's ja selle lisamist RapidAPI kataloogi.

Kuid katsevariandis näidati ainult API arendamise põhialuseid – selliseid nüansse, nagu turvalisus, talitlushäired ja skaleeritavus, ei käsitletud.

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

Allikas: habr.com