Login Demo buchen Demo buchen
Integrations

Integration von DecisionRules mit Azure Functions: Eine Schritt-für-Schritt-Anleitung

Azure Functions bieten eine serverlose Compute-Plattform, die es Ihnen ermöglicht, Code auszuführen, ohne die Infrastruktur verwalten zu müssen. In diesem Leitfaden werden wir die Erstellung einer Azure Function durchgehen, die mit DecisionRules integriert ist, sodass Sie Ihre Geschäftsregeln über eine serverlose API ausführen können.

Integration von DecisionRules mit Azure Functions: Eine Schritt-für-Schritt-Anleitung hero image

Einrichten Ihrer Azure-Funktion

Um zu beginnen, benötigen Sie Visual Studio Code mit der installierten Azure Functions-Erweiterung. So erstellen und deployen Sie Ihre Funktion:

  1. Erstellen Sie ein neues Azure Functions-Projekt in VS Code über die Befehls-Palette (Strg+Shift+P):
    • Wählen Sie "Azure Functions: Neues Projekt erstellen"
    • Wählen Sie JavaScript als Ihre Sprache
    • Wählen Sie HTTP-Trigger als Ihre Vorlage
    • Benennen Sie Ihre Funktion (z.B. "decisionRules")
    • Setzen Sie das Berechtigungsniveau auf "Function"
  2. Sobald Ihr Projekt erstellt ist, müssen Sie die erforderlichen Abhängigkeiten installieren. Öffnen Sie Ihr Terminal und führen Sie aus:
npm install @azure/functions axios

Der Integrationscode

Ihre Azure-Funktion fungiert als Middleware zwischen Ihrer Anwendung und DecisionRules. Die Funktion akzeptiert POST-Anfragen mit Ihrer Regel-ID und Eingabedaten und leitet diese dann an die API von DecisionRules weiter. So sollte Ihr Code aussehen:

const { app } = require('@azure/functions');
const axios = require('axios');

app.http('decisionRules', {
    methods: ['POST'],
    authLevel: 'function',
    handler: async (request, context) => {
        context.log('DecisionRules-Funktion verarbeitet Anfrage.');

        try {
            const body = await request.json();

            // Erforderliche Felder validieren
            if (!body || !body.ruleId) {
                return {
                    status: 400,
                    jsonBody: {
                        error: 'Regel-ID ist erforderlich'
                    }
                };
            }

            // API-Schlüssel aus Umgebungsvariablen abrufen
            const apiKey = process.env.DECISIONRULES_API_KEY;
            if (!apiKey) {
                context.log.error('DecisionRules-API-Schlüssel nicht konfiguriert');
                return {
                    status: 500,
                    jsonBody: {
                        error: 'API-Schlüssel-Konfiguration fehlt'
                    }
                };
            }

            // Anfrage an DecisionRules vorbereiten
            const decisionRulesRequest = {
                method: 'POST',
                url: `https://api.decisionrules.io/rule/solve/${body.ruleId}`,
                headers: {
                    'Authorization': `Bearer ${apiKey}`,
                    'Content-Type': 'application/json'
                },
                data: body.data || {}
            };

            // Optionale Version hinzufügen, falls angegeben
            if (body.version) {
                decisionRulesRequest.headers['X-Version'] = body.version;
            }

            // DecisionRules-API aufrufen
            const response = await axios(decisionRulesRequest);

            // Erfolgreiche Antwort zurückgeben
            return {
                status: 200,
                jsonBody: response.data
            };

        } catch (error) {
            context.log.error('Fehler bei der Ausführung der Entscheidungsregel:', error);

            // Verschiedene Arten von Fehlern behandeln
            if (error.response) {
                // Fehler der DecisionRules-API
                return {
                    status: error.response.status,
                    jsonBody: {
                        error: 'Fehler der DecisionRules-API',
                        details: error.response.data
                    }
                };
            } 
            
            // Allgemeine Fehlermeldung
            return {
                status: 500,
                jsonBody: {
                    error: 'Interner Serverfehler',
                    message: error.message
                }
            };
        }
    }
});

__wf_reserved_inherit

‍

Konfiguration und Bereitstellung

Der wichtigste Teil ist die Sicherung Ihres DecisionRules API-Schlüssels. Fügen Sie ihn als Umgebungsvariable in der Konfiguration Ihrer Azure-Funktion hinzu:

  1. Gehen Sie im Azure-Portal zu Ihrer Function App
  2. Gehen Sie zu Einstellungen > Umgebungsvariablen
  3. Fügen Sie eine neue Anwendungseinstellung hinzu:
    • Name: DECISIONRULES_API_KEY
    • Wert: Ihr DecisionRules API-Schlüssel

__wf_reserved_inherit

Verwendung Ihrer Funktion

Sobald sie bereitgestellt ist, akzeptiert Ihre Funktion POST-Anfragen mit dieser Struktur:

{
    "regelId": "deine-regel-id",
    "daten": {
        // Deine Eingabedaten für die Entscheidungsregel
    }
}

Die Funktion behandelt:

  • Authentifizierung mit DecisionRules
  • Fehlerbehandlung und Validierung
  • Antwortformatierung

Sicherheitsüberlegungen

Die Funktion verwendet die Authentifizierung auf Funktionsebene, was bedeutet, dass jede Anfrage einen Zugriffsschlüssel benötigt. Dieser Schlüssel ist automatisch in der URL Ihrer Funktion enthalten. Stellen Sie sicher, dass Sie:

  • Ihre Funktions-URL und den Schlüssel sicher aufbewahren
  • Ihren DecisionRules-API-Schlüssel in Umgebungsvariablen speichern
  • HTTPS für alle Anfragen verwenden

Dieser serverlose Ansatz bietet mehrere Vorteile:

  • Preisgestaltung nach Ausführung
  • Automatische Skalierung
  • Keine Infrastrukturverwaltung
  • Globale Bereitstellungsoptionen

Mit diesem Setup können Sie nun Ihre DecisionRules-Geschäftsregeln über eine serverlose API ausführen, was die Integration mit anderen Anwendungen und Diensten in Ihrem Ökosystem erleichtert.

David Janata

David Janata

Fullstack-Entwickler