*作者：應健健，新華智雲端計算中心*

> OpenYurt 是業界首個非侵入的邊緣計算雲原生開源專案，透過邊緣自治，雲邊協同，邊緣單元化，邊緣流量閉環等能力為使用者提供雲邊一體化的使用體驗。在 Openyurt 裡邊緣網路可以使用資料過濾框架在不同節點池裡實現邊緣流量閉環能力。

## Yurthub 資料過濾框架解析

Yurthub 本質上是一層 kube-apiserver 的代理，在代理的基礎上加了一層 cache，一來保證邊緣節點離線的情況下可以使用本地 cache 保證業務穩定性,有效的解決了邊緣自治的問題。二來可以降低大量的 list & watch 操作對雲上 api 產生一定的負載。

Yurthub 的資料過濾透過節點上的 pod 以及 kubelet 的請求透過 Load Balancer 傳送給 kube-apiserver，代理接收到響應訊息進行資料過濾處理，之後再將過濾後的資料返回給請求方。如果節點是邊緣節點會根據請求型別對響應請求體中的資源進行本地快取，如果是雲端節點考慮到網路狀態良好不進行本地快取。

Yurthub 的過濾框架實現原理圖：

![](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/29b943747bd643bb819a053b19a33573~tplv-k3u1fbpfcp-zoom-1.image)

Yurthub 目前包含四種過濾規則，透過 addons 請求的 user-agent，resource，verb 判斷經過那個過濾器進行相應的資料過濾。

## 四種過濾規則功能及實現

### ServiceTopologyFilter

主要針對 EndpointSlice 資源進行資料過濾, 但 Endpoint Slice 特性需要在 Kubernetes v1.18 或以上版本才能支援，如果在 1.18 版本以下建議使用 endpointsFilter 過濾器。當經過該過濾器首先透過 kubernetes.io/service-name 找到 endpointSlice 資源所對應的 services 資源，之後判斷 servces 資源是否存在 openyurt.io/topologyKeys 這個 Annotations，如果存在那麼透過這個 Annotations 的值判斷資料過濾規則，最後更新 response data 返回給 addons。

Annotations 的值分為兩大類：

1、kubernetes.io/hostname:只過濾出相同節點的 endpoint ip

2、openyurt.io/nodepool 或者 kubernetes.io/zone: 透過這個 Annotations 獲取對應節點池，最後遍歷 endpointSlice 資源，透過 endpointSlice 裡的 topology 欄位中的 kubernetes.io/hostname 欄位在 endpointSlice 物件裡找到對應的 Endpoints，之後重組 endpointSlice 裡的 Endpoints 後返回給 addons。

程式碼實現：

```
func (fh *serviceTopologyFilterHandler) reassembleEndpointSlice(endpointSlice *discovery.EndpointSlice) *discovery.EndpointSlice {
   var serviceTopologyType string
   // get the service Topology type
   if svcName, ok := endpointSlice.Labels[discovery.LabelServiceName]; ok {
      svc, err := fh.serviceLister.Services(endpointSlice.Namespace).Get(svcName)
      if err != nil {
         klog.Infof("skip reassemble endpointSlice, failed to get service %s/%s, err: %v", endpointSlice.Namespace, svcName, err)
         return endpointSlice
      }
 
      if serviceTopologyType, ok = svc.Annotations[AnnotationServiceTopologyKey]; !ok {
         klog.Infof("skip reassemble endpointSlice, service %s/%s has no annotation %s", endpointSlice.Namespace, svcName, AnnotationServiceTopologyKey)
         return endpointSlice
      }
   }
 
   var newEps []discovery.Endpoint
   // if type of service Topology is 'kubernetes.io/hostname'
   // filter the endpoint just on the local host
   if serviceTopologyType == AnnotationServiceTopologyValueNode {
      for i := range endpointSlice.Endpoints {
         if endpointSlice.Endpoints[i].Topology[v1.LabelHostname] == fh.nodeName {
            newEps = append(newEps, endpointSlice.Endpoints[i])
         }
      }
      endpointSlice.Endpoints = newEps
   } else if serviceTopologyType == AnnotationServiceTopologyValueNodePool || serviceTopologyType == AnnotationServiceTopologyValueZone {
      // if type of service Topology is openyurt.io/nodepool
      // filter the endpoint just on the node which is in the same nodepool with current node
      currentNode, err := fh.nodeGetter(fh.nodeName)
      if err != nil {
         klog.Infof("skip reassemble endpointSlice, failed to get current node %s, err: %v", fh.nodeName, err)
         return endpointSlice
      }
      if nodePoolName, ok := currentNode.Labels[nodepoolv1alpha1.LabelCurrentNodePool]; ok {
         nodePool, err := fh.nodePoolLister.Get(nodePoolName)
         if err != nil {
            klog.Infof("skip reassemble endpointSlice, failed to get nodepool %s, err: %v", nodePoolName, err)
            return endpointSlice
         }
         for i := range endpointSlice.Endpoints {
            if inSameNodePool(endpointSlice.Endpoints[i].Topology[v1.LabelHostname], nodePool.Status.Nodes) {
               newEps = append(newEps, endpointSlice.Endpoints[i])
            }
         }
         endpointSlice.Endpoints = newEps
      }
   }
   return endpointSlice
}
```

