Ako zaistiť rozhranie REST API pre fľaše pomocou JSON Web Token?

Dozvieme sa, ako zabezpečiť REST API pomocou webových tokenov JSON, aby sa zabránilo zneužívaniu používateľmi a aplikáciami tretích strán.


Zostavíme databázovú službu pomocou SQLite a umožňujú používateľom prístup k rozhraniu REST API pomocou metód HTTP, ako sú POST a PUT.

Ďalej sa dozvieme, prečo sú webové tokeny JSON vhodným spôsobom na ochranu odpočinku API namiesto prehľadu a základnej autentifikácie. Skôr ako budeme pokračovať, porozumieme pojmu webové tokeny JSON, REST API a rámec banky.

Webové žetóny JSON

Webový token JSON, známy tiež ako JWT, je bezpečný spôsob prenosu náhodných tokenov medzi dvoma stranami alebo subjektmi. JSON sa zvyčajne skladá z nasledujúcich troch častí.

  • payload
  • hlavička
  • podpis

Pri prenose údajov alebo informácií medzi dvoma stranami používa spoločnosť JSON dva typy štruktúrnych formulárov.

  • serializována
  • deserializovat

Serializovaný formulár sa používa pri prenose údajov do siete prostredníctvom každej žiadosti a odpovede, zatiaľ čo deserializovaný formulár sa používa pri čítaní a zápise údajov do webového tokenu..

V serializovanej podobe sú tri zložky.

  • hlavička
  • payload
  • podpis

Zložka hlavičky definuje kryptografické informácie o tokenoch. Napríklad:

  • Je to podpísané alebo nepodpísané JWT?
  • Definujte techniky algoritmu

Deserializovaná forma, na rozdiel od serializovanej formy, obsahuje dve zložky.

  • payload
  • hlavička

REST API

API (rozhranie na programovanie aplikácií) umožňuje komunikáciu medzi dvoma aplikáciami na získanie alebo odoslanie údajov. Existujú dva populárne typy API – webové a systémové API.

V tomto článku sa zameriame iba na webové rozhranie API. Existujú dva typy webového rozhrania API.

  • Žiadosť – Response API: Rest, GraphQL, Remote Procedure Call (RPC)
  • Event-Driven API: WebHooks, Web Sockets, HTTP Streaming

REST API patrí do kategórie požiadavka-odpoveď. Na vykonávanie operácií API využíva metódy HTTP, ako napríklad GET, POST a PUT.

Klasickým príkladom je prípad, keď používateľ odošle metóde GET webovej službe, aby požiadala o konkrétny zdroj alebo zbierku zdrojov alebo si ho načítala. Server potom odošle späť konkrétny prostriedok alebo zbierku zdrojov späť používateľovi, ktorý oň požiadal.

Rámec banky

Banka je rámec založený na pythone. Je to mikroštruktúra používaná vývojármi pythonu na zostavenie rest API. Hovorí sa tomu mikro rámec, pretože umožňuje vývojárom napríklad pridať vlastnú autentifikáciu a akýkoľvek iný backendový systém založený na preferenciách.

Začnime s implementáciou. Moje nastavenie systému je nasledujúce.

  • Ubuntu ako OS
  • Python 2.7+
  • poštár

Nastaviť virtuálne prostredie pomocou virtualenv

Potrebujeme nastaviť virtuálne prostredie, aby sme zaistili, že niektoré balíky nebudú v konflikte so systémovými balíkmi. Použime virtuálny priestor na vytvorenie nového virtuálneho prostredia.

Ak máte vo vašom systéme k dispozícii príkaz pip, spustite pomocou príkazu pip nasledujúci príkaz a nainštalujte ho.

pip install virtualenv

Ak na svojom zariadení nemáte pip, postupujte takto dokumentácia nainštalovať pip na váš systém.

