精华内容
下载资源
问答
  • Weave

    千次阅读 2018-12-25 14:35:34
    weave网络通信模型 weave通过在docker集群的每个主机上启动虚拟的路由器,将主机作为路由器,形成互联互通的网络拓扑,在此基础上,实现容器的跨主机通信。其主机网络拓扑参见下图: 如上图所示,在每一个部署...

    weave网络通信模型

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

    在这里插入图片描述

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

    在这里插入图片描述

    从上面的网络模型图中可以看出,对每一个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)直接从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                      
    
    Unable to find image 'weaveworks/weaveexec:latest' locally
    
    Trying to pull repository docker.io/weaveworks/weaveexec ...
    
    latest: Pulling from docker.io/weaveworks/weaveexec
    
    79650cf9cc01: Pull complete
    
    a0a33a8311d7: Pull complete
    
    e95af5f75fa8: Pull complete
    
    7119d296ce72: Pull complete
    
    7f0698aa2117: Pull complete
    
    db711cb12a2b: Pull complete
    
    .......
    
         
    
    3)查看镜像,可以发现上面下载的weave路由容器镜像
    
    [root@localhost ~]# docker images
    
    REPOSITORY                         TAG                 IMAGE ID            CREATED             SIZE
    
    docker.io/weaveworks/weaveexec     latest              e4870c565dfa        11 hours ago        107.7 MB
    
    docker.io/weaveworks/weave         latest              70bd2bf0b0eb        11 hours ago        58.22 MB
    
    docker.io/weaveworks/weavedb       latest              9a4a497119c4        3 months ago        252 B
    
    docker.io/centos                 latest              67591570dd29        5 months ago        191.8 MB
    
         
    
    4)此时会发现有两个网桥,一个是Docker默认生成的,另一个是Weave生成的。
    
    [root@localhost ~]# brctl show                                     #yum安装bridge-utils工具后,就会出现brctl命令    
    
    bridge name bridge id       STP enabled interfaces
    
    docker0     8000.0242376456d7   no 
    
    weave       8000.32298bba31f1   no      vethwe-bridge
    
         
    
    查看运行的容器,发现weave路由容器已经自动运行
    
    [root@localhost ~]# docker ps
    
    CONTAINER ID        IMAGE                     COMMAND                  CREATED             STATUS              PORTS               NAMES
    
    c5aacecbe40e        weaveworks/weave:latest   "/home/weave/weaver -"   6 minutes ago       Up 6 minutes                            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)机器环境准备:
    
    node-1    103.10.86.238 
    
    node-2    103.10.86.239    
    
     
    
    node-1宿主机上的应用容器my-test1: 192.168.0.2/24
    
    node-2宿主机上的应用容器my-test2: 192.168.0.3/24
    
     
    
    两台机上均安装Docker及Weave,并均启动好Weave路由容器(安装及启动操作如上)。最好关闭两台机器的防火墙!(如果打开防火墙,需要开放6783端口)
    
     
    
    2)在两台机上均启动一个应用容器,有以下两种方式:
    
    第一种方式:可以直接使用weave run命令;
    
    [root@node-1 ~]# 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版本之后就没有“docker run”这个命令了,所以还是使用下面的第二种方式
    
     
    
    第二种方式:先使用docker run启动好容器,然后使用weave attach命令给容器绑定IP地址
    
    在node-1机器上启动第一个容器my-test1,容器ip绑定为192.168.0.2
    
    [root@node-1 ~]# docker run -itd --name=my-test1 docker.io/centos /bin/bash
    
    06d70049141048798519bfa1292ed81068fc28f1e142a51d22afd8f3fc6d0239
    
    [root@node-1 ~]# weave attach 192.168.0.2/24 my-test1           #使用容器名称或容器id都可以;即给my-test1容器绑定ip为192.168.0.2
    
    192.168.0.2
    
     
    
    [root@node-1 ~]# docker exec -ti my-test1 /bin/bash
    
    [root@00efd39d3a7d /]# 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 5559  bytes 11893401 (11.3 MiB)
    
            RX errors 0  dropped 0  overruns 0  frame 0
    
            TX packets 5287  bytes 410268 (400.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.2  netmask 255.255.255.0  broadcast 0.0.0.0
    
            inet6 fe80::88b0:ddff:fea2:58c5  prefixlen 64  scopeid 0x20<link>
    
            ether 8a:b0:dd:a2:58:c5  txqueuelen 0  (Ethernet)
    
            RX packets 97  bytes 7234 (7.0 KiB)
    
            RX errors 0  dropped 0  overruns 0  frame 0
    
            TX packets 66  bytes 4316 (4.2 KiB)
    
            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 21  bytes 2352 (2.2 KiB)
    
            RX errors 0  dropped 0  overruns 0  frame 0
    
            TX packets 21  bytes 2352 (2.2 KiB)
    
            TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0
    
     
    
    在node-2机器上启动容器my-test2,容器ip绑定为192.168.0.3
    
    [root@node-2 ~]# docker run -itd --name=my-test2 docker.io/centos /bin/bash
    
    8f2ecc2449a0be1f1be2825cb211f275f9adb2109249ab0ff1ced6bbb92dd733
    
    [root@node-2 ~]# weave attach 192.168.0.3/24 my-test2                     //weave detach 192.168.0.3/24 my-test2表示删除这个绑定
    
    192.168.0.3
    
    [root@node-2 ~]# docker exec -ti my-test2 /bin/bash
    
    [root@e0ed62d30226 /]# ifconfig                                          //或者ip addr命令查看
    
    ......
    
    ethwe: flags=4163<UP,BROADCAST,RUNNING,MULTICAST>  mtu 1376
    
            inet 192.168.0.3  netmask 255.255.255.0  broadcast 0.0.0.0
    
            inet6 fe80::3064:8fff:fe3c:909a  prefixlen 64  scopeid 0x20<link>
    
            ether 32:64:8f:3c:90:9a  txqueuelen 0  (Ethernet)
    
            RX packets 63  bytes 4734 (4.6 KiB)
    
            RX errors 0  dropped 0  overruns 0  frame 0
    
            TX packets 34  bytes 2580 (2.5 KiB)
    
            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)容器互联
    
    默认情况下,上面在node-1和node-2两台宿主机上创建的2个容器间都是相互ping不通的。需要使用weave connect命令在两台weave的路由器之间建立连接。
    
    [root@node-1 ~]# weave connect 103.10.86.239                            //连接的是对方宿主机的ip,注意"weave forget ip" z则表示断开这个连接
    
     
    
    然后就会发现,此时位于两台不同主机上的相同子网段内的容器之间可以相互ping通了
    
    [root@node-1 ~]# docker exec -ti my-test1 /bin/bash
    
    [root@00efd39d3a7d /]# 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=3.27 ms
    
    64 bytes from 192.168.0.3: icmp_seq=2 ttl=64 time=0.657 ms
    
    .....
    
     
    
    [root@node-2 ~]# docker exec -ti my-test2 /bin/bash
    
    [root@e0ed62d30226 /]# 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=0.453 ms
    
    64 bytes from 192.168.0.2: icmp_seq=2 ttl=64 time=0.320 ms
    
    .....
    
     
    
    再在node-1上启动容器my-test3,绑定ip为192.168.0.8,在node-2上启动容器my-test4,绑定ip为192.168.0.10
    
    会发现这四个在同一个子网内的容器都是可以相互ping通的。
    
     
    
    --------------------------------------------------------------------------------------------------------
    
    再接着启动与上面不在同一个子网内的容器
    
    node-1上启动容器my-test4,绑定ip为192.168.10.10,node-2上启动容器my-test5,绑定ip为192.168.10.20
    
     
    
    [root@node-1 ~]# docker run -itd --name=my-test5 docker.io/centos /bin/bash
    
    2896b6cad7afcd57d8b9091a020f1837992bade2567752614caf3cb645b6d315
    
    [root@node-1 ~]# weave attach 192.168.10.10/24 my-test5
    
    192.168.10.10
    
    [root@node-1 ~]# docker exec -ti my-test5 /bin/bash
    
    [root@2896b6cad7af /]#
    
     
    
    [root@node-2 ~]# docker run -itd --name=my-test6 docker.io/centos /bin/bash
    
    b4627f0a6e657f5dc719c917349ad832e15f360f75d5743b489f8e7e18b7dc2e
    
    [root@node-2 ~]# weave attach 192.168.10.20/24 my-test6
    
    192.168.10.20
    
    [root@node-2 ~]# docker exec -ti my-test6 /bin/bash
    
    [root@b4627f0a6e65 /]# 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.417 ms
    
    64 bytes from 192.168.10.10: icmp_seq=2 ttl=64 time=0.324 ms
    
    ......
    
     
    
    会发现在跨主机情况下,相同子网内的容器是可以相互通信的;但是处于不同子网的两个容器是不能互联的,尽管这两个容器在同一个主机下也是不能通信的!
    
    这样的好处就是:使用不同子网进行容器间的网络隔离了。
    
     
    
    --------------------------------------------------------------------------------------------------------
    
    注意一个细节,在使用weave的时候:
    
    1)如果使用Docker的原生网络,在容器内部是可以访问宿主机以及外部网络的。也就是说在启动容器的时候,使用了虚拟网卡docker0分配ip,
    
    这种情况下,登陆容器后是可以ping通宿主机ip,并且可以对外联网的!
    
     
    
    这个时候,在宿主机上是可以ping通docker0网桥的ip,但是ping不通weave网桥的ip。这个时候可以使用
    
    "weave expose 192.168.0.1/24"命令来给weave网桥添加IP,以实现容器与宿主机网络连通。如下:
    
     
    
    默认在node-1和node-2宿主机上是ping不通my-test1容器的weave网桥ip的
    
    [root@node-1 ~]# ping 192.168.0.2
    
    PING 192.168.0.2 (192.168.0.2) 56(84) bytes of data.
    
    .......
    
     
    
    [root@node-2 ~]# ping 192.168.0.3
    
    PING 192.168.0.2 (192.168.0.2) 56(84) bytes of data.
    
    .......
    
     
    
    在node-1和node-2两台机器上都添加weave网桥的ip
    
    [root@node-1 ~]# weave expose 192.168.0.1/24            //注意这里的192.168.0.1/24是上面my-test1、my-test2、my-test3、my-test4容器的weave网桥的网关地址
    
    [root@node-2 ~]# weave expose 192.168.0.1/24            //weave hide 192.168.0.1/24表示覆盖/删除这个设置
    
     
    
    然后再在两台宿主机上ping上面同网段内的容器,发现都可以ping通了
    
    [root@node-1 ~]# 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@node-2 ~]# 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@node-1 ~]# weave expose 192.168.10.1/24
    
    [root@node-2 ~]# weave expose 192.168.10.1/24
    
     
    
    [root@node-1 ~]# 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@node-2 ~]# 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)应用隔离:
    
    不同子网容器之间默认隔离的,即便它们位于同一台物理机上也相互不通(使用-icc=false关闭容器互通);不同物理机之间的容器默认也是隔离的
    
      
    
    2)安全性:
    
    可以通过weave launch -password wEaVe设置一个密码用于weave peers之间加密通信
    
      
    
    3)查看weave路由状态:weave ps
    
    [root@node-1 ~]# weave ps
    
    weave:expose 06:9d:3b:91:3d:f3 192.168.0.1/24 192.168.10.1/24
    
    2896b6cad7af 56:46:8c:14:42:e6 192.168.10.10/24
    
    c9aa381c1203 4a:0d:16:4d:bb:c2 192.168.0.8/24
    
    00efd39d3a7d 8a:b0:dd:a2:58:c5 192.168.0.2/24
    
      
    
    [root@node-2 ~]# weave ps
    
    weave:expose 26:b8:82:03:ff:24 192.168.0.1/24 192.168.10.1/24
    
    b4627f0a6e65 22:10:c4:b8:87:b3 192.168.10.20/24
    
    61722c59e3a0 d2:d5:34:1e:86:df 192.168.0.10/24
    
    e0ed62d30226 32:64:8f:3c:90:9a 192.168.0.3/24
    
      
    
    4)效率
    
    weave 路由通过pcap捕获包这种方式来完成封装和解封装这个过程,效率应该是有问题的。
    
    这个过程中需要将数据包从内核态拷贝到用户态,然后按照自定义的格式完成封装和解封装。
    
     
    
    --------------------------------------------------------------------------------------------------
    
    在已经关闭了weave(weave stop)后,发现weave网桥信息还在:
    
    [root@node-2 ~]# brctl show
    
    bridge name bridge id       STP enabled interfaces
    
    docker0     8000.0242b0c9bf2d   no     
    
    weave       8000.22a85b2682a1   no      vethwe-bridge
    
     
    
    [root@node-2 ~]# ifconfig
    
    ........
    
     
    
    weave: flags=4163<UP,BROADCAST,RUNNING,MULTICAST>  mtu 1376
    
            inet 192.168.100.1  netmask 255.255.255.0  broadcast 0.0.0.0
    
            inet6 fe80::20a8:5bff:fe26:82a1  prefixlen 64  scopeid 0x20<link>
    
            ether 22:a8:5b:26:82:a1  txqueuelen 0  (Ethernet)
    
            RX packets 57  bytes 3248 (3.1 KiB)
    
            RX errors 0  dropped 0  overruns 0  frame 0
    
            TX packets 22  bytes 1460 (1.4 KiB)
    
            TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0
    
     
    
    删除weave网桥信息(其他ifconfig命令查出的网络设备删除的方法类似):
    
    [root@node-2 ~]# ip link set dev weave down
    
    [root@node-2 ~]# brctl delbr weave
    
     
    
    [root@node-2 ~]# brctl show
    
    bridge name bridge id       STP enabled interfaces
    
    docker0     8000.0242b0c9bf2d   no 
    

    转自https://blog.csdn.net/mnasd/article/details/83060043

    展开全文
  • weave

    2012-01-08 23:05:24
    weave模板
    weave模板
    展开全文
  • Docker之weave工具

    千次阅读 2015-08-13 10:52:47
    weave什么呢?weave创建了一个虚拟网络,用来连接部署在多台机器上的docker容器。下面看看weave的应用场景:1 应用在使用该网络的时候就像所有的容器都在同一个交换机网络下一样,不需要配置端口映射、连接等等,...

    weave是什么呢?weave创建了一个虚拟网络,用来连接部署在多台机器上的docker容器。

    下面看看weave的应用场景:

    1

    这里写图片描述

    应用在使用该网络的时候就像所有的容器都在同一个交换机网络下一样,不需要配置端口映射、连接等等,容器中的应用提供的服务在weaver网络中可以被外部世界访问,不论你的容器运行在哪里。同样的,已经存在的系统应用也可以暴露给容器中的应用来调用,而不用担心内部应用运行的位置。
    

    2

    这里写图片描述

    weave可以穿透防火墙,流量是被加密的,允许主机连接通过一个不被信任的网络,使用weave你可以方便的部署多个容器在不同的地方运行
    

    3 安装weave

    apt-get install ethtool contrack
    
    git clone https://github.com/zettio/weave.git
    
    cd weave 
    
    chmod 755 weave

    4 假如你有一个docker应用运行在两台不同的主机HOST1和HOST2上面,也就是我们要在这两台主机上各部署一个相同类型的docker应用。

    在HOST1上面: 启动weave

    #这一步先启动weave路由,需要在每一台HOST上都启动
    
    weave launch
    
    #启动一个容器,在命令行设置了一个ip,weave run调用docker run -d,因此我们可以使用这种办法启动一个容器,同理存在weave start命令,它是调用docker start命令启动已经存在的容器,如果我们在该HOST1上有多个容器要部署,则继续执行第二行的命令即可,只要保证容器设置的ip没有冲突即可,同一个网段的ip可以到处使用
    
    ssh=$(weave run 10.1.1.1/24 -t -i ubuntu)

    在HOST2上面: 启动weave

    #这一步有点不一样,我们在HOST2上告诉weave他有一个同行在HOST1上,可以指定ip或者主机名,还可以指定端口。如果在HOST1和HOST2直接有防火墙,要确保tcp/udp的6783端口被打开
    
    weave launch $HOST1
    
    #和第一步中不同的地方在于,配置的IP不一样
    ssh=$(weave run 10.1.1.2/24 -t -i ubuntu)

    我们也可以告诉HOST1去连接HOST2,或者两者都告诉他们,这是没有任何问题的,weave会自动的连接,在他们的服务启动后,我们也可以告诉weave连接多个同行,你可以提供多个ip地址,用空格分开即可。

    在HOST1上面:docker attach $ssh
    
    在HOST2上面:docker attach $ssh

    然后两者进行互ping,会发现网络是通的

    展开全文
  • Habit @ weave是用于控制和监视智能家居和可穿戴设备的Web应用程序。 功耗图和计划动作的能力可以帮助用户做出正确的决定,以便在家中高效节能,而卡路里消耗和睡眠质量图则可能有助于采用改善健康的习惯。 用户可以...
  • AOP是什么? 2016年11月07日 10:29:17 软件工程有一个基本原则叫做“关注点分离”(Concern Separation),通俗的理解就是不同的问题交给不同的部分去解决,每部分专注于解决自己的问题。这年头...

    AOP是什么?

     

    软件工程有一个基本原则叫做“关注点分离”(Concern Separation),通俗的理解就是不同的问题交给不同的部分去解决,每部分专注于解决自己的问题。这年头互联网也天天强调要专注嘛!

    这其实也是一种“分治”或者“分类”的思想,人解决复杂问题的能力是有限的,所以为了控制复杂性,我们解决问题时通常都要对问题进行拆解,拆解的同时建立各部分之间的关系,各个击破之后整个问题也迎刃而解了。人类的思考,复杂系统的设计,计算机的算法,都能印证这一思想。额,扯远了,这跟AOP有神马关系?

    面向切面编程(Aspect Oriented Programming,AOP)其实就是一种关注点分离的技术,在软件工程领域一度是非常火的研究领域。我们软件开发时经常提一个词叫做“业务逻辑”或者“业务功能”,我们的代码主要就是实现某种特定的业务逻辑。但是我们往往不能专注于业务逻辑,比如我们写业务逻辑代码的同时,还要写事务管理、缓存、日志等等通用化的功能,而且每个业务功能都要和这些业务功能混在一起,痛苦!所以,为了将业务功能的关注点和通用化功能的关注点分离开来,就出现了AOP技术。这些通用化功能的代码实现,对应的就是我们说的切面(Aspect)。

    业务功能代码和切面代码分开之后,责任明确,开发者就能各自专注解决问题了,代码可以优雅的组织了,设计更加高内聚低耦合了(终极目标啊!)。但是请注意,代码分开的同时,我们如何保证功能的完整性呢? 你的业务功能依然需要有事务和日志等特性,即切面最终需要合并(专业术语叫做织入, Weave)到业务功能中。怎么做到呢? 这里就涉及AOP的底层技术啦,有三种方式:

    1. 编译时织入:在代码编译时,把切面代码融合进来,生成完整功能的Java字节码,这就需要特殊的Java编译器了,AspectJ属于这一类
    2. 类加载时织入:在Java字节码加载时,把切面的字节码融合进来,这就需要特殊的类加载器,AspectJ和AspectWerkz实现了类加载时织入
    3. 运行时织入:在运行时,通过动态代理的方式,调用切面代码增强业务功能,Spring采用的正是这种方式。动态代理会有性能上的开销,但是好处就是不需要神马特殊的编译器和类加载器啦,按照写普通Java程序的方式来就行了!

    一个场景

    接下来上例子!David对土豪老板定机票的例子比较满意,所以决定继续沿用这个例子。

    Boss在订机票时,我们希望能够记录订机票这个操作所消耗的时间,同时记录日志(这里我们简单的在控制台打印预定成功的信息)。

    我们来看普通青年的做法吧:

     

    package com.tianmaying.aopdemo;
    
    public class Boss {
    
        private BookingService bookingService;
    
        public Boss() {
            this.bookingService = new QunarBookingService();
        }
    
        //...
    
        public void goSomewhere() {
            long start = System.currentTimeMillis();
    
                    //订机票
            boolean status = bookingService.bookFlight();
    
            //查看耗时
            long duration = System.currentTimeMillis() - start;
            System.out.println(String.format("time for booking flight is %d seconds", duration));
    
            //记录日志
            if (status) {
                System.out.println("booking flight succeeded!");
            } else {
                System.out.println("booking flight failed!");
            }
        }
    }
    

    我们看到,在订机票的同时,还要处理查看耗时和记录日志,关注的事情太多了,头大啊。而且项目大了之后,除了订机票之外,很多业务功能都要写类似的代码。让AOP来拯救我们吧!

    使用AOP的场景

    相比在IoC例子中的代码,我们让BookingServicebookFlight()方法返回一个boolean值,表示是否预定成功。这样我们可以演示如何获取被切方法的返回值。

    通过AOP我们怎么做呢,David今天送出独门秘籍,告诉你通过3W方法(What-Where-When)来理解AOP。

    • What:What当然指的时切面啦!首先我们将记录消耗时间和记录日志这两个功能的代码分离出来,我们可以做成两个切面,命名为TimeRecordingAspectLogAspect
    • Where:切面的织入发生在哪呢?切面针对的目标对象(Target)是SmartBoss(区别于Boss)!这里还有有一个很关键的概念叫做切入点(Pointcut),在这个场景中就是指在SmartBoss调用什么方法的时候的时候应用切面。显然,我们希望增强的是bookFlight()方法,即在bookFlight方法调用的地方,我们加入时间记录和日志。
    • When: 什么时候织入呢?这涉及到织入的时机问题,我们可以在bookFlight()执行前织入,执行后织入,或者执行前后同时切入。When的概念用专业术语来说叫做通知(Advice)。

    了解了3W之后,来看看代码吧,先上LogAspect:

    插入一段,POM文件不要忘记了引入Spring AOP相关的依赖:

     

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>4.2.0.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>4.2.0.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.5</version>
        </dependency>  
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjrt</artifactId>
            <version>1.8.5</version>
        </dependency>
    

    LogAspect

     

    package com.tianmaying.aopdemo.aspect;
    
    import org.aspectj.lang.annotation.AfterReturning;
    import org.aspectj.lang.annotation.Aspect;
    import org.aspectj.lang.annotation.Pointcut;
    import org.springframework.stereotype.Component;
    
    @Aspect //1
    @Component
    public class LogAspect {
    
        @Pointcut("execution(* com.tianmaying.aopdemo..*.bookFlight(..))") //2
        private void logPointCut() {
        }
    
        @AfterReturning(pointcut = "logPointCut()", returning = "retVal") //3
        public void logBookingStatus(boolean retVal) {  //4
            if (retVal) {
                System.out.println("booking flight succeeded!");
            } else {
                System.out.println("booking flight failed!");
            }
        }
    }
    

    我们看这段代码:

    1通过一个@Apsect标注,表示LogAspect是一个切面,解决了What问题。2通过定义一个标注了@Pointcut的方法,定义了Where的问题,"execution(* com.tianmaying.aopdemo..*.bookFlight(..))"表示在com.tianmaying.aopdemo包或者子包种调用名称为bookFlight的地方就是切入点!定义Pioncut的语法这里不详解了,David这里要告诉你的时它的作用:解决Where的问题!3通过一个@AfterReturning标注表示在bookFlight()调用之后将切面织入,这是一个AfterReturning类型的Advice,注意这里可以通过returning属性获取bookFlight()的返回值。4这里定义了实现切面功能的代码,经过这么一番闪转腾挪,最后写日志的代码跑到这里来了!

    再来看TimeRecordingAspect:

    TimeRecordingAspect:

     

    package com.tianmaying.aopdemo.aspect;
    
    import org.aspectj.lang.ProceedingJoinPoint;
    import org.aspectj.lang.annotation.Around;
    import org.aspectj.lang.annotation.Aspect;
    import org.aspectj.lang.annotation.Pointcut;
    import org.springframework.stereotype.Component;
    
    @Aspect
    @Component
    public class TimeRecordingAspect {
    
        @Pointcut("execution(* com.tianmaying.aopdemo..*.bookFlight(..))")
        private void timeRecordingPointCut() {
        }
    
        @Around("timeRecordingPointCut()") //1
        public Object recordTime(ProceedingJoinPoint pjp) throws Throwable {  //2
    
            long start = System.currentTimeMillis();
            Object retVal = pjp.proceed(); // 3
    
            long duration = System.currentTimeMillis() - start;
            System.out.println(String.format(
                    "time for booking flight is %d seconds", duration));
    
            return retVal;
        }
    }
    
    • LogAspect不同,因为要计算bookFlight()的耗时,我们必须在调用前后到切入代码,才能算出来这之间的时间差。因此,在1处,我们定义的是一个Around类型的Advice。
    • 2处是实现AroundAdvice的方法,其方法的参数和返回值是固定写法。
    • 3处也是固定写法,表示对目标方法(即bookFlight())的调用,注意不要漏了,漏掉的话原方法就不会被调用了,通常情况下肯定不是你想要的结果!

    回头再看SmartBoss的代码,比Boss简单多了,goSomewhere()方法中只剩下一条语句,酷的掉渣啊,只关注订机票,其他的事情都F**k Off吧!

     

    package com.tianmaying.aopdemo;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Component;
    
    @Component
    public class SmartBoss {
        private BookingService bookingService;
    
            //...
    
        public void goSomewhere() {
            bookingService.bookFlight();
        }
    }
    

    当然,要让代码Run起来,还需要在App类中加上@EnableAspectJAutoProxy标注,这样Spring启动时就去去扫描AOP相关的标注,在创建对象时帮我们去执行织入过程!

    回到定义

    例子讲完!现在我们再来逐一看看AOP中的那些名词定义,这个时候理解这些概念,你应该不会觉得冷冰冰了,应该要有一种"Ya!"的感觉啦!

    • 切面(Aspect):指的就是通用功能的代码实现,比如我们上面演示的时间记录切面,日志切面,它们都是普通的Java类:TimeRecordingAspectLogAspect

    • 目标对象(Target):要被织入切面的对象,例子中的CtripBookingService,有了AOP,它们可以专注于核心业务逻辑代码了!

    • 切入点(Pointcut):定义通知应该切入到什么地方,Spring支持的切入点就是方法调用,切入点的定义可以使用正则表达式,用以描述什么类型的方法调用。@Pointcut就是用来定义切入点的。

    • 通知(Advice):切面是一个类,而通知就是类里的方法以及这个方法如何织入到目标方法的方式(用@AfterReturning@Around标注的方法)。我们的例子中只展示了两类通知,根据织入到目标方法方式的不同,一共可以分为5种:

      • 前置通知(Before)
      • 后置通知(AfterReturning)
      • 异常通知(AfterThrowing)
      • 最终通知(After)
      • 环绕通知(Around)
    • 织入(Weaving):AOP实现的过程,即将切面应用到目标对象,从而创建一个新的代理对象的过程,对于Spring来说,就是初始化Context中的对象时,完成织入操作。

    现在你应该理解Spring中AOP的关键知识和核心原理了,剩下的就是在David给你的3W框架下,去学习每一部分的知识了,比如不同类型通知的写法,PointCut的各种类型的定义方法,切面和目标对象之间参数传递,等等。当然,最关键的还是赶紧实践中用起来!

    转载于:https://www.cnblogs.com/yunian139/p/9178783.html

    展开全文
  • Weave Cloud is built using these Open Source projects: Weave Scope, a powerful container visualization tool that automatically maps Docker containers and their interactions, Weave Cortex, a ...
  • 降价是什么? Markdown是一种轻量级的标记语言,具有纯文本格式语法。 它的设计使其可以转换为许多其他格式,例如Weave播放集格式。 它易于阅读且易于编写。我们选择markdown是因为我们希望作者在他们选择的编辑器...
  • Sage-weave提供了一个用于混合文本和代码以自动生成文档的框架,类似于R语言的 。 Sage-weave允许您创建一个包含LaTeX文本和Sage代码的单个源文件。 然后将它们“编织”到最终的LaTeX文档中,该文档包含原始文本...
  • Weave Scope

    千次阅读 2017-07-24 18:52:20
    安装Weave Scope Weave Scope这个项目会自动生成容器之间的关系图,方便理解容器之间的关系,也方便监控容器化和微服务化的应用。(直接Copy过来的)。 1.安装Docker(略) 2.安装Weave Scope项目 下载二进制安装...
  • #weave什么? 语义:编制 建立一个虚拟网络,用于将运行在不同主机的docker容器连接起来 http:/weave.works https://github.com/weaveworks/weave#readme 准备环境: (1)两台服务器或虚拟机(最好是NAT...
  • python-weave

    2018-08-05 01:23:40
    weave的安装包,具体安装过程,先切换到cmd模式,然后再切换到文件目录。然后执行命令 python setup.py install
  • weave网络介绍

    2020-11-09 17:32:48
    Weave网络介绍 Weave是 Weaveworks 开发的容器网络解决方案。weave 创建的虚拟网络可以将部署在多个主机上的容器连接起来。对容器来说,weave 就像一个巨大的以太网交换机,所有容器都被接入这个交换机,容器可以...
  • docker_weave

    2018-09-20 21:39:00
    curl -L git.io/weave -o /usr/local/bin/weave chmod a+x /usr/local/bin/weave 启动 weave weave launch 生成的三个容器一个是运行服务的容器,其他的两个是数据库服务,和存储服务 查看你weava配置 driver 为 ...
  • weave 的 FAQ

    2020-06-16 17:57:25
    Weave网络使用很多,下面是一些文档供参考: 1:https://www.weave.works/docs/net/latest/faq/ 2.https://www.weave.works/docs/net/latest/troubleshooting/
  • 使用的时https://git.io/weave-kube 的yaml,创建weave-net的pod后一直是CrashLoopBackLoop状态, docker 日志显示ipset v6.32 :Kernel error received: Operation not permitted.
  • Openshift安装weave

    2019-10-16 14:52:31
    weave安装 https://www.weave.works/docs/scope/latest/installing/#k8s oc new-project weave #Scope probe pods need full access to Kubernetes API via ‘weave-scope’ service account oc adm policy add-...
  • centos7 Weave 安装

    千次阅读 2016-11-02 16:41:08
    Weave Weave是Github上一个比较热门的Docker容器网络方案,具有非常良好的易用性且功能强大。Weave 的框架结构图(如下图所示),它包含了两大主要组件: Weave:用户态的shell脚本,用于安装Weave,将container...
  • Weave Scope安装

    千次阅读 2018-06-06 23:31:24
    Weave Scope安装 首先确保已经安装docker 实时了解Docker容器状态 查看容器基础设施的概况,或者专注于一个特殊的微服务。从而轻松发现并纠正问题,确保你的容器化应用的稳定与性能。 内部细节与深度链接 ...
  • weave 命令行参数

    2016-01-04 11:45:00
    weave --help | help weave setup weave version weave launch [--password <password>] [--nickname <nickname>] ...
  • Docker Weave 命令整理

    2018-11-03 15:02:00
    Docker Weave 命令整理 # 查看weave状态 weave status # 查看状态详情 weave status connections # 查看weave相互之间节点建立的关系 weave status peers # 查看当前分配的容器 weave...
  • 引入Brillo和Weave

    2020-06-11 09:04:10
    尽管在2015年Google I / O大会上宣布了它们,但Brillo和Weave是Google的两项新技术,对于一般开发人员社区来说仍然是个谜。 幸运的是,在2016年1月的Ubiquity会议上,...什么是Brillo和Weave? 在我们深入探讨Bril...
  • docker weave安装

    2015-01-19 12:42:00
    1.升级内核到3.10.0以上,...0.80版本:#wget -O /usr/local/bin/weave https://raw.githubusercontent.com/zettio/weave/master/weave0.70版本#yum install -y conntrack-tools#wget -O /usr/local/bin/weave htt...
  • Docker网络Weave.zip

    2019-07-19 08:58:44
    容器内的服务可直接为容器外的应用所访问,而不需要关心容器运行在什么地方。Weave 可穿越防火墙并在部分已连接网络中操作。可以是加密的,也可以通过非信任网络连接。使用 Weave 你可以轻松构建运行于任何地方的多...
  • 一个适配器,在容器内运行并确保容器在运行其入口点之前连接到 weave 网络。 运行适配器 $ docker run -d --name powerstrip-weave \ --expose 80 \ -v /var/run/docker.sock:/var/run/docker.sock \ binocarlos/...
  • 默认情况下,这会从 Github 下载 Weave 二进制文件并将其安装在 /usr/local/bin/weave 下。 如果要通过包管理系统安装: class { 'weave' : install_method => ' package ' , package_name => ' weave ' , ...
  • Kubernetes安装Weave Scope

    2019-04-01 17:40:54
    Weave Scope是Docker和Kubernetes可视化监控工具。 Scope提供了自上而下的集群基础设施和应用的完整视图,用户可以轻松对分布式的容器化应用进行实时监控和问题诊断。 详细步骤: 1,(如果使用的是云环境,...
  • Weave 版本 1.9 ()。 要查看正在运行的 Weave 版本,请单击 有关您可以使用 Wea​​ve 执行的操作的一些示例,请单击 执照 Weave 是根据许可分发的。 下载 文档 您可以找到管理控制台用户指南 Weave 支持来自多个...
  • Docker Weave 应用部署

    2018-11-03 15:42:00
    Docker Weave 应用条件 官方文档:https://www.weave.works/docs/net/latest/install/installing-weave 使用前提: 1. 确保Linux内核版本3.8+,Docker1.10+。 2. 节点之间如果有防火墙时,必须彼此放行TCP ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 10,250
精华内容 4,100
关键字:

weave是什么