Ein Microsoft Fabric-Workload-Backend mit der OpenAPI-Spezifikation (Swagger) einrichten.

Ein Microsoft Fabric-Workload-Back-End ist ein Dienst, der den Fabric-API-Vertrag implementiert, mit dem benutzerdefinierte Workloads nahtlos in die Microsoft Fabric-Plattform integriert werden können. Dieses Back-End verarbeitet die Lebenszyklusvorgänge für Ihre Workloadelemente, einschließlich Erstellung, Abruf, Updates und Löschung.

Dieser Artikel führt Sie durch das schnelle Generieren eines Fabric-Workload-Back-Ends direkt aus einer OpenAPI-Definition (Swagger). Mit diesem API-first-Ansatz können Sie back-End-Logik schnell prototypieren und validieren, auch bevor Sie sie in die vollständige Microsoft Fabric-Entwicklungsumgebung integrieren. Die hier gezeigten Prinzipien gelten allgemein, unabhängig davon, welche spezifischen Tools oder Sprachen Sie auswählen.

In diesem Artikel wird Folgendes vermittelt:

Generieren Sie ein Fabric-Workload-Back-End basierend auf der in einem Beispiel enthaltenen Swagger-Datei.
Grundlegende Struktur und Komponenten eines Fabric-Workload-Back-Ends verstehen.
Führen Sie das generierte Back-End lokal mithilfe von Python und FastAPI aus, und testen Sie es.

In diesem Artikel implementieren Sie die folgenden Kernvorgänge aus dem Elementlebenszyklus. Diese Vorgänge entsprechen den in der Fabric-API-Swagger-Datei definierten Endpunkten.

Element erstellen: Initialisieren neuer Workloadelemente.
Abrufen der Elementnutzlast: Abrufen der Elementkonfiguration.
Element aktualisieren: Vorhandene Elemente ändern.
Element löschen: Elemente aus dem Arbeitsbereich entfernen.

In diesem Artikel wird der Prozess mithilfe von Python und FastAPI mit dem OpenAPI-Generator-Tool veranschaulicht. Der OpenAPI-Generator selbst unterstützt jedoch zahlreiche Programmiersprachen und Frameworks. Sie können beliebige OpenAPI-kompatible Codegenerierungstools oder -methoden auswählen, die dem Fachwissen und projekt Ihres Teams entsprechen, um Ihr Back-End-Skelett zu erstellen.

Voraussetzungen

Bevor Sie die Verfahren in diesem Artikel starten, stellen Sie sicher, dass Sie über die folgenden Elemente verfügen.

Erforderliche Kenntnisse

Grundlegendes zum Lebenszyklus von Microsoft Fabric-Elementen. Lesen Sie Item-Lebenszyklus-Management.

Dieses Verständnis ist für diesen Artikel von entscheidender Bedeutung. Das generierte Back-End implementiert die Lebenszyklusvorgänge (Erstellen, Lesen, Aktualisieren, Löschen) für Fabric-Elemente, wie in der Elementlebenszyklusdokumentation definiert.
Grundlegende Kenntnisse von Python und RESTful APIs.
Vertrautheit mit Microsoft Fabric-Workloadkonzepten.

Erforderliche Software

Python 3.8+. Herunterladen von Python
Node.js, was erforderlich ist, wenn Sie die OpenAPI Generator CLI über npm installieren möchten. Download Node.js.
Git verwenden, um das Beispiel-Repository zu klonen. Githerunterladen .
Ein Code-Editor, z. B. Visual Studio Code, PyCharm oder Ihre bevorzugte integrierte Entwicklungsumgebung (IDE).

Java für OpenAPI-Generator

Die OpenAPI-Generator-CLI erfordert Java als Laufzeitumgebung. Sie müssen keinen Java-Code schreiben. Sie benötigen es nur, um das Generatortool auszuführen.

Die erforderliche Java-Mindestversion ist Java 8. Es wird empfohlen, eine unterstützte LTS-Version (Long-Term Support) wie Java 17 oder Java 21 zu verwenden.

So installieren Sie Java:

Installieren Sie den Microsoft-Build von OpenJDK (empfohlen). Befolgen Sie die Anweisungen für Ihr Betriebssystem unter Installieren des Microsoft Build of OpenJDK.

