OpenShift Serverless Adoption Guide

        # 创建 Operator 所需的 namespace、OperatorGroup 和 Subscription
        
        cat <<EOF | oc apply -f -
        apiVersion: v1
        kind: Namespace
        metadata:
          name: openshift-serverless
        ---
        apiVersion: operators.coreos.com/v1
        kind: OperatorGroup
        metadata:
          name: serverless-operators
          namespace: openshift-serverless
        spec: {}
        ---
        apiVersion: operators.coreos.com/v1alpha1
        kind: Subscription
        metadata:
          name: serverless-operator
          namespace: openshift-serverless
        spec:
          channel: stable
          installPlanApproval: Automatic
          name: serverless-operator
          source: redhat-operators
          sourceNamespace: openshift-marketplace
        EOF
        
        # 验证 Operator 安装完成（约 60 秒）
        
        oc get csv -n openshift-serverless
        
        # 预期输出: serverless-operator.v1.37.1 ... Succeeded

cat <<EOF | oc apply -f -
        apiVersion: operator.knative.dev/v1beta1
        kind: KnativeServing
        metadata:
          name: knative-serving
          namespace: knative-serving
        spec:
          ingress:
            kourier:
              enabled: true
          config:
            network:
              ingress-class: kourier.ingress.networking.knative.dev
            autoscaler:
              enable-scale-to-zero: "true"
              scale-to-zero-grace-period: "30s"
              stable-window: "60s"
            defaults:
              revision-timeout-seconds: "300"
        EOF
        
        # 等待就绪（约 50 秒）
        
        oc wait --for=condition=Ready knativeserving/knative-serving \
          -n knative-serving --timeout=300s

cat <<EOF | oc apply -f -
        apiVersion: operator.knative.dev/v1beta1
        kind: KnativeEventing
        metadata:
          name: knative-eventing
          namespace: knative-eventing
        spec:
          config:
            default-ch-webhook:
              default-ch-config: |
                clusterDefault:
                  apiVersion: messaging.knative.dev/v1
                  kind: InMemoryChannel
        EOF
        
        # 等待就绪（约 90 秒）
        
        oc wait --for=condition=Ready knativeeventing/knative-eventing \
          -n knative-eventing --timeout=300s

        # 创建支持自动扩缩和 Spot 实例的专用机器池
        
        rosa create machinepool \
          --cluster=<cluster-name> \
          --name=serverless-pool \
          --instance-type=m6a.xlarge \
          --min-replicas=0 \
          --max-replicas=10 \
          --enable-autoscaling \
          --labels="node-role.kubernetes.io/serverless=" \
          --taints="serverless=true:NoSchedule" \
          --use-spot-instances \
          --spot-max-price=on-demand
        
        # 验证机器池
        
        rosa list machinepools --cluster=<cluster-name>

apiVersion: serving.knative.dev/v1
        kind: Service
        metadata:
          name: my-function
          namespace: my-project
        spec:
          template:
            spec:
              tolerations:
                - key: "serverless"
                  operator: "Equal"
                  value: "true"
                  effect: "NoSchedule"
              nodeSelector:
                node-role.kubernetes.io/serverless: ""
              containers:
                - image: <registry>/<project>/my-function:latest
                  resources:
                    requests:
                      cpu: 100m
                      memory: 128Mi
                    limits:
                      cpu: 500m
                      memory: 256Mi

import json
        import time
        import os
        import platform
        
        COLD_START = True
        
        def lambda_handler(event, context):
            global COLD_START
            was_cold = COLD_START
            COLD_START = False
            
            name = "World"
            qs = event.get("queryStringParameters") or {}
            if isinstance(qs, dict) and qs.get("name"):
                name = qs["name"]
            
            return {
                "statusCode": 200,
                "headers": {"Content-Type": "application/json"},
                "body": json.dumps({
                    "message": f"Hello, {name}!",
                    "platform": "AWS Lambda",
                    "cold_start": was_cold
                })
            }

