Najlepší framework na vytvorenie API v Python

Toto je druhý článok zo série venovanej téme rozhraní API.

Každý článok sa zaoberá inou témou. Ak práve začínate chápať, ako napísať vlastné API, je užitočné prečítať si všetko po poriadku. Ak to už viete a zaujíma vás konkrétna téma, prejdite rovno na ňu.

1. Jednoduché vysvetlenie API
2. Najlepší framework pre API (tento článok 👇)
3. Tvorba API pomocou FastAPI (čoskoro)
4. Tvorba API pomocou ChatGPT (čoskoro)
5. Top Tools to Test API (čoskoro)
6. Zarábanie na API (čoskoro)

Poďme na to…

API frameworks

V predchádzajúcom článku sme sa dozvedeli, čo je API a ako funguje, takže teraz sa pozrime, ako si vybrať najlepší rámec pre API v jazyku Python. Ak chcete vybrať nástroj, ktorý vám umožní rýchlo a efektívne písať API v jazyku Python, musíte zvážiť nasledujúce veci:

• Veľkosť projektu. Ak bude vaše API súčasťou plnohodnotnej webovej aplikácie, je najlepšie vybrať si framework, ktorý vám umožní vytvoriť samotnú webovú aplikáciu aj jej časť API. Ak potrebujete len API, postačí vám niektorý z mikrorámcov.

• Pracovné zaťaženie. To je zvyčajne priamo určené požiadavkami na procesor a pamäť servera. Najzrejmejším parametrom je počet požiadaviek klienta a servera, ktoré server dokáže spracovať.

• Čas na asimiláciu. Spravidla platí, že čím je rámec výkonnejší, tým viac času je potrebné na jeho osvojenie. Ak už nástroj dobre ovládate, môžete tento parameter samozrejme zanedbať.

Špeciálnym prípadom je jednoduchý prípad, keď potrebujete len klienta na získanie údajov z existujúceho API. Na jeho vytvorenie môžete použiť embedded module alebo niektorú z populárnych knižníc, napríklad httplib2 alebo všetkými obľúbenú requests. Hoci to priamo nesúvisí s témou, pozrieme sa na ne, aby sme si doplnili obraz.

Pozrime sa teraz na najlepšie rámce REST API v jazyku Python, ktoré sú aktívne podporované a vyvíjané, ako aj obľúbené medzi vývojármi a v súčasnosti široko používané. Pre vaše pohodlie som ich rozdelil do troch podmienených kategórií:

• Klientské knižnice
• Mikro frameworky (minimálná sada funkcií)
• Plnohodnotné rámce (úplná sada funkcií)

Začnime jedným jednoduchým…

Klientské knižnice

Requests

Site: https://github.com/psf/requests

Type: KlientsKa knižnica

Requests je veľmi populárna knižnica klienta HTTP v jazyku Python. Dokonca ju odporúča aj oficiálna dokumentácia k Pythonu. Ako napovedá jej názov, používa sa na zadávanie požiadaviek na API. Knižnica podporuje všetky metódy HTTP a pokročilé funkcie, ako je overovanie, cookies relácie, práca s protokolom SSL a mnohé ďalšie.

Práca s Requests je veľmi jednoduchá. Tu je príklad volania API v jazyku Python, keď na autorizáciu na stránke použijete metódu GET:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

>>> import requests
>>> URL = 'https://httpbin.org/basic-auth/user/pass'
>>> r = requests.get(URL, auth=('user', 'pass'))
>>> r.status_code
200
>>> r.headers['content-type']
'application/json; charset=utf8'
>>> r.encoding
'utf-8'
>>> r.text
'{"authenticated": true, ...'
>>> r.json()
{'authenticated': True, ...}

Tu nájdete podrobnú dokumentáciu ku knižnici Requests.

Faster Than Requests

Site: https://github.com/juancarlospaco/faster-than-requests/

Type: KlientsKa knižnica

Celkom zaujímavý balík, ktorý sa aktívne vyvíja. Podľa slov vývojára funguje rýchlejšie ako Requests :) Možno je to tým, že používa hlavne jazyk Nim. Na hlavnej stránke repozitára GitHub je porovnanie výkonu. Tvrdí sa tiež, že knižnica je oveľa kompaktnejšia z hľadiska počtu riadkov kódu.