Überprüfen Sie Ihre Installation. Öffnen Sie ein Terminal oder eine Eingabeaufforderung, und führen Sie Folgendes aus:

java -version

Die Ausgabe sollte folgendem Beispiel entsprechen:

openjdk version "17.0.12" 2024-07-16 LTS
OpenJDK Runtime Environment Microsoft-10377968 (build 17.0.12+7-LTS)
OpenJDK 64-Bit Server VM Microsoft-10377968 (build 17.0.12+7-LTS, mixed mode, sharing)

Wenn Sie Java bereits von einem anderen Anbieter (z. B. Oracle, Eclipse Temurin oder Amazon Corretto) mit Version 8 oder höher installiert haben, können Sie Ihre vorhandene Installation verwenden.

Schritt 1: Einrichten Ihrer Entwicklungsumgebung

Richten Sie zunächst Ihre Entwicklungsumgebung mit den erforderlichen Tools und Paketen ein:

Klonen Sie das Microsoft Fabric-Entwicklerbeispiel-Repository:

git clone https://github.com/microsoft/Microsoft-Fabric-workload-development-sample
cd Microsoft-Fabric-workload-development-sample

Erstellen eines PythonBackend Verzeichnisses:
```
mkdir PythonBackend
cd PythonBackend
```

Erstellen einer virtuellen Python-Umgebung:

# Create a Python virtual environment for the project
python -m venv .venv

# Activate the virtual environment
# Windows
.venv\Scripts\activate

# macOS/Linux
source .venv/bin/activate

Installieren Sie die OpenAPI-Generator-CLI:
```
npm install @openapitools/openapi-generator-cli -g
```
Alternative Installationsmethoden finden Sie in der OpenAPI-Generator-Installationsdokumentation.

Schritt 2: Überprüfen, ob Ihre virtuelle Python-Umgebung aktiv ist

Nachdem Sie Ihre virtuelle Umgebung erstellt haben, müssen Sie sicherstellen, dass Sie den richtigen Python-Dolmetscher verwenden. Mit diesem Ansatz werden Ihre Projektabhängigkeiten isoliert und ordnungsgemäß verwaltet.

Überprüfen der Aktivierung der virtuellen Umgebung

Vergewissern Sie sich, dass Ihre virtuelle Umgebung aktiviert ist. Sie sollten (.venv) am Anfang der Terminalaufforderung sehen.

Wenn die virtuelle Umgebung nicht aktiviert ist, führen Sie Folgendes aus:

# Windows
.venv\Scripts\activate

# macOS/Linux
source .venv/bin/activate

Überprüfen, ob der Python-Interpreter Ihrer virtuellen Umgebung aktiv ist

Vergewissern Sie sich, dass Ihr Terminal den Python-Dolmetscher aus Ihrer virtuellen Umgebung verwendet, nicht die globale Python-Installation Ihres Systems.

Führen Sie den folgenden Befehl aus:

# Display the path to the active Python interpreter
python -c "import sys; print(sys.executable)"

Die erwartete Ausgabe sollte auf Ihre virtuelle Umgebung verweisen:

- Windows: C:\path\to\project\PythonBackend\.venv\Scripts\python.exe
- macOS/Linux: /path/to/project/PythonBackend/.venv/bin/python

Von Bedeutung

Wenn die Ausgabe auf einen anderen Speicherort verweist (z. B. Ihre systemweite Python-Installation), wird Ihre virtuelle Umgebung nicht ordnungsgemäß aktiviert. Überprüfen Sie die Aktivierungsaufgabe und stellen Sie sicher, dass Ihr Terminal-Prompt mit (.venv) erscheint.

Konfigurieren Der IDE (optional)

Die meisten modernen IDEs erkennen automatisch virtuelle Python-Umgebungen. Möglicherweise müssen Sie den Dolmetscher jedoch in Ihren IDE-Einstellungen manuell auswählen.

Beispiel: Visual Studio Code-Konfiguration