from flask import Flask, request, jsonify
        import os
        import time
        import platform
        
        app = Flask(__name__)
        COLD_START = True
        
        @app.route("/", methods=["GET", "POST"])
        def handler():
            global COLD_START
            was_cold = COLD_START
            COLD_START = False
            
            if request.method == "POST":
                event = request.get_json(silent=True) or {}
                name = event.get("name", "World")
            else:
                name = request.args.get("name", "World")
            
            return jsonify({
                "message": f"Hello, {name}!",
                "platform": "OpenShift Serverless (Knative)",
                "cold_start": was_cold,
                "pod_name": os.environ.get("HOSTNAME", "unknown")
            })
        
        if __name__ == "__main__":
            port = int(os.environ.get("PORT", 8080))
            app.run(host="0.0.0.0", port=port)

FROM registry.access.redhat.com/ubi9/python-311:latest
        WORKDIR /app
        COPY requirements.txt .
        RUN pip install --no-cache-dir -r requirements.txt
        COPY app.py .
        EXPOSE 8080
        CMD ["python", "app.py"]

apiVersion: serving.knative.dev/v1
        kind: Service
        metadata:
          name: hello-function
          namespace: serverless-demo
          labels:
            app.kubernetes.io/part-of: serverless-functions
        spec:
          template:
            metadata:
              annotations:
                autoscaling.knative.dev/min-scale: "0"        # 空闲时缩零
                autoscaling.knative.dev/max-scale: "10"        # 最大 pod 数
                autoscaling.knative.dev/target: "50"           # 每 pod 50 并发
                autoscaling.knative.dev/scale-down-delay: "15s"
            spec:
              containerConcurrency: 50
              timeoutSeconds: 300
              containers:
                - image: <registry>/hello-function:latest
                  ports:
                    - containerPort: 8080
                  resources:
                    requests:
                      cpu: 100m
                      memory: 128Mi
                    limits:
                      cpu: 500m
                      memory: 256Mi
                  readinessProbe:
                    httpGet:
                      path: /
                    initialDelaySeconds: 0

        # 实测输出
        
        $ oc get ksvc -n serverless-demo
        NAME             URL                                                                                     LATESTCREATED          LATESTREADY            READY
        hello-function   https://hello-function-serverless-demo.apps.rosa.rosa-fhmhp.r63a.p3.openshiftapps.com   hello-function-00001   hello-function-00001   True
        
        # 热请求测试
        
        $ time curl -sk "https://hello-function-serverless-demo.apps.rosa.rosa-fhmhp.r63a.p3.openshiftapps.com"
        Hi  greeter => '9861675f8845' : 5
        real    0m0.030s
        
        $ time curl -sk "https://hello-function-serverless-demo.apps.rosa.rosa-fhmhp.r63a.p3.openshiftapps.com"
        Hi  greeter => '9861675f8845' : 6
        real    0m0.029s
        
        # 验证 Scale-to-Zero（等待约 120 秒后）
        
        $ oc get pods -n serverless-demo
        No resources found in serverless-demo namespace.    ← Pod 已被移除
        
        $ oc get revisions -n serverless-demo
        NAME                   CONFIG NAME      GENERATION   READY   ACTUAL REPLICAS   DESIRED REPLICAS
        hello-function-00001   hello-function   1            True    0                 0
        
        # ✅ Scale-to-Zero 验证成功：ACTUAL REPLICAS = 0
        
        # 冷启动测试（从零扩容）
        
        $ time curl -sk "https://hello-function-serverless-demo.apps.rosa.rosa-fhmhp.r63a.p3.openshiftapps.com"
        Hi  greeter => '9861675f8845' : 3
        real    0m1.668s    ← 冷启动 ~1.67s
        
        $ time curl -sk "https://hello-function-serverless-demo.apps.rosa.rosa-fhmhp.r63a.p3.openshiftapps.com"
        Hi  greeter => '9861675f8845' : 4
        real    0m0.030s    ← 热请求恢复到 ~30ms

        # 安装 kn CLI（OpenShift Serverless 1.37 配套版本）
        
        $ curl -sL https://mirror.openshift.com/pub/openshift-v4/clients/serverless/1.17.0/kn-linux-amd64.tar.gz \
          | tar xz -C /tmp/
        $ /tmp/kn version
        Version:      v1.17.0
        Build Date:   2025-04-22 16:39:02
        
        # 创建 Python 函数项目（自动生成骨架代码）
        
        $ /tmp/kn func create -l python hello-func
        Created python function in /tmp/hello-func
        
        $ ls /tmp/hello-func/
        .funcignore  func.yaml  function/  requirements.txt
        
        # 注意：没有 Dockerfile！使用 S2I (Source-to-Image) 自动构建

        # function/func.py — ASGI 协议，与 Lambda handler 等价
        
        import json, os, time
        
        COLD_START = True
        
        def new():
            return Function()
        
        class Function:
            async def handle(self, scope, receive, send):
                global COLD_START
                was_cold = COLD_START
                COLD_START = False
                start = time.time()
        
                # 读取请求 body
                body = b""
                while True:
                    msg = await receive()
                    body += msg.get("body", b"")
                    if not msg.get("more_body"): break
        
                # 解析参数（支持 query string 和 JSON body）
                name = "World"
                qs = scope.get("query_string", b"").decode()
                for param in qs.split("&"):
                    if param.startswith("name="): name = param.split("=", 1)[1]; break
                if body:
                    try: data = json.loads(body); name = data.get("name", name)
                    except: pass
        
                # 构建响应
                elapsed = (time.time() - start) * 1000
                resp = json.dumps({
                    "message": f"Hello, {name}!",
                    "platform": "OpenShift Serverless Function (kn func)",
                    "cold_start": was_cold,
                    "processing_time_ms": round(elapsed, 2),
                    "pod_name": os.environ.get("HOSTNAME", "unknown")
                })
        
                await send({"type": "http.response.start", "status": 200,
                             "headers": [[b"content-type", b"application/json"]]})
                await send({"type": "http.response.body", "body": resp.encode()})

        # 暴露 OpenShift 内部镜像仓库
        
        $ oc patch configs.imageregistry.operator.openshift.io/cluster --type merge \
          -p '{"spec":{"defaultRoute":true}}'
        
        $ REGISTRY_HOST=$(oc get route default-route -n openshift-image-registry -o jsonpath='{.spec.host}')
        
        # 构建镜像（S2I 自动构建，无需 Dockerfile！）
        
        $ cd /tmp/hello-func
        $ /tmp/kn func build -r "$REGISTRY_HOST/serverless-demo" -v
        🙌 Function built: default-route-openshift-image-registry.apps.rosa.rosa-fhmhp.r63a.p3.openshiftapps.com/serverless-demo/hello-func:latest
        
        # 推送镜像到内部 Registry
        
        $ TOKEN=$(oc whoami -t)
        $ podman login "$REGISTRY_HOST" -u kubeadmin -p "$TOKEN" --tls-verify=false
        Login Succeeded!
        
        $ podman push "$REGISTRY_HOST/serverless-demo/hello-func:latest" --tls-verify=false
        Writing manifest to image destination
        
        # 部署为 Knative Service（使用集群内部 registry 地址）
        
        $ /tmp/kn service create hello-func \
          --image image-registry.openshift-image-registry.svc:5000/serverless-demo/hello-func:latest \
          -n serverless-demo \
          --annotation autoscaling.knative.dev/min-scale=0 \
          --annotation autoscaling.knative.dev/max-scale=10
        Creating service 'hello-func' in namespace 'serverless-demo':
         12.036s Ready to serve.
        
        Service 'hello-func' created to latest revision 'hello-func-00001' is available at URL:
        https://hello-func-serverless-demo.apps.rosa.rosa-fhmhp.r63a.p3.openshiftapps.com

        # 创建 Dockerfile（等价于 S2I 自动生成的构建逻辑）
        
        cat > /tmp/hello-func/Dockerfile <<'DOCKERFILE'
        FROM registry.access.redhat.com/ubi9/python-312:latest
        WORKDIR /opt/app-root/src
        COPY requirements.txt .
        RUN pip install --no-cache-dir -r requirements.txt
        COPY function/ ./function/
        COPY main.py .
        EXPOSE 8080
        CMD ["python", "main.py"]
        DOCKERFILE
        
        # 创建入口文件 main.py（与 S2I 内部生成的入口一致）
        
        cat > /tmp/hello-func/main.py <<'MAIN'
        import logging
        from func_python.http import serve
        logging.basicConfig(level=logging.INFO)
        try:
            from function import new as handler
        except ImportError:
            from function import handle as handler
        if __name__ == "__main__":
            logging.info("Functions middleware invoking user function")
            serve(handler)
        MAIN
        
        # 确保 function/__init__.py 导出正确
        
        cat > /tmp/hello-func/function/__init__.py <<'INIT'
        from .func import new
        INIT
        
        # 使用 podman 构建镜像
        
        $ cd /tmp/hello-func
        $ podman build -t "$REGISTRY_HOST/serverless-demo/hello-func:dockerfile" .
        STEP 1/7: FROM registry.access.redhat.com/ubi9/python-312:latest
        STEP 2/7: WORKDIR /opt/app-root/src
        STEP 3/7: COPY requirements.txt .
        STEP 4/7: RUN pip install --no-cache-dir -r requirements.txt
        Successfully installed ...
        STEP 5/7: COPY function/ ./function/
        STEP 6/7: COPY main.py .
        STEP 7/7: EXPOSE 8080
        COMMIT default-route-openshift-image-registry.apps.rosa.rosa-fhmhp.r63a.p3.openshiftapps.com/serverless-demo/hello-func:dockerfile
        Successfully tagged ...
        
        # 推送 & 部署
        
        $ podman push "$REGISTRY_HOST/serverless-demo/hello-func:dockerfile" --tls-verify=false
        Writing manifest to image destination
        
        $ /tmp/kn service create hello-func \
          --image image-registry.openshift-image-registry.svc:5000/serverless-demo/hello-func:dockerfile \
          -n serverless-demo --force \
          --annotation autoscaling.knative.dev/min-scale=0 \
          --annotation autoscaling.knative.dev/max-scale=10
        Service 'hello-func' created to latest revision 'hello-func-00001' is available at URL:
        https://hello-func-serverless-demo.apps.rosa.rosa-fhmhp.r63a.p3.openshiftapps.com
        
        # 验证（性能与 S2I 版完全一致）
        
        $ time curl -sk "$FUNC_URL?name=Demo"
        {"message": "Hello, Demo!", "platform": "OpenShift Serverless Function (Dockerfile)",
         "cold_start": true, "processing_time_ms": 0.01,
         "pod_name": "hello-func-00001-deployment-5cf64484f9-vxbl8"}
        real    0m0.031s
        
        $ time curl -sk "$FUNC_URL?name=Dockerfile"
        {"message": "Hello, Dockerfile!", "platform": "OpenShift Serverless Function (Dockerfile)",
         "cold_start": false, "processing_time_ms": 0.01, ...}
        real    0m0.026s

        # 方法一：手动添加 label（适用于已部署的 Service）
        
        $ oc label ksvc hello-func \
          function.knative.dev=true \
          function.knative.dev/name=hello-func \
          boson.dev/function=true \
          -n serverless-demo
        service.serving.knative.dev/hello-func labeled
        
        # 验证 label
        
        $ oc get ksvc hello-func -n serverless-demo -o jsonpath='{.metadata.labels}' | jq .
        {
          "boson.dev/function": "true",
          "function.knative.dev": "true",
          "function.knative.dev/name": "hello-func"
        }
        
        # ✅ 刷新 Web Console → Serverless → Functions，即可看到 hello-func

