一文学会Calico网络自定义

Posted 2023-04-03

参考技术A Calico支持多个容器网络选项，用于可伸缩性、网络性能和与现有基础设施的互操作性。

不同的网络实现更适合不同的环境。Calico提供了几种不需要封装的基于IP路由的网络实现。如果您的部署需要封装，Calico提供覆盖网络(IP in IP或VXLAN)。Calico还支持使用其他Kubernetes网络选项来执行策略。本文档帮助您为集群选择最佳的网络选项。

Calico提供了一些方法，允许pod连接到其他pod、主机和外部网络(例如internet)。

Calico网络：

Calico支持使用边界网关协议(BGP)将路由信息共享到网络中。Calico支持节点到节点的全网格部署(有和没有路由反射器)，以及BGP直接对机架(ToR)路由器顶部的现场部署;允许流量直接路由到工作负载，而不需要NAT或封装。

Calico可以使用许多其他Kubernetes网络选项执行网络策略强制。

下表显示了使用Calico时常见的网络选项。

本节提供更多关于Calico的内置网络选项的细节:

Calico可以与你的路由器使用BGP对等。这提供了出色的性能和易于调试的非封装流量，以及广泛的网络拓扑和连接选项。

此选项还提供了接近主机到主机的性能级别，并允许网络直接看到流量。

当所有节点都在一个L2子网上时，如果底层网络不强制执行IP地址检查，Calico可以在节点之间路由pod流量，而不需要封装。如果您的网络由多个L2子网组成，那么您可以使用路由器在BGP上进行对等，或者使用跨子网封装来仅封装跨子网边界的流量。

如果不允许在集群外部进行工作负载访问或使用基础设施进行对等访问，就无法在pod和不属于Calico集群的目的地之间路由流量。

如果可能，我们建议运行Calico没有网络覆盖/封装。这提供了最高的性能和最简单的网络;离开您的工作负载的包是连接到网络上的包。

但是，当运行在底层网络上时，有选择地使用覆盖(IP中的IP或VXLAN中的IP)是非常有用的，因为底层网络不容易知道工作负载IP。Calico可以对:所有的流量，没有流量，或者只对跨越子网边界的流量进行封装。

IP中的IP或VXLAN封装也可以在子网之间选择性地使用——这提供了子网中未封装的流量的性能优势，适用于织物包含多个L2网络且无法进行对等连接的环境。例如，如果您在AWS中跨多个VPC/子网使用Calico网络，Calico可以选择性地只封装在VPC/子网之间路由的流量，而不封装在每个VPC/子网中运行。

缺省的节点到节点的BGP网格必须关闭，以启用其他BGP拓扑。为此，修改默认的BGP配置资源。

每个节点的BGP对等点应用于集群中的一个或多个节点。您可以通过精确地指定节点的名称或使用标签选择器来选择节点。

Calico 可以配置扮演成一个路由反射器。每个节点要充当路由反射器必须有一个集群ID——通常一个未使用的IPv4地址。

默认的，所有的calico 节点使用64512 autonomous system, 除非特殊指定。下面的命令把它改成64513.

您可以配置每个IP池不同封装配置。然而,你不能一个IP池内混合封装类型。

IP in IP和 VXLAN只支持IPv4地址。

Calico 只有一个选项来选择性地封装流量 ,跨越子网边界。我们建议使用 IP in IP 的 cross subnet 选项把开销降到最低。

注意：切换封装模式会导到正在连接的进程中断。

IP in IP封装可以选择性的执行， 并且仅用于通过子网边界的通信量 。

开启这个功能，设置 ipipMode 为 CrossSubnet

ipipMode 设置 Always

下表针对Calico环境列出了常见的MTU大小。 因为MTU是endpoints间网络路径的全局属性， 你应该设定最低MTU的MTU包可能需要的任何路径。

额外的报头用于在IP和VXLAN IP协议,降低了最小的MTU大小头。在IP使用20-byte头(IP, VXLAN使用50-byte头)。因此,我们建议如下:

当使用flannel的网络时，网络接口的MTU应该匹配flannel接口的MTU。 假如使用flannel的VXLAN， 使用上面的 calico MTU with VXLAN 列的大小。

当你设置MTU,它适用于新工作负载。MTU变化应用于现有的工作负载,必须重新启动calico nodes。

如果您使用的是IP in IP和/或VXLAN calico overlay 网络,设置隧道MTU匹配veth MTU配置的值。

IP在IP隧道作为tunlx出现(例如,tunl0),连同MTU大小。例如:

允许工作负载使用私有IP地址访问互联网,你可以用你现有NAT功能,或者你可以在Calico IPPool上开启natOutgoing。

在以下的示例中,我们创建一个Calicco IPPool，并开启natOutgoing 。Outbound NAT是在节点本地执行的。

您可以创建额外的IPPools不用于IP地址管理,防止NAT某些CIDR块。这是有用的,如果你想让节点NAT网络流量,但不是在某些内部ip范围。例如,如果您不想NAT流量10.0.0.0/8,您可以创建以下池。您必须确保集群之间的网络和10.0.0.0/8可路由。

针对calico节点配置IP自动检测，确保路由使用正确的P地址。

当你安装Calico在一个节点上时，一个IP地址和子网被自动检测。Calico提供几种方式去配置子网自动检测，和支持配置指定的IPs。

针对节点间的路由，每个calico节点必须配置一个IPv4地址 和/或 一个IPV6地址，当安装一个calico在一个节点上时，一个节点资源使用从主机检测到的路由信息自动创建。针对一些部署，你可能想要自动的更新检测，确保节点获取正确的IP地址。

默认的，Calico使用 first-found 方法，也就是说第一个接口第一个有效的IP地址（排除local interface，因为它是docker bridge）.你可以使用以下方法的任一一种改变默认方法。

（1）使用一个能到达特定IP或domain的地址。

（2）使用正则的方式，去匹配接口（interface)

（3）使用正则的方式，去排除匹配的接口（skip interface）

(1) calico node container(start/restart),使用环境变量去设置节点的值

(2) 更新节点的资源

因为你可以通过配置环境变量和节点资源，去更改IP地址和子网，下表描述了这些值如何同步的。

由于默认的自动检测方法是 first valid interface found (first-found). 去使用不同的自动检测方法，使用 kubectl set env 命令指定方法。

（1）IP 或 domain name

（2）包含匹配的接口

（3）排除匹配的接口

在下列情况下,您可能需要配置一个特定的IP子网:

八、IP地址及封装模式切换
针对安装Calico到kubernetes集群中的每个节点，每个manifest包含所有需要的资源。

它安装如下的kubernetes资源：

Calico IPAM从IP pools中分配 IP地址。

如果要修改pods使用的默认IP地址范围，那么修改calico.yaml清单中的 CALICO_IPV4POOL_CIDR 。

默认情况下，清单支持跨子网的IP-in-IP封装。许多用户可能希望禁用IP-in-IP封装，例如在以下情况下。

如果要关闭IP-in-IP的封装，修改清单中的 CALICO-IPV4POOL_IPIP .

默认情况下，Calico清单支持IP-in-IP封装。如果您所在的网络阻塞了ip中的ip，比如Azure，您可能希望切换到Calico的VXLAN封装模式。要做到这一点，在安装时(以便Calico创建默认的IP池与VXLAN和没有IP-in-IP配置必须撤消):

（转）一文学会用 Tensorflow 搭建神经网络

 

一文学会用 Tensorflow 搭建神经网络

 

本文转自：http://www.jianshu.com/p/e112012a4b2d

字数2259 阅读3168 评论8 喜欢11

---

cs224d-Day 6: 快速入门 Tensorflow

本文是学习这个视频课程系列的笔记，课程链接是 youtube 上的，
讲的很好，浅显易懂，入门首选， 而且在github有代码，
想看视频的也可以去他的优酷里的频道找。

