Tworzenie API w Pythonie (z Flask i RapidAPI)

Jeśli czytasz ten artykuł, prawdopodobnie już znasz możliwości, jakie oferuje użycie API (Application Programming Interface).

Dodając do swojej aplikacji jedno z wielu otwartych API, możesz rozszerzyć funkcjonalność tej aplikacji lub dopełnić ją potrzebnymi danymi. Ale co, jeśli opracowałeś unikalną funkcję, którą chciałbyś podzielić się z społecznością?

Odpowiedź jest prosta: musisz stworzyć własne API..

Chociaż z początku może to wydawać się skomplikowanym zadaniem, w rzeczywistości wszystko jest proste. Pokażemy, jak to zrobić za pomocą Pythona.

Co jest potrzebne do rozpoczęcia pracy

Do opracowania API potrzebne są:

• Python 3;
• Flask — prosty i łatwy w użyciu framework do tworzenia aplikacji webowych;
• Flask-RESTful — rozszerzenie dla Flask, które pozwala na szybkie opracowanie REST API z minimalną konfiguracją.

Instalacja odbywa się za pomocą polecenia:

pip install flask-restful

Zalecamy bezpłatny intensywny kurs programowania dla początkujących:
Tworzenie bota telegramowego w C# — 26–28 sierpnia. Bezpłatny intensywny kurs, który pozwoli zrozumieć, jak działają boty asystujące, w szczególności w pracy z API Telegram i innych szczegółach. Trzej najlepsi uczestnicy otrzymają od Skillbox 30 000 rubli..

Zanim zaczniemy

Zamierzamy opracować RESTful API z podstawową funkcjonalnością CRUID..

Aby w pełni zrozumieć zadanie, przyjrzyjmy się dwóm terminom, o których wspomniano wcześniej.

Co to jest REST?

REST API (Representational State Transfer) to API, które wykorzystuje żądania HTTP do wymiany danych.

REST API musi spełniać określone kryteria:

• Architektura klient-serwer: klient wchodzi w interakcję z interfejsem użytkownika, a serwer — z backendem i bazą danych. Klient i serwer są niezależni, każdy z nich może być wymieniony niezależnie od drugiego.
• Bezstanowość — żadne dane klienta nie są przechowywane na serwerze. Stan sesji jest przechowywany po stronie klienta.
• Możliwość buforowania — klienci mogą buforować odpowiedzi serwera, aby poprawić ogólną wydajność.

Co to jest CRUD?

CRUD — koncepcja programowania, która opisuje cztery podstawowe operacje (create, read, update i delete).

W REST API typy żądań i metody żądań odpowiadają za takie operacje jak post, get, put, delete.

Teraz, gdy zrozumieliśmy podstawowe terminy, możemy przystąpić do tworzenia API.

Rozwój

Stwórzmy repozytorium cytatów na temat sztucznej inteligencji. AI to jedna z najszybciej rozwijających się technologii dzisiaj, a Python to popularne narzędzie do pracy z AI.

Dzięki temu API programista Python będzie mógł szybko uzyskać informacje o AI i inspirować się nowymi osiągnięciami. Jeśli programista ma cenne przemyślenia w tej kwestii, będzie mógł dodać je do repozytorium.

Zacznijmy od zaimportowania potrzebnych modułów i skonfigurowania Flask:

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

W tym fragmencie kodu Flask, Api i Resource to klasy, których potrzebujemy.

Reqparse to interfejs parsowania zapytań Flask-RESTful… Będzie także potrzebny moduł random do wyświetlenia losowego cytatu.

Teraz stworzymy repozytorium cytatów na temat AI.

Każdy wpis w repozytorium będzie zawierał:

• cyfrowy identyfikator;
• imię autora cytatu;
• cytat.

Ponieważ to tylko przykład do nauki, przechowamy wszystkie wpisy w liście Python. W prawdziwej aplikacji najprawdopodobniej użyjemy bazy danych.

