Prozess deployen

Mit dem ProcessDefinitionsClient können BPMN-Diagramme in die ProcessCube® Engine hochgeladen und deployed werden.

UploadProcessDefinitionAsync()

Deployed ein BPMN-Diagramm aus einem XML-String:


using ProcessCube.Engine;
 
var engineAddress = "http://localhost:8000";
var client = ClientFactory.CreateProcessDefinitionsClient(engineAddress);
 
// BPMN-XML aus Datei laden
var bpmnXml = await File.ReadAllTextAsync("OrderProcess.bpmn");
 
// Prozess deployen
await client.UploadProcessDefinitionAsync(
    bpmnXml,
    overwriteExisting: true
);
 
Console.WriteLine("Prozess erfolgreich deployed");

Der Parameter overwriteExisting bestimmt, ob ein bereits existierender Prozess mit derselben ID überschrieben werden soll.

Parameter

Parameter	Typ	Beschreibung
`xml`	`string`	BPMN 2.0 XML-Inhalt
`overwriteExisting`	`bool`	Überschreibt existierenden Prozess (optional, default: `false`)

Einzelnen Prozess deployen


using ProcessCube.Engine;
 
var engineAddress = "http://localhost:8000";
var client = ClientFactory.CreateProcessDefinitionsClient(engineAddress);
 
try
{
    // BPMN-Datei laden
    var bpmnPath = "processes/OrderProcess.bpmn";
    var bpmnXml = await File.ReadAllTextAsync(bpmnPath);
 
    Console.WriteLine($"Deploying: {bpmnPath}");
 
    // Deployen mit Überschreiben
    await client.UploadProcessDefinitionAsync(
        bpmnXml,
        overwriteExisting: true
    );
 
    Console.WriteLine("✓ Prozess erfolgreich deployed");
}
catch (FileNotFoundException)
{
    Console.WriteLine("BPMN-Datei nicht gefunden");
}
catch (Exception ex)
{
    Console.WriteLine($"Deployment fehlgeschlagen: {ex.Message}");
}

Mehrere Prozesse deployen


using ProcessCube.Engine;
using System.IO;
 
var engineAddress = "http://localhost:8000";
var client = ClientFactory.CreateProcessDefinitionsClient(engineAddress);
 
// Alle BPMN-Dateien in einem Verzeichnis finden
var processDirectory = "processes";
var bpmnFiles = Directory.GetFiles(processDirectory, "*.bpmn");
 
Console.WriteLine($"Gefunden: {bpmnFiles.Length} BPMN-Dateien");
 
var successCount = 0;
var failCount = 0;
 
foreach (var bpmnFile in bpmnFiles)
{
    try
    {
        var bpmnXml = await File.ReadAllTextAsync(bpmnFile);
        var fileName = Path.GetFileName(bpmnFile);
 
        Console.WriteLine($"Deploying: {fileName}...");
 
        await client.UploadProcessDefinitionAsync(
            bpmnXml,
            overwriteExisting: true
        );
 
        Console.WriteLine($"  ✓ {fileName} deployed");
        successCount++;
    }
    catch (Exception ex)
    {
        Console.WriteLine($"  ✗ {Path.GetFileName(bpmnFile)}: {ex.Message}");
        failCount++;
    }
}
 
Console.WriteLine();
Console.WriteLine($"Deployment abgeschlossen:");
Console.WriteLine($"  Erfolgreich: {successCount}");
Console.WriteLine($"  Fehlgeschlagen: {failCount}");

BPMN-XML direkt erstellen

Für einfache Prozesse kann das BPMN-XML auch direkt im Code erstellt werden:


using ProcessCube.Engine;
 
var engineAddress = "http://localhost:8000";
var client = ClientFactory.CreateProcessDefinitionsClient(engineAddress);
 
// Einfaches BPMN-XML
var bpmnXml = @"<?xml version=""1.0"" encoding=""UTF-8""?>
<bpmn:definitions
    xmlns:bpmn=""http://www.omg.org/spec/BPMN/20100524/MODEL""
    xmlns:bpmndi=""http://www.omg.org/spec/BPMN/20100524/DI""
    xmlns:dc=""http://www.omg.org/spec/DD/20100524/DC""
    id=""Definitions_1""
    targetNamespace=""http://processcube.io/schema/1.0"">
 
  <bpmn:process id=""SimpleProcess"" name=""Simple Process"" isExecutable=""true"">
    <bpmn:startEvent id=""StartEvent_1"" name=""Start"">
      <bpmn:outgoing>Flow_1</bpmn:outgoing>
    </bpmn:startEvent>
 
    <bpmn:endEvent id=""EndEvent_1"" name=""End"">
      <bpmn:incoming>Flow_1</bpmn:incoming>
    </bpmn:endEvent>
 
    <bpmn:sequenceFlow id=""Flow_1"" sourceRef=""StartEvent_1"" targetRef=""EndEvent_1"" />
  </bpmn:process>
 