Tensorflow 官网

---

神经网络是一种数学模型，是存在于计算机的神经系统，由大量的神经元相连接并进行计算，在外界信息的基础上，改变内部的结构，常用来对输入和输出间复杂的关系进行建模。

神经网络由大量的节点和之间的联系构成，负责传递信息和加工信息，神经元也可以通过训练而被强化。

这个图就是一个神经网络系统，它由很多层构成。输入层就是负责接收信息，比如说一只猫的图片。输出层就是计算机对这个输入信息的认知，它是不是猫。隐藏层就是对输入信息的加工处理。

神经网络是如何被训练的，首先它需要很多数据。比如他要判断一张图片是不是猫。就要输入上千万张的带有标签的猫猫狗狗的图片，然后再训练上千万次。

神经网络训练的结果有对的也有错的，如果是错误的结果，将被当做非常宝贵的经验，那么是如何从经验中学习的呢？就是对比正确答案和错误答案之间的区别，然后把这个区别反向的传递回去，对每个相应的神经元进行一点点的改变。那么下一次在训练的时候就可以用已经改进一点点的神经元去得到稍微准确一点的结果。

神经网络是如何训练的呢？每个神经元都有属于它的激活函数，用这些函数给计算机一个刺激行为。

在第一次给计算机看猫的图片的时候，只有部分的神经元被激活，被激活的神经元所传递的信息是对输出结果最有价值的信息。如果输出的结果被判定为是狗，也就是说是错误的了，那么就会修改神经元，一些容易被激活的神经元会变得迟钝，另外一些神经元会变得敏感。这样一次次的训练下去，所有神经元的参数都在被改变，它们变得对真正重要的信息更为敏感。

Tensorflow 是谷歌开发的深度学习系统，用它可以很快速地入门神经网络。

它可以做分类，也可以做拟合问题，就是要把这个模式给模拟出来。

这是一个基本的神经网络的结构，有输入层，隐藏层，和输出层。
每一层点开都有它相应的内容，函数和功能。

那我们要做的就是要建立一个这样的结构，然后把数据喂进去。
把数据放进去后它就可以自己运行，TensorFlow 翻译过来就是向量在里面飞。

这个动图的解释就是，在输入层输入数据，然后数据飞到隐藏层飞到输出层，用梯度下降处理，梯度下降会对几个参数进行更新和完善，更新后的参数再次跑到隐藏层去学习，这样一直循环直到结果收敛。

tensors_flowing.gif

今天一口气把整个系列都学完了，先来一段完整的代码，然后解释重要的知识点！

---

1. 搭建神经网络基本流程

定义添加神经层的函数

1.训练的数据
2.定义节点准备接收数据
3.定义神经层：隐藏层和预测层
4.定义 loss 表达式
5.选择 optimizer 使 loss 达到最小

然后对所有变量进行初始化，通过 sess.run optimizer，迭代 1000 次进行学习：

import tensorflow as tf
import numpy as np

# 添加层
def add_layer(inputs, in_size, out_size, activation_function=None):
    # add one more layer and return the output of this layer
    Weights = tf.Variable(tf.random_normal([in_size, out_size]))
    biases = tf.Variable(tf.zeros([1, out_size]) + 0.1)
    Wx_plus_b = tf.matmul(inputs, Weights) + biases
    if activation_function is None:
        outputs = Wx_plus_b
    else:
        outputs = activation_function(Wx_plus_b)
    return outputs

# 1.训练的数据
# Make up some real data 
x_data = np.linspace(-1,1,300)[:, np.newaxis]
noise = np.random.normal(0, 0.05, x_data.shape)
y_data = np.square(x_data) - 0.5 + noise

# 2.定义节点准备接收数据
# define placeholder for inputs to network  
xs = tf.placeholder(tf.float32, [None, 1])
ys = tf.placeholder(tf.float32, [None, 1])