FUNC_URL="https://hello-func-serverless-demo.apps.rosa.rosa-fhmhp.r63a.p3.openshiftapps.com"
        
        # GET 请求
        
        $ time curl -sk "$FUNC_URL?name=Demo"
        {"message": "Hello, Demo!", "platform": "OpenShift Serverless Function (kn func)",
         "cold_start": true, "processing_time_ms": 0.01,
         "pod_name": "hello-func-00001-deployment-5c4c9b46c9-5s4mc"}
        real    0m0.038s
        
        # 热请求
        
        $ time curl -sk "$FUNC_URL?name=OpenShift"
        {"message": "Hello, OpenShift!", "platform": "OpenShift Serverless Function (kn func)",
         "cold_start": false, "processing_time_ms": 0.01, ...}
        real    0m0.031s
        
        # POST 请求（JSON body）
        
        $ time curl -sk -X POST "$FUNC_URL" -H "Content-Type: application/json" \
          -d '{"name":"KnativeFunction"}'
        {"message": "Hello, KnativeFunction!", "platform": "OpenShift Serverless Function (kn func)",
         "cold_start": false, "processing_time_ms": 0.03, ...}
        real    0m0.030s

apiVersion: tekton.dev/v1
        kind: Pipeline
        metadata:
          name: serverless-function-pipeline
          namespace: serverless-cicd
        spec:
          params:
            - name: git-url
              type: string
            - name: git-revision
              type: string
              default: main
            - name: function-name
              type: string
            - name: image-registry
              type: string
              default: quay.io/my-org
            - name: target-namespace
              type: string
              default: serverless-demo
          workspaces:
            - name: shared-workspace
            - name: docker-credentials
          tasks:
            - name: fetch-source
              taskRef:
                name: git-clone
                kind: ClusterTask
              workspaces:
                - name: output
                  workspace: shared-workspace
              params:
                - name: url
                  value: $(params.git-url)
                - name: revision
                  value: $(params.git-revision)
            - name: build-image
              taskRef:
                name: buildah
                kind: ClusterTask
              runAfter: [fetch-source]
              workspaces:
                - name: source
                  workspace: shared-workspace
                - name: dockerconfig
                  workspace: docker-credentials
              params:
                - name: IMAGE
                  value: "$(params.image-registry)/$(params.function-name):$(params.git-revision)"
            - name: deploy-knative-service
              taskRef:
                name: openshift-client
                kind: ClusterTask
              runAfter: [build-image]
              params:
                - name: SCRIPT
                  value: |
                    oc apply -f knative-service.yaml -n $(params.target-namespace)

        # 替代: AWS EventBridge rule → Lambda (cron)
        
        apiVersion: sources.knative.dev/v1
        kind: PingSource
        metadata:
          name: daily-report-trigger
          namespace: serverless-demo
        spec:
          schedule: "0 2 * * *"          # 每天凌晨 2 点
          contentType: "application/json"
          data: '{"action": "generate-daily-report"}'
          sink:
            ref:
              apiVersion: serving.knative.dev/v1
              kind: Service
              name: daily-report-function