Potom vytvorme adresár na ukladanie alebo držanie nášho virtuálneho prostredia. Na vytvorenie adresára použite príkaz mkdir uvedený nižšie

mkdir flaskproject

Pomocou nasledujúceho príkazu prejdite do adresára flaskproject

CD flaskproject

Vo vnútri adresára flaskproject pomocou nástroja virtualenv vytvorte virtuálne prostredie, ako je uvedené nižšie:

virtualenv flaskapi

Keď ste na vytvorenie virtuálneho prostredia použili nástroj virtualenv, spustite príkaz cd, aby ste zmenili adresár flaskapi ako virtuálne prostredie, a aktivujte ho pomocou príkazu nižšie.

zdrojový kôš / aktivovať

Vykonajte všetky úlohy súvisiace s týmto projektom vo virtuálnom prostredí.

Nainštalujte balíčky pomocou pip

Teraz je čas nainštalovať balíčky, ako sú framework pre baňky a PyJWT, ktoré použijeme na zostavenie zvyšného API a ďalších potrebných balíkov pre náš projekt API..

Vytvorte súbor requirements.txt s nasledujúcimi balíčkami.

banka
Dátum Čas
uuid
Banka-SQLAlchemy
PyJWT

Nainštalujte ich pomocou potrubia.

pip install -r requirements.txt

Vytvorte databázu

Poďme nainštalovať SQLite.

apt-get install sqlite3

Vytvorte databázu s názvom knižnica. V tejto databáze vytvoríme dve tabuľky, a to tabuľku Users and Authors.

Tabuľka používateľov bude obsahovať registrovaných používateľov. Do tabuľky Autori môžu mať prístup iba registrovaní užívatelia.

Tabuľka autorov bude ukladať informácie alebo podrobnosti autorov, ako je meno autora, krajina narodenia atď., Predložené registrovanými používateľmi..

Vytvorte databázu pomocou nasledujúceho príkazu:

sqlite3 library.db

Pomocou nasledujúceho príkazu môžete skontrolovať, či ste úspešne vytvorili databázu:

.databázy

Otvorte nový terminál a vykonajte nasledujúce vo virtuálnom prostredí, ktoré sme vytvorili predtým.

klepnite na aplikáciu.py

Vložte nasledujúci kód do súboru s názvom app.py

z importu banky Flask, žiadosť, jsonify, make_response
z flask_sqlalchemy import SQLAlchemy
z importu werkzeug.security generovať_heslo_hash, skontrolovať_password_hash
importovať
import jwt
import datetime
z balíkov na import functoolov

Prvý riadok v kóde vyššie naimportuje balíčky ako request a jsonify. Žiadosť využijeme na sledovanie údajov na úrovni žiadosti počas žiadosti a na výstup odpovedí v a použijeme jsonify JSON formát.

Na ďalšom riadku sme doviezli SQLAlchemy z flask_sqlalchemy, aby sme do banky integrovali prvky SQLAlchemy..

Z werkzeug.security sme importovali vygenerovať generátor_hesla_hash na vygenerovanie hesla hash pre používateľov a skontrolovať_password_hash skontrolovať heslo používateľa pri porovnaní hesla zadaného používateľmi s heslami používateľov uloženými v databáze..

Nakoniec sme importovali uuid známy tiež ako univerzálne jedinečné identifikátory na generovanie náhodných identifikačných čísel pre používateľov.

Napriek tomu v súbore app.py implementujte konfiguračné nastavenia pre API knižnice pomocou kódu uvedeného nižšie v súbore app.py.

Vložte nasledujúci kód pod vyhlásenie o dovoze.

app = Baňka (__ meno__)

App.config [ ‘SECRET_KEY’] = ‘Th1s1ss3cr3t’
App.config [ ‘SQLALCHEMY_DATABASE_URI’] = ‘SQLite: /////home/michael/geekdemos/geekapp/library.db’
app.config [‘SQLALCHEMY_TRACK_MODIFICATIONS’] = True