# 3.定义神经层：隐藏层和预测层
# add hidden layer 输入值是 xs，在隐藏层有 10 个神经元   
l1 = add_layer(xs, 1, 10, activation_function=tf.nn.relu)
# add output layer 输入值是隐藏层 l1，在预测层输出 1 个结果
prediction = add_layer(l1, 10, 1, activation_function=None)

# 4.定义 loss 表达式
# the error between prediciton and real data    
loss = tf.reduce_mean(tf.reduce_sum(tf.square(ys - prediction),
                     reduction_indices=[1]))

# 5.选择 optimizer 使 loss 达到最小                   
# 这一行定义了用什么方式去减少 loss，学习率是 0.1       
train_step = tf.train.GradientDescentOptimizer(0.1).minimize(loss)


# important step 对所有变量进行初始化
init = tf.initialize_all_variables()
sess = tf.Session()
# 上面定义的都没有运算，直到 sess.run 才会开始运算
sess.run(init)

# 迭代 1000 次学习，sess.run optimizer
for i in range(1000):
    # training train_step 和 loss 都是由 placeholder 定义的运算，所以这里要用 feed 传入参数
    sess.run(train_step, feed_dict={xs: x_data, ys: y_data})
    if i % 50 == 0:
        # to see the step improvement
        print(sess.run(loss, feed_dict={xs: x_data, ys: y_data}))

---

2. 主要步骤的解释：

• 之前写过一篇文章 TensorFlow 入门 讲了 tensorflow 的安装，这里使用时直接导入：

import tensorflow as tf
import numpy as np

• 导入或者随机定义训练的数据 x 和 y：

x_data = np.random.rand(100).astype(np.float32)
y_data = x_data*0.1 + 0.3

• 先定义出参数 Weights，biases，拟合公式 y，误差公式 loss：

Weights = tf.Variable(tf.random_uniform([1], -1.0, 1.0))
biases = tf.Variable(tf.zeros([1]))
y = Weights*x_data + biases
loss = tf.reduce_mean(tf.square(y-y_data))

• 选择 Gradient Descent 这个最基本的 Optimizer：

optimizer = tf.train.GradientDescentOptimizer(0.5)

• 神经网络的 key idea，就是让 loss 达到最小：

train = optimizer.minimize(loss)

• 前面是定义，在运行模型前先要初始化所有变量：

init = tf.initialize_all_variables()

• 接下来把结构激活，sesseion像一个指针指向要处理的地方：

sess = tf.Session()

• init 就被激活了，不要忘记激活：

sess.run(init)

• 训练201步：

for step in range(201):

• 要训练 train，也就是 optimizer：

sess.run(train)

• 每 20 步打印一下结果，sess.run 指向 Weights，biases 并被输出：

if step % 20 == 0:
print(step, sess.run(Weights), sess.run(biases))

所以关键的就是 y，loss，optimizer 是如何定义的。

---

3. TensorFlow 基本概念及代码：

在 TensorFlow 入门 也提到了几个基本概念，这里是几个常见的用法。

• Session

矩阵乘法：tf.matmul

product = tf.matmul(matrix1, matrix2) # matrix multiply np.dot(m1, m2)

定义 Session，它是个对象，注意大写：

sess = tf.Session()

result 要去 sess.run 那里取结果：

result = sess.run(product)

• Variable

用 tf.Variable 定义变量，与python不同的是，必须先定义它是一个变量，它才是一个变量，初始值为0，还可以给它一个名字 counter：

state = tf.Variable(0, name=‘counter‘)

将 new_value 加载到 state 上，counter就被更新：

update = tf.assign(state, new_value)

如果有变量就一定要做初始化：

init = tf.initialize_all_variables() # must have if define variable

• placeholder：

要给节点输入数据时用 placeholder，在 TensorFlow 中用placeholder 来描述等待输入的节点，只需要指定类型即可，然后在执行节点的时候用一个字典来“喂”这些节点。相当于先把变量 hold 住，然后每次从外部传入data，注意 placeholder 和 feed_dict 是绑定用的。