Öffnen Sie Ihren Projektordner in Visual Studio Code.
Öffnen Sie die Befehlspalette:
- Windows oder Linux: Ctrl+Shift+P
- macOS: Cmd+Shift+P
Suchen Sie nach Python: Select Interpreter, und wählen Sie diese Option aus.
Wählen Sie den Dolmetscher in Ihrer virtuellen Umgebung aus:
- Fenster: .venv\Scripts\python.exe
- macOS oder Linux: .venv/bin/python
Überprüfen Sie Ihre Auswahl auf der Statusleiste unten in Visual Studio Code. Es sollte etwa wie folgt angezeigt werden:
```
Python 3.x.x ('.venv': venv)
```
Öffnen Sie ein neues integriertes Terminal (Terminal>New Terminal). Ihre virtuelle Umgebung sollte automatisch aktiviert werden, wie in (.venv) der Eingabeaufforderung angegeben.

Fehler beheben in Ihrer virtuellen Umgebung

Stellen Sie immer sicher, dass Ihre virtuelle Umgebung aktiviert ist, bevor Sie Abhängigkeiten installieren oder Ihre Anwendung ausführen. Das (.venv) Präfix in Ihrem Terminal bestätigt den Aktivierungsstatus. Wenn Importfehler oder fehlende Pakete auftreten, überprüfen Sie, ob Sie den richtigen Python-Interpreter verwenden, indem Sie die zuvor erwähnten Überprüfungsbefehle ausführen.

Tipp

Wenn Ihre IDE Ihre virtuelle Umgebung nicht automatisch erkennt oder der Dolmetscherpfad nicht mit Ihrer virtuellen Umgebung übereinstimmt, probieren Sie die folgenden Lösungen aus:

Stellen Sie sicher, dass Sie Ihre IDE aus dem richtigen Projektverzeichnis öffnen.
Starten Sie Die IDE neu, und versuchen Sie erneut, den Dolmetscher auszuwählen.
Vergewissern Sie sich, dass Ihre virtuelle Umgebung in Ihrem Terminal aktiviert ist.

Schritt 3: Generieren des FastAPI-Projekts aus der OpenAPI-Spezifikation

Verwenden Sie die OpenAPI Generator CLI, um ein Python FastAPI-Projekt aus der Swagger-Spezifikation der Fabric-API zu erstellen.

Ausführen des Generierungsbefehls

Führen Sie den folgenden Befehl aus Ihrem PythonBackend Verzeichnis aus:

openapi-generator-cli generate -i ../Backend/src/Contracts/FabricAPI/Workload/swagger.json -g python-fastapi -o . --additional-properties=packageName=fabric_api

Dieser Befehl weist die OpenAPI-Generator-CLI an, die folgenden Aktionen auszuführen:

Parameter	Wert	BESCHREIBUNG	Erforderlich	Zweck	Referenz
`-i`	`[InputSpecPath]` ¹	Eingabespezifikation: Gibt den Pfad zur Quelldefinitionsdatei OpenAPI (Swagger) an.	Erforderlich	Verweist auf den Fabric-API-Vertrag, der alle Endpunkte, Modelle und Vorgänge definiert.	OpenAPI-Spezifikation
`-g`	`python-fastapi` ²	Generatorname: Weist das Tool an, den `python-fastapi` Generator zum Erstellen von serverseitigem Python-Code zu verwenden.	Erforderlich	Bestimmt das Ausgabeframework und die Sprache für den generierten Back-End-Code.	Python FastAPI-Generator Erkunde alle verfügbaren Servergeneratoren
`-o`	`.`	Ausgabeverzeichnis: Weist den Generator an, die Ausgabedateien im aktuellen Verzeichnis zu platzieren.	Erforderlich	Gibt an, wo die generierte Projektstruktur erstellt wird.	Nicht anwendbar
`--additional-properties`	`packageName=fabric_api`	Generatorspezifische Optionen: Legt den Python-Paketnamen für den generierten Code auf `fabric_api`	Wahlfrei	Passt die generierte Codestruktur und Benennungskonventionen an.	Generatoroptionen

¹ Für [InputSpecPath], der Pfad ist ../Backend/src/Contracts/FabricAPI/Workload/swagger.json.

² Für den Generatorparameter (-g) verwendet dieser Artikel den Wert python-fastapi als Beispiel. OpenAPI-Generator unterstützt zahlreiche serverseitige Codegeneratoren für verschiedene Sprachen und Frameworks. Sie können python-fastapi durch den gewünschten Generator ersetzen. Eine umfassende Liste finden Sie in der OpenAPI Server Generators-Dokumentation.

