Se stai leggendo questo articolo, probabilmente conosci già le possibilità che si aprono quando utilizzi l'API (Application Programming Interface).
Aggiungendo una delle tante API pubbliche alla tua applicazione, puoi estendere la funzionalità di questa applicazione o integrarla con i dati necessari. Ma cosa succede se hai sviluppato una funzionalità unica che desideri condividere con la community?
La risposta è semplice: hai bisogno .
Sebbene all'inizio possa sembrare un compito arduo, in realtà è abbastanza semplice. Ti mostreremo come farlo con Python.
Cosa ti serve per iniziare
Lo sviluppo dell'API richiede:
- Pitone 3;
- — un framework semplice e facile da usare per la creazione di applicazioni web;
- è un'estensione per Flask che consente di sviluppare un'API REST in modo rapido e con una configurazione minima.
L'installazione viene eseguita dal comando:
pip install flask-restfulConsigliamo una programmazione intensiva gratuita per i principianti:
— 26–28 agosto. Un intensivo gratuito che ti consente di capire come funzionano i robot di supporto, le funzionalità di lavorare con l'API di Telegram e altre sfumature. I primi tre partecipanti riceveranno 30 rubli da Skillbox.
Prima di iniziare
Svilupperemo un'API RESTful con un basic .
Per comprendere appieno l'attività, comprendiamo i due termini sopra menzionati.
Cos'è il RIPOSO?
L'API REST (Representational State Transfer) è un'API che utilizza le richieste HTTP per scambiare dati.
Le API REST devono soddisfare determinati criteri:
- Architettura client-server: il client interagisce con l'interfaccia utente e il server interagisce con il back-end e l'archivio dati. Il client e il server sono indipendenti, ciascuno di essi può essere sostituito separatamente dall'altro.
- Stateless: nessun dato del client viene memorizzato sul server. Lo stato della sessione viene memorizzato sul lato client.
- Cacheability: i client possono memorizzare nella cache le risposte del server per migliorare le prestazioni complessive.
Che cos'è CRUD?
CRUDELE è un concetto di programmazione che descrive quattro azioni di base (creare, leggere, aggiornare ed eliminare).
Nell'API REST, i tipi di richiesta e i metodi di richiesta sono responsabili di azioni come post, get, put, delete.
Ora che abbiamo affrontato i termini di base, possiamo iniziare a creare l'API.
Разработка
Creiamo un archivio di citazioni sull'intelligenza artificiale. L'intelligenza artificiale è oggi una delle tecnologie in più rapida crescita e Python è uno strumento popolare per lavorare con l'IA.
Con questa API, uno sviluppatore Python può conoscere rapidamente l'intelligenza artificiale ed essere ispirato da nuovi traguardi. Se lo sviluppatore ha pensieri preziosi su questo argomento, sarà in grado di aggiungerli al repository.
Iniziamo importando i moduli richiesti e impostando Flask:
from flask import Flask
from flask_restful import Api, Resource, reqparse
import random
app = Flask(__name__)
api = Api(app)In questo frammento, Flask, Api e Resource sono le classi di cui abbiamo bisogno.
Reqparse è un'interfaccia di analisi delle richieste Flask-RESTful... Avrai anche bisogno del modulo random per visualizzare una citazione casuale.
Ora creeremo un archivio di citazioni sull'intelligenza artificiale.
Ogni voce repo conterrà:
- documento d'identità digitale;
- il nome dell'autore della citazione;
- citazione.
Poiché questo è solo un esempio di apprendimento, memorizzeremo tutte le voci in un elenco Python. In un'applicazione reale, molto probabilmente useremmo invece un database.
ai_quotes = [
{
"id": 0,
"author": "Kevin Kelly",
"quote": "The business plans of the next 10,000 startups are easy to forecast: " +
"Take X and add AI."
},
{
"id": 1,
"author": "Stephen Hawking",
"quote": "The development of full artificial intelligence could " +
"spell the end of the human race… " +
"It would take off on its own, and re-design " +
"itself at an ever increasing rate. " +
"Humans, who are limited by slow biological evolution, " +
"couldn't compete, and would be superseded."
},
{
"id": 2,
"author": "Claude Shannon",
"quote": "I visualize a time when we will be to robots what " +
"dogs are to humans, " +
"and I’m rooting for the machines."
},
{
"id": 3,
"author": "Elon Musk",
"quote": "The pace of progress in artificial intelligence " +
"(I’m not referring to narrow AI) " +
"is incredibly fast. Unless you have direct " +
"exposure to groups like Deepmind, " +
"you have no idea how fast — it is growing " +
"at a pace close to exponential. " +
"The risk of something seriously dangerous " +
"happening is in the five-year timeframe." +
"10 years at most."
},
{
"id": 4,
"author": "Geoffrey Hinton",
"quote": "I have always been convinced that the only way " +
"to get artificial intelligence to work " +
"is to do the computation in a way similar to the human brain. " +
"That is the goal I have been pursuing. We are making progress, " +
"though we still have lots to learn about " +
"how the brain actually works."
},
{
"id": 5,
"author": "Pedro Domingos",
"quote": "People worry that computers will " +
"get too smart and take over the world, " +
"but the real problem is that they're too stupid " +
"and they've already taken over the world."
},
{
"id": 6,
"author": "Alan Turing",
"quote": "It seems probable that once the machine thinking " +
"method had started, it would not take long " +
"to outstrip our feeble powers… " +
"They would be able to converse " +
"with each other to sharpen their wits. " +
"At some stage therefore, we should " +
"have to expect the machines to take control."
},
{
"id": 7,
"author": "Ray Kurzweil",
"quote": "Artificial intelligence will reach " +
"human levels by around 2029. " +
"Follow that out further to, say, 2045, " +
"we will have multiplied the intelligence, " +
"the human biological machine intelligence " +
"of our civilization a billion-fold."
},
{
"id": 8,
"author": "Sebastian Thrun",
"quote": "Nobody phrases it this way, but I think " +
"that artificial intelligence " +
"is almost a humanities discipline. It's really an attempt " +
"to understand human intelligence and human cognition."
},
{
"id": 9,
"author": "Andrew Ng",
"quote": "We're making this analogy that AI is the new electricity." +
"Electricity transformed industries: agriculture, " +
"transportation, communication, manufacturing."
}
]Ora dobbiamo creare una classe di risorse Quote che definirà le operazioni dei nostri endpoint API. Quattro metodi devono essere dichiarati all'interno della classe: get, post, put, delete.
Iniziamo con il metodo GET
Ti consente di ottenere un preventivo specifico specificando il suo ID o un preventivo casuale se non viene specificato alcun ID.
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", 404Il metodo GET restituisce una citazione casuale se l'ID contiene il valore predefinito, ad es. L'ID non è stato impostato durante la chiamata al metodo.
Se è impostato, il metodo cerca tra virgolette e trova quello che contiene l'ID dato. Se non viene trovato nulla, viene visualizzato il messaggio "Quote not found, 404".
Ricorda, il metodo restituisce uno stato HTTP di 200 se la richiesta ha avuto successo e 404 se la voce non è stata trovata.
Ora creiamo un metodo POST per aggiungere una nuova citazione al repository
Otterrà l'id di ogni nuova citazione durante la digitazione. Inoltre, POST utilizzerà reqparse per analizzare i parametri che andranno nel corpo della richiesta (autore e testo della citazione).
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, 201Nel codice sopra, il metodo POST ha accettato un ID quotazione. Quindi, utilizzando reqparse, ha recuperato l'autore e la citazione dalla richiesta, memorizzandoli nel dizionario params.
Se esiste già un preventivo con l'ID specificato, il metodo visualizza il messaggio appropriato e il codice 400.
Se non è ancora stata creata una citazione con l'ID specificato, il metodo crea una nuova voce con l'ID e l'autore specificati, oltre ad altri parametri. Quindi aggiunge una voce all'elenco ai_quotes e restituisce una voce con una nuova citazione insieme a un codice 201.
Ora creiamo un metodo PUT per modificare una quotazione esistente nel repository
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, 201Il metodo PUT, simile all'esempio precedente, accetta un ID e un input e analizza i parametri di citazione utilizzando reqparse.
Se esiste un preventivo con l'ID specificato, il metodo lo aggiornerà con i nuovi parametri e quindi restituirà il preventivo aggiornato con il codice 200. Se non esiste ancora un preventivo con l'ID specificato, verrà creato un nuovo record con il codice 201.
Infine, creiamo un metodo DELETE per rimuovere una citazione che non ispira più.
def delete(self, id):
global ai_quotes
ai_quotes = [qoute for qoute in ai_quotes if qoute["id"] != id]
return f"Quote with id {id} is deleted.", 200Questo metodo accetta l'ID preventivo come input e aggiorna l'elenco di ai_quotes utilizzando l'elenco condiviso.
Ora che abbiamo creato tutti i metodi, tutto ciò che dobbiamo fare è semplicemente aggiungere la risorsa all'API, impostare il percorso ed eseguire Flask.
api.add_resource(Quote, "/ai-quotes", "/ai-quotes/", "/ai-quotes/<int:id>")
if __name__ == '__main__':
app.run(debug=True)Il nostro servizio API REST è pronto!
Successivamente, possiamo salvare il codice nel file app.py eseguendolo nella console con il comando:
python3 app.pySe tutto va bene, otterremo qualcosa del genere:
* Modalità debug: attiva
* In esecuzione :5000/ (Premere CTRL+C per uscire)
* Riavvio con stat
* Il debugger è attivo!
* PIN del debugger: XXXXXXX
Test dell'API
Dopo che l'API è stata creata, deve essere testata.
Questa operazione può essere eseguita utilizzando l'utilità della console curl o il client Insomnia REST oppure pubblicando l'API sull'API Rapid.
Pubblicazione della nostra API
RapidAPI è il più grande mercato al mondo con oltre 10 API (e circa 000 milione di sviluppatori).
RapidAPI non solo fornisce un'unica interfaccia per lavorare con API di terze parti, ma consente anche di pubblicare rapidamente e facilmente la propria API.
A , devi prima pubblicarlo su un server della rete. Nel nostro caso, useremo . Lavorare con lui non dovrebbe causare alcuna difficoltà, ().
Come pubblicare la tua API su Heroku
1. Installa Heroku.
Il primo passo è registrare e installare Heroku Command Line Interface (CLI). Funziona su Ubuntu 16+.
sudo snap install heroku --classic
Quindi accediamo:
login di heroku
2. Aggiungere i file necessari.
Ora dobbiamo aggiungere i file da pubblicare in una cartella nella nostra applicazione:
- requirements.txt con un elenco di moduli Python richiesti;
- Procfile, che specifica quali comandi devono essere eseguiti per eseguire l'applicazione;
- .gitignore - per escludere i file che non sono necessari sul server.
Il file requirements.txt conterrà le seguenti righe:
- pallone
- pallone riposante
- gunicorn
Tieni presente che abbiamo aggiunto gunicorn (Python WSGI HTTP Server) all'elenco perché dobbiamo eseguire la nostra applicazione sul server.
Procfile conterrà:
web: gunicorn app: app
Contenuto di .gitignore:
*.pyc
__pycache__/Ora che i file sono stati creati, inizializziamo il repository git ed eseguiamo il commit:
git init
git add
git commit -m "First API commit"3. Crea una nuova app Heroku.
heroku createInvio del ramo master al repository Heroku remoto:
git push heroku masterOra puoi iniziare aprendo il servizio API con i comandi:
heroku ps:scale web=1
heroku open
L'API sarà disponibile all'indirizzo .
Come aggiungere la tua API Python al marketplace RapidAPI
Una volta che il servizio API è stato pubblicato su Heroku, puoi aggiungerlo all'API Rapid. Qui su questo argomento.
1. Crea un account RapidAPI.
Registriamo un account gratuito: questo può essere fatto utilizzando Facebook, Google, GitHub.
2. Aggiungere l'API al pannello di controllo.
3. Successivamente, inserisci le informazioni generali sulla tua API.
4. Dopo aver fatto clic su "Aggiungi API", viene visualizzata una nuova pagina in cui è possibile inserire informazioni sulla nostra API.
5. Ora puoi inserire manualmente gli endpoint API o scaricare utilizzando OpenAPI.
Bene, ora devi impostare gli endpoint della nostra API nella pagina Endpoint. Nel nostro caso, gli endpoint corrispondono al concetto di CRUD (get, post, put, delete).
Successivamente, è necessario creare un endpoint GET AI Quote che visualizzi un preventivo casuale (se l'ID è predefinito) o un preventivo per l'ID specificato.
Per creare un endpoint, è necessario fare clic sul pulsante "Crea endpoint".
Ripetiamo questo processo per tutti gli altri endpoint API. È tutto! Congratulazioni, hai pubblicato la tua API!
Se tutto va bene, la pagina dell'API sarà simile a questa:
conclusione
In questo articolo, abbiamo esaminato il processo di creazione del nostro servizio API RESTful in Python, insieme al processo di pubblicazione dell'API nel cloud Heroku e di aggiunta alla directory RapidAPI.
Ma nella versione di prova, sono stati mostrati solo i principi di base dello sviluppo dell'API: non sono state considerate sfumature come sicurezza, tolleranza agli errori e scalabilità.
Quando si sviluppa una vera API, tutto questo deve essere preso in considerazione.
Fonte: habr.com