Najšikovnejšou vecou na tejto knižnici je množstvo pomocných funkcií, ktoré idú nad rámec bežných metód HTTP. Má niekoľko praktických funkcií na úlohy, ako je vyhľadávanie adries URL, sťahovanie zdrojov, napríklad obrázkových súborov, alebo spájanie požiadaviek na viacero adries URL a vrátenie jednej odpovede.

Tu je niekoľko príkladov štandardných požiadaviek API v Python:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

import faster_than_requests as requests

# GET
requests.get("http://httpbin.org/get")

# POST
requests.post("http://httpbin.org/post", "Some Data Here")

# Download a file
requests.download("http://example.com/foo.jpg", "out.jpg")

# Multi-Threaded Web Scraper
requests.scraper(["http://foo.io", "http://bar.io"], threads=True)

# URL-to-SQLite Web Scraper
requests.scraper5("http://foo.io", sqlite_file_path="database.db")

# Regex-powered Web Scraper
requests.scraper6("http://python.org", "(www|http:|https:)+[^s]+[w]")

# CSS Selector Web Scraper
requests.scraper7("http://python.org", "body > div.someclass a#someid")

# WebSockets Binary/Text
requests.websocket_send("ws://echo.websocket.org", "data here")

PycURL

Site: http://pycurl.io/

Type: KlientsKa knižnica

PycURL je len doplnok jazyka Python pre knižnicu libcurl, ktorá sa používa na prenos súborov cez rôzne protokoly. Podporuje protokoly HTTP, FTP, SMTP a mnohé ďalšie. Ak máte radi knižnice cURL alebo libcurl, mohlo by sa vám páčiť aj toto rozhranie Pythonu pre natívnu knižnicu libcurl napísanú v jazyku C/C++.

Veľa zaujímavých vecí nájdete v oficiálnom repozitári PycURL na GitHube. Podrobnejšie informácie o knižnici nájdete aj v oficiálnej dokumentácii.

Nižšie je uvedený príklad, ako vykonať volanie HTTP GET pomocou PycURL.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

import pycurl
from io import BytesIO

buffer = BytesIO()
c = pycurl.Curl()
c.setopt(c.URL, 'http://pycurl.io/')
c.setopt(c.WRITEDATA, buffer)
c.perform()
c.close()
body = buffer.getvalue()
# Telo je reťazec bajtov.
# Aby ste ho mohli vypísať do textového súboru, musíte poznať kódovanie,
# napríklad do štandardného výstupu.
print(body.decode('iso-8859-1'))

urllib3

Site: https://urllib3.readthedocs.io/

Type: KlientsKa knižnica

Táto knižnica jazyka Python má špeciálnu triedu na správu združení pripojení s podporou viacvláknového spracovania, nahrávania súborov, formulárov, spracovania výnimiek a ďalších funkcií. Má prívetivé rozhranie, dobrú dokumentáciu a dokonca zabudovanú podporu pre knižnice tretích strán.

urllib3 je výkonný a ľahko použiteľný klient HTTP pre Python. Funkcionalita knižnice umožňuje organizovať rýchlu a spoľahlivú prácu s takmer akýmkoľvek zdrojom informácií na internete.

Väčšina ekosystému Pythonu už používa urllib3, takže sa možno budete chcieť bližšie pozrieť aj na túto knižnicu.

Príklady volaní API jazyka Python v knižnici urllib3:

1
2
3
4
5
6
7
8
9

>>> import urllib3
>>> http = urllib3.PoolManager(num_pools=2)
>>> resp = http.request('GET', 'http://yahoo.com/')
>>> resp = http.request('GET', 'http://google.com/')
>>> resp = http.request('GET', 'http://httpbin.org/robots.txt')
>>> resp.status
200
>>> resp.data
b"User-agent: *\nDisallow: /deny\n"

Micro frameworks

Flask

Site: https://flask.palletsprojects.com/

Type: Micro framework

Projekt začal ako jednoduchý obal okolo programov Werkzeug a Jinja a dnes sa stal jedným z najpopulárnejších frameworkov na vývoj webových aplikácií v jazyku Python vrátane tvorby API. Repozitár projektu na GitHube má už viac ako 60 000 hviezdičiek. Flask uľahčuje začiatky, rýchlo prináša prvé výsledky a postupne škáluje vašu aplikáciu na ľubovoľnú úroveň.

V priebehu rokov Flask pridal mnoho funkcií, ktoré ho stavajú takmer na úroveň full stack frameworkov. Avšak práve jeho minimalistický prístup k vytváraniu webových aplikácií z neho robí preferovanú voľbu mnohých vývojárov.