Installieren der erforderlichen Abhängigkeiten

Verwenden Sie den folgenden Befehl, um Abhängigkeiten zu installieren:

pip install -r requirements.txt

Unter Windows tritt möglicherweise ein Fehler mit dem uvloop Paket auf. Wenn das passiert:

Öffne deine requirements.txt-Datei.
Suchen Sie den uvloop Eintrag, der möglicherweise ähnlich aussieht wie uvloop==0.17.0. Fügen Sie die plattformbedingte Bedingung am Ende hinzu:
```
uvloop==<existing version>; sys_platform != 'win32'
```
Wenn Ihre Datei z. B. uvloop==0.17.0 enthält, ändern Sie es in uvloop==0.17.0; sys_platform != 'win32'.
Führen Sie pip install -r requirements.txt erneut aus.

Diese Änderung stellt sicher, dass uvloop nur auf Nicht-Windows-Plattformen installiert wird.

Schritt 4: Grundlegendes zur generierten Codestruktur

Der OpenAPI-Generator erstellt ein strukturiertes FastAPI-Projekt mit den folgenden Schlüsselverzeichnissen:

PythonBackend/
├── src/
│   └── fabric_api/
│       ├── apis/              # Generated API route definitions
│       │   ├── item_lifecycle_api.py
│       │   ├── jobs_api.py
│       │   └── endpoint_resolution_api.py
│       ├── impl/              # Where you'll implement controllers
│       │   └── __init__.py
│       ├── models/            # Data models for requests/responses
│       │   ├── create_item_request.py
│       │   └── ...
│       └── main.py            # FastAPI application entry point
├── tests/                     # Generated test files
└── requirements.txt           # Dependencies

Das apis Verzeichnis enthält die Routerdefinitionen für jeden API-Endpunkt.
Das models Verzeichnis enthält Pydantische Modelle für Anforderungs- und Antwortobjekte.
Im impl Verzeichnis implementieren Sie die Controllerlogik.
Die main.py Datei richtet die FastAPI-Anwendung ein.

Schritt 5: Implementieren des ItemLifecycle-Controllers

Erstellen Sie eine Controllerimplementierung, die Fabric-API-Anforderungen verarbeitet. Der Controller erbt von der generierten Basisklasse.

Erstellen Sie item_lifecycle_controller.py im impl Verzeichnis:

# file path: src/fabric_api/impl/item_lifecycle_controller.py

from fabric_api.apis.item_lifecycle_api_base import BaseItemLifecycleApi
from fabric_api.models.get_item_payload_response import GetItemPayloadResponse
from pydantic import Field, StrictStr
from typing_extensions import Annotated
from fastapi import HTTPException

class ItemLifecycleController(BaseItemLifecycleApi):
    """
    Implementation of Item Lifecycle API methods.
    """
    
    async def item_lifecycle_create_item(
        self,
        workspaceId,
        itemType,
        itemId,
        activity_id,
        request_id,
        authorization,
        x_ms_client_tenant_id,
        create_item_request,
    ) -> None:
        """
        Implementation for creating a new item.
        """
        print(f"\n=== CREATE ITEM CALLED ===")
        print(f"Workspace ID: {workspaceId}")
        print(f"Item Type: {itemType}")
        print(f"Item ID: {itemId}")
        print(f"Display Name: {create_item_request.display_name}")
        print(f"Description: {create_item_request.description}")
        if create_item_request.creation_payload:
            print(f"Creation Payload: {create_item_request.creation_payload}")
        print("===========================\n")
        return
    
    async def item_lifecycle_delete_item(
        self,
        workspaceId,
        itemType,
        itemId,
        activity_id,
        request_id,
        authorization,
        x_ms_client_tenant_id,
    ) -> None:
        """
        Implementation for deleting an existing item.
        """
        print(f"Delete item called for itemId: {itemId}")
        return
    
    async def item_lifecycle_get_item_payload(
        self,
        workspaceId,
        itemType,
        itemId,
        activity_id,
        request_id,
        authorization,
        x_ms_client_tenant_id,
    ) -> GetItemPayloadResponse:
        """
        Implementation for retrieving the payload for an item.
        """
        print(f"Get item payload called for itemId: {itemId}")
        # Return a simple payload
        return GetItemPayloadResponse(item_payload={"sample": "data"})
    
    async def item_lifecycle_update_item(
        self,
        workspaceId,
        itemType,
        itemId,
        activity_id,
        request_id,
        authorization,
        x_ms_client_tenant_id,
        update_item_request,
    ) -> None:
        """
        Implementation for updating an existing item.
        """
        print(f"Update item called for itemId: {itemId}")
        return