db = SQLAlchemy (aplikácia)

Teraz vytvorte dva modely pre tabuľku Users and Authors, ako je to znázornené nižšie. Skopírujte a prilepte kód do súboru app.py.

Vložte kód pod toto nastavenie databázy db = SQLAlchemy (app)

používatelia triedy (db.Model):
id = db.Column (db.Integer, Primary_key = True)
public_id = db.Column (db.Integer)
name = db.Column (db.String (50))
heslo = db.Column (db.String (50))
admin = db.Column (db.Boolean)
triedy Autori (db.Model):
id = db.Column (db.Integer, Primary_key = True)
name = db.Column (db.String (50), jedinečný = True, nullable = False))
book = db.Column (db.String (20), unique = True, nullable = False))
country = db.Column (db.String (50), nullable = False))
booker_prize = db.Column (db.Boolean)

Generovanie tabuliek používateľov a autorov

Na termináli zadajte nasledujúci kód vo virtuálnom prostredí, aby ste vygenerovali alebo vytvorili tabuľky pre tabuľky Users a Authors, ako je to znázornené nižšie

z aplikácie na import db
db.create_all ()

Potom otvorte súbor app.py vo virtuálnom prostredí a vytvorte ďalšiu funkciu.

Táto funkcia bude generovať tokeny s cieľom umožniť prístup iba registrovaným používateľom a vykonávať sadu operácií API oproti tabuľke Authors.

Tento kód umiestnite pod databázový model tabuľky Authors

def token_required (f):
@wraps (f)
def dekoratér (* args, ** kwargs):

token = Žiadne

ak ‘x-access-tokeny’ v request.headers:
token = request.headers [‘x-access-tokens’]

ak nie token:
return jsonify ({‘message’: ‘chýba platný token’})

vyskúšajte nasledujúci postup:
data = jwt.decode (token, app.config [SECRET_KEY])
current_user = Users.query.filter_by (public_id = data [‘public_id’]). first ()
s výnimkou:
return jsonify ({‘message’: ‘token is invalid’})

návrat f (current_user, * args, ** kwargs)
návrat dekoratér

Vytvorte trasy pre tabuľku používateľov

Teraz vytvorme trasu, ktorá umožní používateľom zaregistrovať sa do rozhrania Authors API pomocou používateľského mena a hesla, ako je uvedené nižšie.

Znovu otvorte súbor app.py vo virtuálnom prostredí a vložte nasledujúci kód pod funkciu token_required (f)

@ app.route (‘/ register’, metódy = [‘GET’, ‘POST’]))
def signup_user ():
data = request.get_json ()

hashed_password = generovať_password_hash (dáta [‘password’], method = ‘sha256’)

new_user = Používatelia (public_id = str (uuid.uuid4 ()), name = data [‘name’], password = hashed_password, admin = False)
db.session.add (new_user)
db.session.commit ()

return jsonify ({‘message’: ‘úspešne zaregistrované’})

Vo virtuálnom prostredí vytvorte inú cestu v súbore app.py, ktorá umožní zaregistrovaným používateľom prihlásiť sa.

Keď sa užívateľ prihlási, vygeneruje sa náhodný token, pomocou ktorého má používateľ prístup do knižničného rozhrania API.

Vložte kód pod predchádzajúcu trasu, ktorú sme vytvorili.

@ app.route (‘/ login’, metódy = [‘GET’, ‘POST’]))
def login_user ():

auth = request.authorization

ak nie je autor alebo nie je meno používateľa alebo nie.
return make_response (‘nemohol overiť’, 401, {‘WWW.Authentication’: ‘Základná oblasť: "vyžaduje sa prihlásenie",})

user = Users.query.filter_by (meno = auth.username) .first ()

