Kubernetes网络概念初探

小灰灰 2022-11-19 01:17 196阅读 0赞

Kubernetes网络是Kubernetes中一个核心概念。简而言之，Kubernetes网络模型可以确保集群上所有Kubernetes pod都能进行通信。此外，在Kubernetes网络模型的基础上，Kubernetes还有其他核心概念，即Kubernetes Services和Kubernetes Ingress。

本文将使用系统模型的方法探索Kubernetes网络。我们将开发一个简单的模型来了解容器与容器间的通信以及Pod之间的通信。

## 如何看待网络 ##

毫无疑问，网络是一个极为广泛且复杂的领域，它需要多年的理论积累以及实践才能精通。在本文中，我们将在概念层面对网络进行梳理，暂时不涉及实现层面的细节。

![在这里插入图片描述][20210413225354632.png]

理想的网络模型

上图将网络描述为Network Graph，该网络由一组节点以及节点之间的链接组成。如果当且仅当节点之间存在联系时，一个节点才可以与另一个节点交换信息。  
![在这里插入图片描述][20210413225407941.png]  
消息交换框架

一个节点，即源节点，通过将消息放入目标的输入队列，与另一个节点，即目标交换消息。消息交换由源节点观察到的Send Event，Send·M和在目标节点观察到的相应的Receive Event，Recv·M表示。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1JhbmNoZXJMYWJz_size_16_color_FFFFFF_t_70]

消息交换行为

网络中的节点要么是Process，要么是Switch。Process会产生和消耗消息，Switch根据其转发信息库（FIB）处理消息。

![在这里插入图片描述][2021041322551188.png]

S1和S2的转发信息库（FIB）

上图描述了Switch的转发信息库（FIB）S1和S2。在收到消息时，每台Switch都会查询其转发信息库，以决定是发送（deliver）、转发（forward）还是丢弃（discard）该消息。

Switch：

将信息的请求头，即源地址、源端口、目标地址和目标端口与其转发信息库相匹配、  
执行相关操作，默认为弃置（discard）

## Kubernetes网络模型 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1JhbmNoZXJMYWJz_size_16_color_FFFFFF_t_70 1]

Kubernetes网络模型是一个描述性的网络模型，也就是说，任何满足Kubernetes网络模型规范的网络都是Kubernetes网络。

然而，Kubernetes并没有规定如何实现网络模型。事实上，现在市面上有许多替代的实现，称为网络插件。

本节将用一组关于消息交换的约束条件来描述Kubernetes网络模型。

**限制条件：网络可寻址实体**

Kubernetes网络模型定义了3个可寻址实体：K8S pod、K8S 节点以及K8S Service，每个实体都会分配到一个不同的IP地址。

∧ (K8s-Pod(E₁) ∨ K8s-Node(E₁) ∨ K8s-Service(E₁))
    ∧ (K8s-Pod(E₂) ∨ K8s-Node(E₂) ∨ K8s-Service(E₂)):
      addr(E₁, a) ∧ addr(E₂, a)₂
       ⟺ E₁ = E₂

然而，网络模型不对这些IP地址做任何进一步的声明。例如，Kubernetes网络模型不对从这些IP地址中提取的IP地址空间做任何进一步的声明。

**限制条件：容器间通信**

Kubernetes网络模型要求在Pod P上下文中执行的容器C1可以通过localhost与在P上下文中执行的其他容器C2进行通信。

K8s-Pod(P) ∧ K8s-Container(C₁, P) ∧ K8s-Container(C₂, P):
     open(C₂, p) 
      ⟹
       Send(e, C₁, 127.0.0.1, _, 127.0.0.1, p)
        ⟹
         Recv(e, C₂, 127.0.0.1, _, 127.0.0.1, p)

**限制条件：Pod到Pod**

Kubernetes网络模型要求在Pod P1上下文中执行的容器C1可以通过P2的地址与在P2上下文中执行的其他容器C2进行通信。

