CLI-Referenz
Vollständige Referenz aller Befehle der FastAPI-fastkit-Kommandozeilenschnittstelle.
Globale Optionen
Alle Befehle unterstützen diese globalen Optionen:
Globale Optionen
| Option | Beschreibung |
|---|---|
--version |
Die Version von FastAPI-fastkit anzeigen |
--help |
Die Hilfenachricht anzeigen |
Beispiele
$ fastkit --version
FastAPI-fastkit version 1.0.0
$ fastkit --help
Usage: fastkit [OPTIONS] COMMAND [ARGS]...
FastAPI-fastkit CLI
Options:
--version Show the version and exit.
--help Show this message and exit.
Commands:
addroute Add a new route to FastAPI project
init Create a new FastAPI project
list-templates List available FastAPI templates
runserver Start FastAPI development server
startdemo Create FastAPI project from template
Befehle
init
Ein neues FastAPI-Projekt mit interaktiver Einrichtung erstellen.
Syntax
Optionen
| Option | Beschreibung | Standard |
|---|---|---|
--interactive |
Geführte Einrichtung: zuerst Architektur-Preset, dann Funktionsauswahl | aus |
--config <path> |
Das Projekt ohne Eingabeaufforderungen aus einer gespeicherten Konfigurationsdatei erstellen | - |
--save-config <path> |
Zusammen mit --interactive die beantwortete Konfiguration unter diesem Pfad speichern |
- |
--project-name |
Projektname (wird abgefragt, falls weggelassen) | - |
--author |
Name des Autors (wird abgefragt, falls weggelassen) | - |
--author-email |
E-Mail des Autors (wird abgefragt, falls weggelassen) | - |
--description |
Projektbeschreibung (wird abgefragt, falls weggelassen) | - |
--package-manager |
Zu verwendender Paketmanager (pip, uv, pdm, poetry) | uv |
--dry-run |
Zeigt die Dateien und Pakete an, die erstellt würden, ohne etwas zu schreiben | aus |
--no-venv |
Erstellung der virtuellen Umgebung überspringen (impliziert --no-install) |
aus |
--no-install |
Installation der Abhängigkeiten überspringen | aus |
--yes / -y |
Beim Bereitstellen des Projekts im aktuellen Verzeichnis nicht nachfragen, bevor vorhandene Dateien überschrieben werden | aus |
--help |
Hilfe zum Befehl anzeigen | - |
Konfigurationsdateien (--config / --save-config)
Die Antworten einer interaktiven Sitzung sind ein einfaches Mapping, und dieses Mapping lässt sich über eine Datei weitergeben. So wird die Projekterstellung zu etwas, das Sie committen, prüfen und erneut abspielen können.
# eine interaktive Sitzung aufzeichnen
$ fastkit init --interactive --save-config fastkit.config.json
# später ganz ohne Eingabeaufforderungen erneut abspielen
$ fastkit init --config fastkit.config.json
Wenn Sie --save-config nicht übergeben, fragt ein interaktiver Lauf, der bis zum Ende kommt, ob die Auswahl gespeichert werden soll und wohin. Diese Abfrage erscheint nur, wenn ein Mensch am Terminal sitzt — Läufe über Pipes oder in CI bleiben still und aktivieren das Speichern stattdessen über das Flag.
Unterstützte Formate werden anhand der Dateiendung gewählt:
| Endung | Verfügbarkeit |
|---|---|
.json |
Immer (Standardbibliothek) |
.toml |
Immer (Standardbibliothek) |
.yaml / .yml |
Nur wenn PyYAML installiert ist — fastkit fügt es nicht als Laufzeitabhängigkeit hinzu |
Eine geladene Datei muss auf oberster Ebene ein Mapping mit mindestens project_name, author und author_email enthalten. Sie wird anschließend mit denselben Regeln validiert, die auch die interaktiven Abfragen verwenden (Form des Projektnamens, E-Mail-Format, all_dependencies muss eine Liste sein), und jedes Problem wird gemeldet, bevor irgendetwas geschrieben wird. Eine Datei, die nur Funktionsauswahlen auflistet — ohne all_dependencies —, wird über den interaktiven Builder erweitert, sodass eine handgeschriebene Konfiguration und eine Assistentensitzung zur selben Paketmenge führen.
Ein minimales Beispiel:
{
"project_name": "orders-api",
"author": "Developer Kim",
"author_email": "developer@example.com",
"description": "Domain-oriented orders service",
"architecture_preset": "domain-starter",
"package_manager": "uv"
}
Schema der Konfigurationsdatei
Jede Konfigurationsdatei — handgeschrieben oder von --save-config erzeugt — durchläuft denselben Normalisierer, bevor sie den Generator erreicht (normalize_project_config in backend/project_builder/config_schema.py). Ein unbekannter Schlüssel, eine unbekannte Auswahl für eine bekannte Achse oder ein Wert mit falschem Typ wird mit dem betroffenen Namen und der Liste der tatsächlich erlaubten Werte abgelehnt, statt stillschweigend ignoriert zu werden.
| Schlüssel | Form | Hinweise |
|---|---|---|
project_name, author, author_email |
String | Erforderlich |
description |
String | Erforderlich |
architecture_preset (Alias preset) |
"minimal" | "single-module" | "classic-layered" | "domain-starter" |
Sind beide Schreibweisen vorhanden, müssen sie übereinstimmen |
package_manager |
"pip" | "uv" | "pdm" | "poetry" |
|
database |
String oder {"type": <choice>} |
PostgreSQL, MySQL, MongoDB, Redis, SQLite, None |
authentication, async_tasks, testing, caching, monitoring, migrations, logging |
String oder {"type": <choice>} |
Achsen mit Einfachauswahl — die Auswahlmöglichkeiten jeder Achse finden Sie oben im Funktionskatalog |
utilities, tooling |
Liste von Strings | Achsen mit Mehrfachauswahl — Auswahlmöglichkeiten im selben Katalog |
deployment |
Liste von Strings | Teilmenge von Docker, docker-compose; die Wahl von docker-compose zieht Docker automatisch nach |
custom_packages |
Liste von Strings | Zusätzliche Pakete, die unverändert installiert werden |
Jede Achse akzeptiert entweder die reine Auswahl ("authentication": "JWT") oder die Mapping-Form {"type": ...}, die database und die projekteigenen [tool.fastapi-fastkit]-Metadaten verwenden ("authentication": {"type": "JWT"}) — beide werden in dieselbe kanonische Form normalisiert, und --save-config schreibt immer die kanonische Form als reinen String zurück.
Eine Konfiguration, die die meisten Achsen nutzt:
{
"project_name": "orders-api",
"author": "Developer Kim",
"author_email": "developer@example.com",
"description": "Domain-oriented orders service",
"architecture_preset": "domain-starter",
"package_manager": "uv",
"database": "PostgreSQL",
"authentication": "JWT",
"async_tasks": "Celery",
"caching": "Redis",
"migrations": "Alembic",
"tooling": ["ruff", "makefile"],
"deployment": ["Docker"]
}
Dieselbe Konfiguration als TOML:
project_name = "orders-api"
author = "Developer Kim"
author_email = "developer@example.com"
description = "Domain-oriented orders service"
architecture_preset = "domain-starter"
package_manager = "uv"
database = "PostgreSQL"
authentication = "JWT"
async_tasks = "Celery"
caching = "Redis"
migrations = "Alembic"
tooling = ["ruff", "makefile"]
deployment = ["Docker"]
Vorschau und Überspringen von Schritten
--dry-run gibt den Baum aus, der erstellt würde, sowie die Pakete, die installiert würden — zusammen mit dem Paketmanager, der sie installieren würde —, und beendet sich dann, ohne die Festplatte zu berühren:
--no-install stoppt, nachdem die virtuelle Umgebung erstellt wurde; --no-venv überspringt auch die Umgebung (und damit die Installation). Beides ist nützlich in Containern, in CI und überall dort, wo die Umgebung außerhalb von fastkit verwaltet wird.
Bereitstellung im aktuellen Verzeichnis und Bestätigung des Überschreibens (--yes / -y)
Wenn ein Projekt an Ort und Stelle bereitgestellt wird — in den aktuellen Workspace statt in einen neuen Projektordner —, fragt fastkit „Overwrite these files?“, bevor eine bereits vorhandene Datei ersetzt wird. --yes (oder die Kurzform -y) überspringt diese Bestätigung und überschreibt direkt. Die separate Abfrage „Do you want to proceed with project creation?“ ist davon nicht betroffen und wird weiterhin angezeigt. In einer nicht-interaktiven Umgebung (stdin ist kein TTY, etwa in CI oder bei einem Lauf über eine Pipe) wird die Bestätigung des Überschreibens auch ohne --yes automatisch übersprungen.
Interaktive Eingabeaufforderungen
Der Befehl init fragt Sie ab:
- Projektname: Verzeichnis- und Paketname
- Name des Autors: Information zum Autor des Pakets
- E-Mail des Autors: Kontakt-E-Mail des Pakets
- Projektbeschreibung: kurze Beschreibung des Projekts
- Stack-Auswahl: Wahl zwischen minimal, standard oder full
- Paketmanager-Auswahl: Wahl zwischen pip, uv, pdm oder poetry (außer wenn mit
--package-managerangegeben)
Stack-Optionen
MINIMAL-Stack:
fastapi— FastAPI-Frameworkuvicorn— ASGI-Serverpydantic— Datenvalidierungpydantic-settings— Konfigurationsverwaltung
STANDARD-Stack:
- Alle Pakete des MINIMAL-Stacks
sqlalchemy— SQL-Toolkit und ORMalembic— Werkzeug für Datenbankmigrationenpytest— Test-Framework
FULL-Stack:
- Alle Pakete des STANDARD-Stacks
redis— In-Memory-Datenspeichercelery— verteilte Aufgabenwarteschlange
Funktionskatalog des interaktiven Builders (--interactive)
fastkit init --interactive durchläuft statt des obigen Stacks minimal/standard/full einen anderen, achsenbasierten Katalog (maßgebliche Quelle: FastkitConfig.PACKAGE_CATALOG in core/settings.py und DynamicConfigGenerator.build_artifacts() für das, was jede Auswahl erzeugt). Jede Achse hat den Standardwert None (überspringen); utilities und tooling erlauben eine Mehrfachauswahl.
Jede Auswahl erzeugt inzwischen echten Code, nicht nur installierte Pakete — wie sich minimal / single-module (regenerierte main.py) und classic-layered / domain-starter (erhaltene main.py, Warnungen zur manuellen Verdrahtung) unterscheiden, zeigt die Architektur-Preset- / Funktionsmatrix.
| Achse | Auswahlmöglichkeiten | Installierte Pakete | Generierte Dateien |
|---|---|---|---|
database |
PostgreSQL, MySQL, MongoDB, Redis, SQLite, None | PostgreSQL: asyncpg, sqlalchemy · MySQL: aiomysql, sqlalchemy · MongoDB: motor · Redis: redis[hiredis] · SQLite: sqlalchemy, aiosqlite |
Ein Datenbank-Konfigurationsmodul am Pfad des Presets (z. B. src/config/database.py) |
authentication |
JWT, OAuth2, FastAPI-Users, Session-based, None | JWT: pyjwt[crypto], pwdlib[argon2] · OAuth2: authlib, itsdangerous, httpx · FastAPI-Users: fastapi-users[sqlalchemy], pyjwt[crypto], pwdlib[argon2] · Session-based: itsdangerous |
Ein Auth-Konfigurationsmodul am Pfad des Presets; OAuth2 und Session-based ergänzen zusätzlich das Middleware-Setup in main.py |
async_tasks |
Celery, Dramatiq, None | Celery: celery[redis], redis[hiredis] · Dramatiq: dramatiq[redis], redis[hiredis] |
<pkg>/worker.py (Hintergrund-Worker) + <pkg>/features/tasks.py (Task-Routen) |
testing |
Basic, Coverage, Advanced, None | Basic: pytest, pytest-asyncio, httpx · Coverage: + pytest-cov · Advanced: + faker, factory-boy |
pytest.ini; Advanced fügt zusätzlich tests/factories.py und tests/test_factories.py hinzu |
caching |
Redis, None | Redis: redis[hiredis], fastapi-cache2, jinja2 |
<pkg>/features/cache.py (gecachte Endpunkte) |
monitoring |
Loguru, OpenTelemetry, Prometheus, None | Loguru: loguru · OpenTelemetry: opentelemetry-api, opentelemetry-sdk, opentelemetry-instrumentation-fastapi, opentelemetry-exporter-otlp-proto-http · Prometheus: prometheus-client, prometheus-fastapi-instrumentator |
Keine eigene Datei — direkt in main.py verdrahtet (Import / Lifespan / Setup) |
utilities (Mehrfachauswahl) |
CORS, Rate-Limiting, Pagination, WebSocket, None | CORS: keine (in FastAPI integriert) · Rate-Limiting: slowapi · Pagination: fastapi-pagination · WebSocket: websockets |
CORS und Rate-Limiting werden direkt in main.py verdrahtet; Pagination fügt <pkg>/features/pagination.py hinzu, WebSocket fügt <pkg>/features/websocket.py hinzu |
migrations |
Alembic, None | Alembic: alembic |
alembic.ini, alembic/env.py, alembic/script.py.mako, eine Basis-Revision alembic/versions/<id>_initial.py, scripts/migrate.sh — nur wenn die Datenbankachse eine SQL-Datenbank ist |
tooling (Mehrfachauswahl) |
ruff, pre-commit, github-actions, devcontainer, makefile, None | ruff: ruff · pre-commit: pre-commit · github-actions / devcontainer / makefile: keine |
ruff fügt einen [tool.ruff]-Block in pyproject.toml ein (oder schreibt ruff.toml bei pip-Projekten); pre-commit schreibt .pre-commit-config.yaml; github-actions schreibt .github/workflows/test.yml; devcontainer schreibt .devcontainer/devcontainer.json; makefile schreibt Makefile |
logging |
structured, None | Keine (nur stdlib logging + json) |
<pkg>/logging_config.py (strukturiertes JSON-Logging + Request-ID-Middleware), in main.py verdrahtet |
Unabhängig von der Auswahl erhält jedes generierte Projekt die Endpunkte /health und /ready in main.py, und --dry-run gibt genau diese Dateimenge aus, bevor irgendetwas geschrieben wird.
Beispiele
$ fastkit init
Enter the project name: my-api
Enter the author name: John Doe
Enter the author email: john@example.com
Enter the project description: My awesome API
Select stack (minimal, standard, full): standard
Select package manager (pip, uv, pdm, poetry) [uv]: uv
Do you want to proceed with project creation? [y/N]: y
✨ FastAPI project 'my-api' has been created successfully!
Generierte Struktur
Erstellt ein Projekt mit folgender Struktur:
my-api/
├── .venv/ # Virtuelle Umgebung
├── src/
│ ├── __init__.py
│ ├── main.py # FastAPI-Anwendung
│ ├── core/
│ │ ├── __init__.py
│ │ └── config.py # Konfiguration
│ ├── api/
│ │ ├── __init__.py
│ │ ├── api.py # Sammlung der API-Router
│ │ └── routes/
│ │ ├── __init__.py
│ │ └── items.py # Beispielroute
│ ├── crud/
│ │ ├── __init__.py
│ │ └── items.py # CRUD-Operationen
│ ├── schemas/
│ │ ├── __init__.py
│ │ └── items.py # Pydantic-Schemas
│ └── mocks/
│ ├── __init__.py
│ └── mock_items.json # Testdaten
├── tests/
├── scripts/
├── requirements.txt
├── setup.py
└── README.md
addroute
Eine neue API-Route zu einem bestehenden FastAPI-Projekt hinzufügen.
Syntax
Argumente
| Argument | Beschreibung | Erforderlich |
|---|---|---|
ROUTE_NAME |
Name der neuen Route (Plural empfohlen) | Ja |
PROJECT_DIR |
Projektverzeichnis unterhalb Ihres Workspaces (Standard ., das aktuelle Verzeichnis) |
Nein |
Optionen
| Option | Beschreibung | Standard |
|---|---|---|
--layout [classic-layer\|domain] |
Struktur des generierten Routenmoduls; überschreibt die Preset-Metadaten | Automatisch aus dem Preset |
--help |
Hilfe zum Befehl anzeigen | - |
Beispiele
$ cd my-api
$ fastkit addroute users
Adding New Route
┌──────────────────┬──────────────────────────────────────────┐
│ Project │ my-api │
│ Route Name │ users │
│ Target Directory │ ~/my-api │
└──────────────────┴──────────────────────────────────────────┘
Do you want to add route 'users' to project 'my-api'? [Y/n]: y
✨ Successfully added new route 'users' to project 'my-api'
Sie können auch ein Projekt unter Ihrem Workspace per Namen ansteuern, ohne mit cd hineinzuwechseln:
Generierte Dateien
Mit --layout=classic-layer werden diese Dateien unter dem App-Paket erstellt:
src/api/routes/users.py— Routen-Handlersrc/crud/users.py— CRUD-Operationensrc/schemas/users.py— Pydantic-Schemas
Mit --layout=domain wird domains/users/ mit __init__.py, models.py, schemas.py, repository.py, service.py und router.py erstellt. Die Entity hat id: int und name: str und kommt mit einem funktionierenden In-Memory-Repository.
Beide Layouts aktualisieren den bestehenden API-Router und verbinden ihn bei Bedarf mit der Anwendung. Die Pfade folgen dem tatsächlichen App-Paket, einschließlich src/app/.
Ohne die Option wählt [tool.fastapi-fastkit].preset = "domain-starter" das Layout domain. Fehlt preset, wird das Preset aus template abgeleitet; auch fastapi-domain-starter wählt domain. Andere Presets und Projekte ohne einen dieser Metadatenwerte wählen classic-layer. Ein unbekanntes Preset fällt mit einer Warnung auf classic-layer zurück. Eine explizite Auswahl ändert das Preset des Projekts nicht.
Der Befehl zeigt das gewählte Layout vor der Bestätigung an. Ein erneutes Ausführen erhält bestehende Dateien, stellt fehlende Dateien wieder her und vermeidet doppelte Router-Registrierungen. Gleichnamige Module verschiedener Layouts können über Import-Aliase nebeneinander bestehen. Der Generator prüft keine Konflikte bei HTTP-Methode/-Pfad. Eine Migration erfolgt manuell.
Generierte Endpunkte
Das Domänen-Layout erstellt diese Endpunkte (dargestellt mit /api/v1 als bestehendem Präfix der App):
| Methode | Endpunkt | Beschreibung |
|---|---|---|
GET |
/api/v1/users |
Entities auflisten, 200 |
POST |
/api/v1/users |
Entity anlegen, 201 |
GET |
/api/v1/users/{entity_id} |
Entity lesen, 200 oder 404 |
PUT |
/api/v1/users/{entity_id} |
Entity ersetzen, 200 oder 404 |
DELETE |
/api/v1/users/{entity_id} |
Entity löschen, leeres 204 oder 404 |
POST und PUT akzeptieren einen name mit 1–120 Zeichen. IDs werden vom Repository vergeben, und PUT behält sie bei. Für Domänen wird kein PATCH-Endpunkt generiert. Der Speicher ist prozesslokal, geht beim Neustart verloren und ist zwischen Domänen unabhängig; ersetzen Sie das Repository für dauerhafte Persistenz. Tests können über den Service ein frisches Repository injizieren und get_users_service überschreiben.
Das klassische Layout behält seine bestehenden GET/POST/PUT/PATCH/DELETE-Stubs unter /<route_name>/ bei, die Sie selbst implementieren.
Wo der Code eingefügt wird
addroute braucht zwei Dinge vom Projekt: wohin die neuen Imports kommen und wo der Router registriert wird. Vorlagen und generierte Einstiegspunkte markieren beides mit Anker-Kommentaren:
# src/app/api/router.py
from src.app.api import health
# fastkit:imports
api_router = APIRouter()
api_router.include_router(health.router)
# fastkit:routes
Lassen Sie diese Kommentare beim Bearbeiten der Datei an ihrem Platz — addroute fügt direkt unterhalb von # fastkit:imports und # fastkit:routes ein. Ein Projekt, dem sie fehlen (oder das erzeugt wurde, bevor es die Anker gab), funktioniert trotzdem: fastkit greift auf ein AST-basiertes Einfügen zurück, das den Importblock und die Router-Registrierungen selbst findet. Die Anker machen das Ergebnis lediglich vorhersehbar.
addroute liest außerdem den [tool.fastapi-fastkit]-Block des Projekts, um den Einstiegspunkt zu finden, und funktioniert daher auch bei Layouts, die ein reiner Scan des Dateisystems falsch einordnen würde.
startdemo
Ein FastAPI-Projekt aus einer vorgefertigten Vorlage erstellen.
Syntax
Optionen
| Option | Beschreibung | Standard |
|---|---|---|
--project-name |
Projektname (wird abgefragt, falls weggelassen) | - |
--author |
Name des Autors (wird abgefragt, falls weggelassen) | - |
--author-email |
E-Mail des Autors (wird abgefragt, falls weggelassen) | - |
--description |
Projektbeschreibung (wird abgefragt, falls weggelassen) | - |
--package-manager |
Zu verwendender Paketmanager (pip, uv, pdm, poetry) | uv |
--dry-run |
Zeigt die Dateien und Pakete an, die erstellt würden, ohne etwas zu schreiben | aus |
--no-venv |
Erstellung der virtuellen Umgebung überspringen (impliziert --no-install) |
aus |
--no-install |
Installation der Abhängigkeiten überspringen | aus |
--yes / -y |
Beim Bereitstellen des Projekts im aktuellen Verzeichnis nicht nachfragen, bevor vorhandene Dateien überschrieben werden | aus |
--help |
Hilfe zum Befehl anzeigen | - |
Wie init verweigert auch startdemo die Ausführung, wenn das Zielprojektverzeichnis bereits existiert (Error: Project '{name}' already exists.). --dry-run ist die Ausnahme: Da es nie auf die Festplatte schreibt, darf es auch einen Namen verwenden, für den bereits ein Verzeichnis existiert. Was --yes beim Bereitstellen in den aktuellen Workspace bewirkt, erfahren Sie oben unter Bereitstellung im aktuellen Verzeichnis und Bestätigung des Überschreibens.
Interaktive Eingabeaufforderungen
Der Befehl startdemo fragt Sie ab:
- Projektname: Verzeichnisname für das neue Projekt
- Name des Autors: Information zum Autor des Pakets
- E-Mail des Autors: Kontakt-E-Mail
- Projektbeschreibung: kurze Beschreibung
- Paketmanager-Auswahl: Wahl zwischen pip, uv, pdm oder poetry (außer wenn mit
--package-managerangegeben)
Verfügbare Vorlagen
| Vorlage | Beschreibung | Funktionen |
|---|---|---|
fastapi-default |
Einfaches FastAPI-Projekt | Basis-CRUD, Mock-Daten |
fastapi-domain-starter |
Domänenorientierter Starter | Ein Ordner pro Geschäftskonzept, /health |
fastapi-auth-jwt |
JWT-Authentifizierung | Access-/Refresh-Rotation, argon2id, Rollen und Scopes, Alembic |
fastapi-sqlmodel |
Asynchrone SQLModel-Persistenz | SQLModel + asynchrones SQLAlchemy, Alembic, generisches CRUD, Paginierung |
fastapi-llm-agent |
Streaming-Claude-Agent | SSE-Streaming, Tool-Call-Schleife, Konversationsspeicher |
fastapi-custom-response |
Benutzerdefiniertes Antwortsystem | Benutzerdefinierte Antworten, Paginierung |
fastapi-psql-orm |
PostgreSQL-FastAPI-API | PostgreSQL, SQLAlchemy, Alembic |
fastapi-mcp |
Model-Context-Protocol-Server | MCP-Integration |
fastapi-single-module |
Sandbox in einer Datei | Ein Modul, keine Paketgrenzen |
fastapi-empty |
Minimales FastAPI-Projekt | Absolutes Minimum |
fastapi-async-crud |
(veraltet) Asynchrone Item-Management-API | Abgelöst durch fastapi-sqlmodel |
fastapi-dockerized |
(veraltet) Dockerisierte FastAPI-API | Docker-Tooling ist jetzt in den neueren Vorlagen enthalten |
Die veralteten Vorlagen erzeugen weiterhin funktionierende Projekte; sie werden lediglich nicht mehr als Ausgangspunkt empfohlen. Siehe Welchen Starter soll ich wählen?.
Beispiele
$ fastkit startdemo fastapi-psql-orm
Enter the project name: my-blog
Enter the author name: Jane Smith
Enter the author email: jane@example.com
Enter the project description: Blog API with PostgreSQL
Select package manager (pip, uv, pdm, poetry) [uv]: poetry
Do you want to proceed with project creation? [y/N]: y
✨ FastAPI project 'my-blog' from 'fastapi-psql-orm' has been created!
runserver
Den FastAPI-Entwicklungsserver starten.
Syntax
Optionen
| Option | Kurz | Beschreibung | Standard |
|---|---|---|---|
--host |
-h |
Host, an den gebunden werden soll | 127.0.0.1 |
--port |
-p |
Port, an den gebunden werden soll | 8000 |
--reload |
-r |
Automatisches Neuladen aktivieren | True |
--workers |
-w |
Anzahl der Worker | 1 |
--help |
Hilfe zum Befehl anzeigen | - |
Beispiele
# Grundlegende Verwendung (Standardeinstellungen)
$ fastkit runserver
INFO: Uvicorn running on http://127.0.0.1:8000
# Eigener Host und Port
$ fastkit runserver --host 0.0.0.0 --port 8080
INFO: Uvicorn running on http://0.0.0.0:8080
# Automatisches Neuladen deaktivieren
$ fastkit runserver --no-reload
INFO: Uvicorn running on http://127.0.0.1:8000
# Mehrere Worker (Produktion)
$ fastkit runserver --workers 4
INFO: Uvicorn running on http://127.0.0.1:8000
Voraussetzungen
- Muss aus dem Verzeichnis eines FastAPI-Projekts ausgeführt werden
- Das Projekt muss eine FastAPI-App bereitstellen — ermittelt aus
[tool.fastapi-fastkit].app_module, falls vorhanden, andernfalls durch Suche nachmain.py - Die virtuelle Umgebung sollte aktiviert sein
Findet weder der gespeicherte Einstiegspunkt noch die Suche ein Modul, meldet runserver, dass es main.py nicht finden konnte, und bricht ab.
list-templates
Alle verfügbaren FastAPI-Projektvorlagen auflisten.
Syntax
Optionen
| Option | Beschreibung | Standard |
|---|---|---|
--help |
Hilfe zum Befehl anzeigen | - |
Beispiele
$ fastkit list-templates
Available Templates
┌─────────────────────────┬───────────────────────────────────┐
│ fastapi-custom-response │ Async Item Management API with │
│ │ Custom Response System │
│ fastapi-dockerized │ Dockerized FastAPI Item │
│ │ Management API │
│ fastapi-empty │ No description │
│ fastapi-async-crud │ Async Item Management API Server │
│ fastapi-psql-orm │ Dockerized FastAPI Item │
│ │ Management API with PostgreSQL │
│ fastapi-default │ Simple FastAPI Project │
└─────────────────────────┴───────────────────────────────────┘
Projektmetadaten ([tool.fastapi-fastkit])
Jedes von fastkit generierte Projekt hält in seiner eigenen pyproject.toml fest, wie es erzeugt wurde:
[tool.fastapi-fastkit]
managed = true
version = "1.4.0"
template = "fastapi-domain-starter"
preset = "domain-starter"
package_manager = "uv"
app_module = "src.app.main:app"
features = ["database:PostgreSQL", "authentication:JWT"]
| Schlüssel | Bedeutung |
|---|---|
managed |
Immer true; kennzeichnet das Projekt als von fastkit verwaltet |
version |
Die fastkit-Version, die das Projekt generiert hat |
template |
Die startdemo-Vorlage oder die Basisvorlage des Presets |
preset |
Das Architektur-Preset von init --interactive (sonst weggelassen) |
package_manager |
Der Paketmanager, mit dem die Umgebung aufgebaut wurde |
app_module |
Der uvicorn-Einstiegspunkt im Format module:attr |
features |
Flache Liste "<category>:<choice>" der interaktiven Auswahlen |
Dieser Block ist die einzige maßgebliche Quelle für den Einstiegspunkt des Projekts: fastkit runserver liest daraus app_module, bevor es auf das Durchsuchen des Baums zurückgreift, fastkit addroute nutzt ihn, um die Anwendung zu finden, und generierte Dockerfiles verwenden denselben Wert in ihrem CMD.
Der Block wird ganz am Ende der Generierung geschrieben — Paketmanager schreiben pyproject.toml beim Auflösen der Abhängigkeiten neu, daher muss er danach eingetragen werden —, und eine spätere Regenerierung ersetzt ihn, statt eine zweite Kopie anzuhängen. app_module von Hand zu bearbeiten, ist der unterstützte Weg, fastkit über ein Layout zu informieren, das Sie selbst umorganisiert haben.
Umgebungsvariablen
FastAPI-fastkit berücksichtigt folgende Umgebungsvariablen:
| Variable | Beschreibung | Standard |
|---|---|---|
FASTKIT_CONFIG_DIR |
Konfigurationsverzeichnis | ~/.fastkit |
FASTKIT_TEMPLATES_DIR |
Verzeichnis für benutzerdefinierte Vorlagen | Integrierte Vorlagen |
FASTKIT_LOG_LEVEL |
Log-Level | INFO |
FASTKIT_SUBPROCESS_TIMEOUT |
Überschreibt jedes Timeout für Paketmanager-Subprozesse, in Sekunden | je Vorgang (30 / 120 / 900) |
Aufrufe von Paketmanagern sind einzeln begrenzt, sodass ein hängender Kindprozess das CLI niemals blockieren kann: 30 Sekunden für eine Verfügbarkeitsprüfung, 120 für das Erstellen einer virtuellen Umgebung, 900 für die Installation der Abhängigkeiten. FASTKIT_SUBPROCESS_TIMEOUT ersetzt alle drei durch einen einzigen Wert — nützlich in einem langsamen Netzwerk oder um in CI schnell fehlzuschlagen. Ein Wert, der keine positive ganze Zahl ist, wird ignoriert.
Beispiele
Konfigurationsdateien
FastAPI-fastkit kann Konfigurationsdateien für Standardwerte verwenden.
Ort der Konfigurationsdatei
$FASTKIT_CONFIG_DIR/config.yaml(fallsFASTKIT_CONFIG_DIRgesetzt ist)~/.fastkit/config.yaml(Standard)./fastkit.yaml(projektspezifisch)
Konfigurationsformat
# ~/.fastkit/config.yaml
default:
author:
name: "Your Name"
email: "your.email@example.com"
project:
stack: "standard"
create_venv: true
install_deps: true
server:
host: "127.0.0.1"
port: 8000
reload: true
templates:
custom_dir: "~/my-templates"
logging:
level: "INFO"
file: "~/.fastkit/logs/fastkit.log"
Häufige Workflows
1. Neues Projekt erstellen
2. Funktionen zu einem bestehenden Projekt hinzufügen
3. Vorlagen für komplexe Projekte nutzen
# Verfügbare Vorlagen auflisten
$ fastkit list-templates
# Projekt aus Vorlage erzeugen
$ fastkit startdemo
# Für ein Datenbankprojekt fastapi-psql-orm auswählen
# Datenbank einrichten (für die PostgreSQL-Vorlage)
$ cd my-project
$ docker-compose up -d postgres
$ source .venv/bin/activate
$ alembic upgrade head
$ fastkit runserver
Fehlerbehebung
Befehl nicht gefunden
Falls der Befehl fastkit nicht gefunden wird:
-
Installation prüfen:
-
Falls nötig neu installieren:
-
PATH prüfen:
Probleme mit der virtuellen Umgebung
Falls die Erstellung der virtuellen Umgebung fehlschlägt:
-
Python-Version prüfen:
-
venv-Modul prüfen:
-
Manuelle virtuelle Umgebung:
Server startet nicht
Falls fastkit runserver fehlschlägt:
- Prüfen Sie, dass Sie im Projektverzeichnis sind
- Sicherstellen, dass
src/main.pyexistiert -
Virtuelle Umgebung aktivieren:
-
Auf Syntaxfehler prüfen:
Port bereits in Verwendung
Falls Port 8000 belegt ist:
Fortgeschrittene Nutzung
Benutzerdefinierte Vorlagen
Sie können benutzerdefinierte Vorlagen erstellen, indem Sie:
-
Ein Vorlagenverzeichnis anlegen:
-
Eine Umgebungsvariable setzen:
-
Die benutzerdefinierte Vorlage verwenden:
Skripten mit FastAPI-fastkit
Sie können FastAPI-fastkit in Skripten verwenden:
#!/bin/bash
# create-microservices.sh
for service in users products orders; do
echo "Creating $service service..."
fastkit init <<EOF
$service-service
Company Team
team@company.com
$service microservice
minimal
y
EOF
cd "$service-service"
fastkit addroute "$service"
cd ..
done
Integration mit CI/CD
Beispiel für einen GitHub-Actions-Workflow:
name: Test FastAPI-fastkit Project
on: [push, pull_request]
jobs:
test:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v2
- name: Set up Python
uses: actions/setup-python@v2
with:
python-version: '3.12'
- name: Install FastAPI-fastkit
run: pip install fastapi-fastkit
- name: Create test project
run: |
fastkit init <<EOF
test-project
CI
ci@example.com
Test project
standard
y
EOF
- name: Test project
run: |
cd test-project
source .venv/bin/activate
python -m pytest
Unterstützung von Paketmanagern
FastAPI-fastkit unterstützt mehrere Python-Paketmanager, sodass Sie den auswählen können, der am besten zu Ihrem Workflow passt.
Unterstützte Paketmanager
| Manager | Beschreibung | Abhängigkeitsdatei | Am besten für |
|---|---|---|---|
| UV (Standard) | Schneller Python-Paketmanager | pyproject.toml |
Geschwindigkeit und Leistung |
| PDM | Moderne Python-Abhängigkeitsverwaltung | pyproject.toml |
Fortgeschrittene Abhängigkeitsauflösung |
| Poetry | Python-Abhängigkeitsverwaltung und Packaging | pyproject.toml |
Poetry-basierte Workflows |
| PIP | Standard-Python-Paketmanager | requirements.txt |
Klassische Python-Entwicklung |
Paketmanager angeben
Globale Konfiguration
Sie können Ihren bevorzugten Paketmanager für alle Projekte festlegen:
# Using command line options
$ fastkit init --package-manager poetry
$ fastkit startdemo --package-manager pdm
Projektspezifische Auswahl
Jedes Projekt kann einen anderen Paketmanager verwenden. Die Auswahl erfolgt während der Projekterstellung und beeinflusst:
- Format der Abhängigkeitsdatei: jeder Manager erstellt die passenden Dateien
- Verwaltung der virtuellen Umgebung: unterschiedliche Aktivierungsmethoden
- Installation der Abhängigkeiten: managerspezifische Befehle
Funktionen der Paketmanager
UV (Standard)
- Schnell: Rust-basiert, extrem schnelle Abhängigkeitsauflösung
- Kompatibel: Drop-in-Ersatz für pip und pip-tools
- Modern: Unterstützung für PEP-621-Projektmetadaten
PDM
- Modern: PEP-582- und PEP-621-Unterstützung
- Fortgeschritten: ausgefeilte Abhängigkeitsauflösung
- Flexibel: mehrere Projekt-Layouts
Poetry
- Etabliert: ausgereift und weit verbreitet
- Integriert: Build- und Veröffentlichungs-Unterstützung
- Lockfile: poetry.lock für reproduzierbare Builds
PIP
- Standard: in Python enthalten
- Kompatibel: funktioniert überall
- Einfach: geradlinige Abhängigkeitsverwaltung
Arbeiten mit Projekten
Nach dem Erstellen eines Projekts mit einem bestimmten Paketmanager:
UV-Projekte
cd my-project
uv sync # Abhängigkeiten installieren
uv add requests # Neue Abhängigkeit hinzufügen
uv run pytest # Befehle in der Umgebung ausführen
PDM-Projekte
cd my-project
pdm install # Abhängigkeiten installieren
pdm add requests # Neue Abhängigkeit hinzufügen
pdm run pytest # Befehle in der Umgebung ausführen
Poetry-Projekte
cd my-project
poetry install # Abhängigkeiten installieren
poetry add requests # Neue Abhängigkeit hinzufügen
poetry run pytest # Befehle in der Umgebung ausführen
PIP-Projekte
cd my-project
source .venv/bin/activate # Linux/macOS
.venv\Scripts\activate # Windows
pip install -r requirements.txt
pip install requests
pytest
Nächste Schritte
Jetzt, da Sie die CLI verstehen:
- Schnellstart: probieren Sie die Befehle praktisch aus
- Ihr erstes Projekt: bauen Sie eine vollständige Anwendung
- Mitwirken: tragen Sie zu FastAPI-fastkit bei
CLI-Tipps
- Verwenden Sie
--helpmit jedem Befehl für detaillierte Hilfe - Konfigurieren Sie Standardwerte, um die Projekterstellung zu beschleunigen
- Verwenden Sie Vorlagen für komplexe Projekt-Setups
- Kombinieren Sie Befehle für leistungsstarke Workflows