Flask är ett lätt Python-webbramverk som är idealiskt för att bygga RESTful API: er och mikrotjänster. Till skillnad från tyngre ramverk som Django är Flask minimal och meningslös, vilket ger utvecklare full kontroll över applikationsstrukturen. Denna flexibilitet gör det till ett utmärkt val för att utveckla anpassade, skalbara webb-API:er skräddarsydda för specifika projektkrav.
Så, Flask Python är ett mikroramverk som gör att du kan ha en webbapplikation som körs med mycket få steg och nästan ingen installation. Detta ramverk är enkelhet och stark kontroll över vad du vill ha i din applikation har gjort det till ett av de mest använda webbutvecklingsramar.
Python är ett mycket populärt och kraftfullt språk med en stor gemenskap som har funnits länge. Många stora företag, som Google, använder det för sina projekt, och antalet personer som använder det för webbutveckling ökar fortfarande.
Vi visar dig att det är enkelt, flexibelt och modulärt, vilket leder till en trevlig utvecklingsupplevelse.
Vi förväntar oss att användaren har grundläggande kunskaper om Python för att förstå alla presenterade steg. Ändå bör någon person kunna ha applikationen igång efter att ha följt denna handledning.
Ett ramverk är ett bibliotek som används av utvecklare för att bygga och underhålla pålitliga och skalbara webbapplikationer. Det finns flera ramverk tillgänglig för Python, som Tornado, Pyramind och naturligtvis Django (som ofta jämförs med Flask).
Flask (🌶️) är ett Python-mikroramverk för webbutveckling. Trots att den är byggd med en liten kärna och betraktas som ett mycket lätt Web Server Gateway Interface (WSGI), sticker Flask ut för sin lättutökade filosofi. Den har utformats för att skala upp till komplexa applikationer och för att stödja en enkel och snabb start.
Dessutom är en annan stor fördel med Flask dess funktionalitet. Även om det ger förslag kräver Flask inte obligatoriskt projektlayouter eller andra beroenden. Istället tillåter det utvecklare att välja de bibliotek och verktyg de vill använda och har dessutom olika förlängningar tillgängliga, som tillhandahålls av samhället.
API är en förkortning av Application Programming Interface, vilket betyder att det i princip är hur du kommunicerar med en ansökan. Ett REST (Representational State Transfer) API tillåter kommunikation mellan system med standard HTTP-metoder och motsvarar en arkitektonisk stil som syftar till statslös kommunikation och skiljer klient- och serverproblem. Det utbyter vanligtvis data i JSON-format och fungerar med slutpunkter som motsvarar åtgärder som Skapa (POST), Läs (GET), Uppdatera (PUT eller PATCH) och Radera (DELETE). REST API: er används ofta för sin enkelhet, skalbarhet och kompatibilitet med ett brett utbud av klienter och plattformar.
Den REST API på denna övning kommer att skapa en falsk implementering av CRUD-åtgärder över en enhet. Ett API med CRUD tillåter Skapa, Läs, Uppdatera och Ta bort operationer över programmets element.
Den här artikeln guidar dig genom de första stegen för att skapa ett REST API med Flask (🌶️).
Nedan kan du se slutpunkterna du kommer att ha i slutet av handledningen. Dokumentationen som presenteras genereras också av applikationen du kommer att skapa!
Du måste ha Python installerat på den aktuella datorn. Koden som presenteras kommer att överväga Python3. Om du vill använda Python2 och/eller följer denna procedur i en Windows-dator, följ instruktionerna som presenteras i Installationsguide för kolv.
Låt oss börja med skapa en katalog för att lagra projektet. I katalogen du vill ha ditt projekt kör du följande kommandon på skalet:
Vi har skapat flask_demo katalog och flyttade in den. Innan vi börjar installera beroenden, låt oss skapa en virtuell miljö genom att köra följande kommando:
Detta skapar en mapp i ditt projekt med namnet .venv. Efter det måste vi aktivera respektive miljö genom att köra:
Detta innebär att vi nu överväger venv virtuell miljö när du kör någon Python-kod. Det kan vara viktigt att ange vilken miljö du överväger när du kör den i din IDE.
Se till att du har miljön aktiv innan du följer nästa steg. Du kan kontrollera om du befinner dig i miljön genom att titta på vänster sida av konsolen. Om det finns namnet på den virtuella miljön inom parenteser är du redo att gå.
Om du vill inaktivera miljön, kör bara följande kommando:
Innan du börjar utveckla ett Flask API, se till att du har Python installerat. Det rekommenderas att använda en virtuell miljö för att hantera beroenden och hålla projektet isolerat.
Installera Flask-paketet med pip (Python-paketinstallerare):
pip install Flask==2.3.3
I skrivande stund är Flask-stabila versionen 2.3.3. Om du vill ha projektspecifikationerna uppdaterade och anpassade till den här versionen kan du använda en requirements.txt fil istället för att installera Flask manuellt. Du kan kopiera filen nedan till rotkatalogen:
Flask==2.3.3
Därefter behöver du bara köra följande kommando:
pip install -r requirements.txt
Nu är vi redo att börja utveckla vårt REST API.
Den första slutpunkten kod:
### First Steps: Your Hello World Flask API
Here’s how to build your first minimal Flask REST API:
```python
from flask import Flask
app = Flask(__name__)
@app.route('/')
def hello():
return {'message': 'Hello, World!'}
if __name__ == '__main__':
app.run(debug=True)
Det här exemplet ställer in en grundläggande slutpunkt som returnerar ett JSON-svar. Den app kör () funktionen startar en utvecklingsserver som lyssnar på port 5000 som standard.
Vad?! Är det så enkelt? Ja, det är det! Koden görs för att ha en applikation med en implementerad slutpunkt. Nu måste vi helt enkelt definiera Kolvmiljövariabler och se din ansökan?. Observera att du måste vara i mappen med main.py fil för att köra dessa kommandon.
Gå till länken http://localhost:5000/basic_api/hello_world för att se det klassiska budskapet vi alla älskar.
Nu när vi har skapat vår första slutpunkt, låt oss komma tillbaka till det här applikationsblogginläggets huvudsyfte: Ha REST API med den grundläggande CRUD-strukturen. Låt oss bygga ett API som stöder CRUD-operationer på en lista med objekt. Detta är ett vanligt användningsfall inom webbutveckling och backend-tjänster.
from flask import Flask, jsonify, request
app = Flask(__name__)
items = []
@app.route('/items', methods=['GET'])
def get_items():
return jsonify(items)
@app.route('/items', methods=['POST'])
def add_item():
data = request.get_json()
items.append(data)
return jsonify(data), 201
@app.route('/items/<int:index>', methods=['PUT'])
def update_item(index):
data = request.get_json()
items[index] = data
return jsonify(data)
@app.route('/items/<int:index>', methods=['DELETE'])
def delete_item(index):
item = items.pop(index)
return jsonify(item)
Detta enkla REST API i Flask tillåter klienter att hantera en lista med objekt med vanliga HTTP-metoder.
Nu, för var och en av de skapade rutterna är olika metoder tillåtna. Följande slutpunkter är tillgängliga:
Med denna struktur är du redo att skapa ett API med all komplexitet du behöver. Detta är inte den mest skalbara strukturen eftersom du överväger flera valideringar för varje rutt, och strukturen är inte styv. I nästa avsnitt kommer vi att täcka mer skalbar lösning som gör det enkelt att skapa dokumentation när du utvecklar dina slutpunkter.
Ett annat verktyg som är mycket användbart och vanligt att använda i utvecklingen av API: er är Brevbärare. Om du aldrig har använt det rekommenderar vi att du provar det och utforskar det! Det är mycket kraftfullt och kommer öka din utveckling till månen och bortom. 🚀
Innan vi presenterar andra Flask-styrkor, låt oss prata om ritningar. En ritning är ett objekt som mycket liknar ett Flask-applikationsobjekt, men istället för att skapa ett nytt tillåter det förlängningen av det aktuella programmet. Detta kan vara användbart om du vill skapa flera versioner av ett API eller helt enkelt dela upp tjänster inom samma applikation.
Vi kommer att använda denna klasstyp för att presentera olika användningsfallscenarier för en Flask-applikation. Låt oss konvertera koden ovan för att infogas i en ritning och laddas i huvudapplikationen.
Skapa en ny mapp med namnet ritningar för att börja infoga blueprint-moduler när vi går vidare i blogginlägget. Inuti den skapar du en mapp som heter grundläggande slutpunkter och sedan en fil som heter __init__.py:
# blueprints/basic_endpoints/__init__.py
from flask import Blueprint, jsonify
basic_bp = Blueprint('basic_bp', __name__)
@basic_bp.route('/')
def hello():
return jsonify({'message': 'Hello from a Blueprint!'})
Nu main.py filen behöver bara ladda den skapade ritningen och registrera den till applikationsobjektet:
# main.py
from flask import Flask
from blueprints.basic_endpoints import basic_bp
app = Flask(__name__)
app.register_blueprint(basic_bp)
if __name__ == '__main__':
app.run(debug=True)
Nu ska du ha exakt samma slutpunkter men använda strukturen som tillhandahålls av Blueprints. Detta kommer att göra din applikation enklare att hantera och skala när den växer.
Som redan nämnts, Flask är ett mycket minimalt ramverk; i alla fall, det förlitar sig på ett praktiskt verktyg: Jinja-mallmotorn. Detta möjliggör rendering dynamiska HTML-mallar. Även om detta ligger utanför detta blogginläggs räckvidd, kommer vi bara att ge ett litet exempel för att demonstrera konceptet.
Det första du behöver göra är att skapa mallar mapp och inuti den här mappen, sätt in example.html fil.
Observera att det finns två variabler används i mallen inuti {{}}. Detta är ett speciellt format för att inkludera Python-kod i mallen, vilket gör att dynamiskt innehåll kan återges. I det här fallet har vi toppen och botten av variabeln, som kommer att konverteras till text inuti <p> tagg. Nu när mallen är skapad låt oss ladda den med Flask. Låt oss skapa en ny ritning i en annan fil för att visa detta exempel:
<!-- templates/example.html -->
<!DOCTYPE >
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Jinja Template Example</title>
</head>
<body>
<p>{{ top }}</p>
<p>{{ bottom }}</p>
</body>
</html>
Observera att det finns två variabler som används i mallen inuti {{}}. Detta är ett speciellt format för att inkludera Python-kod i mallen, vilket gör att dynamiskt innehåll kan återges. I det här fallet har vi toppen och botten av variabeln, som kommer att konverteras till text inuti <p> tagg. Nu när mallen är skapad låt oss ladda den med Flask. Låt oss skapa en ny ritning i en annan fil för att visa detta exempel:
# blueprints/jinja_demo/__init__.py
from flask import Blueprint, render_template, request
jinja_bp = Blueprint('jinja_bp', __name__)
@jinja_bp.route('/jinja_template')
def jinja_example():
top = request.args.get('top', 'Default Top Text')
bottom = request.args.get('bottom', 'Default Bottom Text')
return render_template('example.html', top=top, bottom=bottom)
Glöm inte att registrera detta ritning i filen main.py:
# main.py
from flask import Flask
from blueprints.jinja_demo import jinja_bp
app = Flask(__name__)
app.register_blueprint(jinja_bp)
if __name__ == '__main__':
app.run(debug=True)
Här kan vi se definitionen av de övre och nedre variablerna baserat på frågeparametrar skickas i webbadressen. Till exempel, om du går till http://localhost:5000/jinja_template? top=topp_text&bottom=botten_text du kommer att få följande resultat:
För fnissarna, låt oss lägga till några CSS till sidan vi just skapat. Skapa statisk mapp med filen example.css inuti.
/* static/example.css */
body {
font-family: Arial, sans-serif;
text-align: center;
background-color: #f9f9f9;
margin-top: 50px;
}
p {
font-size: 24px;
font-weight: bold;
color: #333;
}
Därefter lägger du till motsvarande referens till CSS fil som vi just skapade genom att lägga till detta head-taggen till HTML-filen:
<!-- templates/example.html -->
<!DOCTYPE >
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Jinja Template Example</title>
<link rel="stylesheet" type="text/css" href="{{ url_for('static', filename='example.css') }}">
</head>
<body>
<p>{{ top }}</p>
<p>{{ bottom }}</p>
</body>
</html>
Gå till http://localhost:5000/jinja_template? upp=Avbryt%20the%20rest%20api%20skapande&bottom=I%20Have%20to%20Watch%20This%20Bird och du borde se något så här:
Där! Du har din jinja kraschkurs och en slutpunkt för meme-generator! Rör inte affärskatten! Du kan bli förvånad över vad du hittar...
.webp)
Nu när vi har övervägt några grundläggande funktioner för att ha grundläggande slutpunkter skapade med Flask, låt oss skapa en bättre projektstruktur för våra slutpunkter.
Alla vet att killen har rätt, men det kan vara en tråkig process. Frukta inte! Med användning av Flask-förlängningen Flask-restplus Vi kan få dokumentation genererad automatiskt och med en bättre struktur om du följer deras rekommendationer om skalbara projekt.
För att få det installerat, precis som kolv, kör följande kommando:
pip install flask-restplus
Om du vill ha samma flask-restplus-version som skrivpunkten, lägg bara till
flask-restplus==0.13.0
till filen requirements.txt och installera kraven igen. Det finns några problem relaterade till beroenden, därför måste du också installera versionen 0.16.1 från Verktygsredskap paketera genom att köra:
pip install Werkzeug==0.16.1
Låt oss nu ta en titt på projektstruktur vi har hittills och den vi föreslår för denna plan skapar vi:
För dokumenterade effektmått, låt oss skapa en mapp för att identifiera den enhet vi arbetar med. Detta kommer att underlätta navigeringen genom projektet när det blir större och allt mer komplext. Var och en av mapparna inuti dokumenterade_endpoints fungerar som moduler med funktionaliteter/slutpunkter relaterade till den enheten (i detta fall användare och katter).
Vi presenterar alla slutpunkter som redan skapats med en ny struktur. Slutpunkterna har ingen logik men låter dig förstå stegen som är involverade i deras skapande.
Med det sagt, låt oss gå vidare till koden. För det första bör vi överväga hello_värld slutpunkt med den nya strukturen:
# blueprints/documented_endpoints/hello_world.py
from flask_restplus import Namespace, Resource, fields
hello_ns = Namespace('hello_world', description='Hello World operations')
hello_model = hello_ns.model('HelloWorld', {
'message': fields.String(required=True, description='A hello world message')
})
@hello_ns.route('/')
class HelloWorld(Resource):
@hello_ns.response(200, 'Success', hello_model)
@hello_ns.response(500, 'Internal Server Error')
def get(self):
'''Returns a Hello World message'''
return {'message': 'Hello, World!'}, 200
Låt oss nu bryta ner det. En av de första sakerna du kanske märker är användningen av Namnutrymme och resursklasser. Namnutrymmet är direkt kopplat till en specifik entitet, vilket innebär att alla hello_värld slutpunkter kommer att länkas till motsvarande namnutrymme. Detta kommer att generera hello_värld avsnitt i swagger-dokumentationen.
För att skapa rutter i det här namnutrymmet deklareras olika klasser som ärver från klassen Resource tillsammans med respektive namnrymdsruttdekoratör. Inom den skapade HelloWorld-klassen förklarar vi de metoder den överväger. I vårt fall, endast FÅ presenteras, vilket resulterar i en GET-metod tillgänglig för dokumenterade_endpoints/hello_world slutpunkt.
Den hello_värld Relaterade modeller presenteras och kommer att kopplas till respektive slutpunkt. Detta genererar dokumentationen för slutpunktsvaret och sammanställer respektive svar.
Kommentarerna associerade med de skapade resurserna och respektive metoder kommer att generera beskrivningar på den slutliga dokumentationen. De möjliga fel som slutpunkten kan returnera bör också anges som presenteras i exemplet och kommer också att resultera i ytterligare dokumentation för slutpunkter. Det finns fler funktioner som stöds av flask-restplus-tillägget, till exempel parsers och felhantering. Vänligen hänvisa till deras dokumentation om du vill dra full nytta av dess kapacitet.
Låt oss nu presentera koden för länka detta namnutrymme vi har skapat till en ritning (blueprints/documented_endpoints/__init__.py) och sedan länka ritningen till applikationen (main.py):
# blueprints/documented_endpoints/__init__.py
from flask import Blueprint
from flask_restplus import Api
from .hello_world import hello_ns
blueprint = Blueprint('documented_api', __name__, url_prefix='/documented_api')
api = Api(blueprint, doc='/doc', title='Documented API', description='Auto-generated Swagger Docs with Flask-RESTPlus')
api.add_namespace(hello_ns)
Här, en API-objekt från fask-restplus-modulen är skapad och kopplad till dokumenterad_api ritning. Kopplingen mellan ritningen och hello_värld namnutrymmet vi har skapat görs med detta objekt med add_namnutrymme metod. Slutligen, precis som alla tidigare ritningar, måste vi bara registrera den skapade ritningen till appobjektet. Följ länken http://localhost:5000/documented_api/doc och du får den här sidan:
Låt oss nu presentera koden för dokumentationen av enheterna REST API och jinja mallsida så vem som helst kan enkelt kontrollera alla slutpunkter vi har arbetat med. Detta görs genom att lägga till följande filer:
Även om dessa filer kan se skrämmande ut, logiken är densamma som den som presenteras för hello world-slutpunkten. Den största skillnaden är Användning av modeller för att generera dokumentation och validera förfrågningsorgan som skickats i POST- och PUT-metoder. Analyserare används också för dokumentationen för frågeparametrarna och kan också användas för validering. Detta är användbart för scenarier där data inte skickas via brödtext, till exempel frågeparametrar eller formData.
Sist men inte minst, glöm inte att lägga till följande rader för att skapa namnrymder länkade till Blueprint Vi skapar.
Nedan kan du kontrollera dokumentationens utseende för frågeparametrar och en begäran:
Nu har vi dokumentation av alla effektpunkter och respektive effektpunkter (Naturligtvis!!).
Trots sin enkelhet är Flask ett extremt kraftfullt Python-webbramverk. Det är mycket enklare och enklare än att skapa kompletta applikationer på serversidan. Plus, det kan spara dig så mycket tid!
Förhoppningsvis, i slutet av den här artikeln, har du inga problem med att skapa ett REST API med Flask och automatiskt generera en swagger-dokumentationssida. Dessutom bör du vara bekant med specifika funktioner (som Blueprint-objekt) och ställa in Jinja-mallar.
Ett Flask API hänvisar till en RESTful-webbtjänst byggd med Flask-ramverket i Python. Det exponerar slutpunkter som klienter kan interagera med över HTTP, vilket vanligtvis returnerar data i JSON-format.
Ja, Flask kan användas som ett backend-ramverk för att bygga API: er som serverar data till frontend-applikationer eller tjänster från tredje part.
Flask är ett webbramverk, medan REST är en arkitektonisk stil för att designa nätverksapplikationer. Du kan använda Flask för att implementera REST API: er.
Ja, Flask är ett utmärkt val för att bygga API: er på grund av dess enkelhet, flexibilitet och ett brett utbud av tillägg som stöder dokumentation, autentisering och distribution.
Flask används ofta för att bygga REST API: er, mikrotjänster, administratörspaneler, prototypapplikationer och integration med maskininlärningsmodeller.
.webp)
Associerad utvecklare som arbetar mest med Backend-teknik. En entreprenör med datavetenskapligt intresse. Kärlek till sport, ljudböcker, kaffe och memes!
VD @ Imaginary Cloud och medförfattare till boken Product Design Process. Jag gillar mat, vin och Krav Maga (inte nödvändigtvis i denna ordning).
Människor som läste det här inlägget tyckte också att dessa var intressanta:
.webp)
.webp)
.webp)
.webp)
.webp)
.webp)
.webp)
.webp)
.webp)