这里简单提一下 feed 机制， 给 feed 提供数据，作为 run()
调用的参数， feed 只在调用它的方法内有效, 方法结束, feed 就会消失。

import tensorflow as tf

input1 = tf.placeholder(tf.float32)
input2 = tf.placeholder(tf.float32)
ouput = tf.mul(input1, input2)

with tf.Session() as sess:
  print(sess.run(ouput, feed_dict={input1: [7.], input2: [2.]}))

---

4. 神经网络基本概念

• 激励函数：

例如一个神经元对猫的眼睛敏感，那当它看到猫的眼睛的时候，就被激励了，相应的参数就会被调优，它的贡献就会越大。

下面是几种常见的激活函数：
x轴表示传递过来的值，y轴表示它传递出去的值：

激励函数在预测层，判断哪些值要被送到预测结果那里：

TensorFlow 常用的 activation function

• 添加神经层：

输入参数有 inputs, in_size, out_size, 和 activation_function

import tensorflow as tf

def add_layer(inputs, in_size, out_size,  activation_function=None):

  Weights = tf.Variable(tf.random_normal([in_size, out_size]))
  biases = tf.Variable(tf.zeros([1, out_size]) + 0.1)
  Wx_plus_b = tf.matmul(inputs, Weights) + biases

  if activation_function is None:
    outputs = Wx_plus_b
  else:
    outputs = activation_function(Wx_plus_b)

return outputs

• 分类问题的 loss 函数 cross_entropy ：

# the error between prediction and real data
# loss 函数用 cross entropy
cross_entropy = tf.reduce_mean(-tf.reduce_sum(ys * tf.log(prediction),
                                              reduction_indices=[1]))       # loss
train_step = tf.train.GradientDescentOptimizer(0.5).minimize(cross_entropy)

• overfitting：

下面第三个图就是 overfitting，就是过度准确地拟合了历史数据，而对新数据预测时就会有很大误差：

Tensorflow 有一个很好的工具, 叫做dropout, 只需要给予它一个不被 drop 掉的百分比，就能很好地降低 overfitting。

dropout 是指在深度学习网络的训练过程中，按照一定的概率将一部分神经网络单元暂时从网络中丢弃，相当于从原始的网络中找到一个更瘦的网络，这篇博客中讲的非常详细

代码实现就是在 add layer 函数里加上 dropout, keep_prob 就是保持多少不被 drop，在迭代时在 sess.run 中被 feed:

def add_layer(inputs, in_size, out_size, layer_name, activation_function=None, ):
    # add one more layer and return the output of this layer
    Weights = tf.Variable(tf.random_normal([in_size, out_size]))
    biases = tf.Variable(tf.zeros([1, out_size]) + 0.1, )
    Wx_plus_b = tf.matmul(inputs, Weights) + biases

    # here to dropout
    # 在 Wx_plus_b 上drop掉一定比例
    # keep_prob 保持多少不被drop，在迭代时在 sess.run 中 feed
    Wx_plus_b = tf.nn.dropout(Wx_plus_b, keep_prob)

    if activation_function is None:
        outputs = Wx_plus_b
    else:
        outputs = activation_function(Wx_plus_b, )
    tf.histogram_summary(layer_name + ‘/outputs‘, outputs)  
    return outputs

---

5. 可视化 Tensorboard

Tensorflow 自带 tensorboard ，可以自动显示我们所建造的神经网络流程图：

就是用 with tf.name_scope 定义各个框架，注意看代码注释中的区别：

import tensorflow as tf