apiVersion: sources.knative.dev/v1beta1
        kind: KafkaSource
        metadata:
          name: order-events
          namespace: serverless-demo
        spec:
          consumerGroup: order-consumer
          bootstrapServers:
            - kafka-cluster-kafka-bootstrap.amq-streams:9092
          topics:
            - orders
          sink:
            ref:
              apiVersion: serving.knative.dev/v1
              kind: Service
              name: order-processor

        # 为关键函数设置 PodDisruptionBudget
        
        apiVersion: policy/v1
        kind: PodDisruptionBudget
        metadata:
          name: critical-function-pdb
          namespace: serverless-demo
        spec:
          minAvailable: 1
          selector:
            matchLabels:
              serving.knative.dev/service: order-processor

        # overlays/aro-prod/patches/registry-override.yaml
        
        apiVersion: serving.knative.dev/v1
        kind: Service
        metadata:
          name: FUNCTION_NAME
        spec:
          template:
            spec:
              containers:
                - name: user-container
                  image: myregistry.azurecr.io/serverless/FUNCTION_NAME:TAG
        
        # 其他所有配置（tolerations, nodeSelector, autoscaling,
        
        # env vars, resource limits）保持完全相同。

        # 安装 OpenShift Serverless Logic Operator (GA 版本)
        
        # 注意: 选择 logic-operator (GA, stable channel) 而非 logic-operator-rhel8 (Alpha)
        
        cat <<EOF | oc apply -f -
        apiVersion: v1
        kind: Namespace
        metadata:
          name: openshift-serverless-logic
        ---
        apiVersion: operators.coreos.com/v1
        kind: OperatorGroup
        metadata:
          name: logic-operators
          namespace: openshift-serverless-logic
        spec: {}
        ---
        apiVersion: operators.coreos.com/v1alpha1
        kind: Subscription
        metadata:
          name: logic-operator
          namespace: openshift-serverless-logic
        spec:
          channel: stable
          installPlanApproval: Automatic
          name: logic-operator
          source: redhat-operators
          sourceNamespace: openshift-marketplace
        EOF
        
        # 验证安装（约 60 秒）
        
        oc get csv -n openshift-serverless-logic
        
        # 预期: logic-operator.v1.37.2 ... Succeeded

