前面说到了Flannel的部署，今天这里说下Docker跨主机容器间网络通信的另一个工具Weave的使用。当容器分布在多个不同的主机上时，这些容器之间的相互通信变得复杂起来。容器在不同主机之间都使用的是自己的私有IP地址，不同主机的容器之间进行通讯需要将主机的端口映射到容器的端口上，而且IP地址需要使用主机的IP地址。Weave正是为了解决这个问题而出现的，它把不同主机上容器互相连接的网络虚拟成一个类似于本地网络的网络。

如果了解SDN技术或者部署过OpenStack的网络模块（Neutron）的话，这里通过Weave构建的网络与它们比较类似。它是在一个网络的基础上，构建了一层由软件定义的网络层，这个网络看起来就像是一个本地的局域网，但是实际上它的底层通过另一个网络进行通信。这个网络可能会比实际物理局域网的可靠性要差一些，但是从可用性角度来看，它带来了很大的便利性：可以在位于不同位置的节点之间通信，而好像它们在一个地方一样。也可以把这种网络想象成一个类似于VPN似的东西。

Weave介绍

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Weave是Github上一个比较热门的Docker容器网络方案，具有非常良好的易用性且功能强大。Weave 的框架它包含了两大主要组件：
1）Weave：用户态的shell脚本，用于安装Weave，将container连接到Weave虚拟网络。并为它们分配IP。
2）Weaver：运行于container内，每个Weave网络内的主机都要运行，是一个Go语言实现的虚拟网络路由器。不同主机之间的网络通信依赖于Weaver路由。
   
Weave通过创建虚拟网络使Docker容器能够跨主机通信并能够自动相互发现。
通过weave网络，由多个容器构成的基于微服务架构的应用可以运行在任何地方：主机，多主机，云上或者数据中心。
应用程序使用网络就好像容器是插在同一个网络交换机上一样，不需要配置端口映射，连接等。
在weave网络中，使用应用容器提供的服务可以暴露给外部，而不用管它们运行在何处。类似地，现存的内部系统也可以接受来自于应用容器的请求，而不管容器运行于何处。
  
一个Weave网络由一系列的'peers'构成----这些weave路由器存在于不同的主机上。每个peer都由一个名字，这个名字在重启之后保持不变.这个名字便于用户理解和区分日志信息。
每个peer在每次运行时都会有一个不同的唯一标识符（UID）.对于路由器而言，这些标识符不是透明的，尽管名字默认是路由器的MAC地址。
  
Weave路由器之间建立起TCP连接，通过这个连接进行心跳握手和拓扑信息交换，这些连接可以通过配置进行加密。
peers之间还会建立UDP连接，也可以进行加密，这些UDP连接用于网络包的封装，这些连接是双工的而且可以穿越防火墙。
Weave网络在主机上创建一个网桥,每个容器通过veth pari连接到网桥上，容器由用户或者weave网络的IPADM分配IP地址。

选择Weave的原因？

1
2
3
4
1）无忧的配置
Weave网络能够简化容器网络的配置。因为weave网络中的容器使用标准的端口提供服务（如，MySQL默认使用3306),管理微服务是十分直接简单的。
每个容器都可以通过域名来与另外的容器通信，也可以直接通信而无需使用NAT，也不需要使用端口映射或者复杂的linking.
部署weave容器网络的最大的好处是无需修改你的应用代码。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
2）服务发现
Weave网络通过在每个节点上启动一个"微型的DNS"服务来实现服务发现。你只需要给你的容器起个名字就可以使用服务发现了，还可以在多个同名的容器上提供负载均衡的功能。
  
3）不需要额外的集群存储
所有其它的Docker网络插件，包括Docker自带的"overlay"驱动，在你真正能使用它们之间，都需要安装额外的集群存储----一个像Consul或者Zookeepr那样的中心数据库. 除了安装，维护和管理困难外，甚至Docker主机需要始终与集群存储保持连接，如果你断开了与其的连接，尽管很短暂，你也不能够启动和停止任何容器了。
Weave网络是与Docker网络插件捆绑在一起的，这意味着你可以马上就使用它，而且可以在网络连接出现问题时依旧启动和停止容器。
关于更多Weave Docker插件的介绍，请查看 Weave Network Plugin如何工作.
  