Schritt 6: Konfigurieren und Ausführen der FastAPI-Anwendung

Bevor Sie Ihre FastAPI-Anwendung ausführen, stellen Sie sicher, dass die Portkonfiguration mit der Microsoft Fabric-Entwicklungsumgebung übereinstimmt. Dieser Schritt ist entscheidend für die ordnungsgemäße Integration mit dem Fabric-Entwicklungsgateway.

Grundlegendes zur Portkonfiguration

Wenn Sie eine Microsoft Fabric-Workload entwickeln, leitet das Entwicklungsgateway API-Anforderungen an Ihr Back-End weiter. Für diese Konfiguration ist Folgendes erforderlich:

Ihr Back-End, das auf einem bestimmten Port ausgeführt werden soll (Standard: 5000).
Der Port, der dem WorkloadEndpointURL Wert in Ihrer Workloadkonfiguration entspricht.
Alle Fabric-API-Aufrufe, die über das Entwicklungsgateway an diesen Endpunkt weitergeleitet werden sollen.

Konfigurieren des Workload-Endpunkts (für die Fabric-Integration)

Wenn Sie in die vollständige Microsoft Fabric-Entwicklungsumgebung integriert sind, müssen Sie die Workload-Endpunkt-URL konfigurieren. Diese Konfiguration teilt dem Entwicklungsgateway mit, wo API-Anforderungen weitergeleitet werden sollen.

Suchen oder erstellen Sie Ihre Arbeitsauslastungskonfigurationsdatei (workload-dev-mode.json):
- Der vorgegebene Speicherort ist C:\workload-dev-mode.json.
- Sie können diese Datei später erstellen, wenn Sie die vollständige Fabric-Entwicklungsumgebung einrichten.

Stellen Sie sicher, dass der WorkloadEndpointURL Wert ihrem Back-End-Port entspricht:

{
    "WorkloadEndpointURL": "http://localhost:5000",
    // ... other configuration settings
}

Vollständige Details zur Workloadkonfiguration finden Sie in der Dokumentation zu den ersten Schritten mit dem Erweiterbarkeits-Back-End.

Ausführen der FastAPI-Anwendung

Starten Sie Ihre FastAPI-Anwendung auf Port 5000 (oder den ausgewählten Port, der der Konfiguration entspricht).

Für Windows PowerShell:

$env:PYTHONPATH="src"
uvicorn fabric_api.main:app --host 0.0.0.0 --port 5000

Für eine Windows-Eingabeaufforderung:

set PYTHONPATH=src
uvicorn fabric_api.main:app --host 0.0.0.0 --port 5000

Für macOS oder Linux:

PYTHONPATH=src uvicorn fabric_api.main:app --host 0.0.0.0 --port 5000

Von Bedeutung

Die Einstellung PYTHONPATH ist für Python entscheidend, um die Module richtig zu finden. Diese Umgebungsvariable wirkt sich nur auf die aktuelle Terminalsitzung aus.

Alternativ können Sie den Befehl aus dem src Verzeichnis ausführen:

cd src
python -m uvicorn fabric_api.main:app --host 0.0.0.0 --port 5000

Hinweis

Port 5000 wird häufig als Standard in Microsoft Fabric-Workload-Entwicklungsbeispielen verwendet. Wenn Sie einen anderen Port verwenden müssen:

Ändern Sie den --port Wert in Ihrem uvicorn Befehl (z. B --port 5001. ).
Um diesem neuen Port zu entsprechen, aktualisieren Sie den WorkloadEndpointURL Wert in Ihrer workload-dev-mode.json Datei (z. B "http://localhost:5001". ).

