FastAPI ist ein modernes, leistungsstarkes Web-Framework zum Erstellen von APIs mit Python. Es ist so konzipiert, dass es einfach zu benutzen und zu lernen ist und gleichzeitig leistungsstarke Funktionen wie automatische Validierung, Serialisierung und automatische interaktive API-Dokumentation bietet. Darüber hinaus funktioniert es mit jeder Template-Engine und ermöglicht Ihnen, jede Standard-Template-Konfiguration zu verwenden, die für Ihr Projekt erforderlich ist.

Lassen Sie uns in die Details von FastAPI eintauchen, seine Funktionen und wie man es effektiv nutzt. Später in diesem Artikel werden wir uns auch IronPDF ansehen, ein PDF-Generierungs-Python-Paket von Iron Software.

Hauptmerkmale von FastAPI

1. Hohe Leistungsfähigkeit: FastAPI ist eines der schnellsten verfügbaren Python-Frameworks und mit Node.js und Go vergleichbar. Dies ist der Verwendung von Starlette für die Webparts und Pydantic für die Datenparts zu verdanken.
2. Benutzerfreundlichkeit: Es ist so konzipiert, dass es intuitiv zu bedienen ist und den Zeitaufwand für das Lesen von Dokumentationen reduziert. Das Framework nutzt standardmäßige Python-Typ-Hinweise für die Datenvalidierung und Serialisierung.
3. Automatische interaktive Dokumentation: FastAPI generiert automatisch interaktive API-Dokumentation unter Verwendung von OpenAPI und JSON Schema, die über /docs (Swagger UI) und /redoc (ReDoc) zugänglich ist. Alle Aktualisierungen der API werden automatisch in der Dokumentation reflektiert.
4. Editorunterstützung: Hervorragende Unterstützung für Codevervollständigung und Typüberprüfung in Editoren wie VS Code, was die Entwicklung beschleunigt und Fehler reduziert.
5. Standardbasiert: Es basiert auf den offenen Standards für APIs OpenAPI und JSON Schema und ist vollständig kompatibel mit diesen.

Installation

Sie können FastAPI und Uvicorn (einen ASGI-Server) mit pip installieren:

pip install fastapi
pip install "uvicorn[standard]"

pip install fastapi
pip install "uvicorn[standard]"

Erstellen Ihrer ersten FastAPI-Anwendung

Hier ein einfaches Beispiel, um Ihnen den Einstieg mit FastAPI zu erleichtern und Python-Daten über eine Benutzeroberfläche bereitzustellen:

from fastapi import FastAPI

# Create a FastAPI 'app' instance
app = FastAPI()

# Root path operation
@app.get("/")
def read_root():
    return {"Hello": "World"}

# Path operation for items including query parameter 'q'
@app.get("/items/{item_id}")
def read_item(item_id: int, q: str = None):
    return {"item_id": item_id, "q": q}

from fastapi import FastAPI

# Create a FastAPI 'app' instance
app = FastAPI()

# Root path operation
@app.get("/")
def read_root():
    return {"Hello": "World"}

# Path operation for items including query parameter 'q'
@app.get("/items/{item_id}")
def read_item(item_id: int, q: str = None):
    return {"item_id": item_id, "q": q}

Um die Anwendung auszuführen, verwenden Sie Uvicorn:

uvicorn main:app --reload

uvicorn main:app --reload

Dieser Befehl startet einen Entwicklungsserver und lädt bei Codeänderungen automatisch neu. Sie können auf die interaktive API-Dokumentation unter http://127.0.0.1:8000/docs zugreifen.

Erweiterte Funktionen

FastAPI unterstützt eine Vielzahl fortschrittlicher Funktionen, die es für komplexe Anwendungen geeignet machen:

1. Dependency Injection: FastAPI bietet ein leistungsstarkes Dependency-Injection-System, mit dem Sie Abhängigkeiten sauber und effizient verwalten können.
2. Hintergrundaufgaben: Sie können Hintergrundaufgaben definieren, die nach Erhalt einer Antwort ausgeführt werden sollen. Dies ist nützlich für Aufgaben wie das Versenden von E-Mails oder die Datenverarbeitung.
3. WebSockets: FastAPI unterstützt WebSockets und ermöglicht so die Echtzeitkommunikation zwischen Client und Server.
4. Sicherheit: FastAPI beinhaltet Tools für den Umgang mit Sicherheitsaspekten, darunter OAuth2, JWT-Token und mehr.
5. Datenbankintegration: FastAPI lässt sich mithilfe von Bibliotheken wie SQLAlchemy oder Tortoise-ORM problemlos in Datenbanken integrieren.

Beispiel: Aufbau einer CRUD-API

Lassen Sie uns eine einfache CRUD-API (Create, Read, Update, Delete) zum Verwalten von Objekten erstellen.

1. Definieren Sie das Datenmodell:

from pydantic import BaseModel

# Define a Pydantic model for the item with default description and tax
class Item(BaseModel):
    name: str
    description: str = None
    price: float
    tax: float = None

from pydantic import BaseModel

# Define a Pydantic model for the item with default description and tax
class Item(BaseModel):
    name: str
    description: str = None
    price: float
    tax: float = None

2. Erstellen Sie die FastAPI-Anwendung:

from fastapi import FastAPI, HTTPException

# Initialize 'app' instance and an empty 'items' dictionary
app = FastAPI()
items = {}

# Create operation: Add a new item
@app.post("/items/")
def create_item(item: Item):
    item_id = len(items) + 1
    items[item_id] = item
    return item

# Read operation: Retrieve an item by 'item_id'
@app.get("/items/{item_id}")
def read_item(item_id: int):
    if item_id not in items:
        raise HTTPException(status_code=404, detail="Item not found")
    return items[item_id]

# Update operation: Replace an existing item
@app.put("/items/{item_id}")
def update_item(item_id: int, item: Item):
    if item_id not in items:
        raise HTTPException(status_code=404, detail="Item not found")
    items[item_id] = item
    return item

# Delete operation: Remove an item by 'item_id'
@app.delete("/items/{item_id}")
def delete_item(item_id: int):
    if item_id not in items:
        raise HTTPException(status_code=404, detail="Item not found")
    del items[item_id]
    return {"message": "Item deleted"}

from fastapi import FastAPI, HTTPException

# Initialize 'app' instance and an empty 'items' dictionary
app = FastAPI()
items = {}

# Create operation: Add a new item
@app.post("/items/")
def create_item(item: Item):
    item_id = len(items) + 1
    items[item_id] = item
    return item

# Read operation: Retrieve an item by 'item_id'
@app.get("/items/{item_id}")
def read_item(item_id: int):
    if item_id not in items:
        raise HTTPException(status_code=404, detail="Item not found")
    return items[item_id]

# Update operation: Replace an existing item
@app.put("/items/{item_id}")
def update_item(item_id: int, item: Item):
    if item_id not in items:
        raise HTTPException(status_code=404, detail="Item not found")
    items[item_id] = item
    return item

# Delete operation: Remove an item by 'item_id'
@app.delete("/items/{item_id}")
def delete_item(item_id: int):
    if item_id not in items:
        raise HTTPException(status_code=404, detail="Item not found")
    del items[item_id]
    return {"message": "Item deleted"}

Einführung in IronPDF

IronPDF ist eine leistungsstarke Python-Bibliothek, die für das Erstellen, Bearbeiten und Signieren von PDF-Dateien aus HTML, CSS, Bildern und JavaScript entwickelt wurde. Sie bietet kommerzielle Leistung bei geringem Speicherbedarf. Hauptmerkmale sind:

HTML zu PDF Konvertierung

Konvertieren Sie HTML-Dateien, HTML-Zeichenketten und URLs in PDFs. Beispielsweise eine Webseite mithilfe des Chrome-PDF-Renderers als PDF rendern.

Plattformübergreifende Unterstützung