ak check_password_hash (user.password, auth.password):
token = jwt.encode ({‘public_id’: user.public_id, ‘exp’: datetime.datetime.utcnow () + datetime.timedelta (minutes = 30)}, app.config [‘SECRET_KEY’])
return jsonify ({‘token’: token.decode (‘UTF-8’)})

return make_response (‘nemohol overiť’, 401, {‘WWW.Authentication’: ‘Základná oblasť: "vyžaduje sa prihlásenie",})

Napriek tomu vo virtuálnom prostredí vytvorte ďalšiu cestu v súbore app.py, aby ste získali alebo získali všetkých registrovaných používateľov.

Tento kód skontroluje všetkých registrovaných používateľov v tabuľke Users a vráti konečný výsledok vo formáte JSON.

Vložte nasledujúci kód pod cestu prihlásenia

@ app.route (‘/ users’, methods = [‘GET’]))
def get_all_users ():

users = Users.query.all ()

result = []

pre užívateľa v užívateľoch:
user_data = {}
user_data [‘public_id’] = user.public_id
user_data [‘name’] = user.name
user_data [‘password’] = user.password
user_data [‘admin’] = user.admin

result.append (user_data)

return jsonify ({‘users’: result})

Vytvorte trasy pre tabuľku autorov 

Vytvorme cesty pre tabuľku Autori, aby používatelia mohli načítať všetkých autorov v databáze, ako aj vymazať autorov.

Tieto operácie API môžu vykonávať iba používatelia s platnými tokenmi.

Vo vnútri súboru app.py vytvorte cestu pre registrovaných používateľov, aby vytvorili nových autorov.

Vložte tento kód pod trasu, ktorá umožňuje užívateľovi načítať všetkých registrovaných používateľov.

@ app.route (‘/ author’, metódy = [‘POST’, ‘GET’])
@token_required
def create_author (current_user):

data = request.get_json ()

new_authors = Autori (name = data [‘name’], country = data [‘country’], book = data [‘book’], booker_prize = True, user_id = current_user.id)
db.session.add (new_authors)
db.session.commit ()

return jsonify ({‘message’: ‘new author created’})

Ďalej vytvorte ďalšiu trasu, ktorá umožní zaregistrovanému používateľovi s platným tokénom načítať všetkých autorov v tabuľke Autori, ako je to znázornené nižšie.

Vložte tento kód pod trasu, ktorá umožňuje používateľovi vytvoriť nového autora.

@ app.route (‘/ autori’, metódy = [‘POST’, ‘GET’])
@token_required
def get_authors (current_user):

autorov = Authors.query.filter_by (user_id = current_user.id) .all ()

výstup = []
pre autora v autorovi:

author_data = {}
author_data [‘name’] = autor.name
author_data [‘book’] = author.book
author_data [‘country’] = author.country
author_data [‘booker_prize’] = author.booker_prize
output.append (author_data)

return jsonify ({‘list_of_authors’: output})

Nakoniec, stále v súbore app.py, vytvorte cestu na odstránenie určitého autora, ako je to znázornené nižšie.

Vložte tento kód pod trasu, ktorá umožňuje používateľovi načítať zoznam autorov.

@ app.route (‘/ autoři /’, metódy = [‘DELETE’])
@token_required
def delete_author (current_user, author_id):
author = Author.query.filter_by (id = author_id, user_id = current_user.id) .first ()
ak nie autor:
return jsonify ({‘message’: ‘autor neexistuje’})

db.session.delete (autor)
db.session.commit ()

return jsonify ({‘message’: ‘Autor deleted’})

ak __name__ == ‘__main__’:
app.run (debug = True)

Potom uložte a zatvorte súbor app.py vo virtuálnom prostredí.

Testovanie knižničného rozhrania API s programom Postman

V tejto časti použijeme nástroj na doručovanie pošty na odoslanie požiadavky do databázových služieb. Ak na svojom počítači nemáte poštára, môžete zistiť, ako ho stiahnuť a nainštalovať tu.