ai_quotes = [
    {
        "id": 0,
        "author": "Kevin Kelly",
        "quote": "Plany biznesowe następnych 10 000 startupów łatwo jest przewidzieć: " +
                 "Weź X i dodaj AI."
    },
    {
        "id": 1,
        "author": "Stephen Hawking",
        "quote": "Rozwój pełnej sztucznej inteligencji może " +
                 "oznaczać koniec rasy ludzkiej… " +
                 "Będzie działać samodzielnie i przekształcać " +
                 "się w coraz szybszym tempie. " +
                 "Ludzie, ograniczeni przez wolną ewolucję biologiczną, " +
                 "nie będą mogli konkurować i zostaną zastąpieni."
    },
    {
        "id": 2,
        "author": "Claude Shannon",
        "quote": "Wyobrażam sobie czas, kiedy będziemy dla robotów tym, co " +
                 "psy dla ludzi, " +
                 "i kibicuję maszynom."
    },
    {
        "id": 3,
        "author": "Elon Musk",
        "quote": "Tempo postępu w sztucznej inteligencji " +
                 "(nie mówię o wąskiej AI) " +
                 "jest niesamowicie szybkie. Jeżeli nie masz bezpośredniego " +
                 "dostępu do grup takich jak Deepmind, " +
                 "nie masz pojęcia, jak szybko – rośnie " +
                 "w tempie bliskim wykładniczemu. " +
                 "Ryzyko, że coś poważnie niebezpiecznego " +
                 "się wydarzy, jest w pięcioletnim horyzoncie." +
                 "Max 10 lat."
    },
    {
        "id": 4,
        "author": "Geoffrey Hinton",
        "quote": "Zawsze byłem przekonany, że jedynym sposobem " +
                 "na uruchomienie sztucznej inteligencji " +
                 "jest przeprowadzenie obliczeń w sposób podobny do ludzkiego mózgu. " +
                 "To jest cel, który realizuję. Robimy postępy, " +
                 "choć wciąż musimy wiele nauczyć się o " +
                 "tym, jak naprawdę działa mózg."
    },
    {
        "id": 5,
        "author": "Pedro Domingos",
        "quote": "Ludzie martwią się, że komputery " +
                 "staną się zbyt mądre i przejmą świat, " +
                 "ale prawdziwym problemem jest to, że są zbyt głupie " +
                 "i już przejęły świat."
    },
    {
        "id": 6,
        "author": "Alan Turing",
        "quote": "Wydaje się prawdopodobne, że gdy tylko metoda myślenia maszynowego " +
                 "zacznie działać, nie zajmie długo, " +
                 "aż przewyższy nasze słabe możliwości… " +
                 "Będą mogli prowadzić rozmowy " +
                 "między sobą, aby wyostrzyć swoje umysły. " +
                 "W pewnym momencie zatem, powinniśmy " +
                 "spodziewać się, że maszyny przejmą kontrolę."
    },
    {
        "id": 7,
        "author": "Ray Kurzweil",
        "quote": "Sztuczna inteligencja osiągnie " +
                 "poziom ludzki około 2029 roku. " +
                 "Gdy pójdziemy dalej do, powiedzmy, 2045 roku, " +
                 "pomnożymy inteligencję, " +
                 "biologiczną inteligencję maszyn " +
                 "naszej cywilizacji miliard razy."
    },
    {
        "id": 8,
        "author": "Sebastian Thrun",
        "quote": "Nikt tego tak nie wyraża, ale myślę, że " +
                 "sztuczna inteligencja " +
                 "jest niemal dziedziną humanistyczną. To naprawdę próba " +
                 "zrozumienia ludzkiej inteligencji i ludzkiej poznania."
    },
    {
        "id": 9,
        "author": "Andrew Ng",
        "quote": "Robimy tę analogię, że AI to nowa elektryczność." +
                 "Elektryczność zmieniła przemysły: rolnictwo, " +
                 "transport, komunikację, produkcję."
    }
]