4）在部分连接情况下进行操作
Weave网络能够在节点间转发流量，它甚至能够在网状网络部分连接的情况下工作。这意味着你可以在混合了传统系统和容器化的应用的环境中使用Weave网络来保持通信。
  
5）Weave网络很快
Weave网络自动在两个节点之间选择最快的路径，提供接近本地网络的吞吐量和延迟，而且这不需要你的干预。
关于Fast Datapath如何工作请参考 How Fast Datapath Works .
  
6）组播支持
Weave网络完全支持组播地址和路径。数据可以被发送给一个组播地址，数据的副本可以被自动地广播。
  
7）NAT 转换
使用Weave网络，部署你的应用---无论是点对点的文件共享，基于ip的voice或者其它应用，你都可以充分利用内置的NAT转换。通过Weave网络，你的app将会是可移值的，容器化的，
加上它对网络标准化的处理，将又会使你少关心一件事。
  
8）与任何框架集成: Kubernetes, Mesos, Amazon ECS, …
如果你想为所有的框架使用一个工具，Weave网络是一个好的选择。比如: 除了作为Docker插件使用，你还可以将其作为一个Kubernetes插件plugin.你还可以在 Amazon ECS ,Mesos和
Marathon中使用它.

weave网络通信模型

1
weave通过在docker集群的每个主机上启动虚拟的路由器，将主机作为路由器，形成互联互通的网络拓扑，在此基础上，实现容器的跨主机通信。其主机网络拓扑参见下图：

1
2
3
4
5
如上图所示，在每一个部署Docker的主机（可能是物理机也可能是虚拟机）上都部署有一个W（即weave router，它本身也可以以一个容器的形式部署）。
weave网络是由这些weave routers组成的对等端点（peer）构成，并且可以通过weave命令行定制网络拓扑。
  
每个部署了weave router的主机之间都会建立TCP和UDP两个连接，保证weave router之间控制面流量和数据面流量的通过。控制面由weave routers之间建立的TCP连接构成，通过它进行握手和拓扑关系信息的交换通信。控制面的通信可以被配置为加密通信。而数据面由weave routers之间建立的UDP连接构成，这些连接大部分都会加密。这些连接都是全双工的，并且可以穿越防火墙。
当容器通过weave进行跨主机通信时，其网络通信模型可以参考下图：

1
2
3
4
5
6
7
8
9
10
11
12
从上面的网络模型图中可以看出，对每一个weave网络中的容器，weave都会创建一个网桥，并且在网桥和每个容器之间创建一个veth pair，一端作为容器网卡加入到容器的网络命名空间中，并为容器网卡配置ip和相应的掩码，一端连接在网桥上，最终通过宿主机上weave router将流量转发到对端主机上。
其基本过程如下：
1）容器流量通过veth pair到达宿主机上weave router网桥上。
  
2）weave router在混杂模式下使用pcap在网桥上截获网络数据包，并排除由内核直接通过网桥转发的数据流量，例如本子网内部、本地容器之间的数据以及宿主机和本地容
   器之间的流量。捕获的包通过UDP转发到所其他主机的weave router端。
  
3）在接收端，weave router通过pcap将包注入到网桥上的接口，通过网桥的上的veth pair，将流量分发到容器的网卡上。
     
weave默认基于UDP承载容器之间的数据包，并且可以完全自定义整个集群的网络拓扑，但从性能和使用角度来看，还是有比较大的缺陷的：
1）weave自定义容器数据包的封包解包方式，不够通用，传输效率比较低，性能上的损失也比较大。
2）集群配置比较负载，需要通过weave命令行来手工构建网络拓扑，在大规模集群的情况下，加重了管理员的负担。

Weave的安装与启动

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
1）直接从github下载二进制文件安装。
[root@localhost ~]# wget -O /usr/local/bin/weave https://raw.githubusercontent.com/zettio/weave/master/weave
[root@localhost ~]# chmod a+x /usr/local/bin/weave
      
