kubeadm修改默认证书有效期，解决证书过期问题

向右看齐 2023-03-13 06:07 316阅读 0赞

# kubeadm 修改默认证书有效期 #

## 前言 ##

出于安全考虑，k8s 团队推荐定期更新版本，因此kubeadm生成的证书，有效期默认在代码中写死为1年，一旦证书过期，k8s集群将会崩溃，因此，续期 or 升级，成了一个一年一度必选题。但在生产环境中，每一次版本更新可能存在未知的风险，给已经稳定运行的集群带来诸多不确定性，而每年续期一次证书，对管理不太友好，频繁手动操作也可能会带来额外的风险。去年部署的1.14的集群，证书快要到期了，现在决定修改kubeadm的源码重新编译，将续期证书的有效期进行延长。本篇记载分析源码中证书更新的过程。

## 修改源码 ##

### 准备 ###

首先拉取代码，切换到指定k8s版本的tag，过程参考之前源码分析的第一篇文章：

[k8s源码阅读笔记-准备工作][k8s_-]

也可直接下载相应版本的源码压缩包：

`wget https://codeload.github.com/kubernetes/kubernetes/tar.gz/v1.14.3`

### 代码结构 ###

kubeadm代码结构如下，我们根据cmd命令入手，来找相应的生成证书的逻辑具体在哪。

![50][]

证书生成方式分为两种，一种是执行\*\*`kubeadm init`**命令初始化生成的证书，一种是执行**`kubeadm alpha certs renew`\*\*，分别来看下。

### Init证书 ###

根据cmd的语义，可以很方便的找到相应的逻辑在哪个文件内，例如`kubeadm init` 命令的逻辑，在`cmd/kubeadm/app/cmd/init.go`文件内。

通过函数名称，可以很容易辨认哪个是证书操作的函数，一级一级地查找：

`cmd/kubeadm/app/cmd/init.go:176`

`initRunner.AppendPhase(phases.NewCertsPhase())`

==> `cmd/kubeadm/app/cmd/phases/init/certs.go:62`

`Phases: newCertSubPhases()`

==> `cmd/kubeadm/app/cmd/phases/init/certs.go:96`

`return certsphase.CreateCertAndKeyFilesWithCA(cert, caCert, cfg)`

==> `cmd/kubeadm/app/phases/certs/certs.go:161`

// 这里分两步，第一步生成证书 ，第二步，证书写入磁盘
    func (k *KubeadmCert) CreateFromCA(ic *kubeadmapi.InitConfiguration, caCert *x509.Certificate, caKey *rsa.PrivateKey) error { 
       cfg, err := k.GetConfig(ic)
       if err != nil { 
          return errors.Wrapf(err, "couldn't create %q certificate", k.Name)
       }
       // 生成证书
       cert, key, err := pkiutil.NewCertAndKey(caCert, caKey, cfg)
       if err != nil { 
          return err
       }
       // 写入磁盘
       err = writeCertificateFilesIfNotExist(
          ic.CertificatesDir,
          k.BaseName,
          caCert,
          cert,
          key,
          cfg,
       )
    
       if err != nil { 
          return errors.Wrapf(err, "failed to write or validate certificate %q", k.Name)
       }
    
       return nil
    }

CreateFromCA函数分为两步，第一步生成证书 ，第二步，证书写入磁盘。生成证书这里使用的是单独的封装pkiutil.NewCertAndKey()方法，猜测多个地方会使用到它。

#### 生成证书 ####

`cmd/kubeadm/app/util/pkiutil/pki_helpers.go:76`

==> `cmd/kubeadm/app/util/pkiutil/pki_helpers.go:82`

==> `cmd/kubeadm/app/util/pkiutil/pki_helpers.go:557`