Stellen Sie sicher, dass eine andere Anwendung in Ihrem System ihren ausgewählten Port noch nicht verwendet.

Überprüfen, ob auf Ihr Back-End zugegriffen werden kann

Überprüfen Sie nach dem Starten der Anwendung, ob sie ordnungsgemäß ausgeführt wird:

Überprüfen Sie die Konsolenausgabe. Es sollte ähnlich wie in diesem Beispiel sein:

INFO:     Uvicorn running on http://0.0.0.0:5000 (Press CTRL+C to quit)
INFO:     Started reloader process [xxxx]
INFO:     Started server process [xxxx]
INFO:     Waiting for application startup.
INFO:     Application startup complete.

Testen Sie die API-Dokumentation:
1. Öffnen Sie einen Browser, und gehen Sie zu http://localhost:5000/docs.
2. Vergewissern Sie sich, dass auf der Swagger-Benutzeroberfläche alle verfügbaren Endpunkte angezeigt werden.

Schritt 7: Testen der API

Sie können Ihre API testen, indem Sie entweder Curl-Befehle oder die integrierte Swagger-UI verwenden, die FastAPI bereitstellt.

curl

Führen Sie den folgenden Befehl in Ihrem Terminal aus:

curl -X POST "http://localhost:5000/workspaces/test-workspace/items/TestItemType/test-item-123" \
  -H "Content-Type: application/json" \
  -H "activity-id: test-activity-id" \
  -H "request-id: test-request-123" \
  -H "authorization: SubjectAndAppToken1.0 subjectToken=\"dummy-token\", appToken=\"dummy-app-token\"" \
  -H "x-ms-client-tenant-id: test-tenant-456" \
  -d '{
    "display_name": "Test Item",
    "description": "This is a test item created via curl",
    "creation_payload": {
      "key1": "value1",
      "key2": "value2",
      "nested": {
        "data": "example"
      }
    }
  }'

Swagger UI

FastAPI generiert automatisch interaktive API-Dokumentation, sodass Sie Ihre Endpunkte direkt über Ihren Browser testen können:

Öffnen Sie einen Browser, und gehen Sie zu http://localhost:5000/docs.

Suchen Sie im Abschnitt den ItemLifecyclePOST Endpunkt:

POST /workspaces/{workspaceId}/items/{itemType}/{itemId}

Wählen Sie die Schaltfläche "Ausprobieren" aus .
Füllen Sie die erforderlichen Parameter aus:
- workspaceId: test-workspace
- itemType: TestItemType
- itemId: test-item-123
- activity-id: test-activity-id
- request-id: test-request-123
- authorization: SubjectAndAppToken1.0 subjectToken="dummy-token", appToken="dummy-app-token"
- x-ms-client-tenant-id: test-tenant-456
Verwenden Sie für den Anforderungstext den folgenden Code:
```
{
    "display_name": "Test Item",
    "description": "This is a test item created via Swagger UI",
    "creation_payload": {
        "key1": "value1",
        "key2": "value2",
        "nested": {
        "data": "example"
        }
    }
}
```
Wählen Sie die Schaltfläche "Ausführen " aus, um die Anforderung zu senden.

Die Serverkonsole zeigt eine Ausgabe ähnlich der folgenden Meldungen an:
```
=== CREATE ITEM CALLED ===
Workspace ID: test-workspace
Item Type: TestItemType
Item ID: test-item-123
Display Name: Test Item
Description: This is a test item created via Swagger UI
Creation Payload: {'key1': 'value1', 'key2': 'value2', 'nested': {'data': 'example'}}
===========================
```
Die Antwortdetails werden auch direkt in der Benutzeroberfläche von Swagger angezeigt.

Tipp

Die Verwendung der Swagger-UI ist während der Entwicklung oft einfacher und schneller, da sie eine benutzerfreundliche Schnittstelle zum Testen von API-Endpunkten bietet, ohne curl-Befehle manuell zu erstellen.

Schritt 8: Erkunden der API-Dokumentation

FastAPI generiert automatisch interaktive API-Dokumentation:

Öffnen Sie einen Browser, und gehen Sie zu http://localhost:5000/docs.
Auf der angezeigten Benutzeroberfläche von Swagger können Sie alle Endpunkte erkunden und testen.
Um die Endpunkte zum Erstellen, Abrufen, Aktualisieren und Löschen anzuzeigen, wählen Sie den ItemLifecycle Abschnitt aus.