Teraz musimy utworzyć klasę zasobów Quote, która będzie definiować operacje punktów końcowych naszego API. W klasie należy zadeklarować cztery metody: get, post, put, delete.

Zacznijmy od metody GET

Umożliwia ona uzyskanie określonego cytatu, podając jego ID, lub losowego cytatu, jeśli ID nie jest podane.

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 "Quote not found", 404

Metoda GET zwraca losowy cytat, jeśli ID ma wartość domyślną, tzn. gdy wywołanie metody nie zawiera ID.

Jeśli ID jest podane, metoda przeszukuje cytaty w poszukiwaniu tego, który odpowiada podanemu ID. Jeśli nic nie zostanie znalezione, pojawia się komunikat „Quote not found, 404”.

Pamiętaj: metoda zwraca status HTTP 200 w przypadku udanego żądania i 404, jeśli rekord nie został znaleziony.

Teraz stwórzmy metodę POST do dodawania nowego cytatu do repozytorium

Będzie ona przyjmować identyfikator każdego nowego cytatu podczas wprowadzania. Ponadto POST będzie korzystać z reqparse do analizy parametrów, które będą w ciele żądania (autor i tekst cytatu).

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"Quote with id {id} already exists", 400
      quote = {
          "id": int(id),
          "author": params["author"],
          "quote": params["quote"]
      }
      ai_quotes.append(quote)
      return quote, 201

W powyższym kodzie metoda POST przyjęła ID cytatu. Następnie, korzystając z reqparse, uzyskała autora i cytat z żądania, zapisując je w słowniku params.

Jeśli cytat o podanym ID już istnieje, metoda wyświetli odpowiednią wiadomość i kod 400.

Jeśli cytat o podanym ID jeszcze nie został utworzony, metoda tworzy nowy wpis z podanym ID i autorem, a także innymi parametrami. Następnie dodaje wpis do listy ai_quotes i zwraca wpis z nowym cytatem razem z kodem 201.

Teraz tworzymy metodę PUT do zmiany istniejącego cytatu w repozytorium

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, podobnie jak w poprzednim przykładzie, przyjmuje ID i input oraz parsuje parametry cytatu, używając reqparse.

Jeśli cytat o podanym ID istnieje, metoda zaktualizuje go nowymi parametrami, a następnie zwróci zaktualizowany cytat z kodem 200. Jeśli cytat o podanym ID jeszcze nie istnieje, zostanie utworzony nowy wpis z kodem 201.

Na koniec stwórzmy metodę DELETE do usuwania cytatu, który już nie inspiruje.

def delete(self, id):
      global ai_quotes
      ai_quotes = [qoute for qoute in ai_quotes if qoute["id"] != id]
      return f"Cytat o id {id} został usunięty.", 200

Ta metoda przyjmuje ID cytatu jako wejście i aktualizuje listę ai_quotes, wykorzystując ogólną listę.

Teraz, gdy stworzyliśmy wszystkie metody, wszystko, co musimy zrobić, to dodać zasób do API, ustawić ścieżkę i uruchomić Flask.

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

Nasz serwis REST API jest gotowy!

Następnie możemy zapisać kod w pliku app.py, uruchamiając go w konsoli za pomocą polecenia:

python3 app.py

Jeśli wszystko przebiegnie pomyślnie, otrzymamy coś takiego:

* Tryb debugowania: włączony
* Uruchamiane na 127.0.0.1:5000\/ (Naciśnij CTRL+C, aby zakończyć)
* Restartowanie z stat
* Debugger jest aktywny!
* PIN debuggera: XXXXXXX

Testujemy API

Po utworzeniu API należy je przetestować.

Można to zrobić za pomocą narzędzia konsolowego curl lub klienta Insomnia REST, bądź publikując API na Rapid API.

Publikujemy nasze API

RapidAPI to największy na świecie rynek z ponad 10 000 API (i około 1 miliona programistów).

