Se state leggendo questo articolo, è probabile che siate già familiari con le opportunità offerte dall'uso delle API (Application Programming Interface).
Aggiungendo una delle numerose API aperte alla vostra applicazione, potete espandere la funzionalità di quell'applicazione o arricchirla con dati necessari. Ma cosa fare se avete sviluppato una funzione unica che volete condividere con la comunità?
La risposta è semplice: bisogna .
Nonostante all'inizio possa sembrare un compito arduo, in realtà è tutto molto semplice. Vi spiegheremo come farlo utilizzando Python.
Cosa serve per iniziare
Per sviluppare un'API sono necessari:
- Python 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 avviene con il comando:
pip install flask-restfulConsigliamo un corso intensivo gratuito di programmazione per principianti:
— dal 26 al 28 agosto. Corso intensivo gratuito che permette di comprendere come funzionano i bot assistenti, le peculiarità del lavoro con l'API di Telegram e altri dettagli. I tre migliori partecipanti riceveranno 30.000 rubli da Skillbox..
Prima di iniziare
Siamo pronti a sviluppare un'API RESTful con funzionalità di base .
Per comprendere appieno il compito, analizziamo due termini menzionati sopra.
Cos'è il REST?
L'API REST (Representational State Transfer) è un'API che utilizza richieste HTTP per lo scambio di dati.
Le API REST devono rispettare determinati criteri:
- Architettura client-server: il client interagisce con l'interfaccia utente, mentre il server interagisce con il backend e il database. Client e server sono indipendenti, ognuno dei due può essere sostituito separatamente dal'altra.
- Stateless — nessun dato del client viene conservato sul server. Lo stato della sessione è mantenuto sul lato client.
- Cacheable — i client possono memorizzare nella cache le risposte del server per migliorare le prestazioni complessive.
Cos'è il CRUD?
CRUD è un concetto di programmazione che descrive quattro azioni fondamentali (create, read, update e delete).
Nell'API REST, i tipi di richieste e i metodi di richiesta sono responsabili di azioni come post, get, put, delete.
Ora che abbiamo chiarito i termini di base, possiamo procedere alla creazione dell'API.
Sviluppo
Creiamo un repository di citazioni sull'intelligenza artificiale. L'IA è una delle tecnologie in maggior sviluppo oggi, mentre Python è uno strumento popolare per lavorare con l'IA.
Con questa API, uno sviluppatore Python potrà rapidamente ottenere informazioni sull'IA e ispirarsi a nuove conquiste. Se uno sviluppatore ha pensieri preziosi su questo argomento, potrà aggiungerli al repository.
Iniziamo importando i moduli necessari e configurando 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 per il parsing delle richieste di Flask-RESTful… Sarà inoltre necessario il modulo random per visualizzare una citazione casuale.
Ora creeremo un repository di citazioni sull'IA.
Ogni voce del repo conterrà:
- un ID numerico;
- il nome dell'autore della citazione;
- la citazione.
Poiché si tratta solo di un esempio per l'apprendimento, conserveremo tutte le voci in un elenco Python. In un'applicazione reale, probabilmente utilizzeremmo un database.
ai_quotes = [
{
"id": 0,
"author": "Kevin Kelly",
"quote": "I piani aziendali dei prossimi 10.000 startup sono facili da prevedere: " +
"Prendi X e aggiungi AI."
},
{
"id": 1,
"author": "Stephen Hawking",
"quote": "Lo sviluppo di un'intelligenza artificiale completa potrebbe " +
"significare la fine della razza umana… " +
"Prenderebbe il volo da sola e si riprogetterebbe " +
"a un ritmo sempre crescente. " +
"Gli esseri umani, limitati da una lenta evoluzione biologica, " +
"non potrebbero competere e verrebbero superati."
},
{
"id": 2,
"author": "Claude Shannon",
"quote": "Visualizzo un tempo in cui noi saremo per i robot ciò che " +
"i cani sono per gli esseri umani, " +
"e tifo per le macchine."
},
{
"id": 3,
"author": "Elon Musk",
"quote": "Il ritmo dei progressi nell'intelligenza artificiale " +
"(non mi riferisco all'IA ristretta) " +
"è incredibilmente veloce. A meno che tu non abbia un'esposizione diretta " +
"a gruppi come Deepmind, " +
"non hai idea di quanto velocemente — sta crescendo " +
"a un ritmo prossimo all'esponenziale. " +
"Il rischio che accada qualcosa di seriamente pericoloso " +
"è nell'arco temporale di cinque anni." +
"Dieci anni al massimo."
},
{
"id": 4,
"author": "Geoffrey Hinton",
"quote": "Sono sempre stato convinto che l'unico modo " +
"per far funzionare l'intelligenza artificiale " +
"sia quello di eseguire i calcoli in un modo simile a quello del cervello umano. " +
"Questo è l'obiettivo che ho perseguito. Stiamo facendo progressi, " +
"anche se abbiamo ancora molto da imparare su " +
"come funziona realmente il cervello."
},
{
"id": 5,
"author": "Pedro Domingos",
"quote": "La gente si preoccupa che i computer diventino " +
"troppo intelligenti e prendano il controllo del mondo, " +
"ma il vero problema è che sono troppo stupidi " +
"e hanno già preso il controllo del mondo."
},
{
"id": 6,
"author": "Alan Turing",
"quote": "Sembra probabile che una volta avviato il " +
"metodo di pensiero della macchina, non ci vorrebbe molto " +
"per superare i nostri deboli poteri… " +
"Essi sarebbero in grado di conversare " +
"tra di loro per affinare la loro intelligenza. " +
"A un certo punto, quindi, dovremmo " +
"aspettarci che le macchine prendano il controllo."
},
{
"id": 7,
"author": "Ray Kurzweil",
"quote": "L'intelligenza artificiale raggiungerà " +
"livelli umani intorno al 2029. " +
"Se seguiamo oltre, diciamo, fino al 2045, " +
"avremo moltiplicato l'intelligenza, " +
"l'intelligenza della macchina biologica umana " +
"della nostra civiltà di un miliardo di volte."
},
{
"id": 8,
"author": "Sebastian Thrun",
"quote": "Nessuno lo esprime in questo modo, ma penso " +
"che l'intelligenza artificiale " +
"sia quasi una disciplina umanistica. È davvero un tentativo " +
"di comprendere l'intelligenza umana e la cognizione umana."
},
{
"id": 9,
"author": "Andrew Ng",
"quote": "Stiamo facendo questa analogia che l'IA è la nuova elettricità." +
"L'elettricità ha trasformato industrie: agricoltura, " +
"trasporti, comunicazione, manifattura."
}
]Ora dobbiamo creare una classe risorsa Quote, che definirà le operazioni degli endpoint della nostra API. All'interno della classe dobbiamo dichiarare quattro metodi: get, post, put, delete.
Cominciamo con il metodo GET
Esso consente di ottenere una citazione specifica indicando il suo ID o una citazione casuale, se non viene fornito un 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 ha il valore predefinito, ovvero quando il metodo viene chiamato senza specificare un ID.
Se l'ID è fornito, il metodo cerca tra le citazioni e trova quella che corrisponde all'ID specificato. Se non viene trovata nulla, viene visualizzato il messaggio “Quote not found, 404”.
Ricorda: il metodo restituisce uno stato HTTP 200 in caso di richiesta riuscita e 404 se il record non è stato trovato.
Ora creiamo un metodo POST per aggiungere una nuova citazione al repository
Esso riceverà l'identificatore di ogni nuova citazione all'input. Inoltre, il POST utilizzerà reqparse per analizzare i parametri che saranno 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 ricevuto l'ID della citazione. Poi, utilizzando reqparse, ha ottenuto l'autore e la citazione dalla richiesta, memorizzandoli nel dizionario params.
Se una citazione con l'ID fornito esiste già, il metodo restituisce un messaggio appropriato e il codice 400.
Se la citazione con l'ID fornito non è stata ancora creata, il metodo crea un nuovo record con l'ID e l'autore specificati, insieme agli altri parametri. Poi aggiunge il record alla lista ai_quotes e restituisce il record con la nuova citazione insieme al codice 201.
Ora creiamo un metodo PUT per modificare una citazione 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, prende l'ID e l'input e analizza i parametri della citazione, utilizzando reqparse.
Se la citazione con l'ID specificato esiste, il metodo la aggiornerà con i nuovi parametri e poi restituirà la citazione aggiornata con codice 200. Se la citazione con l'ID specificato non esiste ancora, verrà creata un nuova registrazione con codice 201.
Infine, creiamo un metodo DELETE per rimuovere la citazione che non ci ispira più.
def delete(self, id):
global ai_quotes
ai_quotes = [quote for quote in ai_quotes if quote["id"] != id]
return f"Citazione con id {id} è stata eliminata.", 200Questo metodo riceve l'ID della citazione come input e aggiorna l'elenco ai_quotes, utilizzando l'elenco globale.
Ora che abbiamo creato tutti i metodi, tutto ciò che dobbiamo fare è semplicemente aggiungere la risorsa all'API, definire il percorso e avviare Flask.
api.add_resource(Quote, "\/ai-quotes", "\/ai-quotes\/", "\/ai-quotes\/")
if __name__ == '__main__':
app.run(debug=True)Il nostro servizio API REST è pronto!
Successivamente, possiamo salvare il codice in un file app.py, eseguendolo nella console con il comando:
python3 app.pySe tutto va bene, otterremo qualcosa del genere:
* Modalità debug: attivata
* In esecuzione su :5000\/ (Premere CTRL+C per uscire)
* Riavvio con stat
* Debugger attivo!
* PIN del debugger: XXXXXXX
Testiamo l'API
Dopo che l'API è stata creata, deve essere testata.
Questo può essere fatto utilizzando l'utility da console curl o il client Insomnia REST, oppure pubblicando l'API su Rapid API.
Pubblicando la nostra API
RapidAPI è il più grande marketplace al mondo con oltre 10.000 API (e circa 1 milione di sviluppatori).
RapidAPI non solo fornisce un'interfaccia unica per lavorare con API di terze parti, ma offre anche la possibilità di pubblicare rapidamente e senza problemi la propria API.
Per , è necessario prima pubblicarla su un server online. Nel nostro caso utilizziamo . Lavorarci non dovrebbe creare difficoltà, ().
Come pubblicare la tua API su Heroku
1. Installiamo Heroku.
Per prima cosa, bisogna registrarsi e installare Heroku Command Line Interface (CLI). Questo funziona su Ubuntu 16+.
sudo snap install heroku --classic
Poi effettuiamo il login:
heroku login
2. Aggiungiamo i file necessari.
Ora è necessario aggiungere i file per la pubblicazione nella cartella dell'applicazione:
- requirements.txt con l'elenco dei moduli Python necessari;
- Procfile, che indica quali comandi devono essere eseguiti per avviare l'applicazione;
- .gitignore — per escludere i file che non sono necessari sul server.
Il file requirements.txt conterrà le seguenti righe:
- flask
- flask-restful
- gunicorn
Si prega di notare: abbiamo aggiunto gunicorn (Python WSGI HTTP Server) nell'elenco, poiché è necessario eseguire la nostra applicazione sul server.
Il Procfile conterrà:
web: gunicorn app:app
Contenuto di .gitignore:
*.pyc
__pycache__/Ora che i file sono stati creati, iniziamo a inizializzare il repository git e a fare il commit:
git init
git add
git commit -m "Primo commit dell'API"3. Creiamo una nuova applicazione Heroku.
heroku createInviamo il branch master nel repository remoto Heroku:
git push heroku masterOra possiamo 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
Dopo che il servizio API è stato pubblicato su Heroku, puoi aggiungerlo a Rapid API. Qui su questo argomento.
1. Creiamo un account RapidAPI.
Registrati per un account gratuito, puoi farlo tramite Facebook, Google, GitHub.
2. Aggiungiamo l'API nella dashboard.
3. Successivamente, inseriamo le informazioni generali sulla nostra API.
4. Dopo aver cliccato su “Aggiungi API”, appare una nuova pagina in cui puoi inserire le informazioni sulla nostra API.
5. Ora puoi sia inserire manualmente gli endpoint dell'API, sia caricare utilizzando OpenAPI.
Adesso dobbiamo definire gli endpoint della nostra API nella pagina Endpoint. Nel nostro caso, gli endpoint corrispondono al concetto di CRUD (get, post, put, delete).
Poi dobbiamo creare l'endpoint GET AI Quote, che restituisce una citazione casuale (nel caso in cui l'ID sia predefinito) o una citazione per un ID specificato.
Per creare l'endpoint, premi il pulsante “Crea Endpoint”.
Ripeti questo processo per tutti gli altri endpoint dell'API. È tutto! Congratulazioni, hai pubblicato la tua API!
Se va tutto bene, la pagina dell'API apparirà in questo modo:
Conclusione
In questo articolo abbiamo esaminato il processo di creazione del proprio Servizio API RESTful in Python, insieme al processo di pubblicazione dell'API nel cloud Heroku e alla sua aggiunta nel catalogo RapidAPI.
Ma nella versione di prova sono stati mostrati solo i principi di base dello sviluppo API — aspetti come sicurezza, resilienza e scalabilità non sono stati trattati.
Quando si sviluppa una vera API, è necessario tenerne conto.
Fonte: habr.com