∧ K8s-Pod(P₁) ∧ K8s-Container(C₁, P₁)
    ∧ K8s-Pod(P₂) ∧ K8s-Container(C2, P₂):
     addr(P₁, sa) ∧ addr(P₁, ta) ∧ open(C₂, tp)
      ⟹
       Send(e, C₁, sa, sp, ta, tp)
        ⟹
         Recv(e, C₂, sa, sp, ta, tp)

**限制条件：Process到Pod**

Kubernetes网络模型要求托管在节点N上的一个Process，称为Daemon D，可以通过P的地址与托管在N上的Pod P上下文中执行的任何容器C进行通信。  
K8s-Node(N) ∧ K8s-Daemon(D) ∧ K8s-Pod§ ∧ K8s-

Container(C, P):
     host(N, D) ∧ host(N, P) ∧ addr(P, a) ∧ open(C, p)
      ⟹
       Send(e, D, _, _, a, p)
        ⟹
         Recv(e, C, _, _, a, p)

## Kubernetes网络作为Network Graph ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1JhbmNoZXJMYWJz_size_16_color_FFFFFF_t_70 2]

本节用Kubernetes Network Graph这个理想的模型来描述Kubernetes网络模型。

下图描述了本节内容中的用例：Kubernetes集群K1由2个节点组成。每个节点托管2个Pod。每个Pod执行2个容器，一个容器监听8080端口，一个容器监听9090端口。此外，每个节点托管1个Daemon。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1JhbmNoZXJMYWJz_size_16_color_FFFFFF_t_70 3]

我们可以将Kubernetes集群网络建模为一个具有一组节点和一组链接的Graph。

**节点**

每个K8S容器C映射到网络Process C

K8s-Pod(P) ∧ K8s-Container(C, P):
      Process(C)

每个Daemon D映射到网络Process C

K8s-Daemon(D):
      Process(D)

每个K8s Pod P映射到网络Switch P, Pod的Switch

K8s-Pod(P):
      Switch(P)

每个K8S节点N 映射到网络 Switch N，节点的Switch：

K8s-Pod(N):
      Switch(N)

**链接**

每个容器C会被链接到其Pod Switch P

K8s-Pod(P) ∧ K8s-Container(C, P):
     link(C, P)

每个Daemon D会被链接到其节点Switch N

K8s-Node(N) ∧ K8s-Daemon(D):
     host(N, D)
      ⟹
       link(D, N)

每个Pod Switch P会被链接到其节点Switch N

K8s-Node(N) ∧ K8s-Pod(P):
     host(N, P)
      ⟹
       link(P, N)

每个节点Switch N1会被链接到其他各节点Switch N2

K8s-Node(N₁) ∧ K8s-Node(N₂):
     N₁ ≠ N₂
      ⟹
       link(N₁, N₂)

**在Pod Switch的转发信息库**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1JhbmNoZXJMYWJz_size_16_color_FFFFFF_t_70 4]

P2的转发信息库

1. Delivery on localhost
    K8s-Pod(P) ∧ K8s-Container(C, P):
     open(C, p) 
      ⟹
       [* * 127.0.0.1 p Deliver(C)] in FIB[P]
    2. Delivery on Pod Address
    K8s-Pod(P) ∧ K8s-Container(C, P):
     addr(P, a) ∧ open(C, p) 
      ⟹
       [* * a p Deliver(C)] in FIB[P]
    3. Local Forwarding Rule
    K8s-Node(N) ∧ K8s-Pod(P):
     host(N, P) 
      ⟹
       [* * * * Forward(N)] in FIB[P]

**在节点Switch的转发信息库**

![在这里插入图片描述][20210413225957651.png]

转发信息库 N2

1.  Node to Pod Forwarding Rule  
    K8s-Node(N) ∧ K8s-Pod§:  
    host(N, P) ∧ addr(P, a)  
    ⟹  
    \[\* \* a \* Forward§\] in FIB\[N\]
2.  Node to Node Forwalding Rule  
    K8s-Node(N₁) ∧ K8s-Node(N₂) ∧ K8s-Pod§:  
    N₁ ≠ N₂ ∧ host(N₂, P) ∧ addr(P, a)  
    ⟹  
    \[\* \* a \* Forward(N₂)\] in FIB\[N₁\]