RapidAPI nie tylko zapewnia jednolity interfejs do pracy z zewnętrznymi API, ale także umożliwia szybkie i łatwe opublikowanie własnego API.

Aby aby to zrobić, najpierw musisz opublikować je na jakimś serwerze w Internecie. W naszym przypadku skorzystamy z Heroku. Praca z nim nie powinna sprawić żadnych trudności, (więcej informacji można znaleźć tutaj).

Jak opublikować swoje API na Heroku

1. Instalujemy Heroku.

Na początek należy zarejestrować się i zainstalować Heroku Command Line Interface (CLI). Działa to na Ubuntu 16+.

sudo snap install heroku --classic

Następnie logujemy się:

heroku login

2. Dodajemy potrzebne pliki.

Teraz musimy dodać pliki do publikacji do folderu w naszej aplikacji:

• requirements.txt z listą potrzebnych modułów Pythona;
• Procfile, który określa, jakie polecenia powinny zostać wykonane do uruchomienia aplikacji;
• .gitignore — do wykluczenia plików, które nie są potrzebne na serwerze.

Plik requirements.txt będzie zawierał następujące linie:

• flask
• flask-restful
• gunicorn

Proszę zwrócić uwagę: dodaliśmy gunicorn (Python WSGI HTTP Server) do listy, ponieważ musimy uruchomić naszą aplikację na serwerze.

Plik Procfile będzie zawierał:

web: gunicorn app:app

Zawartość .gitignore:

*.pyc
__pycache__/

Teraz, gdy pliki zostały utworzone, zainicjujmy repozytorium git i zróbmy commit:

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

3. Tworzymy nowe aplikację Heroku.

heroku create

Wysyłamy master branch do zdalnego repozytorium Heroku:

git push heroku master

Teraz można rozpocząć, otwierając API Service za pomocą poleceń:

heroku ps:scale web=1
heroku open
 

API będzie dostępne pod adresem your-random-heroku-name.herokuapp.com/ai-quotes.

Jak dodać swoje Python API do rynku RapidAPI

Po opublikowaniu API Service na Heroku, można dodać go do Rapid API. Oto szczegółowa dokumentacja na ten temat.

1. Tworzymy konto w RapidAPI.

Rejestrujemy darmowe konto — można to zrobić za pomocą Facebooka, Google'a, GitHuba.

2. Dodajemy API do panelu zarządzania.

3. Następnie wprowadzamy ogólne informacje o swoim API.

4. Po naciśnięciu „Dodaj API” pojawi się nowa strona, na której można wprowadzić informacje o naszym API.

5. Teraz można ręcznie wprowadzić punkty końcowe API lub wgrać plik swagger za pomocą OpenAPI.

A teraz musimy określić punkty końcowe naszego API na stronie Punkty końcowe. W naszym przypadku punkty końcowe odpowiadają koncepcji CRUD (get, post, put, delete).

Następnie musimy utworzyć punkt końcowy GET AI Quote, który zwraca losowy cytat (w przypadku, gdy ID jest domyślne) lub cytat dla wskazanego ID.

Aby utworzyć punkt końcowy, należy nacisnąć przycisk „Utwórz Punkt Końcowy”.

Powtarzamy ten proces dla wszystkich innych punktów końcowych API. To wszystko! Gratulacje, opublikowałeś swoje API!

Jeśli wszystko jest w porządku, strona API będzie wyglądać mniej więcej tak:

Podsumowanie

W tym artykule omówiliśmy proces tworzenia własnego serwisu RESTful API na Pythonie, wraz z procesem publikacji API w chmurze Heroku i dodawania go do katalogu RapidAPI.

Jednak w wersji testowej przedstawiono tylko podstawowe zasady tworzenia API — takie niuanse jak bezpieczeństwo, odporność na błędy i skalowalność nie były omawiane.

Przy projektowaniu rzeczywistego API wszystko to należy wziąć pod uwagę.

Źródło: habr.com