K8s同Pod内请求先经Rego框架B再转发至Java应用A实现方案咨询

因为两个容器处于同一个Kubernetes Pod中，它们可以通过localhost直接通信，最直接的实现方式是让B作为反向代理/请求网关，直接接收Pod的入站请求，完成策略校验后再转发给A。以下是具体实现步骤和细节：

核心思路 #

1. 配置B监听Pod对外暴露的端口（如8080），作为请求的唯一入口。
2. A仅在Pod内部监听另一个端口（如8081），不对外直接暴露。
3. 当请求到达B后，先执行Rego策略校验：
   • 校验通过：将请求完整转发到A的本地端口，再把A的响应返回给客户端。
   • 校验不通过：直接返回403 Forbidden或其他自定义错误响应。

具体配置与代码示例 #

1. Kubernetes Deployment配置 #

确保B的端口被设置为Pod的对外暴露端口，A的端口仅在内部可用：

apiVersion: apps/v1
kind: Deployment
metadata:
  name: combined-app-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: combined-app
  template:
    metadata:
      labels:
        app: combined-app
    spec:
      containers:
      - name: policy-service-b
        image: your-go-rego-image:v1
        ports:
        - containerPort: 8080  # 对外接收请求的端口
        env:
        - name: APP_A_TARGET
          value: "http://localhost:8081"  # A的内部访问地址
      - name: rest-app-a
        image: your-java-rest-image:v1
        ports:
        - containerPort: 8081  # 仅Pod内部可访问

对应的Service需要指向B的端口：

apiVersion: v1
kind: Service
metadata:
  name: combined-app-service
spec:
  selector:
    app: combined-app
  ports:
  - protocol: TCP
    port: 80
    targetPort: 8080  # 指向B的容器端口
  type: ClusterIP  # 根据需求选择NodePort/LoadBalancer

2. Go服务B的代码逻辑 #

在B中扩展反向代理功能，结合Rego策略校验：

package main

import (
	"context"
	"log"
	"net/http"
	"net/http/httputil"
	"net/url"
	"os"

	"github.com/open-policy-agent/opa/rego"
)

func evaluateRegoPolicy(requestData map[string]interface{}) (bool, error) {
	// 加载Rego策略（可替换为文件加载方式）
	policy := `
	package app.auth
	default allow = false
	allow {
		# 替换为你的实际策略逻辑，例如允许特定方法、路径或请求头
		input.method == "GET"
		input.path == "/api/health"
	}
	`

	// 编译并执行规则
	query, err := rego.New(
		rego.Query("data.app.auth.allow"),
		rego.Module("policy.rego", policy),
	).PrepareForEval(nil)
	if err != nil {
		return false, err
	}

	results, err := query.Eval(context.Background(), rego.EvalInput(requestData))
	if err != nil {
		return false, err
	}

	// 解析规则结果
	if len(results) == 0 || !results[0].Expressions[0].Value.(bool) {
		return false, nil
	}
	return true, nil
}

func proxyToA(w http.ResponseWriter, r *http.Request) {
	targetURL, _ := url.Parse(os.Getenv("APP_A_TARGET"))
	proxy := httputil.NewSingleHostReverseProxy(targetURL)

	// 修改请求Host头，避免A端的Host校验问题
	r.Host = targetURL.Host
	// 转发请求并回写响应
	proxy.ServeHTTP(w, r)
}

func main() {
	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
		// 提取请求信息作为Rego输入
		requestInput := map[string]interface{}{
			"method":  r.Method,
			"path":    r.URL.Path,
			"headers": r.Header,
			// 可根据需求添加请求体、查询参数等
		}

		// 执行策略校验
		allowed, err := evaluateRegoPolicy(requestInput)
		if err != nil {
			log.Printf("Policy evaluation error: %v", err)
			http.Error(w, "Internal Server Error", http.StatusInternalServerError)
			return
		}

		if !allowed {
			http.Error(w, "Forbidden by policy", http.StatusForbidden)
			return
		}

		// 转发请求到A
		proxyToA(w, r)
	})

	log.Println("Policy service B starting on port 8080...")
	log.Fatal(http.ListenAndServe(":8080", nil))
}

额外注意事项 #

• 请求完整性：确保B转发请求时完整传递HTTP方法、路径、请求头、请求体等信息，避免丢失关键数据。
• 超时与错误处理：为转发请求添加超时机制，处理A服务不可用的情况，返回合适的错误响应。
• 性能优化：如果请求量较大，可以在B中添加连接池、缓存策略校验结果（若规则允许），提升处理效率。

内容的提问来源于stack exchange，提问作者N Deepak Prasath