Okrem poštára môžeme využiť aj iné nástroje, ako napr curl poslať požiadavky na server.

Otvorte nový terminál a napíšte nasledujúce:

poštár

Príkazový poštár spôsobí, že váš webový prehľadávač zobrazí nasledujúcu stránku:

postman_signup

Môžete sa rozhodnúť zaregistrovať sa a vytvoriť bezplatný účet, ale preskočíme a získame priamy prístup k aplikácii na testovanie rozhrania API knižnice, ako je to znázornené nižšie:

Otestujte api knižnice

V tejto časti povolíme používateľovi zaregistrovať sa do knižnice API poskytnutím používateľského mena a jedinečného hesla vo formáte JSON pomocou metódy POST pomocou nasledujúcich krokov:

  • Kliknite na kartu s názvom Telo
  • Potom kliknite na nespracované tlačidlo a vyberte formát JSON
  • zadajte používateľské meno a heslo na registráciu, ako je to zobrazené na snímke obrazovky
  • Vedľa tlačidla odoslať zadajte nasledujúcu adresu URL http://127.0.0.1/register
  • Nakoniec zmeňte metódu na POST a stlačte tlačidlo Odoslať.

užívateľ sa zaregistruje pre API

Zobrazí nasledujúci výstup, ako je to znázornené nižšie:

Teraz sme úspešne zaregistrovali používateľa. Poďme ďalej umožniť používateľovi, ktorý sa práve zaregistroval, prihlásiť sa, aby vygeneroval dočasný náhodný token, aby mal prístup do tabuľky Autorov pomocou nasledujúcich krokov:

  •  Kliknite na kartu autorizácie.
  • V časti Typ vyberte základné overenie.
  • Potom vyplňte formulár pre užívateľské meno a heslo s užívateľským menom a heslom, ktoré ste predtým zaregistrovali.
  • Nakoniec stlačte tlačidlo Odoslať a prihláste sa a vygenerujte náhodný token.

Po úspešnom prihlásení používateľa sa pre používateľa vygeneruje náhodný token, ako je to znázornené na snímke obrazovky.

Vytvorený náhodný token použijeme na prístup do tabuľky Authors.

V tejto časti pridáme informácie o autorovi do tabuľky Autorov pomocou metódy POST pomocou nasledujúcich krokov:

  • Kliknite na kartu hlavičky
  • Zahrňte nasledujúce hlavičky HTTP zobrazené na snímke obrazovky

  • Ďalej kliknite na kartu tela a zadajte podrobnosti o novom autorovi
  • Potom stlačením tlačidla Odoslať pridajte podrobnosti o autorovi do tabuľky autora

Informácie autorov v tabuľke Autori môžete získať aj pomocou nasledujúcich pokynov:

  • Uistite sa, že váš vygenerovaný token je v časti hlavičky. ak tam nie je, musíte ho vyplniť svojím tokenom.
  • Okrem tlačidla Odoslať zadajte túto adresu URL http://127.0.0.1/authors
  • Potom zmeňte metódu HTTP na GET a stlačením tlačidla odoslať vyhľadajte podrobnosti o autorovi.

Nakoniec môžete odstrániť autorov v tabuľke Authors pomocou metódy DELETE pomocou nasledujúcich krokov:

  • Uistite sa, že váš token je stále v časti hlavičky. Na karte Hlavičky môžete skontrolovať, či sú potrebné potrebné informácie.
  • Okrem tlačidla Odoslať zadajte túto adresu URL http://127.0.0.1/sam
  • Potom stlačením tlačidla Odoslať vymažete zadaného používateľa.

Celý zdrojový kód nájdete na Github.  Môžete ho klonovať a skontrolovať na vašom zariadení.

Tagy:

  • krajta

Jeffrey Wilson Administrator
Sorry! The Author has not filled his profile.
follow me
    Like this post? Please share to your friends:
    Adblock
    detector
    map