## 示例 ##

本节将通过一些例子，按照Kubernetes集群网络K1中的消息生命（Life of a Message）来进行讲解。

**容器到容器**

容器C1.1需要与容器C1.2进行通信：

*  C1.1在P1的上下文中执行
 *  C1.2在P1的上下文中执行

C₁.₁通过127.0.0.1:9090到C₁.₂

节点内Pod到Pod通信  
![在这里插入图片描述][20210413230043326.png]

容器C 1.1需要与C 3.1进行通信：

*  C 1.1在N1节点上的P1上下文中执行
 *  C 3.1在N1节点上的P3上下文中执行

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1JhbmNoZXJMYWJz_size_16_color_FFFFFF_t_70 5]

C 1.1通过10.1.1.2:8080到C 3.1

**节点间Pod到Pod通信**

容器C 1.1需要与容器C 2.1进行通信：

*  C1.1是在N1节点上托管的P1的上下文中执行的
 *  C2.1在节点N2上的P2上下文中执行

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1JhbmNoZXJMYWJz_size_16_color_FFFFFF_t_70 6]

C1.1通过10.1.2.1:8080到C2.1

**Daemon到Pod通信**

Daemon D1需要与容器 C 1.1通信：

*  D1托管在节点N1上
 *  C 1.1在Pod P1的上下文中执行，该Pod托管在节点N1上

![在这里插入图片描述][2021041323015937.png]

D1通过10.1.1.1:8080到C 1.1

## 总结 ##

Kubernetes网络模型是一个允许性的网络模型，也就是说，任何满足Kubernetes网络模型约束的网络都是一个有效的Kubernetes网络。

将Kubernetes网络模型映射到Network Graph，使我们能够在概念层面上对网络进行推理，并且跳过了在实现层面上推理所需的一系列细节。

在后续的文章中，我们将使用这个Network Graph来讨论Kubernetes服务、Kubernetes Ingress和Kubernetes策略。

原文链接：  
[https://dominik-tornow.medium.com/kubernetes-networking-22ea81af44d0][https_dominik-tornow.medium.com_kubernetes-networking-22ea81af44d0]

[20210413225354632.png]: /images/20221022/41a4f01cca60482a859f6590be2003f5.png
[20210413225407941.png]: /images/20221022/a7549da274c4464da64e64ec19345854.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1JhbmNoZXJMYWJz_size_16_color_FFFFFF_t_70]: /images/20221022/2c4aea8bb76640d899e4da016886e6e2.png
[2021041322551188.png]: /images/20221022/a858e126320b46d29e9b432589dd0ac6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1JhbmNoZXJMYWJz_size_16_color_FFFFFF_t_70 1]: /images/20221022/49174c061e7a4fc1b7431d9ed4547d11.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1JhbmNoZXJMYWJz_size_16_color_FFFFFF_t_70 2]: /images/20221022/ee0e392615784b23916c2aeb6cd6950e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1JhbmNoZXJMYWJz_size_16_color_FFFFFF_t_70 3]: /images/20221022/077e5f5f322448afa489de1284fb1946.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1JhbmNoZXJMYWJz_size_16_color_FFFFFF_t_70 4]: /images/20221022/902ca46f8f9448988eaabf8cb2b3d405.png
[20210413225957651.png]: /images/20221022/81b8497135a847ffba64a05cb6904c6b.png
[20210413230043326.png]: /images/20221022/09b8d81e1949417aadf25df4bf5cf33e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1JhbmNoZXJMYWJz_size_16_color_FFFFFF_t_70 5]: /images/20221022/4706c0b4208d48299957b5fa9c65846f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1JhbmNoZXJMYWJz_size_16_color_FFFFFF_t_70 6]: /images/20221022/192238bb32be43008772f8d551b3f8d2.png
[2021041323015937.png]: /images/20221022/2e1fae92f32c4e36b537bf2ba981f79f.png
[https_dominik-tornow.medium.com_kubernetes-networking-22ea81af44d0]: https://dominik-tornow.medium.com/kubernetes-networking-22ea81af44d0