Flask ponúka rôzne možnosti na dosiahnutie vášho cieľa a nenúti vás používať konkrétne knižnice ani dodržiavať presne definovanú štruktúru projektu. Nástroje a knižnice, ktoré chcete používať, si môžete vybrať sami.

Existuje mnoho užitočných rozšírení vyvinutých a podporovaných komunitou, ktoré uľahčujú pridávanie funkcií do vašej aplikácie.

Takto môžete napísať jednoduchú webovú aplikáciu “Hello World” v jazyku Flask:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

from flask import Flask

app = Flask(__name__)

@app.route('/')
def hello_world():
    return 'Hello, World!'

if __name__ == '__main__':
    app.run()

Ďalšie informácie a dokumentáciu o Flasku nájdete na webovej stránke projektu a zoznam ďalších zdrojov a zásuvných modulov v tomto úložisku na GitHube.

Odporúčam tiež oficiálny návod od samotného Miguela Grinberga, vynikajúcu sériu článkov na portáli Hackers and Slackers a komunitu používateľov na Reddite.

Tornado

Site: https://www.tornadoweb.org/

Type: Micro framework

Tornado je framework a asynchrónna sieťová knižnica. Obsahuje aj rozhranie servera a klienta HTTP, ako aj rozhranie WebSocket na obojsmernú komunikáciu so servermi, ktoré podporujú WebSocket.

Tornado podporuje všetky základné funkcie middlewaru potrebné na spracovanie požiadaviek a odpovedí HTTP, šablón a smerovania.

Podporuje aj coroutines (kooperatívne trasy), čo z neho robí skvelý nástroj na vytváranie serverových backendov s dlhými cyklami načítavania údajov a trvalými spojeniami, najmä pre WebSocket.

Jednoduchý backend pre rozhranie API v aplikácii Tornado možno vytvoriť takto:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

import asyncio
import tornado.web

class MainHandler(tornado.web.RequestHandler):
    def get(self):
        self.write("Hello, world")

def make_app():
    return tornado.web.Application([
        (r"/", MainHandler),
    ])

async def main():
    app = make_app()
    app.listen(8888)
    await asyncio.Event().wait()

if __name__ == "__main__":
    asyncio.run(main())

Tornado existuje už dlho, ale niektoré jeho funkcie sú v porovnaní s modernými rámcami REST trochu zastarané. Napriek tomu je veľmi populárny, keďže úložisko na GitHube má takmer 21 tisíc hviezdičiek.

FastAPI

Site: https://fastapi.tiangolo.com/

Type: Micro framework

FastAPI je jeden z novších frameworkov Pythonu. Podľa vývojárov je veľmi rýchly, vysoko výkonný a podporuje kompaktnú štruktúru kódovania, čo vedie k veľmi rýchlemu vývoju aplikácií.

FastAPI je založený na možnostiach asyncio v jazyku Python, ktoré boli štandardizované ako špecifikácia ASGI na vytváranie asynchrónnych webových aplikácií. FastAPI je takmer rovnako výkonný ako Flask a podporuje vstavané procedúry na integráciu s databázami, vykonávanie úloh na pozadí, pripojenie vlastného middlewaru a ďalšie.

S viac ako 50 000 hviezdičkami na adrese repozitár na GitHube si FastAPI získava popularitu v komunite Pythonu a neustále ho vyvíja skupina aktívnych odborníkov, ktorú tvorí viac ako 100 ľudí.

Tu sa dozviete, ako môžete vytvoriť jednoduché rozhranie REST API pomocou FastAPI:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
def read_root():
    return {"Hello": "World"}

@app.get("/items/{item_id}")
def read_item(item_id: int, q: str = None):
    return {"item_id": item_id, "q": q}

Oficiálna dokumentácia: https://fastapi.tiangolo.com

Repozitár GitHub: https://github.com/tiangolo/fastapi

Sanic

Site: https://sanic.dev/en/

Type: Micro framework

Sanic je ďalší webový rámec Python založený na asynchrónnych technológiách. Je to veľmi ľahký framework s podporou všetkých základných funkcií HTTP a middleware aplikácií.