def add_layer(inputs, in_size, out_size, activation_function=None):
    # add one more layer and return the output of this layer
    # 区别：大框架，定义层 layer，里面有 小部件
    with tf.name_scope(‘layer‘):
        # 区别：小部件
        with tf.name_scope(‘weights‘):
            Weights = tf.Variable(tf.random_normal([in_size, out_size]), name=‘W‘)
        with tf.name_scope(‘biases‘):
            biases = tf.Variable(tf.zeros([1, out_size]) + 0.1, name=‘b‘)
        with tf.name_scope(‘Wx_plus_b‘):
            Wx_plus_b = tf.add(tf.matmul(inputs, Weights), biases)
        if activation_function is None:
            outputs = Wx_plus_b
        else:
            outputs = activation_function(Wx_plus_b, )
        return outputs


# define placeholder for inputs to network
# 区别：大框架，里面有 inputs x，y
with tf.name_scope(‘inputs‘):
    xs = tf.placeholder(tf.float32, [None, 1], name=‘x_input‘)
    ys = tf.placeholder(tf.float32, [None, 1], name=‘y_input‘)

# add hidden layer
l1 = add_layer(xs, 1, 10, activation_function=tf.nn.relu)
# add output layer
prediction = add_layer(l1, 10, 1, activation_function=None)

# the error between prediciton and real data
# 区别：定义框架 loss
with tf.name_scope(‘loss‘):
    loss = tf.reduce_mean(tf.reduce_sum(tf.square(ys - prediction),
                                        reduction_indices=[1]))

# 区别：定义框架 train
with tf.name_scope(‘train‘):
    train_step = tf.train.GradientDescentOptimizer(0.1).minimize(loss)

sess = tf.Session()

# 区别：sess.graph 把所有框架加载到一个文件中放到文件夹"logs/"里 
# 接着打开terminal，进入你存放的文件夹地址上一层，运行命令 tensorboard --logdir=‘logs/‘
# 会返回一个地址，然后用浏览器打开这个地址，在 graph 标签栏下打开
writer = tf.train.SummaryWriter("logs/", sess.graph)
# important step
sess.run(tf.initialize_all_variables())

运行完上面代码后，打开 terminal，进入你存放的文件夹地址上一层，运行命令 tensorboard --logdir=‘logs/‘ 后会返回一个地址，然后用浏览器打开这个地址，点击 graph 标签栏下就可以看到流程图了：

---

6. 保存和加载

训练好了一个神经网络后，可以保存起来下次使用时再次加载：

import tensorflow as tf
import numpy as np

## Save to file
# remember to define the same dtype and shape when restore
W = tf.Variable([[1,2,3],[3,4,5]], dtype=tf.float32, name=‘weights‘)
b = tf.Variable([[1,2,3]], dtype=tf.float32, name=‘biases‘)

init= tf.initialize_all_variables()

saver = tf.train.Saver()

# 用 saver 将所有的 variable 保存到定义的路径
with tf.Session() as sess:
   sess.run(init)
   save_path = saver.save(sess, "my_net/save_net.ckpt")
   print("Save to path: ", save_path)


################################################

# restore variables
# redefine the same shape and same type for your variables
W = tf.Variable(np.arange(6).reshape((2, 3)), dtype=tf.float32, name="weights")
b = tf.Variable(np.arange(3).reshape((1, 3)), dtype=tf.float32, name="biases")

# not need init step

saver = tf.train.Saver()
# 用 saver 从路径中将 save_net.ckpt 保存的 W 和 b restore 进来
with tf.Session() as sess:
    saver.restore(sess, "my_net/save_net.ckpt")
    print("weights:", sess.run(W))
    print("biases:", sess.run(b))

tensorflow 现在只能保存 variables，还不能保存整个神经网络的框架，所以再使用的时候，需要重新定义框架，然后把 variables 放进去学习。

---

ok, 搞定快速入门，明天写用 RNN 做命名实体识别。

我是 不会停的蜗牛 Alice
85后全职主妇
喜欢人工智能，行动派
创造力，思考力，学习力提升修炼进行中
欢迎您的喜欢，关注和评论！

---

 推荐拓展阅读

 

 著作权归作者所有

Run With Artificial Intelligence, not Against. ...