### EndpointsFilter

針對 endpoints 資源進行相應的資料過濾，首先判斷 endpoint 是否存在對應的 service，透過 node 的 label: apps.openyurt.io/nodepool 獲取節點池，之後獲取節點池下的所有節點，遍歷 endpoints.Subsets 下的資源找出同一個節點池的 Ready pod address 以及 NotReady pod address 重組成新的 endpoints 之後返回給 addons。

```
func (fh *endpointsFilterHandler) reassembleEndpoint(endpoints *v1.Endpoints) *v1.Endpoints {
   svcName := endpoints.Name
   _, err := fh.serviceLister.Services(endpoints.Namespace).Get(svcName)
   if err != nil {
      klog.Infof("skip reassemble endpoints, failed to get service %s/%s, err: %v", endpoints.Namespace, svcName, err)
      return endpoints
   }
   // filter the endpoints on the node which is in the same nodepool with current node
   currentNode, err := fh.nodeGetter(fh.nodeName)
   if err != nil {
      klog.Infof("skip reassemble endpoints, failed to get current node %s, err: %v", fh.nodeName, err)
      return endpoints
   }
   if nodePoolName, ok := currentNode.Labels[nodepoolv1alpha1.LabelCurrentNodePool]; ok {
      nodePool, err := fh.nodePoolLister.Get(nodePoolName)
      if err != nil {
         klog.Infof("skip reassemble endpoints, failed to get nodepool %s, err: %v", nodePoolName, err)
         return endpoints
      }
      var newEpSubsets []v1.EndpointSubset
      for i := range endpoints.Subsets {
         endpoints.Subsets[i].Addresses = filterValidEndpointsAddr(endpoints.Subsets[i].Addresses, nodePool)
         endpoints.Subsets[i].NotReadyAddresses = filterValidEndpointsAddr(endpoints.Subsets[i].NotReadyAddresses, nodePool)
         if endpoints.Subsets[i].Addresses != nil || endpoints.Subsets[i].NotReadyAddresses != nil {
            newEpSubsets = append(newEpSubsets, endpoints.Subsets[i])
         }
      }
      endpoints.Subsets = newEpSubsets
      if len(endpoints.Subsets) == 0 {
         // this endpoints has no nodepool valid addresses for ingress controller, return nil to ignore it
         return nil
      }
   }
   return endpoints
}
```

### MasterServiceFilter

針對 services 下的域名進行 ip 以及埠替換，這個過濾器的場景主要在於邊緣端的 pod 無縫使用 InClusterConfig 訪問叢集資源。

```
func (fh *masterServiceFilterHandler) ObjectResponseFilter(b []byte) ([]byte, error) {
   list, err := fh.serializer.Decode(b)
   if err != nil || list == nil {
      klog.Errorf("skip filter, failed to decode response in ObjectResponseFilter of masterServiceFilterHandler, %v", err)
      return b, nil
   }
 
   // return data un-mutated if not ServiceList
   serviceList, ok := list.(*v1.ServiceList)
   if !ok {
      return b, nil
   }
 
   // mutate master service
   for i := range serviceList.Items {
      if serviceList.Items[i].Namespace == MasterServiceNamespace && serviceList.Items[i].Name == MasterServiceName {
         serviceList.Items[i].Spec.ClusterIP = fh.host
         for j := range serviceList.Items[i].Spec.Ports {
            if serviceList.Items[i].Spec.Ports[j].Name == MasterServicePortName {
               serviceList.Items[i].Spec.Ports[j].Port = fh.port
               break
            }
         }
         klog.V(2).Infof("mutate master service into ClusterIP:Port=%s:%d for request %s", fh.host, fh.port, util.ReqString(fh.req))
         break
      }
   }
 
   // return the mutated serviceList
   return fh.serializer.Encode(serviceList)
}
```

### DiscardCloudService

該過濾器針對兩種 service 其中的一種型別是 LoadBalancer，因為邊緣端無法訪問 LoadBalancer 型別的資源，所以該過濾器會將這種型別的資源直接過濾掉。另外一種是針對 kube-system 名稱空間下的 x-tunnel-server-internal-svc，這個 services 主要存在 cloud 節點用於訪問 yurt-tunnel-server，對於 edge 節點會直接過濾掉該 service。