cat <<EOF | oc apply -f -
        apiVersion: sonataflow.org/v1alpha08
        kind: SonataFlowPlatform
        metadata:
          name: sonataflow-platform
          namespace: serverless-demo
        spec:
          build:
            config:
              strategyOptions:
                KanikoBuildCacheEnabled: "true"
          devMode: {}
        EOF

        # 使用 CNCF Serverless Workflow 规范定义多步骤工作流
        
        apiVersion: sonataflow.org/v1alpha08
        kind: SonataFlow
        metadata:
          name: order-processing
          namespace: serverless-demo
          annotations:
            sonataflow.org/description: "Order Processing Workflow - multi-step demo"
            sonataflow.org/version: "1.0.0"
            sonataflow.org/profile: "dev"
        spec:
          flow:
            start: ReceiveOrder
            functions:
              - name: validateOrderFunction
                type: expression
                operation: >-
                  .order | if .items != null and (.items | length) > 0 and .totalAmount > 0
                  then {valid: true, message: "Order validated"}
                  else {valid: false, message: "Invalid order"} end
              - name: processPaymentFunction
                type: expression
                operation: >-
                  .order | {paymentId: "PAY-" + (.orderId // "unknown"),
                  status: "approved", method: .paymentMethod, amount: .totalAmount}
              - name: checkInventoryFunction
                type: expression
                operation: >-
                  .order.items | map({itemId: .id, name: .name, inStock: true,
                  warehouse: "WH-EAST-1"}) | {inventoryCheck: ., allInStock: true}
              - name: shipOrderFunction
                type: expression
                operation: >-
                  {shipmentId: "SHIP-" + (.order.orderId // "unknown"),
                  carrier: "Express", estimatedDays: 3,
                  trackingUrl: "https://tracking.example.com/SHIP-" + (.order.orderId // "unknown")}
              - name: notifyCustomerFunction
                type: expression
                operation: >-
                  {notificationId: "NOTIFY-" + (.order.orderId // "unknown"),
                  channel: "email", recipient: .order.customerEmail,
                  status: "sent", message: "Your order has been shipped!"}
            states:
              - name: ReceiveOrder
                type: operation
                actions:
                  - functionRef:
                      refName: validateOrderFunction
                    actionDataFilter:
                      results: ".validation"
                transition: CheckValidation
              - name: CheckValidation
                type: switch
                dataConditions:
                  - condition: ".validation.valid == true"
                    transition: ProcessPayment
                  - condition: ".validation.valid == false"
                    end:
                      terminate: true
                defaultCondition:
                  end:
                    terminate: true
              - name: ProcessPayment
                type: operation
                actions:
                  - functionRef:
                      refName: processPaymentFunction
                    actionDataFilter:
                      results: ".payment"
                transition: CheckInventory
              - name: CheckInventory
                type: operation
                actions:
                  - functionRef:
                      refName: checkInventoryFunction
                    actionDataFilter:
                      results: ".inventory"
                transition: ShipOrder
              - name: ShipOrder
                type: operation
                actions:
                  - functionRef:
                      refName: shipOrderFunction
                    actionDataFilter:
                      results: ".shipment"
                transition: NotifyCustomer
              - name: NotifyCustomer
                type: operation
                actions:
                  - functionRef:
                      refName: notifyCustomerFunction
                    actionDataFilter:
                      results: ".notification"
                end:
                  terminate: true

        # 实测输出
        
        $ oc get sonataflow -n serverless-demo
        NAME               PROFILE   VERSION   URL                                                                                                        READY   REASON
        order-processing   dev       1.0.0     https://order-processing-serverless-demo.apps.rosa.rosa-fhmhp.r63a.p3.openshiftapps.com/order-processing   True
        
        $ oc get pods -n serverless-demo -l app=order-processing
        NAME                               READY   STATUS    RESTARTS   AGE
        order-processing-fbf46f984-8wsfm   1/1     Running   0          115s
        
        # 测试工作流 — 提交订单
        
        SONATA_URL="https://order-processing-serverless-demo.apps.rosa.rosa-fhmhp.r63a.p3.openshiftapps.com/order-processing"
        
        $ time curl -sk -X POST "$SONATA_URL" \
          -H "Content-Type: application/json" \
          -d '{"workflowdata":{"order":{"orderId":"ORD-001","customerEmail":"user@example.com",
               "paymentMethod":"credit_card","totalAmount":199.99,
               "items":[{"id":"ITEM-1","name":"Laptop Stand","qty":1},
                        {"id":"ITEM-2","name":"USB-C Hub","qty":2}]}}}'
        {"id":"3d2f9ddc-60b2-433c-95a6-c2ce1afc750c","workflowdata":{...}}
        real    0m0.288s    ← 首次请求
        
        # 热请求
        
        $ time curl -sk -X POST "$SONATA_URL" \
          -H "Content-Type: application/json" \
          -d '{"workflowdata":{"order":{"orderId":"ORD-002","customerEmail":"test@example.com",
               "paymentMethod":"debit","totalAmount":50.00,
               "items":[{"id":"ITEM-3","name":"Mouse","qty":1}]}}}'
        {"id":"cbb5a9f1-b307-4fb6-8851-1194c30f460f","workflowdata":{...}}
        real    0m0.110s    ← 热请求 ~110ms
        
        # Dev 工具 URL（自动生成）
        
        # SwaggerUI: https://order-processing-serverless-demo.apps.rosa.rosa-fhmhp.r63a.p3.openshiftapps.com/q/swagger-ui
        
        # DevUI:     https://order-processing-serverless-demo.apps.rosa.rosa-fhmhp.r63a.p3.openshiftapps.com/q/dev-ui

        # 关键监控指标（通过 OpenShift Monitoring / Prometheus 获取）
        
        # 1. 每个函数的请求延迟 (P95)
        
        histogram_quantile(0.95,
          sum(rate(revision_request_latencies_bucket[5m])) by (le, service_name))
        
        # 2. 每个函数的请求数
        
        sum(rate(revision_request_count[5m])) by (service_name)
        
        # 3. 活跃 pod 数量（验证 scale-to-zero 是否工作）
        
        sum(autoscaler_actual_pods) by (service_name)
        
        # 4. 冷启动延迟 (P95)
        
        histogram_quantile(0.95,
          sum(rate(activator_request_latencies_bucket{cold_start="true"}[5m])) by (le))

        # 列出所有 Knative Services
        
        $ oc get ksvc -n serverless-demo
        NAME             URL                                                                                     LATESTCREATED          LATESTREADY            READY
        hello-function   https://hello-function-serverless-demo.apps.rosa.rosa-fhmhp.r63a.p3.openshiftapps.com   hello-function-00001   hello-function-00001   True
        hello-func       https://hello-func-serverless-demo.apps.rosa.rosa-fhmhp.r63a.p3.openshiftapps.com       hello-func-00001       hello-func-00001       True
        
        # 查看 Revisions（版本历史）
        
        $ oc get revisions -n serverless-demo
        NAME                   CONFIG NAME      GENERATION   READY   ACTUAL REPLICAS   DESIRED REPLICAS
        hello-function-00001   hello-function   1            True    0                 0
        hello-func-00001       hello-func       1            True    1                 1
        
        # 查看所有 Serverless 资源概览
        
        $ oc get ksvc,revisions,pingsource,sonataflow -n serverless-demo
        NAME                                        URL                    LATESTCREATED          READY
        service.serving.knative.dev/hello-function   https://hello-func...  hello-function-00001   True
        service.serving.knative.dev/hello-func       https://hello-func...  hello-func-00001       True
        
        NAME                                              CONFIG NAME      READY   ACTUAL REPLICAS
        revision.serving.knative.dev/hello-function-00001  hello-function   True    0
        revision.serving.knative.dev/hello-func-00001      hello-func       True    1
        
        NAME                                        SINK                     SCHEDULE      READY
        pingsource.sources.knative.dev/demo-ping    http://hello-function... */1 * * * *   True
        
        NAME                                     PROFILE   VERSION   READY
        sonataflow.sonataflow.org/order-processing dev      1.0.0     True
        
        # 更新函数（创建新 revision）
        
        oc set image ksvc/hello-function \
          user-container=<registry>/hello-function:v2 \
          -n serverless-demo
        
        # 金丝雀发布（90/10 流量分割）
        
        oc patch ksvc hello-function -n serverless-demo --type merge -p '
        spec:
          traffic:
            - revisionName: hello-function-00001
              percent: 90
            - revisionName: hello-function-00002
              percent: 10
        '
        
        # 回滚到之前的 revision
        
        oc patch ksvc hello-function -n serverless-demo --type merge -p '
        spec:
          traffic:
            - revisionName: hello-function-00001
              percent: 100
        '
        
        # 强制预热（避免冷启动）
        
        oc annotate ksvc hello-function \
          autoscaling.knative.dev/min-scale=1 \
          -n serverless-demo --overwrite

        # 检查 Knative Serving 组件状态
        
        $ oc get knativeserving -n knative-serving
        NAME              VERSION   READY   REASON
        knative-serving   1.17      True
        
        # 检查 Serverless 基础组件 pod 状态
        
        $ oc get pods -n knative-serving
        NAME                                      READY   STATUS    AGE
        activator-76c876897-74jlb                 2/2     Running   4h
        autoscaler-5cf6d5d889-nrf8w               2/2     Running   4h
        controller-656bffbb85-kqbnk               2/2     Running   4h
        webhook-5fd78f67b4-qs5fk                  2/2     Running   4h
        ...
        
        # 检查 Ingress Gateway
        
        $ oc get pods -n knative-serving-ingress
        NAME                                      READY   STATUS    AGE
        3scale-kourier-gateway-7cf56975cd-qg6zp   1/1     Running   4h
        net-kourier-controller-7bfd97bb65-7bkpl   1/1     Running   4h
        
        # 查看函数的事件（排查启动问题）
        
        $ oc get events -n serverless-demo --sort-by='.lastTimestamp' | tail -10
        
        # 查看 Knative Service 的 conditions
        
        $ oc get ksvc hello-func -n serverless-demo -o jsonpath='{range .status.conditions[*]}{.type}={.status} {.message}{"\n"}{end}'
        ConfigurationsReady=True
        Ready=True
        RoutesReady=True