7

我有一个多租户集群，其中多租户是通过命名空间实现的。每个租户都有自己的命名空间。一个租户的 Pod 不能与其他租户的 Pod 通信。但是，每个租户中的一些 pod 必须使用 Ingress 向 Internet 公开服务。

这我走了多远（我正在使用 Calico）：

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: tenant1-isolate-namespace
  namespace: tenant1
spec:
  policyTypes:
  - Ingress
  podSelector: {} # Select all pods in this namespace
  ingress:
  - from:
    - namespaceSelector:
        matchLabels:
          name: tenant1 # white list current namespace

为每个命名空间 ( tenant1, tenant2, ... ) 部署，这限制了其命名空间内 pod 之间的通信。但是，这会阻止kube-system命名空间中的 pod 与此命名空间中的 pod 通信。

但是，kube-system默认情况下，命名空间没有任何标签，因此我不能专门将该命名空间列入白名单。

我通过手动给它一个标签找到了一个（肮脏的）解决方法：

kubectl label namespace/kube-system permission=talk-to-all

并将白名单规则添加到网络策略中：

...
  - from:
    - namespaceSelector:
        matchLabels:
          permission: talk-to-all # allow namespaces that have the "talk-to-all privilege"

有没有更好的解决方案，无需手动给出kube-system标签？

编辑：我尝试另外添加一个“OR”规则，以专门允许来自具有标签“app=nginx-ingress”的 pod 的通信，但没有运气：

  - from
    ...
    - podSelector:
        matchLabels:
          app: nginx-ingress # Allow pods that have the app=nginx-ingress label
4

4 回答 4

4

api版本：networking.k8s.io/v1

namespaceSelector 旨在仅按标签匹配命名空间。无法按名称选择命名空间。

podSelector 只能选择与 NetworkPolicy 对象在同一命名空间中的 pod。对于位于不同命名空间中的对象，只能选择整个命名空间。

以下是 Kubernetes 网络策略实现的示例：

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: test-network-policy
  namespace: default
spec:
  podSelector:
    matchLabels:
      role: db
  policyTypes:
  - Ingress
  - Egress
  ingress:
  - from:
    - ipBlock:
        cidr: 172.17.0.0/16
        except:
        - 172.17.1.0/24
    - namespaceSelector:
        matchLabels:
          project: myproject
    - podSelector:
        matchLabels:
          role: frontend
    ports:
    - protocol: TCP
      port: 6379
  egress:
  - to:
    - ipBlock:
        cidr: 10.0.0.0/24
    ports:
    - protocol: TCP
      port: 5978

按照这个链接阅读对整个网络策略概念的很好的解释，或者这个链接来观看讲座。

api版本：projectcalico.org/v3

Calico API 为您提供了更多编写 NetworkPolicy 规则的选项，因此，在某些时候，您可以用更少的精力和精力来实现您的目标。

例如，使用网络策略的 Calico 实现，您可以：

  • 为规则设置操作（允许、拒绝、记录、通过），
  • 使用否定匹配（protocol、notProtocol、selector、notSelector），
  • 应用更复杂的标签选择器（有（k），k不在{'v1'，'v2'}中），
  • 将选择器与运算符 && 结合起来，
  • 使用端口范围（端口：[8080，“1234：5678”，“命名端口”]），
  • 匹配其他命名空间中的 pod。

但是，您仍然只能通过标签匹配命名空间。

考虑阅读 Calico文档以了解详细信息。

这是 Calico 网络策略实现的示例：

apiVersion: projectcalico.org/v3
kind: NetworkPolicy
metadata:
  name: allow-tcp-6379
  namespace: production
spec:
  selector: role == 'database'
  types:
  - Ingress
  - Egress
  ingress:
  - action: Allow
    protocol: TCP
    source:
      selector: role == 'frontend'
    destination:
      ports:
      - 6379
  egress:
  - action: Allow
于 2018-06-12T14:15:27.807 回答
2

实际上，tenant1Pod 需要专门访问kube-dns命名kube-system空间。

一种不需要kube-system标记命名空间的方法是以下策略。虽然kube-dns可以使用这种方法在任何命名空间中，但它可能不适合您。