2）启动weave路由器，这个路由器其实也是以容器的形式运行的。（前提是已经启动了docker服务进程）
[root@localhost ~]# weave launch weave [--no-detect-tls] 
Trying to pull repository docker.io/weaveworks/weave ... 
latest: Pulling from docker.io/weaveworks/weave
605ce1bd3f31: Pull complete 
158c8654e528: Pull complete 
bfc39f563ffa: Pull complete 
8646fd58e941: Pull complete 
05f4261dc16c: Pull complete 
96ad94aa18d5: Pull complete 
.......
      
3）查看镜像，可以发现上面下载的weave路由容器镜像
[root@localhost ~]# docker images
REPOSITORY                       TAG                 IMAGE ID            CREATED             SIZE
docker.io/weaveworks/weaveexec   latest              e85f0baea6a8        12 hours ago        74.22 MB
docker.io/weaveworks/weave       latest              cbfe14a12711        12 hours ago        59.46 MB
docker.io/weaveworks/weavedb     latest              9d95756f4947        6 days ago          282 B
      
4）此时会发现有两个网桥，一个是Docker默认生成的，另一个是Weave生成的。
[root@localhost ~]# brctl show                                     #yum安装bridge-utils工具后，就会出现brctl命令    
bridge name     bridge id               STP enabled     interfaces
docker0         8000.0242eb16438d       no
weave           8000.000000000000       no              vethwe-bridge
      
查看运行的容器，发现weave路由容器已经自动运行
[root@localhost ~]# docker ps
CONTAINER ID        IMAGE                     COMMAND                  CREATED              STATUS              PORTS               NAMES
f30fe9258e1f        weaveworks/weave:latest   "/home/weave/weaver -"   About a minute ago   Up About a minute                       weave
   
weave关闭
[root@localhost ~]# weave stop
或者直接关闭weave容器
[root@localhost ~]# docker stop weave
[root@localhost ~]# docker rm weave
   
weave命令帮助
[root@localhost ~]# weave --help
Usage:
weave --help | help
      setup
      version
weave launch        [--password <pass>] [--trusted-subnets <cidr>,...]
                    [--host <ip_address>]
                    [--name <mac>] [--nickname <nickname>]
                    [--no-restart] [--resume] [--no-discovery] [--no-dns]
                    [--ipalloc-init <mode>]
                    [--ipalloc-range <cidr> [--ipalloc-default-subnet <cidr>]]
                    [--plugin=false] [--proxy=false]
                    [-H <endpoint>] [--without-dns] [--no-multicast-route]
                    [--no-rewrite-hosts] [--no-default-ipalloc]
                    [--hostname-from-label <labelkey>]
                    [--hostname-match <regexp>]
                    [--hostname-replacement <replacement>]
                    [--rewrite-inspect]
                    [--log-level=debug|info|warning|error]
                    <peer> ...
weave prime
weave env           [--restore]
      config
      dns-args
weave connect       [--replace] [<peer> ...]
      forget        <peer> ...
weave attach        [--without-dns] [--rewrite-hosts] [--no-multicast-route]
                      [<addr> ...] <container_id>
      detach        [<addr> ...] <container_id>
weave expose        [<addr> ...] [-h <fqdn>]
      hide          [<addr> ...]
weave dns-add       [<ip_address> ...] <container_id> [-h <fqdn>] |
                    <ip_address> ... -h <fqdn>
      dns-remove    [<ip_address> ...] <container_id> [-h <fqdn>] |
                    <ip_address> ... -h <fqdn>
      dns-lookup    <unqualified_name>
weave status        [targets | connections | peers | dns | ipam]
      report        [-f <format>]
      ps            [<container_id> ...]
weave stop
weave reset         [--force]
      rmpeer        <peer_id> ...