Okrem toho Sanic podporuje možnosť písania vlastných protokolov a middlewarových komponentov na prispôsobenie protokolu požiadaviek a odpovedí. Sanic má vlastný vstavaný webový server na urýchlenie vývoja a tiež sa dobre integruje s Nginx pre priemyselné aplikácie.

Tu sa dozviete, ako napísať jednoduché rozhranie API v aplikácii Sanic:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

from sanic import Sanic
from sanic.response import json

app = Sanic()

@app.route('/')
async def test(request):
    return json({'hello': 'world'})

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=8000)

Viac informácií nájdete v Sanic repository na GitHub alebo Sanic Getting Started Guide.

Falcon

Site: https://falconframework.org/

Type: Micro framework

Falcon je jednoduchý a robustný framework na vytváranie rozsiahlych aplikačných backendov a mikroslužieb. Podporuje architektonický štýl REST a pracuje so servermi kompatibilnými s WSGI alebo ASGI.

Falcon má objektovo orientované rozhranie založené na triedach na definovanie zdrojov API. Podporuje základné funkcie HTTP a middleware aplikácií vrátane spracovania protokolu HTTP, smerovania, spracovania médií, súborov cookie a nástrojov URI.

Tu nájdete návod na vytvorenie rozhrania API REST pomocou objektovo orientovaného prístupu softvéru Falcon:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

class QuoteResource:
    def on_get(self, req, resp):
        """Handles GET requests"""
        quote = {
            'quote': (
                "I've always been more interested in "
                "the future than in the past."
            ),
            'author': 'Grace Hopper'
        }
        resp.media = quote

api = falcon.API()
api.add_route('/quote', QuoteResource())

Viac informácií nájdete v úložisku Falcon na GitHube. Ak chcete začať vyvíjať v systéme Falcon, odporúčame prečítať si oficiálnu dokumentáciu projektu.

Bottle

Site: https://bottlepy.org/

Type: Micro framework

Bottle je veľmi ľahký mikrorámec. Má veľmi malú veľkosť, je distribuovaný ako len jeden súbor a závisí len od štandardnej knižnice Pythonu.

Bottle je skvelý na:

• rýchle prototypovanie nápadov
• učenie sa, ako sa vytvárajú frameworky
• vytváranie a spúšťanie jednoduchých osobných webových aplikácií

Bottle zároveň poskytuje všetky komponenty potrebné na vytvorenie kompletného backendu pre rozhranie REST API, ktoré sa spolieha na smerovanie a šablóny. Podporuje väčšinu obvyklých funkcií súvisiacich s protokolom HTTP, ako sú súbory cookie, hlavičky, metadáta a nahrávanie súborov. Má tiež zabudovaný server HTTP.

Rýchla a jednoduchá aplikácia na Bottle vyzerá takto:

1
2
3
4
5
6
7

from bottle import route, run, template

@route('/hello/<name>')
def index(name):
    return template('<b>Hello {{name}}</b>!', name=name)

run(host='localhost', port=8080)

Viac informácií nájdete v repozitár Fľaša na GitHube. V oficiálnej dokumentácii nájdete príručku na rýchly štart, podrobnosti o konfigurácii a zbierku užitočných článkov.

Hug

Site: https://www.hug.rest/

Type: Micro framework

hug je v skutočnosti rámec API s viacerými rozhraniami. Ponúka skvelý spôsob vytvárania rozhraní REST API oddelením obchodnej logiky rozhrania API od samotného rozhrania a priradením závislostí verzií.

Pretože sa hug zameriava na vytváranie API, jeho možnosti sú prísne obmedzené na spracovanie I/O, smerovanie a typové anotácie. Podporuje však možnosť pridávať rozšírenia.

Jednou zo zaujímavých vlastností hug je možnosť poskytovať logiku API prostredníctvom CLI, HTTP alebo lokálnej funkcie, čo umožňuje používať hug ako štandardný modul jazyka Python.

Tu je návod, ako napísať API v hug:

1
2
3
4
5
6

import hug

@hug.get('/happy_birthday')
def happy_birthday(name, age:hug.types.number=1):
    """Says happy birthday to a user"""
    return "Happy {age} Birthday {name}!".format(**locals())

👉 Všimnite si, že pri použití hug môže nastať problém, ak potrebujete prijaté požiadavky vopred spracovať. Keďže telo požiadavky sa odovzdáva vláknu, môžete ho prečítať len raz.