</bpmn:definitions>";
 
// Deployen
await client.UploadProcessDefinitionAsync(bpmnXml, overwriteExisting: true);
 
Console.WriteLine("SimpleProcess deployed");

Für komplexe Prozesse sollten Sie einen BPMN-Editor wie das ProcessCube® Studio verwenden, anstatt BPMN-XML manuell zu erstellen.

Deploy und sofort starten


using ProcessCube.Engine;
 
var engineAddress = "http://localhost:8000";
var client = ClientFactory.CreateProcessDefinitionsClient(engineAddress);
 
// 1. BPMN laden und deployen
var bpmnXml = await File.ReadAllTextAsync("PaymentProcess.bpmn");
 
await client.UploadProcessDefinitionAsync(
    bpmnXml,
    overwriteExisting: true
);
 
Console.WriteLine("Prozess deployed");
 
// 2. Direkt nach dem Deployment starten
var payload = new PaymentPayload(
    PaymentId: "PAY-789",
    Amount: 250.00m,
    Currency: "EUR"
);
 
var response = await client.StartProcessInstanceAsync(
    processModelId: "PaymentProcess",
    startEventId: "StartEvent_1",
    initialToken: payload
);
 
Console.WriteLine($"Prozess gestartet: {response.ProcessInstanceId}");
 
// Payload-Definition
internal sealed record PaymentPayload(
    string PaymentId,
    decimal Amount,
    string Currency
);

Deployment validieren

Prüfen Sie nach dem Deployment, ob der Prozess verfügbar ist:


using ProcessCube.Engine;
 
var engineAddress = "http://localhost:8000";
var client = ClientFactory.CreateProcessDefinitionsClient(engineAddress);
 
var processModelId = "OrderProcess";
 
// 1. BPMN laden und deployen
var bpmnXml = await File.ReadAllTextAsync($"{processModelId}.bpmn");
 
await client.UploadProcessDefinitionAsync(
    bpmnXml,
    overwriteExisting: true
);
 
Console.WriteLine($"{processModelId} deployed");
 
// 2. Validierung - Prozess in Liste suchen
var processes = await client.GetProcessModelsAsync();
var deployedProcess = processes.FirstOrDefault(p => p.Id == processModelId);
 
if (deployedProcess != null)
{
    Console.WriteLine($"✓ Deployment validiert");
    Console.WriteLine($"  Name: {deployedProcess.Name}");
    Console.WriteLine($"  Version: {deployedProcess.Version}");
    Console.WriteLine($"  Start-Events: {deployedProcess.StartEvents.Count}");
}
else
{
    Console.WriteLine($"✗ Prozess '{processModelId}' nicht in Engine gefunden");
}

Mit Authentifizierung

Wenn die Engine mit Authority gesichert ist:


using ProcessCube.Engine;
using ProcessCube.Engine.Client.Identity;
 
// Identity Provider erstellen
var identityProvider = new ClientCredentialsIdentityProvider(
    authorityAddress: "http://localhost:11235",
    clientId: "deployment-service",
    clientSecret: "secret-key",
    scope: "engine_write"
);
 
// Token abrufen
var identity = await identityProvider.GetIdentityAsync();
 
// Client mit Identity erstellen
var client = ClientFactory.CreateProcessDefinitionsClient(
    engineAddress: "http://localhost:8000",
    identity: identity
);
 
// BPMN laden und deployen (authentifiziert)
var bpmnXml = await File.ReadAllTextAsync("OrderProcess.bpmn");
 
await client.UploadProcessDefinitionAsync(
    bpmnXml,
    overwriteExisting: true
);
 
Console.WriteLine("Authenticated deployment successful");

Für Deployments benötigen Sie den Scope engine_write in Ihrem Access Token.

Deployment-Pipeline

Beispiel für eine automatisierte Deployment-Pipeline:


using ProcessCube.Engine;
using ProcessCube.Engine.Client.Identity;
 
public class ProcessDeploymentService
{
    private readonly IProcessDefinitionsClient _client;
 
    public ProcessDeploymentService(string engineAddress, string authorityAddress)
    {
        // Mit Authentifizierung
        var identityProvider = new ClientCredentialsIdentityProvider(
            authorityAddress: authorityAddress,
            clientId: Environment.GetEnvironmentVariable("PROCESSCUBE_CLIENT_ID"),
            clientSecret: Environment.GetEnvironmentVariable("PROCESSCUBE_CLIENT_SECRET"),
            scope: "engine_write engine_read"
        );
 
        var identity = identityProvider.GetIdentityAsync().Result;
 
        _client = ClientFactory.CreateProcessDefinitionsClient(
            engineAddress,
            identity
        );
    }
 