where <peer>     = <ip_address_or_fqdn>[:<port>]
      <cidr>     = <ip_address>/<routing_prefix_length>
      <addr>     = [ip:]<cidr> | net:<cidr> | net:default
      <endpoint> = [tcp://][<ip_address>]:<port> | [unix://]/path/to/socket
      <peer_id>  = <nickname> | <weave internal peer ID>
      <mode>     = consensus[=<count>] | seed=<mac>,... | observer
       
接下来就可以运行应用容器，使用weave提供的网络功能了。


Weave的应用示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
1）机器环境准备：
node1    10.10.172.201 
node2    10.10.172.202    
  
node1宿主机上的应用容器my-test1: 192.168.0.2/24
node2宿主机上的应用容器my-test2: 192.168.0.3/24
  
两台机上均安装Docker及Weave，并均启动好Weave路由容器（安装及启动操作如上）。最好关闭两台机器的防火墙！（如果打开防火墙，需要开放6783端口）
  
2）在两台机上均启动一个应用容器，有以下两种方式：
第一种方式：可以直接使用weave run命令；
[root@node1 ~]# weave run 192.168.0.2/24 -itd docker.io/centos /bin/bash
The 'weave run' command has been removed as of Weave Net version 2.0
Please see release notes for further information
  
由上可知，weave在2.0版本之后就没有“weave run”这个命令了，所以还是使用下面的第二种方式
  
第二种方式：先使用docker run启动好容器，然后使用weave attach命令给容器绑定IP地址
在node1机器上启动第一个容器my-test1，容器ip绑定为192.168.0.2
[root@node1 ~]# docker run -itd --name=my-test1 docker.io/centos /bin/bash
02b376c8c34c7a099b391c58974db638315d52673d27360c8ab031ee0fd23d70
[root@node1 ~]# weave attach 192.168.0.2/24 my-test1           #使用容器名称或容器id都可以；即给my-test1容器绑定ip为192.168.0.2
192.168.0.2
  
[root@node1 ~]# docker exec -ti my-test1 /bin/bash 
[root@02b376c8c34c /]# ifconfig              #执行安装yum install -y net-tools，就会出现ifconfig命令  
eth0: flags=4163<UP,BROADCAST,RUNNING,MULTICAST>  mtu 1500
        inet 172.17.0.2  netmask 255.255.0.0  broadcast 0.0.0.0
        inet6 fe80::42:acff:fe11:2  prefixlen 64  scopeid 0x20<link>
        ether 02:42:ac:11:00:02  txqueuelen 0  (Ethernet)
        RX packets 4302  bytes 13338144 (12.7 MiB)
        RX errors 0  dropped 0  overruns 0  frame 0
        TX packets 4161  bytes 283007 (276.3 KiB)
        TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0
ethwe: flags=4163<UP,BROADCAST,RUNNING,MULTICAST>  mtu 1376
        inet 192.168.0.2  netmask 255.255.255.0  broadcast 192.168.0.255
        inet6 fe80::64f9:5bff:feb1:3764  prefixlen 64  scopeid 0x20<link>
        ether 66:f9:5b:b1:37:64  txqueuelen 0  (Ethernet)
        RX packets 12  bytes 948 (948.0 B)
        RX errors 0  dropped 0  overruns 0  frame 0
        TX packets 4  bytes 300 (300.0 B)
        TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0
lo: flags=73<UP,LOOPBACK,RUNNING>  mtu 65536
        inet 127.0.0.1  netmask 255.0.0.0
        inet6 ::1  prefixlen 128  scopeid 0x10<host>
        loop  txqueuelen 0  (Local Loopback)
        RX packets 0  bytes 0 (0.0 B)
        RX errors 0  dropped 0  overruns 0  frame 0
        TX packets 0  bytes 0 (0.0 B)
        TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0
  
在node2机器上启动容器my-test2，容器ip绑定为192.168.0.3
[root@node2 ~]# docker run -itd --name=my-test2 docker.io/centos /bin/bash
e67b403a7eeaa46e462f8752da8b362ac65341d7d83d6f03a67482a19c550c37
[root@node2 ~]# weave attach 192.168.0.2/24 my-test2                     //weave detach 192.168.0.3/24 my-test2表示删除这个绑定
192.168.0.3
[root@node2 ~]# docker exec -ti my-test2 /bin/bash
[root@e67b403a7eea /]# ifconfig                                          //或者ip addr命令查看
eth0: flags=4163<UP,BROADCAST,RUNNING,MULTICAST>  mtu 1500
        inet 172.17.0.2  netmask 255.255.0.0  broadcast 0.0.0.0
        inet6 fe80::42:acff:fe11:2  prefixlen 64  scopeid 0x20<link>
        ether 02:42:ac:11:00:02  txqueuelen 0  (Ethernet)
        RX packets 4999  bytes 13378310 (12.7 MiB)
        RX errors 0  dropped 0  overruns 0  frame 0
        TX packets 4825  bytes 333445 (325.6 KiB)
        TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0
ethwe: flags=4163<UP,BROADCAST,RUNNING,MULTICAST>  mtu 1376
        inet 192.168.0.3  netmask 255.255.255.0  broadcast 192.168.0.255
        inet6 fe80::ac9b:28ff:fe47:794c  prefixlen 64  scopeid 0x20<link>
        ether ae:9b:28:47:79:4c  txqueuelen 0  (Ethernet)
        RX packets 12  bytes 948 (948.0 B)
        RX errors 0  dropped 0  overruns 0  frame 0
        TX packets 4  bytes 300 (300.0 B)
        TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0
lo: flags=73<UP,LOOPBACK,RUNNING>  mtu 65536
        inet 127.0.0.1  netmask 255.0.0.0
        inet6 ::1  prefixlen 128  scopeid 0x10<host>
        loop  txqueuelen 0  (Local Loopback)
        RX packets 0  bytes 0 (0.0 B)
        RX errors 0  dropped 0  overruns 0  frame 0
        TX packets 0  bytes 0 (0.0 B)
        TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0
  
温馨提示：
上面在docker run启动容器时，可以添加--net=none参数，这个表示容器启动后不使用默认的虚拟网卡docker0自动分配的ip，而是使用weave绑定的ip；
当然也可以选择不添加这个参数去启动容器，这样，容器启动后就会有两个网卡，即两个ip：
一个是docker0自动分配的ip，这个适用于同主机内的容器间通信，即同主机的容器使用docker0分配的ip可以相互通信；另一个就是weave网桥绑定的ip。
  
3）容器互联
默认情况下，上面在node1和node2两台宿主机上创建的2个容器间都是相互ping不通的。需要使用weave connect命令在两台weave的路由器之间建立连接。
[root@node1 ~]# weave connect 10.10.172.202                            //连接的是对方宿主机的ip，注意"weave forget ip" z则表示断开这个连接
[root@node2 ~]# weave connect 10.10.172.201
  
然后就会发现，此时位于两台不同主机上的相同子网段内的容器之间可以相互ping通了
[root@node1 ~]# docker exec -ti my-test1 /bin/bash
[root@02b376c8c34c /]# ping 192.168.0.3
PING 192.168.0.3 (192.168.0.3) 56(84) bytes of data.
64 bytes from 192.168.0.3: icmp_seq=1 ttl=64 time=0.995 ms
64 bytes from 192.168.0.3: icmp_seq=2 ttl=64 time=0.865 ms
.....
  
[root@node2 ~]# docker exec -ti my-test2 /bin/bash
[root@e67b403a7eea /]# ping 192.168.0.2
PING 192.168.0.2 (192.168.0.2) 56(84) bytes of data.
64 bytes from 192.168.0.2: icmp_seq=1 ttl=64 time=1.88 ms
64 bytes from 192.168.0.2: icmp_seq=2 ttl=64 time=0.804 ms
.....
  
再在node1上启动容器my-test3，绑定ip为192.168.0.8，在node2上启动容器my-test4，绑定ip为192.168.0.10
会发现这四个在同一个子网内的容器都是可以相互ping通的。
  
--------------------------------------------------------------------------------------------------------
再接着启动与上面不在同一个子网内的容器
node1上启动容器my-test5，绑定ip为192.168.10.10，node2上启动容器my-test6，绑定ip为192.168.10.20
  
[root@node1 ~]# docker run -itd --name=my-test5 docker.io/centos /bin/bash
66fc03e4310c507fa2d9cb09261cf4412367de0a0dbc9a1e8fd009bf405bca3e
[root@node1 ~]# weave attach 192.168.10.10/24 my-test5
192.168.10.10
[root@node1 ~]# docker exec -ti my-test5 /bin/bash
[root@66fc03e4310c /]#
  
[root@node2 ~]# docker run -itd --name=my-test6 docker.io/centos /bin/bash
3f8a275050007e4fe6b0b9a8be2fd9596ba60edf8803d97f7a6d63d763749c1c
[root@node2 ~]# weave attach 192.168.10.20/24 my-test6
192.168.10.20
[root@node2 ~]# docker exec -ti my-test6 /bin/bash
[root@3f8a27505000 /]# ping 192.168.10.10
PING 192.168.10.10 (192.168.10.10) 56(84) bytes of data.
64 bytes from 192.168.10.10: icmp_seq=1 ttl=64 time=1.85 ms
64 bytes from 192.168.10.10: icmp_seq=2 ttl=64 time=0.930 ms
......
  
会发现在跨主机情况下，相同子网内的容器是可以相互通信的；但是处于不同子网的两个容器是不能互联的，尽管这两个容器在同一个主机下也是不能通信的！
这样的好处就是：使用不同子网进行容器间的网络隔离了。
  
--------------------------------------------------------------------------------------------------------
注意一个细节，在使用weave的时候：
1）如果使用Docker的原生网络，在容器内部是可以访问宿主机以及外部网络的。也就是说在启动容器的时候，使用了虚拟网卡docker0分配ip，
这种情况下，登陆容器后是可以ping通宿主机ip，并且可以对外联网的！
  
这个时候，在宿主机上是可以ping通docker0网桥的ip，但是ping不通weave网桥的ip。这个时候可以使用
"weave expose 192.168.0.1/24"命令来给weave网桥添加IP，以实现容器与宿主机网络连通。如下：
  
默认在node1和node2宿主机上是ping不通my-test1容器的weave网桥ip的
[root@node1 ~]# ping 192.168.0.2
PING 192.168.0.2 (192.168.0.2) 56(84) bytes of data.
.......
  
[root@node2 ~]# ping 192.168.0.3
PING 192.168.0.2 (192.168.0.2) 56(84) bytes of data.
.......
  
在node1和node2两台机器上都添加weave网桥的ip
[root@node1 ~]# weave expose 192.168.0.1/24            //注意这里的192.168.0.1/24是上面my-test1、my-test2、my-test3、my-test4容器的weave网桥的网关地址
[root@node2 ~]# weave expose 192.168.0.1/24            //weave hide 192.168.0.1/24表示覆盖/删除这个设置
  
然后再在两台宿主机上ping上面同网段内的容器，发现都可以ping通了
[root@node1 ~]# ping 192.168.0.10
PING 192.168.0.3 (192.168.0.3) 56(84) bytes of data.
64 bytes from 192.168.0.3: icmp_seq=4 ttl=64 time=0.391 ms
64 bytes from 192.168.0.3: icmp_seq=5 ttl=64 time=0.363 ms
  
[root@node2 ~]# ping 192.168.0.8
PING 192.168.0.3 (192.168.0.3) 56(84) bytes of data.
64 bytes from 192.168.0.3: icmp_seq=4 ttl=64 time=0.391 ms
64 bytes from 192.168.0.3: icmp_seq=5 ttl=64 time=0.363 ms
  
然后再给另一网段的容器的weave网桥添加ip（可以在宿主机上对不同网段的容器的weave网桥添加ip）
[root@node1 ~]# weave expose 192.168.10.1/24
[root@node2 ~]# weave expose 192.168.10.1/24
  
[root@node1 ~]# ping 192.168.10.20
PING 192.168.10.20 (192.168.10.20) 56(84) bytes of data.
64 bytes from 192.168.10.20: icmp_seq=1 ttl=64 time=2.50 ms
64 bytes from 192.168.10.20: icmp_seq=2 ttl=64 time=0.318 ms
  
[root@node2 ~]# ping 192.168.10.10
PING 192.168.10.10 (192.168.10.10) 56(84) bytes of data.
64 bytes from 192.168.10.10: icmp_seq=1 ttl=64 time=0.335 ms
64 bytes from 192.168.10.10: icmp_seq=2 ttl=64 time=0.310 ms
  
2）如果不适用Docker的原生网络，即在容器启动的时候，添加--net=none，这样容器启动后，就不会使用docker0网卡分配ip。
这种情况下，登陆容器后发现不能访问宿主机以及外部网络的，而在宿主机上也不能ping通容器ip。
这个时候添加对应容器网段的weave网桥ip，这样可以实现容器与宿主机网络连通。但是，此时在容器内部依然不能访问外部网络。
  
所以说，可以同时使用Docker的原生网络和weave网络来实现容器互联及容器访问外网和端口映射。
使用外部网络及端口映射的时候就使用docker0网桥，需要容器互联的时候就使用weave网桥。每个容器分配两个网卡。

weave的其他特性

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
1）应用隔离：
不同子网容器之间默认隔离的，即便它们位于同一台物理机上也相互不通（使用-icc=false关闭容器互通）；不同物理机之间的容器默认也是隔离的
   
2）安全性：
可以通过weave launch -password wEaVe设置一个密码用于weave peers之间加密通信
   
3)查看weave路由状态：weave ps
[root@node1 ~]# weave ps
weave:expose 46:9f:2b:68:7b:8b 192.168.0.1/24 192.168.10.1/24
66fc03e4310c 76:3a:a0:ea:bd:ea 192.168.10.10/24
a05c5c68536c 0a:42:bc:34:a6:2b 192.168.0.4/24
02b376c8c34c 66:73:47:af:14:c4 192.168.0.2/24
   