Kompatibel mit verschiedenen .NET-Plattformen, einschließlich .NET Core, .NET Standard und .NET Framework. Es unterstützt Windows, Linux und macOS.

Bearbeitung und Signierung

Eigenschaften festlegen, Sicherheit mit Passwörtern und Berechtigungen hinzufügen und digitale Signaturen auf Ihre PDFs anwenden.

Seitentemplates und Einstellungen

Passen Sie PDFs mit Kopfzeilen, Fußzeilen, Seitenzahlen und anpassbaren Rändern an. Unterstützt responsive Layouts und benutzerdefinierte Papiergrößen.

Standardkonformität

Hält sich an PDF-Standards wie PDF/A und PDF/UA. Unterstützt UTF-8-Zeichenkodierung und verarbeitet Assets wie Bilder, CSS und Schriftarten.

Generieren von PDF-Dokumenten mithilfe von IronPDF und FastAPI

pip install fastapi ironpdf

from fastapi import FastAPI
from fastapi.responses import FileResponse
from ironpdf import *

# Apply your IronPDF license key
License.LicenseKey = "key"

# Initialize 'app' instance
app = FastAPI()

# Route for simple greeting
@app.get("/")
def read_root():
    return {"Hello": "IronPDF"}

# Route that reads items with path and query parameters
@app.get("/items/{item_id}")
def read_item(item_id: int, q: str = None):
    return {"item_id": item_id, "q": q}

# Route for generating a PDF document
@app.get("/pdf")
async def get_pdf(greet1: str = None, greet2: str = None):
    # Use ChromePdfRenderer to create PDF from HTML
    renderer = ChromePdfRenderer()
    content = "<h1>Document Generated using IronPDF with FastAPI GET</h1>"
    content += "<p> Demonstrate PDF generation using User Inputs</p>"
    content += f"<p>Greetings from: {greet1}</p>"
    content += f"<p>And Greetings from: {greet2}</p>"
    pdf = renderer.RenderHtmlAsPdf(content)
    
    # Save the PDF to a file
    pdf.SaveAs("fastapi.pdf")
    
    # Create a response with the generated PDF
    headers = {
        "Content-Disposition": "inline; filename=sample.pdf"
    }
    return FileResponse("fastapi.pdf", media_type="application/pdf", headers=headers)

from fastapi import FastAPI
from fastapi.responses import FileResponse
from ironpdf import *

# Apply your IronPDF license key
License.LicenseKey = "key"

# Initialize 'app' instance
app = FastAPI()

# Route for simple greeting
@app.get("/")
def read_root():
    return {"Hello": "IronPDF"}

# Route that reads items with path and query parameters
@app.get("/items/{item_id}")
def read_item(item_id: int, q: str = None):
    return {"item_id": item_id, "q": q}

# Route for generating a PDF document
@app.get("/pdf")
async def get_pdf(greet1: str = None, greet2: str = None):
    # Use ChromePdfRenderer to create PDF from HTML
    renderer = ChromePdfRenderer()
    content = "<h1>Document Generated using IronPDF with FastAPI GET</h1>"
    content += "<p> Demonstrate PDF generation using User Inputs</p>"
    content += f"<p>Greetings from: {greet1}</p>"
    content += f"<p>And Greetings from: {greet2}</p>"
    pdf = renderer.RenderHtmlAsPdf(content)
    
    # Save the PDF to a file
    pdf.SaveAs("fastapi.pdf")
    
    # Create a response with the generated PDF
    headers = {
        "Content-Disposition": "inline; filename=sample.pdf"
    }
    return FileResponse("fastapi.pdf", media_type="application/pdf", headers=headers)

Code-Erklärung

Dieses Codebeispiel zeigt die Integration von IronPDF mit FastAPI zur dynamischen Generierung von PDF-Dokumenten basierend auf Benutzereingaben und deren Bereitstellung als herunterladbare Antwort.

1. Lizenzschlüssel festlegen: Wendet den IronPDF-Lizenzschlüssel an, um die Funktionen zu aktivieren.