    public async Task<DeploymentResult> DeployProcessAsync(
        string bpmnFilePath,
        bool overwrite = true)
    {
        var result = new DeploymentResult
        {
            FileName = Path.GetFileName(bpmnFilePath),
            StartTime = DateTime.UtcNow
        };
 
        try
        {
            // BPMN laden
            var bpmnXml = await File.ReadAllTextAsync(bpmnFilePath);
 
            // Deployen
            await _client.UploadProcessDefinitionAsync(
                bpmnXml,
                overwriteExisting: overwrite
            );
 
            // Validieren
            var processes = await _client.GetProcessModelsAsync();
            var deployed = processes.FirstOrDefault(p =>
                p.Xml.Contains(bpmnXml.Substring(0, 100))
            );
 
            result.Success = deployed != null;
            result.ProcessModelId = deployed?.Id;
            result.Version = deployed?.Version;
        }
        catch (Exception ex)
        {
            result.Success = false;
            result.ErrorMessage = ex.Message;
        }
        finally
        {
            result.EndTime = DateTime.UtcNow;
            result.Duration = result.EndTime - result.StartTime;
        }
 
        return result;
    }
 
    public async Task<List<DeploymentResult>> DeployDirectoryAsync(
        string directoryPath)
    {
        var results = new List<DeploymentResult>();
        var bpmnFiles = Directory.GetFiles(directoryPath, "*.bpmn");
 
        foreach (var bpmnFile in bpmnFiles)
        {
            var result = await DeployProcessAsync(bpmnFile);
            results.Add(result);
 
            var status = result.Success ? "✓" : "✗";
            Console.WriteLine($"{status} {result.FileName} ({result.Duration.TotalSeconds:F2}s)");
 
            if (!result.Success)
            {
                Console.WriteLine($"  Error: {result.ErrorMessage}");
            }
        }
 
        return results;
    }
}
 
public class DeploymentResult
{
    public string FileName { get; set; }
    public bool Success { get; set; }
    public string? ProcessModelId { get; set; }
    public string? Version { get; set; }
    public string? ErrorMessage { get; set; }
    public DateTime StartTime { get; set; }
    public DateTime EndTime { get; set; }
    public TimeSpan Duration { get; set; }
}
 
// Verwendung
var service = new ProcessDeploymentService(
    "http://localhost:8000",
    "http://localhost:11235"
);
 
var results = await service.DeployDirectoryAsync("./processes");
 
Console.WriteLine($"\nDeployment Summary:");
Console.WriteLine($"  Success: {results.Count(r => r.Success)}");
Console.WriteLine($"  Failed: {results.Count(r => !r.Success)}");

Fehlerbehandlung


using ProcessCube.Engine;
using ProcessCube.Engine.Client.Exceptions;
 
var engineAddress = "http://localhost:8000";
var client = ClientFactory.CreateProcessDefinitionsClient(engineAddress);
 
try
{
    var bpmnXml = await File.ReadAllTextAsync("OrderProcess.bpmn");
 
    await client.UploadProcessDefinitionAsync(
        bpmnXml,
        overwriteExisting: true
    );
 
    Console.WriteLine("Deployment erfolgreich");
}
catch (EngineClientException ex) when (ex.StatusCode == 400)
{
    Console.WriteLine("Ungültiges BPMN-XML");
    Console.WriteLine($"Details: {ex.Message}");
}
catch (EngineClientException ex) when (ex.StatusCode == 401)
{
    Console.WriteLine("Nicht authentifiziert");
}
catch (EngineClientException ex) when (ex.StatusCode == 403)
{
    Console.WriteLine("Fehlende Berechtigung für Deployment");
}
catch (EngineClientException ex) when (ex.StatusCode == 409)
{
    Console.WriteLine("Prozess existiert bereits (overwriteExisting: false)");
}
catch (FileNotFoundException ex)
{
    Console.WriteLine($"BPMN-Datei nicht gefunden: {ex.FileName}");
}
catch (HttpRequestException ex)
{
    Console.WriteLine($"Verbindungsfehler: {ex.Message}");
}
catch (Exception ex)
{
    Console.WriteLine($"Unerwarteter Fehler: {ex.Message}");
}

Best Practice: Validieren Sie BPMN-XML vor dem Deployment mit einem XML-Schema-Validator, um Fehler frühzeitig zu erkennen.

Nächste Schritte

Prozess starten - Deployed Prozesse ausführen
Prozesse auflisten - Deployment validieren
Prozess-Verwaltung - Zurück zur Übersicht