[root@node2 ~]# weave ps
weave:expose 22:ee:41:9f:e4:9a 192.168.0.1/24 192.168.10.1/24
3f8a27505000 66:bd:3c:4f:5b:7c 192.168.10.20/24
c37c12cc01a3 ae:5c:0e:64:1b:20 192.168.0.10/24
e67b403a7eea 06:c3:64:3c:c9:3e 192.168.0.3/24
   
4)效率
weave 路由通过pcap捕获包这种方式来完成封装和解封装这个过程，效率应该是有问题的。
这个过程中需要将数据包从内核态拷贝到用户态，然后按照自定义的格式完成封装和解封装。
  
--------------------------------------------------------------------------------------------------
在已经关闭了weave（weave stop）后，发现weave网桥信息还在：
[root@node2 ~]# weave stop
[root@node2 ~]# brctl show
bridge name     bridge id               STP enabled     interfaces
docker0         8000.024222bb5763       no              veth479c96d
                                                        vethdd2d391
                                                        vethe098b20
weave           8000.000000000000       no              vethwe-bridge
                                                        vethwepl5202
                                                        vethwepl5560
                                                        vethwepl5638
  
[root@node2 ~]# ifconfig
........
  
weave: flags=4163<UP,BROADCAST,RUNNING,MULTICAST>  mtu 1376
        inet 192.168.0.1  netmask 255.255.255.0  broadcast 192.168.0.255
        inet6 fe80::20ee:41ff:fe9f:e49a  prefixlen 64  scopeid 0x20<link>
        ether 22:ee:41:9f:e4:9a  txqueuelen 0  (Ethernet)
        RX packets 144  bytes 9377 (9.1 KiB)
        RX errors 0  dropped 0  overruns 0  frame 0
        TX packets 34  bytes 1740 (1.6 KiB)
        TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0
  