Preto ak prečítate telo požiadavky v metóde, ktorá požiadavky predbežne spracúva, vlákno zostane prázdne a hug z neho nebude môcť získať vstupné parametre. Problém sa rieši vytvorením ďalšieho vlákna pred čítaním parametrov.

Viac informácií nájdete v hug repozitár na GitHub, ako aj v hug oficiálna dokumentácia.

Eve

Site: https://python-eve.org/

Type: Micro framework

Eve je mikroframework pre API postavený nad Flaskom. Cieľom Eve je mimoriadne rýchly a jednoduchý vývoj REST API. Preto je postavený na princípoch Flasku, pričom ponecháva bokom všetky komponenty webovej aplikácie Flask.

Eve podporuje všetky najpoužívanejšie šablóny REST API, ako sú operácie CRUD, prispôsobiteľné koncové body API, filtrovanie, triedenie, viacstránkové formáty, JSON/XML/JSONP.

Podporuje aj pokročilé funkcie, ako je autentifikácia, CORS, caching, obmedzenie rýchlosti a ďalšie. Eve podporuje aj integráciu s databázami MongoDB a SQL.

Eve môže na definovanie zdrojov a koncových bodov API používať konfiguračný súbor vo formáte Python. Rozhranie REST API tak možno vytvoriť pomocou deklaratívnej syntaxe JSON.

Ďalšie informácie nájdete v príručke Getting Eve up and running alebo si pozrite Eve repository GitHub.

Fullstack frameworks

Django

Site: https://www.djangoproject.com/

Type: Fullstack framework

Django je plnohodnotný webový rámec v jazyku Python. Je to jeden z najstarších a najpopulárnejších webových frameworkov, repozitár Django má na GitHube takmer 67 tisíc hviezdičiek.

Rámec Django má veľa funkcií na vytváranie plnohodnotných webových aplikácií. Okrem podpory všetkých potrebných funkcií HTTP vrátane middleware aplikácií medzi jeho funkcie patria vzorky MVC, pohľady na dáta, práca s databázou, formuláre, šablóny, zabezpečenie, ukladanie do vyrovnávacej pamäte a ďalšie.

Samozrejme, používať Django len na vytvorenie backendu REST API je jednoznačne prehnané. Preto môžete na tento účel použiť špeciálny framework Django REST, ktorý je projektom podporovaným komunitou. Využíva Django ako základný engine a poskytuje jednoduchšie rozhranie špecifické pre vývoj REST API.

Viac informácií o práci s nimi nájdete v oficiálnom repozitári Django a/alebo oficiálnom repozitári Django REST. A na tomto odkaze nájdete Django REST Quick Start Guide.

TurboGears

Site: https://turbogears.org/

Type: Fullstack framework

TurboGears je ďalší full-stack framework. Hlavnou myšlienkou pri jeho vývoji bolo umožniť škálovanie projektu z jednoduchej aplikácie (v jednom súbore) na full-stack aplikáciu. TurboGears tak môže poskytnúť pocit práce s mikrorámcom, ale zároveň poskytuje všetky nástroje potrebné na vývoj plnohodnotnej webovej aplikácie.

TurboGears je vytvorený so schémou MVC (Model-View-Controller) ako iné plnohodnotné frameworky. Podporuje šablóny, správu stránok, autentifikáciu a autorizáciu, ukladanie do vyrovnávacej pamäte a podporu rôznych databáz a migráciu schém.

Najzákladnejšia verzia sa vytvára veľmi jednoducho. Vytvorte súbor tgapp.py a deklarujte v ňom kontrolér:

1
2
3
4
5
6
7
8

class RootController(TGController):
    @expose()
    def index(self):
        return 'Hello World'

    @expose()
    def hello(self, person):
        return 'Hello %s' % person

Aby kontrolér fungoval, musíte vytvoriť aplikáciu:

1
2
3
4
5
6
7
8

from tg import MinimalApplicationConfigurator

config = MinimalApplicationConfigurator()
config.update_blueprint({
    'root_controller': RootController()
})

application = config.make_wsgi_app()

Nakoniec zadajte príkaz na spustenie tejto aplikácie:

1
2
3
4
5

from wsgiref.simple_server import make_server

print("Serving on port 8080...")
httpd = make_server('', 8080, application)
httpd.serve_forever()

Potom spustite aplikáciu príkazom python tgapp.py a spustí sa server na porte 8080. Otvorte prehliadač, zadajte adresu http://localhost:8080 a zobrazí sa vám text Hello, world.