2. FastAPI-Initialisierung: Initialisiert eine FastAPI-Instanz (app), um HTTP-Anfragen zu bearbeiten.

3. Basis-Routen-Handler:

   • read_root(): Antwortet mit einer einfachen JSON-Nachricht, die "Hello IronPDF" anzeigt, wenn auf die Root-URL (/) zugegriffen wird.
   • read_item(): Akzeptiert einen item_id Pfadparameter und einen optionalen q Abfrageparameter. Gibt eine JSON-Antwort mit diesen Parametern zurück.

4. PDF-Erzeugungsroute (/pdf):

   • get_pdf(): Diese asynchrone Funktion verarbeitet GET-Anfragen an den /pdf Endpunkt mit optionalen Abfrageparametern namens greet1 und greet2.
   • Konstruiert einen HTML-String (content), der folgendes enthält:
     • Eine Überschrift, die den Ursprung und Zweck des Dokuments angibt.
     • Ein Absatz, der die PDF-Erzeugung mithilfe von Benutzereingaben demonstriert (greet1 und greet2).
   • Verwendet ChromePdfRenderer() von IronPDF, um den HTML-Inhalt in ein PDF zu rendern (pdf = renderer.RenderHtmlAsPdf(content)).
   • Speichert das generierte PDF als "fastapi.pdf" (pdf.SaveAs("fastapi.pdf")).

5. Servieren des PDFs:

   • Konfiguriert die Antwort-Header, um anzugeben, dass das PDF inline im Browser angezeigt werden soll ("Content-Disposition": "inline; filename=sample.pdf").
   • Erstellt ein FileResponse Objekt, das auf die generierte PDF-Datei mit dem entsprechenden Medientyp zeigt ("application/pdf").
   • Gibt das FileResponse Objekt zurück, das den Download des PDF-Dokuments auslöst, wenn der /pdf Endpunkt aufgerufen wird.

Dieses Codebeispiel veranschaulicht, wie IronPDF nahtlos mit FastAPI integriert werden kann, um dynamisch PDF-Dokumente basierend auf Benutzereingaben zu generieren und bereitzustellen. Es zeigt die Fähigkeit, HTML-Inhalte in PDFs zu konvertieren, und macht es für Anwendungen geeignet, die eine dynamische Dokumentgenerierung und Bereitstellung über HTTP erfordern.

Ausgabe

Unten sehen Sie die von den APIs generierte Swagger-Ausgabe

PDF

IronPDF-Lizenz

IronPDF läuft mit dem Lizenzschlüssel for Python. IronPDF for Python bietet einen kostenlosen Testlizenz Schlüssel, damit Benutzer die Funktionen vor dem Kauf ausprobieren können.

Platzieren Sie den Lizenzschlüssel am Anfang des Skripts, bevor Sie das IronPDF-Paket verwenden:

from ironpdf import *
# Apply your license key
License.LicenseKey = "key"

from ironpdf import *
# Apply your license key
License.LicenseKey = "key"

Abschluss

FastAPI ist ein leistungsstarkes und benutzerfreundliches Framework zum Erstellen von APIs in Python. FastAPI hat hohe Leistung, automatische Dokumentation und fortschrittliche Funktionen, die es zu einer hervorragenden Wahl für sowohl Anfänger als auch erfahrene Entwickler machen. Egal, ob Sie eine einfache API oder eine komplexe Webanwendung aufbauen, FastAPI bietet die Werkzeuge, die Sie benötigen, um erfolgreich zu sein.

IronPDF ist eine robuste Python-Bibliothek zum Erstellen, Bearbeiten und Rendern von PDF-Dokumenten aus HTML-Inhalten. Es bietet Funktionen wie HTML-zu-PDF-Konvertierung, Erstellung interaktiver Formulare, PDF-Manipulation (Zusammenführen, Aufteilen) und Textextraktion. Ideal zum einfachen Erzeugen dynamischer PDFs und zur Integration in verschiedene Python-Anwendungen.