之前一直介绍flannel的使用,现在正是进入代码讲解,看看flannel是如何实现的,先看启动
func main() {
flag.Set("logtostderr", "true")
// 解析参数
flag.Parse()
if flag.NArg() > 0 || opts.help {
fmt.Fprintf(os.Stderr, "Usage: %s [OPTION]...\n", os.Args[0])
flag.PrintDefaults()
os.Exit(0)
}
if opts.version {
fmt.Fprintln(os.Stderr, version.Version)
os.Exit(0)
}
flagutil.SetFlagsFromEnv(flag.CommandLine, "FLANNELD")
// 确定使用的端口
extIface, err := LookupExtIface(opts.iface)
if err != nil {
log.Error("Failed to find interface to use: ", err)
os.Exit(1)
}
sm, err := newSubnetManager()
if err != nil {
log.Error("Failed to create SubnetManager: ", err)
os.Exit(1)
}
// 注册 SIGINT and SIGTERM信号监听
log.Info("Installing signal handlers")
sigs := make(chan os.Signal, 1)
signal.Notify(sigs, os.Interrupt, syscall.SIGTERM)
ctx, cancel := context.WithCancel(context.Background())
go shutdown(sigs, cancel)
// 获取网络配置如backend等
config, err := getConfig(ctx, sm)
if err == errCanceled {
exit()
}
// 创建backend manager
bm := backend.NewManager(ctx, sm, extIface)
be, err := bm.GetBackend(config.BackendType)
if err != nil {
log.Errorf("Error fetching backend: %s", err)
exit()
}
bn, err := be.RegisterNetwork(ctx, config)
if err != nil {
log.Errorf("Error registering network: %s", err)
exit()
}
// 启动ipmasq
if opts.ipMasq {
err = network.SetupIPMasq(config.Network)
if err != nil {
log.Errorf("Failed to set up IP Masquerade: %v", err)
}
defer func() {
if err := network.TeardownIPMasq(config.Network); err != nil {
log.Errorf("Failed to tear down IP Masquerade: %v", err)
}
}()
}
if err := WriteSubnetFile(opts.subnetFile, config.Network, opts.ipMasq, bn); err != nil {
log.Warningf("Failed to write subnet file: %s", err)
} else {
log.Infof("Wrote subnet file to %s", opts.subnetFile)
}
// 启动 backend network阻塞直到服务启动
go bn.Run(ctx)
log.Infof("Finished starting backend.")
daemon.SdNotify(false, "READY=1")
// 重新租约
_ = MonitorLease(ctx, sm, bn)
exit()
}
上面的代码是服务的入口,先解析参数,在之前的应用的时候就有使用参数
flag.StringVar(&opts.etcdEndpoints, "etcd-endpoints", "http://127.0.0.1:4001,http://127.0.0.1:2379", "a comma-delimited list of etcd endpoints")
flag.StringVar(&opts.etcdPrefix, "etcd-prefix", "/coreos.com/network", "etcd prefix")
flag.StringVar(&opts.iface, "iface", "", "interface to use (IP or name) for inter-host communication")
flag.StringVar(&opts.subnetFile, "subnet-file", "/run/flannel/subnet.env", "filename where env variables (subnet, MTU, ... ) will be written to")
flag.IntVar(&opts.subnetLeaseRenewMargin, "subnet-lease-renew-margin", 60, "Subnet lease renewal margin, in minutes.")
flag.BoolVar(&opts.ipMasq, "ip-masq", false, "setup IP masquerade rule for traffic destined outside of overlay network")
这些截取的参数有事比较重要,大概说一下
etcd-endpoints:连接etcd地址
etcd-prefix :在etcd里面路径前缀
iface:主机间流量互通的网卡
subnet-file:生成docker网络信息的路径
subnet-lease-renew-margin:这个是自网段的租约时间
ip-masq:是否启动ipmasq,就是SANT
当解析完参数后LookupExtIface检查网卡是否存在,并且返回外部接口信息
&backend.ExternalInterface{
Iface: iface,
IfaceAddr: ifaceAddr,
ExtAddr: extAddr,
}
Iface是制定的外网端口,如果publicip没有制定,IfaceAddr等于ExtAddr。这个容器出去的外部端口就设定成功了。
然后通过newSubnetManager去创建子网管理器,如果没有设置kubernetes子网管理的话,默认使用的就是通过etcd做子网管理,
func newSubnetManager() (subnet.Manager, error) {
if opts.kubeSubnetMgr {
return kube.NewSubnetManager()
}
cfg := &etcdv2.EtcdConfig{
Endpoints: strings.Split(opts.etcdEndpoints, ","),
Keyfile: opts.etcdKeyfile,
Certfile: opts.etcdCertfile,
CAFile: opts.etcdCAFile,
Prefix: opts.etcdPrefix,
Username: opts.etcdUsername,
Password: opts.etcdPassword,
}
return etcdv2.NewLocalManager(cfg)
}
连接上etcd。创建网sm以后,注册SIGINT and SIGTERM这个主要是优雅的停止服务使用。getConfig里面调用的是getNetworkConfig
func (esr *etcdSubnetRegistry) getNetworkConfig(ctx context.Context) (string, error) {
key := path.Join(esr.etcdCfg.Prefix, "config")
resp, err := esr.client().Get(ctx, key, &etcd.GetOptions{Quorum: true})
if err != nil {
return "", err
}
return resp.Node.Value, nil
}
这个也是就是第一篇的实战的时候设置的config。从config里面获取backend是udp还是vxlan或者是别的。通过be, err := bm.GetBackend(config.BackendType)创建相应的backend。
befunc, ok := constructors[betype]
if !ok {
return nil, fmt.Errorf("unknown backend type: %v", betype)
}
be, err := befunc(bm.sm, bm.extIface)
这样就获取到制定的backend,下面就是开始注册网络RegisterNetwork了,
每个backend都有自己的RegisterNetwork
下面以vxlan为例
func (be *VXLANBackend) RegisterNetwork(ctx context.Context, config *subnet.Config) (backend.Network, error) {
// Parse our configuration
cfg := struct {
VNI int
Port int
GBP bool
}{
VNI: defaultVNI,
}
if len(config.Backend) > 0 {
if err := json.Unmarshal(config.Backend, &cfg); err != nil {
return nil, fmt.Errorf("error decoding VXLAN backend config: %v", err)
}
}
devAttrs := vxlanDeviceAttrs{
vni: uint32(cfg.VNI),
name: fmt.Sprintf("flannel.%v", cfg.VNI),
vtepIndex: be.extIface.Iface.Index,
vtepAddr: be.extIface.IfaceAddr,
vtepPort: cfg.Port,
gbp: cfg.GBP,
}
dev, err := newVXLANDevice(&devAttrs)
if err != nil {
return nil, err
}
subnetAttrs, err := newSubnetAttrs(be.extIface.ExtAddr, dev.MACAddr())
if err != nil {
return nil, err
}
lease, err := be.subnetMgr.AcquireLease(ctx, subnetAttrs)
switch err {
case nil:
case context.Canceled, context.DeadlineExceeded:
return nil, err
default:
return nil, fmt.Errorf("failed to acquire lease: %v", err)
}
// vxlan's subnet is that of the whole overlay network (e.g. /16)
// and not that of the individual host (e.g. /24)
vxlanNet := ip.IP4Net{
IP: lease.Subnet.IP,
PrefixLen: config.Network.PrefixLen,
}
if err = dev.Configure(vxlanNet); err != nil {
return nil, err
}
return newNetwork(be.subnetMgr, be.extIface, dev, vxlanNet, lease)
}
配置vxlan的vtep设备,AcquireLease分配人一个子网租约,就是分配一个网段。再回到main里面,如果设置ipmaq就是添加一个NAT的IPtable是规则,接着就是就是写docker的网络配置文件WriteSubnetFile,最后启动go bn.Run(ctx),它会阻塞,在另一个协程中运行,MonitorLease就是默认每隔60分钟续约一下。main解析完成,服务启动。