Flask er en let Python-webramme ideel til opbygning af RESTful API'er og mikrotjenester. I modsætning til tungere rammer som Django er Flask minimal og meningsløs, hvilket giver udviklere fuld kontrol over applikationsstrukturen. Denne fleksibilitet gør det til et fremragende valg til udvikling af brugerdefinerede, skalerbare web-API'er skræddersyet til specifikke projektkrav.
Så, Flaske Python er et mikroframework, der giver dig mulighed for at køre en webapplikation med meget få trin og næsten ingen opsætning. Denne rammes enkelhed og stærke kontrol over, hvad du vil have i din applikation, har gjort den til en af de mest anvendte webudviklingsrammer.
Python er et meget populært og kraftfuldt sprog med et stort samfund, der har eksisteret i lang tid. Mange store virksomheder, såsom Google, bruger det til deres projekter, og antallet af mennesker, der bruger det til webudvikling er stadig stigende.
Vi viser dig, at det er enkelt, fleksibelt og modulært, hvilket fører til en fornøjelig udviklingsoplevelse.
Vi forventer, at brugeren har en vis grundlæggende viden om Python at forstå alle de præsenterede trin. Ikke desto mindre skal enhver person være i stand til at få applikationen i gang efter at have fulgt denne vejledning.
En ramme er et bibliotek, der bruges af udviklere til at opbygge og vedligeholde pålidelige og skalerbare webapplikationer. Der er flere rammer tilgængelig for Python, såsom Tornado, Pyramind og selvfølgelig Django (som ofte sammenlignes med Flask).
Flask (🌶️) er et Python-mikroframework til webudvikling. På trods af at den er bygget med en lille kerne og betragtes som en meget let Web Server Gateway Interface (WSGI), skiller Flask sig ud for sin letudvidede filosofi. Den er designet til at skalere op til komplekse applikationer og til at understøtte en nem og hurtig start.
Desuden er en anden stor fordel ved Flask dens funktion. Selvom det giver forslag, kræver Flask ikke obligatorisk projektlayout eller andre afhængigheder. I stedet giver det udviklere mulighed for at vælge de biblioteker og værktøjer, de ønsker at bruge, og har desuden forskellige udvidelser tilgængelige, som leveres af samfundet.
API er et akronym for Application Programming Interface, hvilket betyder, at det dybest set er hvordan du kommunikerer med en applikation. En REST (Representational State Transfer) API tillader kommunikation mellem systemer ved hjælp af standard HTTP-metoder og svarer til en arkitektonisk stil der sigter mod statsløs kommunikation og adskiller klient- og serverproblemer. Det udveksler typisk data i JSON-format og fungerer ved hjælp af slutpunkter, der svarer til handlinger som Create (POST), Read (GET), Update (PUT eller PATCH) og Delete (DELETE). REST API'er bruges i vid udstrækning på grund af deres enkelhed, skalerbarhed og kompatibilitet med en bred vifte af klienter og platforme.
Den REST API på denne øvelse vil skabe en falsk implementering af CRUD-handlinger over en enhed. En API med CRUD tillader handlinger Opret, Læs, Opdater og Slet over applikationens elementer.
Denne artikel vil guide dig gennem de første trin til at oprette en REST API ved hjælp af Flask (🌶️).
Nedenfor kan du se de slutpunkter, du vil have i slutningen af vejledningen. Den præsenterede dokumentation genereres også af den applikation, du opretter!
Du skal have Python installeret på den aktuelle maskine. Den præsenterede kode vil overveje Python3. Hvis du vil bruge Python2 og/eller følger denne procedure i en Windows-maskine, skal du følge instruktionerne i Installationsvejledning til kolbe.
Lad os starte med oprettelse af en mappe at gemme projektet. I den mappe, du vil have dit projekt, skal du køre følgende kommandoer på skallen:
Vi har skabt flask_demo mappe og flyttede den ind. Før vi begynder at installere afhængigheder, lad os oprette en virtuelt miljø ved at køre følgende kommando:
Dette opretter en mappe i dit projekt med navnet .venv. Derefter skal vi aktivere det respektive miljø ved at køre:
Det betyder, at vi nu overvejer venv virtuelt miljø når du kører en Python-kode. Det kan være vigtigt at angive det miljø, du overvejer, når du kører det i din IDE.
Sørg for, at du har miljøet aktiv før du følger de næste trin. Du kan kontrollere, om du er inde i miljøet ved at se til venstre side af konsollen. Hvis der er navnet på det virtuelle miljø inden for parenteser, er du klar til at gå.
Hvis du vil Deaktiver miljøet, bare kør følgende kommando:
Før du begynder at udvikle en Flask API, skal du sikre dig, at du har Python installeret. Det anbefales at bruge et virtuelt miljø til at administrere afhængigheder og holde dit projekt isoleret.
Installer Flask-pakken ved hjælp af pip (Python-pakkeinstallationsprogram):
pip install Flask==2.3.3
I skrivende stund er den stabile version af Flask 2.3.3. Hvis du vil have projektspecifikationerne opdateret og tilpasset denne version, kan du bruge en requirements.txt fil i stedet for at installere Flask manuelt. Du kan kopiere filen nedenfor til rodmappen:
Flask==2.3.3
Derefter skal du bare køre følgende kommando:
pip install -r requirements.txt
Nu er vi klar til at begynde at udvikle vores REST API.
Den første endepunkt kode:
### 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)
Dette eksempel opretter et grundlæggende slutpunkt, der returnerer et JSON-svar. Den app.run () funktionen starter en udviklingsserver, der lytter på port 5000 som standard.
Hvad?! Er det så simpelt? Ja, det er det! Koden er lavet for at have en applikation med et implementeret slutpunkt. Nu er vi simpelthen nødt til at definere Flaskemiljøvariabler og se din ansøgning?. Bemærk, at du skal være i mappen med main.py fil til at køre disse kommandoer.
Få adgang til linket http://localhost:5000/basic_api/hello_world for at se det klassiske budskab, vi alle elsker.
Nu hvor vi har oprettet vores første slutpunkt, lad os vende tilbage til dette applikationsblogindlægs hovedformål: Har REST API med den grundlæggende CRUD-struktur. Lad os bygge en API, der understøtter CRUD-operationer på en liste over elementer. Dette er et almindeligt anvendelsestilfælde inden for webudvikling og backend-tjenester.
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)
Denne enkle REST API i Flask giver klienter mulighed for at administrere en liste over elementer ved hjælp af standard HTTP-metoder.
Nu er forskellige metoder tilladt for hver af de oprettede ruter. Følgende endepunkter er tilgængelige:
Med denne struktur er du klar til Opret en API med al den kompleksitet, du har brug for. Dette er ikke den mest skalerbare struktur, da du overvejer flere valideringer for hver rute, og strukturen er ikke stiv. I de næste afsnit dækker vi mere skalerbar løsning der muliggør nem oprettelse af dokumentation, når du udvikler dine slutpunkter.
Et andet værktøj, der er meget nyttigt og almindeligt at bruge i udviklingen af API'er, er Postbud. Hvis du aldrig har brugt det, anbefaler vi, at du prøver det og udforsker det! Det er meget magtfuldt og vil Forøg din udvikling til månen og videre. 🚀
Før vi præsenterer andre Flask-styrker, lad os tale om tegninger. En blueprint er et objekt, der meget ligner et Flask-applikationsobjekt, men i stedet for at oprette et nyt, tillader det udvidelsen af det aktuelle program. Dette kan være nyttigt, hvis du vil oprette flere versioner af en API eller blot opdele tjenester inden for den samme applikation.
Vi bruger denne klassetype til at præsentere forskellige brugsscenarier for en Flask-applikation. Lad os konvertere koden ovenfor, der skal indsættes i en plan og indlæses i hovedapplikationen.
Opret en ny mappe med navnet blueprints for at begynde at indsætte blueprint-moduler, når vi skrider frem i blogindlægget. Inde i det skal du oprette en mappe med navnet grundlæggende slutpunkter og derefter en fil med navnet __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 skal bare indlæse den oprettede blueprint og registrere den til 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 skal du have nøjagtigt de samme slutpunkter, men bruge strukturen leveret af Blueprints. Dette vil gøre din applikation lettere at administrere og skalere, efterhånden som den vokser.
Som allerede nævnt, Flask er en meget minimal ramme; Det er dog afhængig af et praktisk værktøj: Jinja-skabelonmotoren. Dette giver mulighed for rendering dynamiske HTML-skabeloner. Selvom dette er uden for dette blogindlægs omfang, vil vi bare give et lille eksempel for at demonstrere konceptet.
Den første ting du skal gøre er at oprette skabeloner mappe og inde i denne mappe skal du indsætte example.html fil.
Bemærk, at der er to variabler i brug i skabelonen inde i {{}}. Dette er et specielt format til at inkludere Python-kode inde i skabelonen, hvilket gør det muligt at gengive dynamisk indhold. I dette tilfælde har vi toppen og bunden af variablen, som konverteres til tekst inde i <p> tag. Nu hvor skabelonen er oprettet, lad os indlæse den ved hjælp af Flask. Lad os oprette en ny plan i en anden fil for at demonstrere dette eksempel:
<!-- 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>
Bemærk, at der er to variabler i brug i skabelonen indeni {{}}. Dette er et specielt format til at inkludere Python-kode inde i skabelonen, hvilket gør det muligt at gengive dynamisk indhold. I dette tilfælde har vi toppen og bunden af variablen, som konverteres til tekst inde i <p> tag. Nu hvor skabelonen er oprettet, lad os indlæse den ved hjælp af Flask. Lad os oprette en ny plan i en anden fil for at demonstrere dette eksempel:
# 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)
Glem ikke at registrere dette blueprint 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)
Her kan vi se definitionen af de øverste og nederste variabler baseret på forespørgselsparametre sendt i URL'en. For eksempel, hvis du går til http://localhost:5000/jinja_template? top=top_tekst&bottom=bund_tekst du får følgende resultat:
Til fnisen, lad os tilføje nogle CSS til den side, vi lige har oprettet. Opret statisk mappe med filen example.css indeni.
/* 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;
}
Derefter tilføjes den tilsvarende reference til CSS fil, vi lige har oprettet ved at tilføje dette head-tag til 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å til http://localhost:5000/jinja_template? top=Annuller%20The%20Rest%20API%20Creation&bottom=I%20Have%20To%20Watch%20This%20Bird og du skulle se noget som dette:
Der! Du har din jinja lynkursus og et meme-generator-slutpunkt! Rør ikke Business Cat! Du kan blive overrasket over, hvad du finder...
.webp)
Nu hvor vi har overvejet nogle grundlæggende funktionaliteter for at have grundlæggende slutpunkter oprettet med Flask, lad os skabe en bedre projektstruktur for vores slutpunkter.
Alle ved, at fyren har ret, men det kan være en kedelig proces. Frygt ikke! Ved brug af flaskeforlængelsen Flask-Restplus Vi kan få dokumentation genereret automatisk og med en bedre struktur hvis du følger deres anbefalinger om skalerbare projekter.
For at få det installeret, ligesom kolbe, skal du køre følgende kommando:
pip install flask-restplus
Hvis du vil have den samme flask-restplus-version som skrivepunktet, skal du bare tilføje
flask-restplus==0.13.0
til filen requirements.txt og installer kravene igen. Der er nogle problemer relateret til afhængigheder, derfor skal du også installere version 0.16.1 fra Værktøj pakke ved at køre:
pip install Werkzeug==0.16.1
Lad os nu tage et kig på projektstruktur vi har indtil videre, og den, vi foreslår til denne plan, vi opretter:
Til dokumenterede endepunkter, lad os oprette en mappe til at identificere den enhed, vi arbejder på. Dette vil lette navigationen gennem projektet, efterhånden som det bliver større og mere komplekst. Hver af mapperne inde i dokumenterede_slutpunkter fungerer som moduler med funktionaliteter/slutpunkter relateret til den enhed (i dette tilfælde brugere og katte).
Vi præsenterer alle de slutpunkter, der allerede er oprettet med en ny struktur. Slutpunkterne har ingen logik, men giver dig mulighed for at forstå de trin, der er involveret i deres oprettelse.
Når det er sagt, lad os gå videre til koden. For det første bør vi overvej hello_verden endepunkt med den nye struktur:
# 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
Lad os nu nedbryde det. En af de første ting, du måske bemærker, er brugen af Navneområde og ressourceklasser. Navneområdet er direkte knyttet til en bestemt enhed, hvilket betyder, at alle hello_verden slutpunkter vil blive knyttet til det tilsvarende navnerum. Dette vil generere hello_verden afsnit i swagger-dokumentationen.
For at oprette ruter i dette navneområde deklareres forskellige klasser, der arver fra klassen Resource, sammen med den respektive navnerumsrutedekorator. Inden for den oprettede HelloWorld-klasse erklærer vi de metoder, den overvejer. I vores tilfælde er det kun FÅ præsenteres, hvilket resulterer i en GET-metode tilgængelig for dokumenterede_slutpunkter/hello_world endepunkt.
Den hello_verden relaterede modeller præsenteres og vil blive knyttet til det respektive endepunkt. Dette genererer dokumentationen for slutpunktsresponsen og sammenstiller det respektive svar.
Kommentarerne knyttet til de oprettede ressourcer og respektive metoder genereres beskrivelser på den endelige dokumentation. De mulige fejl, som slutpunktet kan returnere, skal også specificeres som vist i eksemplet og vil også resultere i yderligere dokumentation for slutpunkter. Der er flere funktionaliteter understøttet af flask-restplus-udvidelsen, såsom parsere og fejlhåndtering. Henvis venligst til deres dokumentation hvis du vil drage fuld fordel af dens muligheder.
Lad os nu præsentere koden til link dette navneområde, vi har oprettet, til en plan (blueprints/documented_endpoints/__init__.py) og derefter linke planen til 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)
Her, en API-objekt fra fask-restplus-modul er oprettet og knyttet til dokumenteret_api plan. Forbindelsen mellem planen og hello_verden navneområde, vi har oprettet, udføres med dette objekt med add_navneområde metode. Endelig, ligesom alle de tidligere tegninger, skal vi bare registrer den oprettede blueprint til appobjektet. Følg linket http://localhost:5000/documented_api/doc og du får denne side:
Lad os nu præsentere koden til dokumentationen af enhederne REST API og jinja skabelonside så enhver person nemt kan kontrollere alle de slutpunkter, vi har arbejdet på. Dette gøres ved at tilføje følgende filer:
Selvom disse filer måske ser skræmmende ud, er logikken den samme som den, der præsenteres for hello world-slutpunktet. Den største forskel er Brug af modeller at generere dokumentation og validere anmodningsorgan sendt i POST- og PUT-metoder. Parsere bruges også til forespørgselsparams-dokumentationen og kan også bruges til validering. Dette er nyttigt i scenarier, hvor dataene ikke sendes via brødtekst, såsom forespørgselsparams eller formData.
Sidst men ikke mindst, glem ikke at tilføje følgende linjer for at få oprettet navneområder, der er knyttet til Blueprint Vi skaber.
Nedenfor kan du kontrollere dokumentationsudseendet for forespørgselsparametre og en anmodningstekst:
Nu har vi dokumentation af alle endepunkter og de respektive endepunkter (Selvfølgelig!!).
På trods af sin enkelhed er Flask en ekstremt kraftfuld Python-webramme. Det er meget nemmere og mere ligetil end at oprette komplette applikationer på serversiden. Plus, det kan spare dig så meget tid!
Forhåbentlig har du ved slutningen af denne artikel ingen problemer med at oprette en REST API ved hjælp af Flask og automatisk generere en swagger-dokumentationsside. Derudover skal du være bekendt med specifikke funktioner (såsom Blueprint-objekter) og opsætning af Jinja-skabeloner.
A Flask API refers to a RESTful web service built using the Flask framework in Python. It exposes endpoints that clients can interact with over HTTP, typically returning data in JSON format.
Yes, Flask can be used as a backend framework to build APIs that serve data to frontend applications or third-party services.
Flask is a web framework, while REST is an architectural style for designing networked applications. You can use Flask to implement REST APIs.
Yes, Flask is an excellent choice for building APIs due to its simplicity, flexibility, and a wide range of extensions that support documentation, authentication, and deployment.
Flask is commonly used for building REST APIs, microservices, admin dashboards, prototyping applications, and integrating with machine learning models.
.webp)
Associeret udvikler, der arbejder mest med Backend-teknologier. En iværksætter med datavidenskabsinteresse. Kærlighed til sport, lydbøger, kaffe og memes!
CEO @ Imaginary Cloud og medforfatter af bogen Product Design Process. Jeg nyder mad, vin og Krav Maga (ikke nødvendigvis i denne rækkefølge).
People who read this post, also found these interesting:
.webp)
.webp)
.webp)
.webp)
.webp)
.webp)
.webp)
.webp)
