Als u dit artikel leest, bent u waarschijnlijk al bekend met de mogelijkheden die het gebruik van een API (Application Programming Interface) biedt.
Door een van de vele open API's aan uw applicatie toe te voegen, kunt u de functionaliteit van deze applicatie uitbreiden of aanvullen met de benodigde gegevens. Maar wat als u een unieke functie heeft ontwikkeld die u wilt delen met de community?
Het antwoord is eenvoudig: u moet .
Hoewel dit in het begin een complexe taak lijkt, is het in werkelijkheid heel eenvoudig. We zullen u vertellen hoe dit te doen met Python.
Wat u nodig heeft om te beginnen
Voor de ontwikkeling van een API zijn de volgende benodigdheden:
- Python 3;
- ā een eenvoudig en gebruiksvriendelijk framework voor het maken van webapplicaties;
- ā een uitbreiding voor Flask die het mogelijk maakt om snel en met minimale configuratie een REST API te ontwikkelen.
De installatie gebeurt met de volgende opdracht:
pip install flask-restfulWe raden een gratis intensieve programmeercursus voor beginners aan:
ā van 26-28 augustus. Een gratis intensieve cursus die het mogelijk maakt om te begrijpen hoe hulpprogramma's werken, de speciale kenmerken van het werken met de Telegram API en andere nuances. De drie beste deelnemers ontvangen van Skillbox 30.000 roebel..
Voordat we beginnen
gaan we een RESTful API ontwikkelen met basis- .
Om de taak volledig te begrijpen, laten we de twee hierboven genoemde termen toelichten.
Wat is REST?
REST API (Representational State Transfer) is een API die HTTP-aanvragen gebruikt voor het uitwisselen van gegevens.
REST API's moeten voldoen aan bepaalde criteria:
- Client-serverarchitectuur: de client interacteert met de gebruikersinterface, terwijl de server met de backend en de gegevensopslag werkt. Client en server zijn onafhankelijk van elkaar, elk van hen kan apart van de ander worden vervangen.
- Stateless ā er worden geen klantgegevens op de server opgeslagen. De sessietoestand wordt aan de klantzijde bewaard.
- Cachebaarheid ā klanten kunnen de serverantwoorden cachen om de algehele prestaties te verbeteren.
Wat is CRUD?
CRUD ā een programmeerconcept dat vier basisacties beschrijft (create, read, update en delete).
In een REST API zijn de type aanvragen en de aanvraagmethoden verantwoordelijk voor acties zoals post, get, put, delete.
Nu we de basisbegrippen hebben begrepen, kunnen we beginnen met het maken van de API.
Ontwikkeling
Laten we een citatenrepository over kunstmatige intelligentie creƫren. AI is een van de snelst groeiende technologieƫn vandaag de dag, en Python is een populair hulpmiddel voor het werken met AI.
Met deze API kan de Python-ontwikkelaar snel informatie over AI verkrijgen en geĆÆnspireerd raken door nieuwe prestaties. Als de ontwikkelaar waardevolle gedachten over dit onderwerp heeft, kan hij deze aan het repository toevoegen.
Laten we beginnen met het importeren van de benodigde modules en het instellen van Flask:
from flask import Flask
from flask_restful import Api, Resource, reqparse
import random
app = Flask(__name__)
api = Api(app)In deze Flask-snipet zijn Api en Resource de klassen die we nodig hebben.
Reqparse is de interface voor het parseren van verzoeken in Flask-RESTful... We hebben ook de random-module nodig om een willekeurige citaat weer te geven.
Nu gaan we het citatenrepository over AI maken.
Elke record in het repository zal bevatten:
- een digitale ID;
- de naam van de auteur van het citaat;
- het citaat.
Aangezien dit slechts een voorbeeld is voor educatieve doeleinden, slaan we alle records op in een Python-lijst. In een echte applicatie zouden we in plaats daarvan waarschijnlijk een database gebruiken.
ai_quotes = [
{
"id": 0,
"author": "Kevin Kelly",
"quote": "De bedrijfsplannen van de volgende 10.000 startups zijn gemakkelijk te voorspellen: " +
"Neem X en voeg AI toe."
},
{
"id": 1,
"author": "Stephen Hawking",
"quote": "De ontwikkeling van volledige kunstmatige intelligentie kan " +
"het einde van de menselijke ras betekenenā¦ " +
"Het zou zelfstandig opstijgen en " +
"zichzelf opnieuw ontwerpen " +
"op een steeds toenemende snelheid. " +
"Mensen, die beperkt zijn door langzame biologische evolutie, " +
"zouden niet kunnen concurreren en zouden overvleugeld worden."
},
{
"id": 2,
"author": "Claude Shannon",
"quote": "Ik stel me een tijd voor waarin we voor robots zijn wat " +
"honden voor mensen zijn, " +
"en ik steun de machines."
},
{
"id": 3,
"author": "Elon Musk",
"quote": "De snelheid van de voortgang in kunstmatige intelligentie " +
"(ik verwijs niet naar smalle AI) " +
"is ongelooflijk snel. Tenzij je directe " +
"blootstelling hebt aan groepen zoals Deepmind, " +
"heb je geen idee hoe snel ā het groeit " +
"met een tempo dat dicht bij exponentieel ligt. " +
"Het risico dat er iets ernstig gevaarlijks " +
"gebeurt, ligt in de tijdspanne van vijf jaar. " +
"10 jaar maximaal."
},
{
"id": 4,
"author": "Geoffrey Hinton",
"quote": "Ik ben altijd ervan overtuigd geweest dat de enige manier " +
"om kunstmatige intelligentie aan de praat te krijgen " +
"is door de berekening op een manier uit te voeren die lijkt op de menselijke hersenen. " +
"Dat is het doel dat ik heb nagestreefd. We maken vorderingen, " +
"alhoewel we nog veel te leren hebben over " +
"hoe de hersenen echt werken."
},
{
"id": 5,
"author": "Pedro Domingos",
"quote": "Mensen maken zich zorgen dat computers " +
"te slim zullen worden en de wereld overnemen, " +
"maar het echte probleem is dat ze te dom zijn " +
"en ze de wereld al hebben overgenomen."
},
{
"id": 6,
"author": "Alan Turing",
"quote": "Het lijkt waarschijnlijk dat zodra de machine denktechniek " +
"is gestart, het niet lang zal duren " +
"om onze zwakke vermogens te overtreffenā¦ " +
"Ze zouden in staat zijn om met elkaar te converseren " +
"om hun wijsheid te scherpen. " +
"Op een bepaald moment moeten we daarom " +
"verwachten dat de machines de controle overnemen."
},
{
"id": 7,
"author": "Ray Kurzweil",
"quote": "Kunstmatige intelligentie zal rond 2029 " +
"de menselijke niveaus bereiken. " +
"Als je dat verder doorvoert naar, laten we zeggen, 2045, " +
"hebben we de intelligentie, " +
"de menselijke biologische machine-intelligentie " +
"van onze beschaving een miljard keer vermenigvuldigd."
},
{
"id": 8,
"author": "Sebastian Thrun",
"quote": "Niemand verwoordt het zo, maar ik denk " +
"dat kunstmatige intelligentie " +
"bijna een menswetenschap is. Het is echt een poging " +
"om menselijke intelligentie en menselijke cognitie te begrijpen."
},
{
"id": 9,
"author": "Andrew Ng",
"quote": "We maken deze analogie dat AI de nieuwe elektriciteit is." +
"Elektriciteit heeft industrieƫn getransformeerd: landbouw, " +
"transport, communicatie, productie."
}
]Nu moeten we een resourceklasse Quote maken, die de endpoints van onze API definieert. Binnen de klasse moeten vier methoden worden gedeclareerd: get, post, put, delete.
Laten we beginnen met de GET-methode.
Deze maakt het mogelijk om een bepaalde quote te ontvangen door het ID op te geven, of een willekeurige quote als het ID niet is opgegeven.
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 niet gevonden", 404De GET-methode retourneert een willekeurige quote als het ID het standaardwaarde bevat, dat wil zeggen dat het ID niet is opgegeven bij het aanroepen van de methode.
Als het is opgegeven, zoekt de methode tussen de quotes en vindt degene met het opgegeven ID. Als er niets wordt gevonden, verschijnt er een bericht āQuote niet gevonden, 404ā.
Vergeet niet: de methode retourneert HTTP-status 200 bij een succesvolle aanvraag en 404 als het record niet is gevonden.
Laten we nu de POST-methode maken om een nieuwe quote aan de repository toe te voegen.
Deze ontvangt het ID van elke nieuwe quote bij het invoeren. Bovendien zal POST reqparse gebruiken voor het parseren van de parameters die in de body van de aanvraag komen (auteur en tekst van de quote).
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 met id {id} bestaat al", 400
quote = {
"id": int(id),
"author": params["author"],
"quote": params["quote"]
}
ai_quotes.append(quote)
return quote, 201In de bovenstaande code heeft de POST-methode het ID van de quote geaccepteerd. Vervolgens, met behulp van reqparse, heeft het de auteur en de quote uit de aanvraag gekregen en deze opgeslagen in een dictionary params.
Als er al een quote met het opgegeven ID bestaat, geeft de methode een bijbehorend bericht en code 400 weer.
Als er nog geen quote met het opgegeven ID is aangemaakt, maakt de methode een nieuw record aan met het opgegeven ID en auteur, evenals andere parameters. Vervolgens voegt hij het record toe aan de lijst ai_quotes en retourneert de record met de nieuwe quote samen met code 201.
Laten we nu de PUT-methode maken om een bestaande quote in de repository te wijzigen.
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, 201De PUT-methode, vergelijkbaar met het vorige voorbeeld, neemt een ID en invoer en analyseert de citatieparameters met behulp van reqparse.
Als de citatie met de opgegeven ID bestaat, zal de methode deze bijwerken met de nieuwe parameters en vervolgens de bijgewerkte citatie weergeven met code 200. Als er nog geen citatie met de opgegeven ID bestaat, wordt er een nieuwe registratie gemaakt met code 201.
Laten we eindelijk een DELETE-methode creƫren om een citatie te verwijderen die ons niet langer inspireert.
def delete(self, id):
global ai_quotes
ai_quotes = [quote for quote in ai_quotes if quote["id"] != id]
return f"Quote met id {id} is verwijderd.", 200Deze methode ontvangt de ID van de citatie als invoer en werkt de lijst ai_quotes bij met behulp van de globale lijst.
Nu we alle methoden hebben gemaakt, is het enige wat we hoeven te doen, gewoon de resource aan de API toe te voegen, een pad in te stellen en Flask te starten.
api.add_resource(Quote, "\/ai-quotes", "\/ai-quotes\/", "\/ai-quotes\/\")
if __name__ == '__main__':
app.run(debug=True)Onze REST API-dienst is klaar!
Daarna kunnen we de code opslaan in een bestand app.py en deze vanuit de console uitvoeren met het commando:
python3 app.pyAls alles goed gaat, krijgen we iets als dit:
* Debugmodus: aan
* Draait op :5000\/ (Druk op CTRL+C om te stoppen)
* Herstarten met stat
* Debugger is actief!
* Debugger PIN: XXXXXXX
API testen
Nadat de API is gemaakt, moet deze getest worden.
Dit kan gedaan worden met de consoletool curl of de Insomnia REST-client, of door de API te publiceren op Rapid API.
Publiceer onze API
RapidAPI is de grootste marktplaats ter wereld met meer dan 10.000 API's (en ongeveer 1 miljoen ontwikkelaars).
RapidAPI biedt niet alleen een enkele interface voor het werken met externe API's, maar maakt het ook mogelijk om snel en eenvoudig je eigen API te publiceren.
To , moet je het eerst publiceren op een server in het netwerk. In ons geval gebruiken we . Het werken daarmee zou geen problemen moeten opleveren, ().
Hoe je jouw API op Heroku kunt publiceren
1. Installeer Heroku.
Eerst moet je je registreren en de Heroku Command Line Interface (CLI) installeren. Dit werkt op Ubuntu 16+.
sudo snap install heroku --classic
Log dan in:
heroku login
2. Voeg de benodigde bestanden toe.
Nu moeten we de bestanden die we willen publiceren aan de map in onze applicatie toevoegen:
- requirements.txt met de lijst van benodigde Python-modules;
- Procfile, dat aangeeft welke commando's uitgevoerd moeten worden om de applicatie te starten;
- .gitignore ā om bestanden uit te sluiten die niet op de server nodig zijn.
Het bestand requirements.txt zal de volgende regels bevatten:
- flask
- flask-restful
- voor het verwerken van webverzoeken. Wanneer Quay een verzoek ontvangt (via onze eigen API, of via de Docker API), wordt er een gevent worker toegewezen. Normaal gesproken moet deze worker verbinding maken met de database. Na de eerste storing ontdekten we dat de gevent workers verbinding maakten met de database met de standaardinstellingen.
Let op: we hebben gunicorn (Python WSGI HTTP Server) aan de lijst toegevoegd, omdat we onze applicatie op de server moeten draaien.
Procfile bevat:
web: gunicorn app:app
Inhoud van .gitignore:
*.pyc
__pycache__/Nu we de bestanden hebben aangemaakt, laten we het git-repo initialiseren en committen:
git init
git add
git commit -m "Eerste API commit"3. Laten we een nieuwe Heroku-app maken.
heroku createStuur de master branch naar de remote Heroku repo:
git push heroku masterNu kunnen we beginnen met het openen van de API-service met de volgende commando's:
heroku ps:scale web=1
heroku open
De API is bereikbaar op .
Hoe je jouw Python API aan de RapidAPI-marktplaats toevoegt
Nadat de API-service op Heroku is gepubliceerd, kun je deze aan Rapid API toevoegen. Hier is over dit onderwerp.
1. Maak een RapidAPI-account aan.
Registreer een gratis account - dit kan via Facebook, Google, GitHub.
2. Voeg de API toe aan het dashboard.
3. Vul vervolgens de algemene informatie over je API in.
4. Na het klikken op āAdd APIā verschijnt er een nieuwe pagina waar je informatie over onze API kunt invoeren.
5. Nu kun je ofwel handmatig de API-eindpunten invoeren, of uploaden met OpenAPI.
Nu moet je de eindpunten van onze API op de pagina Eindpunten instellen. In ons geval komen de eindpunten overeen met het CRUD-concept (get, post, put, delete).
Vervolgens moet je een GET AI Quote-eindpunt maken dat een willekeurige quote retourneert (tenzij het ID standaard is) of een quote voor het opgegeven ID.
Om een eindpunt te creĆ«ren, klik op de knop āCreate Endpointā.
Herhaal dit proces voor alle andere API-eindpunten. Dat is alles! Gefeliciteerd, je hebt je API gepubliceerd!
Als alles goed gaat, zal de API-pagina er ongeveer zo uitzien:
Conclusie
In dit artikel hebben we het proces bestudeerd van het creƫren van onze eigen RESTful API-service in Python, samen met het publiceren van de API in de cloud op Heroku en het toevoegen ervan aan de RapidAPI-catalogus.
Maar in de testversie zijn alleen de basisprincipes van API-ontwikkeling getoond - zaken zoals beveiliging, fouttolerantie en schaalbaarheid zijn niet besproken.
Bij de ontwikkeling van een echte API moet hier rekening mee worden gehouden.
Bron: habr.com
