In diesem Beitrag zeige ich Schritt für Schritt, wie sich aus einem SQL Server Integration Services (SSIS) Paket heraus ein Microsoft Fabric Notebook starten lässt.
Das Szenario ist einfach:
Nach einem erfolgreichen Datenupload oder einer sonstigen ETL-Verarbeitung soll in Fabric eine weiterführende Verarbeitung angestoßen werden, beispielsweise Transformationen, Validierungen oder ein Import in ein Lakehouse. Statt diesen Schritt manuell oder zeitgesteuert auszuführen, kann das Notebook direkt aus dem SSIS-Paket heraus per REST API gestartet werden.
Im Folgenden beschreibe ich die notwendigen Schritte und zeige die relevanten Codebestandteile.
Architekturüberblick
Die Lösung besteht aus folgenden Komponenten:
- App-Registrierung (Service Principal) in Azure
- Berechtigung des Service Principals im Fabric-Arbeitsbereich
- Fabric Notebook
- SSIS-Paket mit Script Task
- Authentifizierung per OAuth2 (Client Credentials Flow)
- REST API-Aufruf zum Start des Notebooks
1. App-Registrierung (Service Principal) in Azure
Zunächst wird im Azure-Portal eine App-Registrierung erstellt.
Benötigt werden:
- Client-ID
- Tenant-ID
- Client-Secret
Diese Informationen werden später im SSIS-Paket als Projektparameter hinterlegt.
2. Service Principal im Fabric-Arbeitsbereich berechtigen
Damit das Notebook gestartet werden kann, muss der Service Principal im entsprechenden Fabric-Arbeitsbereich berechtigt werden.
Vorgehen:
- Arbeitsbereich öffnen
- Zugriff verwalten
- Service Principal hinzufügen
- Mindestens „Mitwirkender“ oder entsprechend ausreichende Berechtigung vergeben
3. Notebook-ID und Workspace-ID ermitteln
Für den REST-Aufruf werden zwei IDs benötigt:
- Workspace-ID
- Notebook-ID
Die Workspace-ID findet sich in der URL des Arbeitsbereichs.
Die Notebook-ID kann ebenfalls aus der URL des Notebooks entnommen werden.
Beispielstruktur:
https://app.powerbi.com/groups/<Workspace-ID>/synapsenotebooks/<Notebook-ID>
4. Projektparameter im SSIS-Paket definieren
In Visual Studio (SSDT) werden zunächst Projektparameter angelegt:
ClientIdTenantIdClientSecret
Diese enthalten die Informationen aus der App-Registrierung.
Zusätzlich werden auf Paketebene Variablen definiert:
WorkspaceIdNotebookId
5. Script Task konfigurieren
Im Control Flow wird ein Script Task eingefügt.
Dort müssen die Projektparameter und Paketvariablen als ReadOnlyVariables eingebunden werden.
6. Benötigte Namespaces hinzufügen
Im Script-Editor müssen folgende Namespaces ergänzt werden:
#region Namespaces
using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Web.Script.Serialization;
using STT = System.Threading.Tasks; // Alias for System.Threading.Tasks
#endregion
Zusätzlich müssen die entsprechenden Referenzen eingebunden werden:
- System.Net.Http
- System.Web
- System.Web.Extensions
7. Access Token abrufen (Client Credentials Flow)
Zunächst wird ein Access Token vom Microsoft Identity Platform Endpoint angefordert.
Methode zum Abrufen des Tokens
/// <summary>
/// Get an access token for the Fabric API via client credentials flow.
/// Scope: https://api.fabric.microsoft.com/.default
/// </summary>
private static async STT.Task<string> GetAccessTokenAsync(
string tenantId,
string clientId,
string clientSecret)
{
string url = $"https://login.microsoftonline.com/{tenantId}/oauth2/v2.0/token";
using (var client = new HttpClient())
{
var body = new FormUrlEncodedContent(new[]
{
new KeyValuePair<string,string>("client_id", clientId),
new KeyValuePair<string,string>("client_secret", clientSecret),
new KeyValuePair<string,string>("grant_type", "client_credentials"),
new KeyValuePair<string,string>("scope", "https://api.fabric.microsoft.com/.default")
});
var response = await client.PostAsync(url, body);
var json = await response.Content.ReadAsStringAsync();
if (!response.IsSuccessStatusCode)
{
throw new ApplicationException(
$"Token Request failed: {(int)response.StatusCode} {response.ReasonPhrase}\r\n" +
$"Body: {json}");
}
var serializer = new JavaScriptSerializer();
var dict = serializer.Deserialize<Dictionary<string, object>>(json);
if (!dict.ContainsKey("access_token"))
throw new ApplicationException("Token Response enth�lt kein access_token.");
return dict["access_token"].ToString();
}
}
8. Notebook per REST API starten
Sobald das Access Token vorliegt, kann das Notebook gestartet werden.
Methode zum Starten des Notebooks
/// <summary>
/// Call up the notebook in Fabric via the job scheduler.
/// POST https://api.fabric.microsoft.com/v1/workspaces/{workspaceId}/items/{artifactId}/jobs/instances?jobType=RunNotebook
/// Body: { "executionData": {} }
/// </summary>
private static async STT.Task RunNotebookJobAsync(
string accessToken,
string workspaceId,
string artifactId)
{
string url = $"https://api.fabric.microsoft.com/v1/workspaces/{workspaceId}/items/{artifactId}/jobs/instances?jobType=RunNotebook";
using (var client = new HttpClient())
{
client.DefaultRequestHeaders.Authorization =
new AuthenticationHeaderValue("Bearer", accessToken);
string jsonBody = "{\"executionData\": {}}";
using (var content = new StringContent(jsonBody, Encoding.UTF8, "application/json"))
{
var response = await client.PostAsync(url, content);
var responseBody = await response.Content.ReadAsStringAsync();
if (!response.IsSuccessStatusCode)
{
throw new ApplicationException(
$"Fabric API-Call failed: {(int)response.StatusCode} {response.ReasonPhrase}\r\n" +
$"Response: {responseBody}");
}
}
}
}
9. Main-Methode im Script Task
In der Main()-Methode werden die SSIS-Variablen ausgelesen und die oben definierten Methoden aufgerufen:
/// <summary>
/// This method is called when this script task executes in the control flow.
/// Before returning from this method, set the value of Dts.TaskResult to indicate success or failure.
/// To open Help, press F1.
/// </summary>
public void Main()
{
try
{
string tenantId = (string)Dts.Variables["$Project::TenantId"].Value;
string clientId = (string)Dts.Variables["$Project::ClientId"].Value;
string clientSecret = (string)Dts.Variables["$Project::ClientSecret"].GetSensitiveValue();
string workspaceId = (string)Dts.Variables["User::WorkspaceId"].Value;
string notebookItemId = (string)Dts.Variables["User::NotebookItemId"].Value;
string accessToken = GetAccessTokenAsync(
tenantId, clientId, clientSecret
).GetAwaiter().GetResult();
RunNotebookJobAsync(
accessToken, workspaceId, notebookItemId
).GetAwaiter().GetResult();
Dts.TaskResult = (int)ScriptResults.Success;
}
catch (Exception ex)
{
Dts.Events.FireError(
0,
"RunFabricNotebook",
ex.ToString(),
string.Empty,
0);
Dts.TaskResult = (int)ScriptResults.Failure;
}
}
10. Ablauf testen
Wird das SSIS-Paket nun ausgeführt, sollte im Fabric-Arbeitsbereich unter „Letzte Ausführungen“ ein neuer Notebook-Run erscheinen.
Hinweise zur Praxis
- Secrets sollten nicht ungeschützt im Projekt gespeichert werden.
- In produktiven Umgebungen empfiehlt sich eine sichere Ablage (z. B. Azure Key Vault).
- Fehlerbehandlung kann erweitert werden (Logging der Response-Inhalte).
- Der Rückgabestatus des Notebook-Jobs kann zusätzlich abgefragt werden, falls eine synchrone Verarbeitung notwendig ist.
Fazit
Mit diesem Ansatz lässt sich ein Fabric Notebook sauber in bestehende SSIS-Prozesse integrieren. Der Aufruf erfolgt standardisiert über die REST API, authentifiziert per Service Principal.
Damit wird es möglich, klassische Integration-Services-Prozesse mit Fabric-Workloads zu kombinieren, ohne manuelle Zwischenschritte.
Bei Bedarf lässt sich das Muster erweitern, etwa um:
- Übergabe von Parametern an das Notebook
- Polling auf den Jobstatus
- Integration in komplexere Orchestrierungen
Der technische Kern bleibt jedoch derselbe. Token beschaffen, REST-Endpunkt aufrufen, Notebook-Job starten.