---                                                                                                                                                                                                           
# Default deny all ingress & egress policy, except allow kube-dns                                                                                                                                             
# All traffic except this must be explicity allowed.                                                                                                                                                          
kind: NetworkPolicy                                                                                                                                                                                           
apiVersion: networking.k8s.io/v1                                                                                                                                                                              
metadata:                                                                                                                                                                                                     
  name: default-deny-all-except-kube-dns                                                                                                                                                                      
  namespace: tenant1                                                                                                                                                                                        
spec:                                                                                                                                                                                                         
  podSelector: {}                                                                                                                                                                                             
  egress:                                                                                                                                                                                                     
  - to:                                                                                                                                                                                                       
    - podSelector:                                                                                                                                                                                            
        matchLabels:                                                                                                                                                                                          
          k8s-app: kube-dns                                                                                                                                                                                   
 - ports:             
   - protocol: TCP                                                                                                                                                                                         
     port: 53                                                                                                                                                                                                                                                                                     
   - protocol: UDP                                                                                                                                                                                           
     port: 53                                                                                                                                                                                                
 policyTypes:                                                                                                                                                                                                
 - Ingress                                                                                                                                                                                                   
 - Egress

然后，您还需要一个“在命名空间策略中允许所有内容”，如下所示：

---                                                                                                                                                                                                           
# Allow intra namespace traffic for development purposes only.                                                                                                                                                
kind: NetworkPolicy                                                                                                                                                                                           
apiVersion: networking.k8s.io/v1                                                                                                                                                                              
metadata:                                                                                                                                                                                                     
  name: allow-intra-namespace                                                                                                                                                                                 
  namespace: tenant1                                                                                                                                                                                        
spec:                                                                                                                                                                                                         
  podSelector:                                                                                                                                                                                                
    matchLabels:                                                                                                                                                                                              
  ingress:                                                                                                                                                                                                    
  - from:                                                                                                                                                                                                     
    - podSelector: {}                                                                                                                                                                                         
  egress:                                                                                                                                                                                                     
  - to:                                                                                                                                                                                                       
    - podSelector: {}                                                                                                                                                                                         
  policyTypes:                                                                                                                                                                                                
  - Ingress                                                                                                                                                                                                   
  - Egress

最后，您需要添加特定策略，例如入口规则。最好allow-intra-namespace用特定规则替换该策略以适应各个 pod，您tenant1可以这样做。

这些已改编自该网站：https ://github.com/ahmetb/kubernetes-network-policy-recipes

于 2018-06-28T02:39:54.477 回答
1

我在使用默认法兰绒 CNI 的 k3os 上。它在 kube-system 命名空间上有默认标签：

$ kubectl describe ns kube-system
Name:         kube-system
Labels:       kubernetes.io/metadata.name=kube-system
Annotations:  <none>
Status:       Active

这对我有用：

- namespaceSelector:
    matchLabels:
      kubernetes.io/metadata.name: kube-system

这是我的完整 yaml，它允许 kube-system 命名空间中的所有外部流量和 kube-dns 用于出口：

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: default-egress
spec:
  podSelector: {}
  policyTypes:
  - Egress
  egress:
  - to:
    - namespaceSelector:
        matchLabels:
          kubernetes.io/metadata.name: kube-system
      podSelector:
        matchLabels:
          k8s-app: kube-dns
    ports:
      - port: 53
        protocol: UDP
  - to:
    - ipBlock:
        cidr: 0.0.0.0/0
        except:
        - 10.0.0.0/8
        - 172.16.0.0/12
        - 192.168.0.0/16
于 2021-07-22T18:11:55.547 回答
0

如果我理解正确，您使用的是印花布。只需使用他们的示例来了解如何在不破坏 kube-dns 通信的情况下实现默认拒绝。在这里找到

apiVersion: projectcalico.org/v3
kind: GlobalNetworkPolicy
metadata:
  name: deny-app-policy
spec:
  namespaceSelector: has(projectcalico.org/name) && projectcalico.org/name not in {"kube-system", "calico-system"}
  types:
  - Ingress
  - Egress
  egress:
  # allow all namespaces to communicate to DNS pods
  - action: Allow
    protocol: UDP
    destination:
      selector: 'k8s-app == "kube-dns"'
      ports:
      - 53
于 2020-12-10T14:47:35.453 回答