白名单" kube-system"使用NetworkPolicy的命名空间

时间:2018-06-12 00:03:48

标签: kubernetes project-calico kubernetes-networkpolicy

我有一个多租户群集,通过命名空间实现多租户。每个租户都有自己的命名空间。租户的吊舱无法与其他租户的吊舱交谈。但是,每个租户中的一些pod必须使用Ingress将服务暴露给互联网。

这我到底有多远(我使用的是Calico):

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>

<div id="character">Character</div>
<div id="redBox">Red Box</div>

为每个命名空间(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,...)部署,这限制了其命名空间内的pod之间的通信。但是,这可以防止tenant2命名空间中的pod与此命名空间中的pod进行通信。

但是,kube-system命名空间默认没有任何标签,因此我无法专门列出此命名空间。

我通过手动为其指定了一个(脏)解决方法:

kube-system

将白名单规则添加到networkpolicy:

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" 标签?

修改:我试图另外添加&#34; OR&#34;规则专门允许来自具有标签&#34; app = nginx-ingress&#34;的广告连播,但没有运气:

kube-system

4 个答案:

答案 0 :(得分:2)

apiVersion: 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

按照此link阅读网络政策整体概念的完整解释,或link观看演讲。

<强> apiVersion: projectcalico.org/v3

Calico API为您提供了更多编写NetworkPolicy规则的选项,因此,在某些时候,您可以通过减少工作量和精力充沛来实现目标。

例如,使用Calico实施的网络策略,您可以:

  • 设置规则的操作(允许,拒绝,记录,通过),
  • 使用否定匹配(protocol,notProtocol,selector,notSelector),
  • 应用更复杂的标签选择器(has(k),k不在{'v1','v2'}),
  • 将选择器与operator&amp;&amp;,&amp;,
  • 组合在一起
  • 使用端口范围(端口:[8080,&#34; 1234:5678&#34;,&#34; named-port&#34;]),
  • 匹配其他命名空间中的pod。

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

考虑详细阅读Calico documentation

以下是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

答案 1 :(得分:0)

实际上,tenant1个Pod将需要访问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: 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

答案 2 :(得分:0)

如果我正确理解您正在使用印花布。只需使用他们的示例来说明如何实现默认拒绝而不中断kube-dns通信。 找到here

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

答案 3 :(得分:0)

我在 k3os 上使用默认法兰绒 CNI。它在 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