Se stai leggendo questo articolo, probabilmente sei già familiare con le opportunità offerte dall'uso delle API (Application Programming Interface).
Aggiungendo alla tua applicazione una delle tante API pubbliche, puoi ampliare la funzionalità dell'applicazione o integrarla con dati utili. Ma cosa fare se hai sviluppato una funzione unica che vuoi condividere con la comunità?
La risposta è semplice: devi .
Anche se inizialmente può sembrare un compito complesso, in realtà è molto semplice. Ti spiegheremo come farlo utilizzando Python.
Cosa ti serve per iniziare
Per sviluppare un'API ti servono:
- Python 3;
- — un framework semplice e facile da usare per la creazione di applicazioni web;
- — un'estensione per Flask che consente di sviluppare rapidamente un'API REST con una configurazione minima.
L'installazione si esegue con il comando:
pip install flask-restfulTi consigliamo un corso intensivo gratuito di programmazione per principianti:
— dal 26 al 28 agosto. Un corso gratuito che ti permette di comprendere come funzionano i bot assistenti, le peculiarità del lavoro con l'API di Telegram e altri aspetti. I tre migliori partecipanti riceveranno 30.000 rubli da Skillbox.
Prima di iniziare
Intendiamo sviluppare un'API RESTful con funzionalità di base .
Per comprendere completamente il compito, analizziamo due termini menzionati in precedenza.
Che cos'è REST?
Un'API REST (Representational State Transfer) è un'API che utilizza richieste HTTP per lo scambio di dati.
Le API REST devono soddisfare determinati criteri:
- Architettura client-server: il client interagisce con l'interfaccia utente, mentre il server gestisce il backend e il database. Client e server sono indipendenti, ognuno può essere sostituito separatamente dall'altro.
- Stateless: nessun dato del client è memorizzato sul server. Lo stato della sessione è mantenuto sul lato client.
- Cacheabilità: i client possono memorizzare nella cache le risposte del server per migliorare le prestazioni complessive.
Che cos'è CRUD?
CRUD è un concetto di programmazione che descrive quattro azioni fondamentali (creare, leggere, aggiornare e cancellare).
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 iniziare a creare l'API.
Sviluppo
Creiamo un repository di citazioni sull'intelligenza artificiale. L'IA è una delle tecnologie in più rapida evoluzione oggi, mentre Python è uno strumento popolare per lavorare con l'IA.
Con questo API, uno sviluppatore Python potrà ottenere rapidamente informazioni sull'IA e trarre ispirazione dai nuovi risultati. Se lo sviluppatore ha idee preziose su questo argomento, potrà aggiungerle 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 snippet, Flask, Api e Resource sono le classi di cui abbiamo bisogno.
Reqparse è l'interfaccia di parsing delle richieste di Flask-RESTful... Avremo anche bisogno del 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é questo è solo un esempio per l'apprendimento, salveremo tutte le registrazioni nella lista Python. In una reale applicazione, invece, saremo probabilmente inclini a utilizzare un database.
ai_quotes = [
{
"id": 0,
"author": "Kevin Kelly",
"quote": "I piani aziendali delle prossime 10.000 startup sono facili da prevedere: " +
"Prendi X e aggiungi l'AI."
},
{
"id": 1,
"author": "Stephen Hawking",
"quote": "Lo sviluppo di un'intelligenza artificiale completa potrebbe " +
"segnare la fine della razza umana… " +
"Si auto-alzerebbe e si riprogetterebbe " +
"a un ritmo sempre crescente. " +
"Gli esseri umani, limitati dalla lenta evoluzione biologica, " +
"non potrebbero competere e verrebbero superati."
},
{
"id": 2,
"author": "Claude Shannon",
"quote": "Visualizzo un'epoca in cui noi saremo per i robot ciò che " +
"i cani sono per gli umani, " +
"e tifo per le macchine."
},
{
"id": 3,
"author": "Elon Musk",
"quote": "Il ritmo del progresso nell'intelligenza artificiale " +
"(non mi riferisco all'AI ristretta) " +
"è incredibilmente rapido. A meno che tu non abbia un'esposizione diretta " +
"a gruppi come Deepmind, " +
"non hai idea di quanto velocemente — sta crescendo " +
"a un ritmo vicino all'esponenziale. " +
"Il rischio che accada qualcosa di realmente pericoloso " +
"è nell'orizzonte di cinque anni." +
"Dieci al massimo."
},
{
"id": 4,
"author": "Geoffrey Hinton",
"quote": "Sono sempre stato convinto che l'unico modo " +
"per far funzionare l'intelligenza artificiale " +
"sia fare i calcoli in modo simile a come fa il cervello umano. " +
"Quello è 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": "Le persone si preoccupano 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 delle macchine, " +
"non ci vorrebbe molto " +
"per superare i nostri poteri deboli… " +
"Sarebbero in grado di conversare " +
"tra loro per affilare il loro ingegno. " +
"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 entro il 2029. " +
"Proseguendo oltre, diciamo, 2045, " +
"avremo moltiplicato l'intelligenza, " +
"l'intelligenza biologica umana " +
"della nostra civiltà di un miliardo di volte."
},
{
"id": 8,
"author": "Sebastian Thrun",
"quote": "Nessuno lo formula in questo modo, ma penso che " +
"l'intelligenza artificiale " +
"sia quasi una disciplina umanistica. È davvero un tentativo " +
"di comprendere l'intelligenza e la cognizione umana."
},
{
"id": 9,
"author": "Andrew Ng",
"quote": "Stiamo facendo questa analogia che l'AI è la nuova elettricità." +
"L'elettricità ha trasformato le industrie: agricoltura, " +
"trasporti, comunicazione, manifattura."
}
]Ora dobbiamo creare una classe di risorse Quote, che definirà le operazioni degli endpoint della nostra API. All'interno della classe, dobbiamo dichiarare quattro metodi: get, post, put, delete.
Iniziamo con il metodo GET
Questo consente di ottenere una specifica citazione fornendo il suo ID o una citazione casuale se l'ID non è specificato.
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, cioè quando viene chiamato il metodo senza specificare l'ID.
Se è specificato, il metodo cerca tra le citazioni e trova quella con l'ID corrispondente. Se non viene trovata nulla, viene restituito 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 viene trovato.
Ora creiamo il metodo POST per aggiungere una nuova citazione al repository.
Riceverà l'identificatore di ogni nuova citazione in input. Inoltre, il POST utilizzerà reqparse per analizzare i parametri che arriveranno 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"La citazione con ID {id} esiste già", 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. Successivamente, utilizzando reqparse, ha ottenuto l'autore e la citazione dalla richiesta, memorizzandoli nel dizionario params.
Se una citazione con l'ID specificato esiste già, il metodo restituisce un messaggio corrispondente e il codice 400.
Se una citazione con l'ID specificato non è stata ancora creata, il metodo crea una nuova voce con l'ID dato e l'autore, insieme ad altri parametri. Poi aggiunge la voce alla lista ai_quotes e restituisce la voce con la nuova citazione insieme al codice 201.
Adesso 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 restituirà la citazione aggiornata con codice 200. Se la citazione con l'ID specificato non esiste, verrà creata una nuova voce 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 = [qoute for qoute in ai_quotes if qoute["id"] != id]
return f"La citazione con id {id} è stata eliminata.", 200Questo metodo riceve l'ID della citazione all'input e aggiorna l'elenco di ai_quotes, utilizzando l'elenco globale.
Ora che abbiamo creato tutti i metodi, tutto ciò che dobbiamo fare è aggiungere la risorsa all'API, impostare il percorso e avviare Flask.
api.add_resource(Quote, "/ai-quotes", "/ai-quotes/", "/ai-quotes/<int:id>")
if __name__ == '__main__':
app.run(debug=True)Il nostro servizio REST API è 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
* Il debugger è attivo!
* PIN del debugger: XXXXXXX
Testiamo l'API
Dopo aver creato l'API, è necessario testarla.
È possibile farlo utilizzando l'utilità da console curl o il client Insomnia REST, oppure pubblicando l'API su RapidAPI.
Pubbliciamo la nostra API
RapidAPI è il più grande marketplace al mondo con oltre 10.000 API (e circa 1 milione di sviluppatori).
RapidAPI non solo offre un'interfaccia unica per lavorare con API di terze parti, ma consente anche di pubblicare rapidamente e facilmente la propria API.
Per , prima è necessario pubblicarla su un server online. In questo caso utilizzeremo . Lavorare con esso non dovrebbe presentare difficoltà, ().
Come pubblicare la tua API su Heroku
1. Installiamo Heroku.
Per prima cosa, è necessario registrarsi e installare l'Heroku Command Line Interface (CLI). Funziona su Ubuntu 16+.
sudo snap install heroku --classic
Successivamente, effettua il login:
heroku login
2. Aggiungere i file necessari.
Ora è necessario aggiungere i file per la pubblicazione nella cartella della nostra 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 servono 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) all'elenco, poiché è necessario eseguire la nostra applicazione sul server.
Il Procfile conterrà:
web: gunicorn app:app
Il contenuto di .gitignore:
*.pyc
__pycache__/Ora che i file sono stati creati, iniziamo a inizializzare il repo git e a fare un commit:
git init
git add
git commit -m "Primo commit API"3. Creiamo una nuova applicazione Heroku.
heroku createInviamo il branch master nel repo remoto di 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 RapidAPI. Qui trovi su questo tema.
1. Creiamo un account RapidAPI.
Registrati per un account gratuito — puoi farlo tramite Facebook, Google, GitHub.
2. Aggiungi l'API nel pannello di controllo.
3. Successivamente, inserisci le informazioni generali sulla tua API.
4. Dopo aver fatto clic su "Aggiungi API", si apre una nuova pagina dove puoi inserire le informazioni sulla nostra API.
5. Ora puoi inserire manualmente gli endpoint API o caricare utilizzando OpenAPI.
Ora dobbiamo definire gli endpoint della nostra API nella pagina Endpoint. Nel nostro caso, gli endpoint corrispondono al concetto di CRUD (get, post, put, delete).
Successivamente, dobbiamo creare l'endpoint GET AI Quote, che restituisce una citazione casuale (se l'ID è predefinito) o una citazione per l'ID specificato.
Per creare l'endpoint, clicchiamo il pulsante “Create Endpoint”.
Ripetiamo questo processo per tutti gli altri endpoint API. E con questo, abbiamo finito! Congratulazioni, hai pubblicato la tua API!
Se tutto va bene, la pagina API apparirà più o meno così:
Conclusione
In questo articolo abbiamo esplorato il processo di creazione del nostro servizio RESTful API in Python, insieme al processo di pubblicazione dell'API nel cloud Heroku e della sua aggiunta al catalogo RapidAPI.
Ma nel campione di test sono stati mostrati solo i principi di base dello sviluppo API: aspetti come sicurezza, resilienza e scalabilità non sono stati considerati.
Quando si sviluppa un'API reale, è necessario tenere conto di tutto ciò.
Fonte: habr.com