删除weave网桥信息（其他ifconfig命令查出的网络设备删除的方法类似）：
[root@node2 ~]# ip link set dev weave down
[root@node2 ~]# brctl delbr weave
  
[root@node2 ~]# brctl show
bridge name     bridge id               STP enabled     interfaces
docker0         8000.024222bb5763       no              veth479c96d
                                                        vethdd2d391
                                                        vethe098b20

注：weave给容器指定的IP地址会随着容器的重启而消失。




本文转自 dengaosky 51CTO博客，原文链接：http://blog.51cto.com/dengaosky/2069478，如需转载请自行联系原作者

Docker网络解决方案-Weave部署记录相关推荐

  1. Docker网络解决方案 - Weave部署记录

    前面说到了Flannel的部署,今天这里说下Docker跨主机容器间网络通信的另一个工具Weave的使用.当容器分布在多个不同的主机上时,这些容器之间的相互通信变得复杂起来.容器在不同主机之间都使用的 ...

  2. Docker网络解决方案 - Calico部署记录

    Docker网络解决方案 - Calico部署记录 参考文章: (1)Docker网络解决方案 - Calico部署记录 (2)https://www.cnblogs.com/kevingrace/p ...

  3. Docker网络解决方案-Flannel部署记录

    Docker跨主机容器间网络通信实现的工具有Pipework.Flannel.Weave.Open vSwitch(虚拟交换机).Calico实现跨主机容器间的通信.其中Pipework.Weave. ...

  4. 跟风学Docker之四：Docker网络解决方案

    2019独角兽企业重金招聘Python工程师标准>>> 跟风学Docker之四:Docker网络解决方案 博客分类: docker 前言:前面的部分一直都是单机跑docker,但实际 ...

  5. Docker管理工具-Swarm部署记录

    Swarm介绍 Swarm是Docker公司在2014年12月初发布的一套较为简单的工具,用来管理Docker集群,它将一群Docker宿主机变成一个单一的,虚拟的主机.Swarm使用标准的Docke ...

  6. docker——网络及项目部署

    docker网络 理解docker0 将之前学习的镜像全部删除,查看一下ip,发现基础的网卡有三个,分别如下 [root@izbp1bc82otjd8cslsu9zsz ~]# ip attr Obj ...

  7. Linux下smokeping网络监控环境部署记录

    smokeping是一款监控网络状态和稳定性的开源软件(它是rrdtool的作者开发的),通过它可以监控到公司IDC的网络状况,如延时,丢包率,是否BGP多线等: smokeping会向目标设备和系统 ...

  8. Docker管理工具 - Swarm部署记录

    Swarm是Docker原生的集群管理软件,与Kubernetes比起来比较简单.Swarm这个项目名称特别贴切.在Wiki的解释中,Swarm behavior是指动物的群集行为.比如我们常见的蜂群 ...

  9. Docker集群管理工具-Kubernetes部署记录

    Kubernetes介绍 Kubernetes是Google开源的容器集群管理系统,是基于Docker构建一个容器的调度服务,提供资源调度.均衡容灾.服务注册.动态扩缩容等功能套件. Kubernet ...