// NewSignedCert creates a signed certificate using the given CA certificate and key
    func NewSignedCert(cfg *certutil.Config, key crypto.Signer, caCert *x509.Certificate, caKey crypto.Signer) (*x509.Certificate, error) { 
    	serial, err := rand.Int(rand.Reader, new(big.Int).SetInt64(math.MaxInt64))
    	if err != nil { 
    		return nil, err
    	}
    	if len(cfg.CommonName) == 0 { 
    		return nil, errors.New("must specify a CommonName")
    	}
    	if len(cfg.Usages) == 0 { 
    		return nil, errors.New("must specify at least one ExtKeyUsage")
    	}
    
    	certTmpl := x509.Certificate{ 
    		Subject: pkix.Name{ 
    			CommonName:   cfg.CommonName,
    			Organization: cfg.Organization,
    		},
    		DNSNames:     cfg.AltNames.DNSNames,
    		IPAddresses:  cfg.AltNames.IPs,
    		SerialNumber: serial,
    		NotBefore:    caCert.NotBefore,
        // 过期时间在这里，默认是当前时间+1年，这里可以修改一下，改成10年
    		// NotAfter: time.Now().Add(duration365d).UTC(),
        NotAfter:     time.Now().Add(duration365d * 10).UTC(),
    		KeyUsage:     x509.KeyUsageKeyEncipherment | x509.KeyUsageDigitalSignature,
    		ExtKeyUsage:  cfg.Usages,
    	}
    	certDERBytes, err := x509.CreateCertificate(cryptorand.Reader, &certTmpl, caCert, key.Public(), caKey)
    	if err != nil { 
    		return nil, err
    	}
    	return x509.ParseCertificate(certDERBytes)
    }

这里是init证书默认定义有效期的位置，renew证书应该也是调用的这里，是不是呢？还是再来确认一下。

### Renew证书 ###

根据cmd的语义，可以很方便的找到相应的逻辑在哪个文件内，例如`kubeadm alpha certs renew`命令的逻辑，在`cmd/kubeadm/app/cmd/alpha/certs.go`文件内。

通过函数名称，可以很容易初步锁定在`newCmdCertsRenewal()`函数，再开始一级一级地查找：

`cmd/kubeadm/app/cmd/alpha/certs.go:60`

==> `cmd/kubeadm/app/cmd/alpha/certs.go:68`

==> `cmd/kubeadm/app/cmd/alpha/certs.go:99`

// get the implementation of renewing this certificate
    			renewalFunc := generateRenewalFunction(cert, caCert, cfg)

==> `cmd/kubeadm/app/cmd/alpha/certs.go:151`

// 更新已存在的证书
    err = renewal.RenewExistingCert(internalcfg.CertificatesDir, cert.BaseName, renewer)

==> `cmd/kubeadm/app/phases/certs/renewal/renewal.go:42`

newCert, newKey, err := impl.Renew(cfg)

这里发现impl.Renew()是个接口方法，倒回上一级去查看impl

==> `cmd/kubeadm/app/cmd/alpha/certs.go:148`

renewer, err := getRenewer(cfg, caCert.BaseName)

==> `cmd/kubeadm/app/cmd/alpha/certs.go:166`

func getRenewer(cfg *renewConfig, caCertBaseName string) (renewal.Interface, error) { 
    	if cfg.useAPI { 
    		kubeConfigPath := cmdutil.GetKubeConfigPath(cfg.kubeconfigPath)
    		client, err := kubeconfigutil.ClientSetFromFile(kubeConfigPath)
    		if err != nil { 
    			return nil, err
    		}
        // k8s自管理式的刷新证书
    		return renewal.NewCertsAPIRenawal(client), nil
    	}
    
    	caCert, caKey, err := certsphase.LoadCertificateAuthority(cfg.cfg.CertificatesDir, caCertBaseName)
    	if err != nil { 
    		return nil, err
    	}
      // 刷新本地文件证书
    	return renewal.NewFileRenewal(caCert, caKey), nil
    }

这里的证书刷新方式分为两种，一种是k8s自管理式的证书，一种是本地文件证书(默认`/etc/kubernetes/pki/`)，两种方式有何差别，参考官方文档:

[Certificate Management with kubeadm][]

自管理的证书有效期默认3个月。而一般使用的都是本地证书文件，所以直接看第二种

`cmd/kubeadm/app/phases/certs/renewal/filerenewal.go:34`

// NewFileRenewal takes a certificate pair to construct the Interface.
    func NewFileRenewal(caCert *x509.Certificate, caKey *rsa.PrivateKey) Interface { 
    	return &FileRenewal{ 
    		caCert: caCert,
    		caKey:  caKey,
    	}
    }
    
    // Renew takes a certificate using the cert and key
    func (r *FileRenewal) Renew(cfg *certutil.Config) (*x509.Certificate, *rsa.PrivateKey, error) { 
    	return pkiutil.NewCertAndKey(r.caCert, r.caKey, cfg)
    }

Renew方法在下面，果然，也是调用的 `pkiutil.NewCertAndKey()`方法，也即是说，在上面修改那一行代码，init和renew的时候生成证书都会调用，都会生效。

修改完成，开始重新编译！

## 编译 ##

go环境问题这里不赘述了，网上文章很多，跳过。

如果是linux，直接执行:

make WHAT=cmd/kubeadm GOFLAGS=-v

如果是mac，执行:

make cross WHAT=cmd/kubeadm GOFLAGS=-v

报错：

./hack/run-in-gopath.sh:行33: _output/bin/deepcopy-gen: 权限不够
    make[1]: *** [gen_deepcopy] 错误 1
    make: *** [generated_files] 错误 2

解决办法:

chmod +x _output/bin/deepcopy-gen

重新编译，执行完成后，编译好的二进制文件路径为:

./_output/local/bin/linux/amd64/kubeadm

使用此文件，覆盖原来的kubeadm文件:

mv /usr/bin/kubeadm /usr/bin/kubeadm-bak
    cp ./_output/local/bin/linux/amd64/kubeadm  /usr/bin/kubeadm

## 验证 ##

### init新建证书 ###

先看看kubeadm init时创建的证书

[root@vm254011 ~]# kubeadm init --config kubeadmin-config.yaml
    
    ...
    Your Kubernetes control-plane has initialized successfully!
    ...
    
    [root@vm254011 ~]# openssl x509 -in /etc/kubernetes/pki/apiserver.crt -noout -text |grep ' Not'
                Not Before: May 11 12:17:34 2020 GMT
                Not After : May  9 12:17:34 2030 GMT
    
    [root@vm254011 ~]# date
    2020年 05月 11日 星期二 20:37:55 CST

可以看到，证书有效期为10年(默认时间为UTC时间，实际本地时区为UTC+8)

### renew刷新证书 ###

下面的步骤适用于 **证书续期** 或 **证书过期后** 的处理方法

过了一个晚上，再来对上面init创建的证书进行renew:

# 如果etcd也是一起托管的，直接执行一条命令即可：
    # kubeadm alpha certs renew all --config=./kubeadmin-config.yaml
    
    # 因为我的环境里etcd不是static pod托管，而是外部二进制部署的，所以这里不需要更新etcd的证书
    [root@vm254011 ~]# kubeadm alpha certs renew apiserver --config=./kubeadmin-config.yaml
    [root@vm254011 ~]# kubeadm alpha certs renew apiserver-kubelet-client --config=./kubeadmin-config.yaml
    [root@vm254011 ~]# kubeadm alpha certs renew front-proxy-client --config=./kubeadmin-config.yaml
    
    [root@vm254011 ~]# openssl x509 -in /etc/kubernetes/pki/apiserver.crt -noout -text |grep ' Not'
                Not Before: May 11 12:17:34 2020 GMT
                Not After : May 10 00:36:16 2030 GMT
    
    [root@vm254011 ~]# date
    2020年 05月 12日 星期二 08:37:01 CST
    
    [root@vm254011 ~]# stat /etc/kubernetes/pki/apiserver
    最近访问：2020-05-12 08:36:23.764591842 +0800
    最近更改：2020-05-12 08:36:16.395438142 +0800
    最近改动：2020-05-12 08:36:16.395438142 +0800
    
    # 基于新证书重新生成各个组件的配置文件
    kubeadm alpha kubeconfig user --org system:masters --client-name kubernetes-admin  > /etc/kubernetes/admin.conf
    kubeadm alpha kubeconfig user --client-name system:kube-controller-manager > /etc/kubernetes/controller-manager.conf
    kubeadm alpha kubeconfig user --client-name system:kube-scheduler > /etc/kubernetes/scheduler.conf
    
    # 重启kubelet组件
    systemctl restart kubelet
    # 重启controller、scheduler、apiserver3个组件docker容器
    # docker restart 命令
    
    # 复制证书和配置文件到其他master
    scp -r /etc/kubernetes/pki/* root@vm254012:/etc/kubernetes/pki/
    scp /etc/kubernetes/scheduler.conf root@vm254012:/etc/kubernetes/
    scp /etc/kubernetes/controller-manager.conf root@vm254012:/etc/kubernetes/
    scp /etc/kubernetes/admin.conf root@vm254012:/etc/kubernetes/
    
    # 其他master同样重启kubelet和3个组件docker容器
    # ...

可以看到，renew的证书，有效期也是长达10年的。

[k8s_-]: https://github.com/yinwenqin/kubeSourceCodeNote/blob/master/README.md
[50]: http://mycloudn.upweto.top/20200511162242.jpg
[Certificate Management with kubeadm]: https://v1-14.docs.kubernetes.io/docs/tasks/administer-cluster/kubeadm/kubeadm-certs/#renew-certificates-with-the-certificates-api