In a multi-cluster Kubernetes environment, managing and securing network traffic between clusters is crucial. Network policies provide a way to control the flow of traffic at the pod level, ensuring that only authorized communication occurs between clusters. In this blog post, we will explore how to implement network policies for multi-cluster communication control in Kubernetes.

Prerequisites

Before we dive into the implementation, let's review the prerequisites:

1. A multi-cluster Kubernetes environment with at least two clusters.
2. kubectl configured to interact with both clusters.
3. Calico or another network policy provider installed on both clusters.

Creating Network Policies

To create a network policy, we need to define the rules that govern the flow of traffic between pods. Here's an example of a network policy that allows traffic between two pods in different namespaces:

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-inter-namespace-traffic
  namespace: namespace-1
spec:
  podSelector:
    matchLabels:
      app: app-1
  policyTypes:
  - Ingress
  ingress:
  - from:
    - podSelector:
        matchLabels:
          app: app-2
          namespace: namespace-2
    ports:
    - protocol: TCP
      port: 80

In this example, the network policy is named allow-inter-namespace-traffic and is applied to the namespace-1 namespace. The podSelector field specifies the pods that the policy applies to, in this case, pods with the label app: app-1. The policyTypes field specifies the types of traffic that the policy allows, in this case, ingress traffic. The ingress field specifies the rules for incoming traffic, in this case, allowing traffic from pods with the label app: app-2 in the namespace-2 namespace on port 80.

Applying Network Policies Across Clusters

Once we have created a network policy, we need to apply it to both clusters. To do this, we can use the kubectl apply command with the --all-namespaces flag to apply the policy to all namespaces in both clusters:

kubectl apply -f network-policy.yaml --all-namespaces --context cluster-1
kubectl apply -f network-policy.yaml --all-namespaces --context cluster-2

In this example, we are applying the network-policy.yaml file to all namespaces in both clusters, cluster-1 and cluster-2.

Verifying Network Policies

To verify that the network policies are working as expected, we can use the kubectl get networkpolicies command to view the policies in each cluster:

kubectl get networkpolicies --all-namespaces --context cluster-1
kubectl get networkpolicies --all-namespaces --context cluster-2

We can also use the kubectl describe networkpolicy command to view the details of a specific policy:

kubectl describe networkpolicy allow-inter-namespace-traffic --namespace namespace-1 --context cluster-1
kubectl describe networkpolicy allow-inter-namespace-traffic --namespace namespace-1 --context cluster-2

Conclusion

Implementing network policies for multi-cluster communication control in Kubernetes is essential for securing network traffic between clusters. By defining the rules that govern the flow of traffic between pods, we can ensure that only authorized communication occurs between clusters. With the kubectl apply command and the --all-namespaces flag, we can easily apply network policies to all namespaces in multiple clusters. By verifying the policies with the kubectl get networkpolicies and kubectl describe networkpolicy commands, we can ensure that the policies are working as expected.