Python är ett av de mest lättlästa och lättskrivna programmeringsspråken genom tiderna. Under åren har Pythons popularitet bara ökat, och den används i stor utsträckning inom webbapplikationsutveckling, skript, skapande av spel, vetenskaplig beräkning, etc.
Flask är ett Python-webbapplikationsramverk som vinner popularitet på grund av dess enkla användning för Python-nybörjare. I den här handledningen ska vi ta en titt på EVE, ett REST API-byggande ramverk baserat på Flask, MongoDB och Redis. Från de officiella dokumenten:
Drift av Flask, MongoDB, Redis och goda avsikter gör Eve att utan ansträngning bygga och distribuera mycket anpassningsbara, fullt utrustade RESTful Web Service.
Vad vi kommer att skapa
I den här självstudien ser vi hur man bygger REST API:er med EVE-ramverket. Därefter, med hjälp av AngularJS kommer vi att designa gränssnittet för en enkel app och göra den funktionell genom att konsumera REST-API:erna byggda med EVE. I den här handledningen implementerar vi följande funktionalitet:
- Skapa användar-API
- Validera användar-API
- Add Items API
- Ta bort Items API
- Uppdatera Items API
Komma igång
Installation
Vi kommer att använda pip för att installera EVE.
pip install eve
Vi kommer att använda MongoDB som databas. Ta en titt på de officiella dokumenten för installation enligt ditt system.
Skapa Basic API
Skapa en projektmapp som heter PythonAPI . Navigera till PythonAPI och skapa en fil som heter api.py . Inuti api.py importera EVE och skapa ett EVE-objekt.
from eve import Eve app = Eve()
Kör sedan app när programmet körs som ett huvudprogram.
from eve import Eve
app = Eve()
if __name__ == '__main__':
app.run()
Kör din MongoDB med följande kommando:
mongod --dbpath= <PATH-TO> /data/db/
Som du kan se måste vi ange en sökväg för db-filerna. Skapa helt enkelt data/db i ditt filsystem och kör kommandot ovan.
Tillsammans med en instans av MongoDB körs kräver EVE en konfigurationsfil med information om API-resurserna. Så i PythonAPI skapa en annan fil som heter settings.py och lägg till följande kod:
DOMAIN = {'user': {}}
Ovanstående kod informerar EVE om att en resurs för användare är tillgänglig.
Spara alla filer och kör api.py :
python api.py
API:t bör vara online enligt bilden:
Vi kommer att använda Postman REST Client för att skicka förfrågningar till API:erna. Det är gratis och kan installeras med ett enkelt klick. När installationen är klar, starta appen och ange API URL (http://127.0.0.1:5000/) och klicka på skicka. Du bör ha svaret som visas:
Eftersom vi inte har anropat någon specifik API-resurs kommer den att visa alla tillgängliga resurser. Försök nu att ringa användaren resurs och du bör ha svaret specifikt för användaren .
Skapa och validera användar-API
Skapa användar-API
Vi börjar med att bygga ett API för att skapa eller registrera en användare för vår applikation. Användaren skulle ha vissa fält som Förnamn , Efternamn , Användarnamn , Lösenord och Telefonnummer .
Så först måste vi definiera ett schema för en användare. Schema definierar fälten och datatyperna för nyckelfälten. Öppna settings.py och ändra DOMAIN genom att definiera ett schema som visas :
DOMAIN = {
'user': {
'schema': {
'firstname': {
'type': 'string'
},
'lastname': {
'type': 'string'
},
'username': {
'type': 'string',
'unique': True
},
'password': {
'type': 'string'
},
'phone': {
'type': 'string'
}
}
}
}
Som du kan se i ovanstående kod har vi definierat nyckelfälten som behövs för att skapa en användare och dess datatyp definierad i schemat. Spara ändringarna och kör api.py . Från Postman Client försök att göra en POST-begäran tillsammans med de nödvändiga parametrarna till http://127.0.0.1/user som visas:
På POST-begäran till användaren skickade den en 405-metod ej tillåten fel. Som standard accepterar EVE endast GET-förfrågningar. Om vi vill använda någon annan metod måste vi definiera den explicit. Öppna settings.py och definiera resursmetoderna som visas :
RESOURCE_METHODS = ['GET', 'POST']
Spara ändringarna och kör api.py . Försök nu igen att POSTA till användaren och du bör ha följande svar:
Som du kan se ovan lyckades POST-begäran. Vi har inte definierat databaskonfigurationerna i vår settings.py , så EVE slutförde begäran med den körande instansen av MongoDB . Låt oss logga in på MongoDB skal och se den nyskapade posten. När MongoDB-instansen körs, utlöser du mongo-skalet:
mongo
Väl inne i mongo shell, lista alla tillgängliga databaser.
show databases;
Det måste finnas en eve databas. Byt till eve databas.
use eve;
Kör show kommando för att lista tabellerna i eve databas.
show tables;
De listade tabellerna måste ha en tabell som heter user . Lista posterna från användaren tabell med följande kommando:
db.user.find()
Här är de valda posterna från användartabellerna:
Validera användar-API
Därefter skapar vi ett API för att validera en befintlig användare. Normalt, om vi gör en get begäran till användarens slutpunkt (http://127.0.0.1:5000/user), kommer den att ge ut information om alla registrerade användare från databasen. Vi måste genomföra två saker här. Först måste vi verifiera en användare med förnamn och lösenord, och för det andra måste vi returnera användarinformationen från databasen vid framgångsrik autentisering.
För att få detaljer baserade på förnamnet måste vi lägga till ett extra uppslagsfält i DOMAIN i settings.py .
'additional_lookup': {
'url': 'regex("[\w]+")',
'field': 'username',
}
Som framgår av koden ovan har vi lagt till ett uppslagsfält för användarnamn . Nu när en GET-begäran skickas till http://127.0.0.1:5000/user/ användarnamnet . När vi gör en begäran till en viss användare skickar vi även användarnamnet och lösenord för autentisering.
Vi kommer att göra grundläggande autentisering för att verifiera en viss användare baserat på användarnamn och lösenord. Först måste vi importera Basic Auth klass från EVE. Skapa en klass som heter Authenticate för att implementera autentiseringen som visas:
from eve.auth import BasicAuth
class Authenticate(BasicAuth):
def check_auth(self, username, password, allowed_roles, resource,
method):
Nu, när resursen är användare och begärandemetoden är GET , kommer vi att autentisera användaren. Vid lyckad autentisering kommer användarinformationen för användaren med förnamn i API-slutpunkten att returneras. Vi kommer också att begränsa användarskapandet genom att tillhandahålla ett användarnamn och lösenord. Så om metoden är POST och API-slutpunkt är användare, kontrollerar och validerar vi användarnamnet och lösenordet. Så här är hela Autentisera klass:
class Authenticate(BasicAuth):
def check_auth(self, username, password, allowed_roles, resource,
method):
if resource == 'user' and method == 'GET':
user = app.data.driver.db['user']
user = user.find_one({'username': username,'password':password})
if user:
return True
else:
return False
elif resource == 'user' and method == 'POST':
return username == 'admin' and password == 'admin'
else:
return True
Vi måste skicka Authenticate klassnamn när API:t initieras. Så ändra API-initieringskoden som visas:
if __name__ == '__main__':
app = Eve(auth=Authenticate)
app.run()
Spara alla ändringar och kör api.py . Försök att skicka en grundläggande autentiseringsbegäran med ett användarnamn och lösenord från Postman till http://127.0.0.1/user/username (ersätt användarnamnet med ett annat befintligt användarnamn). Vid framgångsrik autentisering bör du få användarinformationen som svar som visas:
Lägg till, ta bort och uppdatera objekt
Lägg till objekt-API
För att skapa ett Add item API behöver vi bara skapa ett nytt schema för artikeln i settings.py .
'item': {
'schema': {
'name':{
'type': 'string'
},
'username': {
'type': 'string'
}
}
} Add Item API skulle hjälpa varje inloggad användare att lägga till ett objekt. Vi kommer att spara objektet tillsammans med användarnamnet för användaren som skrev in objektet. Spara ändringarna och försök göra en POST-förfrågan till http://127.0.0.1/item som visas:
Ta bort Item API
För att ta bort ett objekt som skapats av en användare behöver vi bara anropa objektets slutpunkt /item_id . Men att bara anropa en DELETE-förfrågan kommer inte att radera objektet. För att radera ett objekt måste vi också tillhandahålla en _etag relaterad till ett visst föremål. En gång artikel-id och _etag matchar, raderas objektet från databasen. Så här anropas metoden DELETE i objektslutpunkt.
Uppdatera Item API
Update API liknar Delete API. Allt vi behöver göra är att skicka en PATCH-förfrågan med artikel-id och _etag och formulärfälten som behöver uppdateras. Så här uppdateras artikelinformationen:
