Kyma/Kubernetes mit ABAP Cloud: Cloud-Native Extensions entwickeln

apiVersion: apps/v1
kind: Deployment
metadata:
  name: sales-extension-backend
  namespace: sales-extension
  labels:
    app: sales-extension
    component: backend
spec:
  replicas: 2
  selector:
    matchLabels:
      app: sales-extension
      component: backend
  template:
    metadata:
      labels:
        app: sales-extension
        component: backend
    spec:
      containers:
        - name: backend
          image: myregistry.io/sales-extension:1.0.0
          ports:
            - containerPort: 8080
          env:
            - name: ABAP_CLOUD_URL
              valueFrom:
                secretKeyRef:
                  name: abap-destination
                  key: url
            - name: NODE_ENV
              value: "production"
          resources:
            requests:
              memory: "256Mi"
              cpu: "100m"
            limits:
              memory: "512Mi"
              cpu: "500m"
          livenessProbe:
            httpGet:
              path: /health
              port: 8080
            initialDelaySeconds: 30
            periodSeconds: 10
          readinessProbe:
            httpGet:
              path: /ready
              port: 8080
            initialDelaySeconds: 5
            periodSeconds: 5

apiVersion: v1
kind: Service
metadata:
  name: sales-extension-backend
  namespace: sales-extension
spec:
  selector:
    app: sales-extension
    component: backend
  ports:
    - port: 8080
      targetPort: 8080
  type: ClusterIP
---
# api-rule.yaml
apiVersion: gateway.kyma-project.io/v1beta1
kind: APIRule
metadata:
  name: sales-extension-api
  namespace: sales-extension
spec:
  gateway: kyma-gateway.kyma-system.svc.cluster.local
  host: sales-extension.c-abc123.kyma.ondemand.com
  service:
    name: sales-extension-backend
    port: 8080
  rules:
    - path: /.*
      methods: ["GET", "POST", "PUT", "DELETE"]
      accessStrategies:
        - handler: jwt
          config:
            jwks_urls:
              - https://mysubaccount.authentication.eu10.hana.ondemand.com/token_keys
            trusted_issuers:
              - https://mysubaccount.authentication.eu10.hana.ondemand.com/oauth/token

apiVersion: services.cloud.sap.com/v1
kind: ServiceBinding
metadata:
  name: abap-destination-binding
  namespace: sales-extension
spec:
  serviceInstanceName: destination-instance
  secretName: abap-destination
  parameters:
    # Destination im BTP Cockpit muss existieren
    destinationName: "ABAP_CLOUD_BACKEND"

const axios = require('axios');

class AbapCloudClient {
  constructor() {
    // Credentials aus Kubernetes Secret (Environment Variables)
    this.baseUrl = process.env.ABAP_CLOUD_URL;
    this.clientId = process.env.ABAP_CLIENT_ID;
    this.clientSecret = process.env.ABAP_CLIENT_SECRET;
    this.tokenUrl = process.env.ABAP_TOKEN_URL;
    this.accessToken = null;
    this.tokenExpiry = null;
  }

  async getAccessToken() {
    // Token cachen bis kurz vor Ablauf
    if (this.accessToken && this.tokenExpiry > Date.now() + 60000) {
      return this.accessToken;
    }

    const response = await axios.post(this.tokenUrl,
      'grant_type=client_credentials', {
        headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
        auth: {
          username: this.clientId,
          password: this.clientSecret
        }
      });

    this.accessToken = response.data.access_token;
    this.tokenExpiry = Date.now() + (response.data.expires_in * 1000);
    return this.accessToken;
  }

  async getSalesOrders(filter = '') {
    const token = await this.getAccessToken();
    const url = `${this.baseUrl}/sap/opu/odata4/sap/zsalesorder/srvd/sap/zsalesorder/0001/SalesOrder`;

    const response = await axios.get(url, {
      headers: {
        'Authorization': `Bearer ${token}`,
        'Accept': 'application/json'
      },
      params: { '$filter': filter }
    });

    return response.data.value;
  }

  async createSalesOrder(orderData) {
    const token = await this.getAccessToken();
    const url = `${this.baseUrl}/sap/opu/odata4/sap/zsalesorder/srvd/sap/zsalesorder/0001/SalesOrder`;

    const response = await axios.post(url, orderData, {
      headers: {
        'Authorization': `Bearer ${token}`,
        'Content-Type': 'application/json'
      }
    });

    return response.data;
  }
}

module.exports = AbapCloudClient;

apiVersion: serverless.kyma-project.io/v1alpha2
kind: Function
metadata:
  name: order-created-handler
  namespace: sales-extension
spec:
  runtime: nodejs18
  source:
    inline:
      source: |
        const axios = require('axios');

        module.exports = {
          main: async function (event, context) {
            console.log('Received event:', JSON.stringify(event.data));

            // Event-Daten aus CloudEvents-Format extrahieren
            const orderData = event.data;
            const orderId = orderData.SalesOrderId;
            const customerId = orderData.CustomerId;

            // Externe API benachrichtigen (z.B. CRM-System)
            try {
              await axios.post('https://crm-api.example.com/orders', {
                sapOrderId: orderId,
                customerId: customerId,
                status: 'CREATED'
              });

              return { statusCode: 200, body: 'Notification sent' };
            } catch (error) {
              console.error('CRM notification failed:', error.message);
              return { statusCode: 500, body: error.message };
            }
          }
        };
      dependencies: |
        {
          "dependencies": {
            "axios": "^1.6.0"
          }
        }
  subscriptions:
    - name: order-events
      source: sap.s4.beh.salesorder.v1.SalesOrder.Created.v1
      typeMatching: exact

const express = require('express');
const AbapCloudClient = require('./abap-client');
const MLPredictor = require('./ml-predictor');

const app = express();
const abapClient = new AbapCloudClient();
const mlPredictor = new MLPredictor();

app.get('/api/discount/:customerId', async (req, res) => {
  try {
    const { customerId } = req.params;
    const { orderValue } = req.query;

    // 1. Kundendaten aus ABAP Cloud abrufen
    const customer = await abapClient.getCustomer(customerId);

    // 2. ML-Modell für Rabattvorhersage aufrufen
    const predictedDiscount = await mlPredictor.predict({
      customerTier: customer.CustomerTier,
      totalRevenue: customer.TotalRevenue,
      ordersCount: customer.OrdersCount,
      orderValue: parseFloat(orderValue)
    });

    // 3. Ergebnis zurückgeben
    res.json({
      customerId: customerId,
      customerName: customer.CustomerName,
      suggestedDiscount: predictedDiscount,
      maxDiscount: getMaxDiscount(customer.CustomerTier)
    });
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

function getMaxDiscount(tier) {
  const limits = { 'GOLD': 25, 'SILVER': 15, 'BRONZE': 10 };
  return limits[tier] || 5;
}

app.listen(8080);