feat: enhance WAF deployment with private backend access, update ingress configurations, and improve deployment documentation

Author: Abdul-Microsoft

App/frontend-app/src/components/documentViewer/iFrameComponent.tsx

@@ -36,7 +36,7 @@ export function IFrameComponent({ className, metadata, urlWithSasToken, iframeKe
                 );
             }
             case "application/pdf": {
-                const url = new URL(urlWithSasToken);
+                const url = new URL(urlWithSasToken, window.location.origin);
                 url.searchParams.append("embed", "True");
 
                 return <iframe title="PDF Viewer" key={iframeKey} src={url.toString()} width="100%" height="100%" />;

App/frontend-app/vite.config.ts

@@ -1,19 +1,35 @@
-import { defineConfig } from "vite";
+import { defineConfig, loadEnv } from "vite";
 import react from "@vitejs/plugin-react";
 import postcss from "./postcss.config.js";
 
-export default defineConfig({
-    plugins: [react()],
-    css: {
-        postcss,
-    },
-    server: {
-        watch: {
-            usePolling: true,
+export default defineConfig(({ mode }) => {
+    const env = loadEnv(mode, process.cwd(), '');
+    const backendTarget = env.BACKEND_PROXY_TARGET || 'http://aiservice-service:80';
+
+    return {
+        plugins: [react()],
+        css: {
+            postcss,
+        },
+        server: {
+            watch: {
+                usePolling: true,
+            },
+            host: true,
+            strictPort: true,
+            port: 5900,
+            allowedHosts: true,
+            proxy: {
+                '/backend': {
+                    target: backendTarget,
+                    changeOrigin: true,
+                    rewrite: (path: string) => path.replace(/^\/backend/, ''),
+                },
+                '/api': {
+                    target: backendTarget,
+                    changeOrigin: true,
+                },
+            },
         },
-        host: true,
-        strictPort: true,
-        port : 5900,
-        allowedHosts: true
-    }
+    };
 });

Deployment/kubernetes/deploy.ingress.internal.yaml.template

@@ -24,13 +24,6 @@ spec:
   - host: {{ fqdn }}
     http:
       paths:
-      - path: /backend(/|$)(.*)
-        pathType: Prefix
-        backend:
-          service:
-            name: aiservice-service
-            port:
-              number: 9001
       - path: /()(.*)
         pathType: Prefix
         backend:

Deployment/kubernetes/deploy.ingress.waf.yaml.template

@@ -1,7 +1,7 @@
 # NetworkPolicy to restrict backend services (aiservice, kernelmemory) to only
-# accept traffic from within the cluster — frontend pods and internal ingress.
-# This ensures backend APIs are not directly accessible from the public internet
-# when WAF deployment mode is enabled.
+# accept traffic from authorized pods within the cluster.
+# Frontend (frontapp) and aiservice can reach backend; external traffic is blocked.
+# Applied automatically in WAF deployment mode.
 ---
 apiVersion: networking.k8s.io/v1
 kind: NetworkPolicy
@@ -19,16 +19,18 @@ spec:
   policyTypes:
   - Ingress
   ingress:
-  # Allow traffic from frontend pods in the same namespace
+  # Allow traffic from frontend pods (Vite proxy forwards API calls to aiservice)
   - from:
     - podSelector:
         matchLabels:
           app: frontapp
+  # Allow traffic from aiservice to kernelmemory (inter-service communication)
+  - from:
+    - podSelector:
+        matchLabels:
+          app: aiservice
   # Allow traffic from ingress controller namespace (app-routing-system)
   - from:
     - namespaceSelector:
         matchLabels:
           kubernetes.io/metadata.name: app-routing-system
-  # Allow traffic from within the ns-km namespace (inter-service communication)
-  - from:
-    - podSelector: {}

Deployment/kubernetes/deploy.networkpolicy.yaml.template

@@ -964,8 +964,16 @@ try {
     # Front App
     ###############################
 
-    $frontAppConfigServicePlaceholders = @{
-        '{{ backend-fqdn }}' = "https://${fqdn}/backend"
+    # WAF mode: use relative path so browser calls go through frontend Vite proxy (backend stays private)
+    # Standard mode: use absolute URL (backend is on public ingress)
+    if ($isWafDeployment) {
+        $frontAppConfigServicePlaceholders = @{
+            '{{ backend-fqdn }}' = "/backend"
+        }
+    } else {
+        $frontAppConfigServicePlaceholders = @{
+            '{{ backend-fqdn }}' = "https://${fqdn}/backend"
+        }
     }
 
     ## Load and update the front app configuration template
@@ -1025,19 +1033,17 @@ try {
     kubectl apply -f "./kubernetes/deploy.service.yaml" -n $kubenamespace
 
     # 5.5. Deploy Ingress Controller in Kubernetes for external access
-    kubectl apply -f "./kubernetes/deploy.ingress.yaml" -n $kubenamespace
-
-    # 5.6. WAF Mode: Deploy internal backend ingress and network policies
     if ($isWafDeployment) {
-        Write-Host "Applying WAF-specific configurations: internal backend ingress and network policies..." -ForegroundColor Cyan
-
-        # Deploy internal ingress for backend services (no public exposure)
-        kubectl apply -f "./kubernetes/deploy.ingress.internal.yaml.template" -n $kubenamespace
+        # WAF mode: use WAF ingress (no public backend route — backend traffic proxied through frontend)
+        Write-Host "Applying WAF-specific ingress (backend is private, proxied through frontend)..." -ForegroundColor Cyan
+        kubectl apply -f "./kubernetes/deploy.ingress.yaml" -n $kubenamespace
 
-        # Deploy network policies to restrict backend traffic to internal only
+        # Deploy network policies to restrict direct backend pod access
         kubectl apply -f "./kubernetes/deploy.networkpolicy.yaml.template" -n $kubenamespace
-
-        Write-Host "WAF network policies and internal backend ingress applied successfully." -ForegroundColor Green
+        Write-Host "WAF ingress and network policies applied successfully." -ForegroundColor Green
+    } else {
+        # Standard mode: public ingress with backend route
+        kubectl apply -f "./kubernetes/deploy.ingress.yaml" -n $kubenamespace
     }
 
     # #####################################################################

Deployment/resourcedeployment.ps1

@@ -150,19 +150,24 @@ azd env set AZURE_ENV_VM_ADMIN_PASSWORD <your-password>
 
 When deploying with WAF configuration (`enablePrivateNetworking: true`), the following security measures are applied:
 
-- **AKS Private Cluster**: The AKS API server is configured as a private cluster, not accessible from the public internet.
-- **Frontend-Only Public Ingress**: Only the frontend web application is exposed publicly through the WAF/Application Gateway ingress. The `/backend` API route is removed from the public ingress.
-- **Internal Backend Ingress**: Backend API services (`aiservice`, `kernelmemory`) are accessible only through an internal ingress that is not exposed to the public internet.
-- **Kubernetes Network Policies**: NetworkPolicy resources enforce traffic isolation — backend pods only accept traffic from frontend pods and the internal ingress controller within the cluster.
+- **Public Ingress (Frontend Only)**: Only the frontend web application is exposed through the public nginx ingress. **No backend API routes are on the public ingress** — backend services are completely private.
+- **Server-Side Proxy**: The frontend container (Vite) acts as a reverse proxy. Browser API calls to `/backend` are intercepted by the frontend server and forwarded internally to the backend service via ClusterIP DNS — the request never leaves the cluster.
+- **ClusterIP Services**: Backend services (`aiservice`, `kernelmemory`) use ClusterIP services for internal communication only. They have no public IP or external load balancer.
+- **Kubernetes Network Policies**: NetworkPolicy resources enforce traffic isolation — backend pods only accept traffic from frontend pods and the ingress controller within the cluster.
 - **Private Endpoints**: All Azure PaaS services (Cosmos DB, Storage, Search, OpenAI, etc.) use private endpoints and are not accessible from the public internet.
 
 **Traffic Flow (WAF mode):**
 ```
-Internet → WAF/Application Gateway → Public Ingress → Frontend (frontapp)
-                                                         ↓ (internal)
-                                                   Backend (aiservice) → Azure PaaS (via Private Endpoints)
-                                                         ↓ (internal)
-                                                   Kernel Memory Service → Azure PaaS (via Private Endpoints)
+Internet → Public Ingress (nginx) → / → Frontend (frontapp:5900)
+                                              ↓
+                                    Vite Proxy (server-side)
+                                    /backend → aiservice (ClusterIP, internal only)
+                                    /api     → aiservice (ClusterIP, internal only)
+                                                   ↓
+                                             Azure PaaS (via Private Endpoints)
+
+Backend API from internet → NOT ROUTABLE (no public ingress route exists)
+Direct access to backend pods → BLOCKED by NetworkPolicy
 ```
 
 ### 3.4 Advanced Configuration (Optional)