A ak odošlete dotaz http://localhost:8080/hello?person=MyName, uvidíte odpoveď Hello MyName.

To je všetko.

Pozrite si repozitár TurboGears na GitHub, aby ste lepšie pochopili tento rámec. A aby ste mohli začať, preštudujte si dokumentáciu TurgoGears.

web2py

Site: http://www.web2py.com/

Type: Fullstack framework

Web2py je open-source, full-stack framework napísaný a naprogramovaný v jazyku Python. Jeho hlavným cieľom je vyvíjať rýchle, škálovateľné a bezpečné webové aplikácie založené na databáze.

Jadrom Web2py sú moduly na spracovanie HTTP a URL. Má tiež zabudovaný plánovač na vykonávanie úloh na pozadí. Okrem toho má web2py databázovú abstrakčnú vrstvu, ktorá mapuje objekty jazyka Python na databázové objekty, ako sú tabuľky, dotazy a záznamy.

Vrstva abstrakcie databázy pracuje v spojení so sadou ovládačov, ktoré podporujú mnohé populárne databázy, ako napríklad SQLite, MySQL, PostgreSQL, Oracle, DB2, MSSQL, MongoDB a ďalšie.

Má tiež plnohodnotnú podporu pre MVC, validáciu formulárov, zabezpečenie, riadenie prístupu a mnoho ďalších nástrojov.

Web2py sa dodáva v binárnych balíkoch, ktoré spustíte na svojom počítači a potom prostredníctvom webového rozhrania vytvoríte svoju webovú aplikáciu alebo službu.

Podrobný prehľad nájdete v repozitári web2py na GitHube. Projekt má aj vynikajúcu dokumentáciu v rôznych jazykoch, oficiálnu aj vytvorenú komunitou, s príkladmi a výukovými videami.

Pyramid

Site: https://trypyramid.com/

Type: Fullstack framework

Pyramid je ďalší plnohodnotný webový rámec Python, ktorého základnou myšlienkou je začať v malom a podľa potreby sa rozrásť na veľký projekt. Tento prístup umožňuje vývojárom začať s Pyramidom ako s mikroframeworkom.

Okrem toho je Pyramid dostatočne flexibilný na to, aby sa dal rozširovať a pridávať nové komponenty na zvládnutie všetkých úloh potrebných na vytvorenie rozsiahlej webovej aplikácie.

Pyramid obsahuje všetky štandardné funkcie webového frameworku, ako je schéma MVC, smerovanie, šablóny, zabezpečenie, relácie, databázy a protokolovanie. Má tiež zabudovaný webový server pserve, ale bez problémov spolupracuje s Apache a Nginx pre seriózne aplikácie.

Tu je príklad jednoduchého backendu na Pyramide.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

from wsgiref.simple_server import make_server
from pyramid.config import Configurator
from pyramid.response import Response

def hello_world(request):
    return Response('Hello World!')

if __name__ == '__main__':
    with Configurator() as config:
        config.add_route('hello', '/')
        config.add_view(hello_world, route_name='hello')
        app = config.make_wsgi_app()
    server = make_server('0.0.0.0', 6543, app)
    server.serve_forever()

Rovnako ako v predchádzajúcich prípadoch odporúčam prečítať si repozitár Pyramid na GitHube, príručku Pyramid Quick Start Guide a oficiálnu dokumentáciu Pyramid.

Záver

Tento článok je pomerne dlhý a musíte si uvedomiť, že je to len stručný prehľad niektorých najpopulárnejších riešení na vývoj vášho API. Vždy si môžete pozrieť podrobnejšie informácie a vybrať si produkt, ktorý sa vám najviac páči, na vytvorenie vlastného jedinečného projektu.

A podelím sa o ďalší odkaz, ktorý je dobré si pozrieť. Je to porovnanie výkonu mnohých rámcov pre webové aplikácie, ktoré vykonávajú základné úlohy, ako je serializácia JSON, prístup k databáze a spracovanie šablón na strane servera.

Každý rámec beží v reálnej konfigurácii. Výsledky sú získané na cloudových inštanciách a na fyzickom hardvéri. Testovacie implementácie boli väčšinou vytvorené komunitou a všetky zdrojové kódy sú k dispozícii na repozitári GitHub.

V ďalšej časti sa pozrieme na praktický príklad, ako napísať svoje API a potom ho správne zdokumentovať.

Prajem veľa úspechov! 👍