```
func (fh *discardCloudServiceFilterHandler) ObjectResponseFilter(b []byte) ([]byte, error) {
   list, err := fh.serializer.Decode(b)
   if err != nil || list == nil {
      klog.Errorf("skip filter, failed to decode response in ObjectResponseFilter of discardCloudServiceFilterHandler %v", err)
      return b, nil
   }
 
   serviceList, ok := list.(*v1.ServiceList)
   if ok {
      var svcNew []v1.Service
      for i := range serviceList.Items {
         nsName := fmt.Sprintf("%s/%s", serviceList.Items[i].Namespace, serviceList.Items[i].Name)
         // remove lb service
         if serviceList.Items[i].Spec.Type == v1.ServiceTypeLoadBalancer {
            if serviceList.Items[i].Annotations[filter.SkipDiscardServiceAnnotation] != "true" {
               klog.V(2).Infof("load balancer service(%s) is discarded in ObjectResponseFilter of discardCloudServiceFilterHandler", nsName)
               continue
            }
         }
 
         // remove cloud clusterIP service
         if _, ok := cloudClusterIPService[nsName]; ok {
            klog.V(2).Infof("clusterIP service(%s) is discarded in ObjectResponseFilter of discardCloudServiceFilterHandler", nsName)
            continue
         }
 
         svcNew = append(svcNew, serviceList.Items[i])
      }
      serviceList.Items = svcNew
      return fh.serializer.Encode(serviceList)
   }
 
   return b, nil
}
```

## 過濾框架現狀

目前的過濾框架比較僵硬，將資源過濾硬編碼至程式碼中，只能是已註冊的資源才能進行相應的過濾,為了解決這個問題，需要對過濾框架進行相應的改造。

### 解決方案

#### 方案一：

使用引數或者環境變數的形式自定義過濾配置，但是這種方式有以下弊端：

1、配置複雜需要將所以需要自定義的配置寫入到啟動引數或者讀取環境變數 例如下格式：

```
--filter_serviceTopology=coredns/endpointslices#list,kube-proxy/services#list;watch --filter_endpointsFilter=nginx-ingress-controller/endpoints#list;watch
```

2、無法熱更新，每次修改配置都需要重啟 Yurthub 生效。

#### 方案二：

1、使用 configmap 的形式自定義過濾配置降低配置複雜度配置格式(user-agent/resource#list,watch) 多個資源透過逗號隔開。如下所示：

```
filter_endpoints: coredns/endpoints#list;watch,test/endpoints#list;watch
filter_servicetopology: coredns/endpointslices#list;watch
filter_discardcloudservice: ""
filter_masterservice: ""
```

2、利用 Informer 機制保證配置實時生效

綜合以上兩點在 OpenYurt 中我們選擇瞭解決方案二。

## 開發過程中遇到的問題

在邊緣端 Informer watch 的 api 地址是 Yurthub 的代理地址，那麼 Yurthub 在啟動代理埠之前都是無法保證 configmap 的資料是正常的。如果在啟動完成之後 addons 的請求先於 configmap 資料更新 這個時候會導致資料在沒有過濾的情況下就返回給了 addons，這樣會導致很多預期以外的問題。

為了解決這個問題 我們需要在 apporve 中加入 WaitForCacheSync 保證資料同步完成之後才能返回相應的過濾資料，但是在 apporve 中加入 WaitForCacheSync 也直接導致 configmap 進行 watch 的時候也會被阻塞，所以需要在 WaitForCacheSync 之前加入一個白名單機制，當 Yurthub 使用 list & watch 訪問 configmap 的時候我們直接不進行資料過濾，相應的程式碼邏輯如下：

```
func (a *approver) Approve(comp, resource, verb string) bool {
   if a.isWhitelistReq(comp, resource, verb) {
      return false
   }
   if ok := cache.WaitForCacheSync(a.stopCh, a.configMapSynced); !ok {
      panic("wait for configMap cache sync timeout")
   }
   a.Lock()
   defer a.Unlock()
   for _, requests := range a.nameToRequests {
      for _, request := range requests {
         if request.Equal(comp, resource, verb) {
            return true
         }
      }
   }
   return false
}
```

## 總結

1、透過上述的擴充套件能力可以看出，YurtHub 不僅僅是邊緣節點上的帶有資料快取能力的反向代理。而是對 Kubernetes 節點應用生命週期管理加了一層新的封裝，提供邊緣計算所需要的核心管控能力。

2、YurtHub 不僅僅適用於邊緣計算場景，其實可以作為節點側的一個常備元件，適用於使用 Kubernetes 的任意場景。相信這也會驅動 YurtHub 向更高效能，更高穩定性發展。

點選[**此處**](https://github.com/openyurtio/openyurt)，立即瞭解 OpenYurt 專案！

OpenYurt 之 Yurthub 資料過濾框架解析

相關文章