最新文章

  1. Spring+SpringMVC+MyBatis深入学习及搭建(十)——MyBatis逆向工程
  2. leetcode 72. 编辑距离
  3. Peter Cnudde谈雅虎如何使用Hadoop、深度学习和大数据平台
  4. 查询ms sql 2005版本号
  5. python爬虫完整实例-Python爬虫 实例
  6. php文章编辑页面,zblogphp在文章页面中增加直达后台编辑该文章内容功能
  7. Device Tree（三）：代码分析【转】
  8. antd table设置表格一个单元格的字体颜色_微软Office三件套，各有一个效率神器，全都知道的人不超过1%...
  9. python库（2）—— threading
  10. 美图秀秀计算机教程,美图秀秀批处理软件详细图文版使用教程，一起学习吧
  11. （附源码）ssm教培管理系统 毕业设计 230932
  12. 企业级无线无缝漫游之思创漫游3.0 Plus ，三层漫游
  13. 一个屌丝程序猿的人生（二）
  14. linux ftw()函数使用方法 实例
  15. python自定义标识符的使用区分大小写吗_Python中的标识符是不区分大小写的
  16. 罗技 连点 脚本_走心分享！当评测罗技MASTER 3遇上ANYWHERE 3
  17. 拓尔思信息科技股份有限公司2019校园春季招聘
  18. 串口服务器直连路由器如何配置,塔石物联网:串口服务器如何实现跨网段传输！...
  19. 服务器基础知识【初学者必看】
  20. ViewPager设置页面缩放

热门文章

  1. 银联接口的一些加密方式
  2. [翻译]XNA在线俱乐部网站即将开站！
  3. 使用IConfigurationSectionHandler在web.config中增加自定义配置
  4. .NET+Oracle 9i时产生的未在本地计算机上注册“OraOLEDB.Oracle.1”提供程序
  5. UI Framework-1: Ash Color Chooser
  6. Nginx+php+fastcgi的原理与关系
  7. 1、检测是用那个浏览器打开的
  8. PHP程序员最常犯的11个MySQL错误
  9. mysql 5.7.11 压缩包安装办法遇到故障后彻底卸载办法
  10. 路由器互通过程(简述）