Die folgende Abbildung zeigt ein Beispiel für die Swagger-UI mit den Fabric-API-Endpunkten.

Schritt 9: Implementieren erweiterter Funktionen

Die vorherigen Schritte haben ein grundlegendes Beispiel für die Implementierung der ItemLifecycle API mithilfe von Python mit FastAPI bereitgestellt. Denken Sie daran, dass dieser Artikel ein grundlegendes Beispiel ist, das nur die Kernkonzepte veranschaulicht. Für ein robustes Back-End in Produktionsqualität implementieren Sie in der Regel mehr Funktionalität, z. B.:

Erstellen Sie Dienstklassen zum Verarbeiten von Geschäftslogik, Datenbankvorgängen und anderen Elementen einer Dienstebene:

# src/fabric_api/services/storage_service.py
class StorageService:
    async def create_item(self, workspace_id, item_type, item_id, item_data):
        """
        Store the item in a database or other persistent storage
        """
        # Implementation here
        pass

    async def get_item(self, workspace_id, item_type, item_id):
        """
        Retrieve an item from storage
        """
        # Implementation here
        pass

Verwenden Sie die Abhängigkeitsinjektion in Ihrem Controller:

# src/fabric_api/impl/item_lifecycle_controller.py
from fabric_api.services.storage_service import StorageService

class ItemLifecycleController(BaseItemLifecycleApi):
    def __init__(self):
        self.storage_service = StorageService()

    async def item_lifecycle_create_item(self, workspaceId, ...):
        # Use the service
        await self.storage_service.create_item(workspaceId, itemType, itemId, create_item_request)

Fehlerbehandlung hinzufügen:

async def item_lifecycle_create_item(self, ...):
    try:
        # Your implementation
        await self.storage_service.create_item(...)
        return None
    except ValueError as e:
        # Client error
        raise HTTPException(status_code=400, detail=str(e))
    except Exception as e:
        # Server error
        raise HTTPException(status_code=500, detail="Internal server error")

Hier sind weitere Überlegungen für ein robustes Back-End:

Implementierung der verbleibenden Controller: Implementieren Sie z. B. die Jobs-API und die Endpunktauflösungs-API.
Authentifizierung und Autorisierung: Schützen Sie Ihre Endpunkte, indem Sie Token und Berechtigungen überprüfen. Weitere Informationen finden Sie unter Back-End-Authentifizierung und Autorisierungsübersicht.
Beständiger Speicher: Integration in Datenbanken oder andere Speicherlösungen für die Datenpersistenz.
Protokollierung und Überwachung: Implementieren Sie umfassende Protokollierung und Überwachung, um den Anwendungsstatus und die Leistung zu verfolgen.
Tests: Schreiben sie Komponenten- und Integrationstests, um Zuverlässigkeit und Korrektheit zu gewährleisten.

Schlussfolgerung

Sie richten nun erfolgreich ein Back-End der Microsoft Fabric-Workload-API mithilfe von Python mit FastAPI ein. Diese Implementierung führt Folgendes aus:

Verwendet das OpenAPI-Generator-Tool, um ein FastAPI-Projekt zu erstellen.
Implementiert die erforderlichen Controller für die Verarbeitung von Fabric-API-Anforderungen.

Dieser Artikel ist ein einfaches Beispiel, das veranschaulicht, wie eine API für ItemLifecycle mithilfe von Python implementiert wird. Weitere Verbesserungen und Überlegungen, z. B. die in Schritt 9 beschriebenen: Implementieren erweiterter Funktionen sind erforderlich, um ein qualitativ hochwertiges, robustes und sicheres Back-End zu erstellen, das für eine Produktionsumgebung geeignet ist.

Eine vollständige Integration in Microsoft Fabric erfordert die Implementierung einer ordnungsgemäßen Authentifizierungsbehandlung, beständigen Speicher, umfassende Fehlerbehandlung und benutzerdefinierte Geschäftslogik, die für Ihre Workload spezifisch ist.

Feedback

War diese Seite hilfreich?

Last updated on 2026-04-29