【Kubernetes】——开启Aggregator Apiserver

Bertha 。 2023-07-13 08:06 7阅读 0赞

### 一、前言 ###

今天搭建了三节点k8s集群做测试用，具体流程可以参见我的博客：[搭建k8s多节点集群][k8s]。因为用到了扩展api，所以需要开启**AA模式**（API Aggregation）。API Aggregation 允许在不修改 Kubernetes 核心代码的同时扩展 Kubernetes API，即将第三方服务注册到 Kubernetes API 中，这样就可以通过 Kubernetes API 来访问外部服务。备注：另外一种扩展 Kubernetes API 的方法是使用 [CustomResourceDefinition (CRD)][CustomResourceDefinition _CRD]。

更多信息大家可以看官方文档：[https://k8smeetup.github.io/docs/tasks/access-kubernetes-api/configure-aggregation-layer/][https_k8smeetup.github.io_docs_tasks_access-kubernetes-api_configure-aggregation-layer] 。本文只谈如何部署。

注明：第二章是参考博文：[详解kubeadm生成的证书][kubeadm] 作者写的很到位，所以加进来了。想直接操作解决问题的话可以直接跳到第三章。

### 二、kubeadm生成的证书 ###

使用kubeadm创建完Kubernetes集群后, 默认会在`/etc/kubernetes/pki`目录下存放集群中需要用到的证书文件, 整体结构如下图所示:

/etc/kubernetes/pki$ tree
    .
    ├── apiserver.crt
    ├── apiserver-etcd-client.crt
    ├── apiserver-etcd-client.key
    ├── apiserver.key
    ├── apiserver-kubelet-client.crt
    ├── apiserver-kubelet-client.key
    ├── ca.crt
    ├── ca.key
    ├── etcd
    │   ├── ca.crt
    │   ├── ca.key
    │   ├── healthcheck-client.crt
    │   ├── healthcheck-client.key
    │   ├── peer.crt
    │   ├── peer.key
    │   ├── server.crt
    │   └── server.key
    ├── front-proxy-ca.crt
    ├── front-proxy-ca.key
    ├── front-proxy-client.crt
    ├── front-proxy-client.key
    ├── sa.key
    └── sa.pub
    
    1 directory, 22 files

以上22个文件就是kubeadm为我们创建的所有证书相关的文件, 下面我们来一一解析

**证书分组**

Kubernetes把证书放在了两个文件夹中

*  /etc/kubernetes/pki
 *  /etc/kubernetes/pki/etcd

我们再将这22个文件按照更细的粒度去分组

**Kubernetes 集群根证书**

Kubernetes 集群根证书CA(Kubernetes集群组件的证书签发机构)

*  `/etc/kubernetes/pki/ca.crt`
 *  `/etc/kubernetes/pki/ca.key`

以上这组证书为签发其他Kubernetes组件证书使用的根证书, 可以认为是Kubernetes集群中证书签发机构之一

由此根证书签发的证书有:

1.  kube-apiserver 组件持有的服务端证书
    
     *  `/etc/kubernetes/pki/apiserver.crt`
     *  `/etc/kubernetes/pki/apiserver.key`
2.  kubelet 组件持有的客户端证书, 用作 kube-apiserver 主动向 kubelet 发起请求时的客户端认证
    
     *  `/etc/kubernetes/pki/apiserver-kubelet-client.crt`
     *  `/etc/kubernetes/pki/apiserver-kubelet-client.key`

> 注意: Kubernetes集群组件之间的交互是双向的, kubelet 既需要主动访问 kube-apiserver, kube-apiserver 也需要主动向 kubelet 发起请求, 所以双方都需要有自己的根证书以及使用该根证书签发的服务端证书和客户端证书. 在 kube-apiserver 中, 一般明确指定用于 https 访问的服务端证书和带有`CN 用户名`信息的客户端证书. 而在 kubelet 的启动配置中, 一般只指定了 ca 根证书, 而没有明确指定用于 https 访问的服务端证书, 这是因为, 在生成服务端证书时, 一般会指定服务端地址或主机名, kube-apiserver 相对变化不是很频繁, 所以在创建集群之初就可以预先分配好用作 kube-apiserver 的 IP 或主机名/域名, 但是由于部署在 node 节点上的 kubelet 会因为集群规模的变化而频繁变化, 而无法预知 node 的所有 IP 信息, 所以 kubelet 上一般不会明确指定服务端证书, 而是只指定 ca 根证书, 让 kubelet 根据本地主机信息自动生成服务端证书并保存到配置的`cert-dir`文件夹中.

好了, 至此, Kubernetes集群根证书所签发的证书都在上面了, 算上根证书一共涉及到6个文件, 22-6=16, 我们还剩下16个文件

**汇聚层证书**

kube-apiserver 的另一种访问方式就是使用 `kubectl proxy` 来代理访问, 而该证书就是用来支持SSL代理访问的. 在该种访问模式下, 我们是以http的方式发起请求到代理服务的, 此时, 代理服务会将该请求发送给 kube-apiserver, 在此之前, 代理会将发送给 kube-apiserver 的请求头里加入证书信息, 以下两个配置

API Aggregation允许在不修改Kubernetes核心代码的同时扩展Kubernetes API. 开启 API Aggregation 需要在 kube-apiserver 中添加如下配置:

--requestheader-client-ca-file=<path to aggregator CA cert>
    --requestheader-allowed-names=front-proxy-client
    --requestheader-extra-headers-prefix=X-Remote-Extra-
    --requestheader-group-headers=X-Remote-Group
    --requestheader-username-headers=X-Remote-User
    --proxy-client-cert-file=<path to aggregator proxy cert>
    --proxy-client-key-file=<path to aggregator proxy key>

**官方警告: 除非你了解保护 CA 使用的风险和机制, 否则不要在不通上下文中重用已经使用过的 CA**

如果 kube-proxy 没有和 API server 运行在同一台主机上，那么需要确保启用了如下 apiserver 标记：

`--enable-aggregator-routing=true`

<table> 
 <tbody> 
  <tr> 
   <td> <pre><code>客户端 ---发起请求---&gt; 代理 ---Add Header:发起请求---&gt; kube-apiserver
                   (客户端证书)                        (服务端证书)
</code></pre> </td> 
  </tr> 
 </tbody> 
</table>

kube-apiserver 代理根证书(客户端证书)

用在`requestheader-client-ca-file`配置选项中, kube-apiserver 使用该证书来验证客户端证书是否为自己所签发

*  `/etc/kubernetes/pki/front-proxy-ca.crt`
 *  `/etc/kubernetes/pki/front-proxy-ca.key`

由此根证书签发的证书只有一组:

代理层(如汇聚层aggregator)使用此套代理证书来向 kube-apiserver 请求认证

1.  代理端使用的客户端证书, 用作代用户与 kube-apiserver 认证
    
     *  `/etc/kubernetes/pki/front-proxy-client.crt`
     *  `/etc/kubernetes/pki/front-proxy-client.key`

参考文档:

*  kube-apiserver 配置参数: [https://kubernetes.io/docs/reference/command-line-tools-reference/kube-apiserver/][https_kubernetes.io_docs_reference_command-line-tools-reference_kube-apiserver]
 *  使用汇聚层扩展 Kubernetes API: [https://kubernetes.io/docs/concepts/extend-kubernetes/api-extension/apiserver-aggregation/][https_kubernetes.io_docs_concepts_extend-kubernetes_api-extension_apiserver-aggregation]
 *  配置汇聚层: [https://kubernetes.io/docs/tasks/access-kubernetes-api/configure-aggregation-layer/][https_kubernetes.io_docs_tasks_access-kubernetes-api_configure-aggregation-layer]

至此, 刨除代理专用的证书外, 还剩下 16-4=12 个文件

**etcd 集群根证书**

etcd集群所用到的证书都保存在`/etc/kubernetes/pki/etcd`这路径下, 很明显, 这一套证书是用来专门给etcd集群服务使用的, 设计以下证书文件

etcd 集群根证书CA(etcd 所用到的所有证书的签发机构)

*  `/etc/kubernetes/pki/etcd/ca.crt`
 *  `/etc/kubernetes/pki/etcd/ca.key`

由此根证书签发机构签发的证书有:

1.  etcd server 持有的服务端证书
    
     *  `/etc/kubernetes/pki/etcd/server.crt`
     *  `/etc/kubernetes/pki/etcd/server.key`
2.  peer 集群中节点互相通信使用的客户端证书
    
     *  `/etc/kubernetes/pki/etcd/peer.crt`
     *  `/etc/kubernetes/pki/etcd/peer.key`
        
        注: Peer：对同一个etcd集群中另外一个Member的称呼
3.  pod 中定义 Liveness 探针使用的客户端证书
    
    kubeadm 部署的 Kubernetes 集群是以 pod 的方式运行 etcd 服务的, 在该 pod 的定义中, 配置了 Liveness 探活探针
    
     *  `/etc/kubernetes/pki/etcd/healthcheck-client.crt`
     *  `/etc/kubernetes/pki/etcd/healthcheck-client.key`
        
        当你 describe etcd 的 pod 时, 会看到如下一行配置:
        
        <table> 
         <tbody> 
          <tr> 
           <td> <pre><code>Liveness:       exec [/bin/sh -ec ETCDCTL_API=3 etcdctl --endpoints=https://[127.0.0.1]:2379 --cacert=/etc/kubernetes/pki/etcd/ca.crt --cert=/etc/kubernetes/pki/etcd/healthcheck-client.crt --key=/etc/kubernetes/pki/etcd/healthcheck-client.key get foo] delay=15s timeout=15s period=10s #success=1 #failure=8
        </code></pre> </td> 
          </tr> 
         </tbody> 
        </table>
4.  配置在 kube-apiserver 中用来与 etcd server 做双向认证的客户端证书
    
     *  `/etc/kubernetes/pki/apiserver-etcd-client.crt`
     *  `/etc/kubernetes/pki/apiserver-etcd-client.key`

至此, 介绍了涉及到 etcd 服务的10个证书文件, 12-10=2, 仅剩两个没有介绍到的文件啦, 胜利✌️在望, 坚持一下~

**Serveice Account秘钥**

最后介绍的这组”证书”其实不是证书, 而是一组秘钥. 看着后缀名是不是有点眼熟呢, 没错, 这组秘钥对儿其实跟我们在Linux上创建, 用于免密登录的密钥对儿原理是一样的~

> 这组的密钥对儿仅提供给 kube-controller-manager 使用. kube-controller-manager 通过 sa.key 对 token 进行签名, master 节点通过公钥 sa.pub 进行签名的验证

*  `/etc/kubernetes/pki/sa.key`
 *  `/etc/kubernetes/pki/sa.pub`

至此, kubeadm 工具帮我们创建的所有证书文件都已经介绍完了, 整个 Kubernetes&etcd 集群中所涉及到的绝大部分证书都差不多在这里了. 有的行家可能会看出来, 至少还少了一组证书呀, 就是 kube-proxy 持有的证书怎么没有自动生成呀. 因为 kubeadm 创建的集群, kube-proxy 是以 pod 形式运行的, 在 pod 中, 直接使用 service account 与 kube-apiserver 进行认证, 此时就不需要再单独为 kube-proxy 创建证书了. 如果你的 kube-proxy 是以守护进程的方式直接运行在宿主机的, 那么你就需要为它创建一套证书了. 创建的方式也很简单, 直接使用上面第一条提到的 `Kubernetes 集群根证书` 进行签发就可以了(注意CN和O的设置)

### 三、kube-apiserver配置文件 ###

介绍完第二章后，咱们正式来解决一下kubeadm安装后开启aggregator的操作。

1、默认情况下在/etc/kubernetes/manifests/目录下的kube-apiserver.yaml文件中。

/etc/kubernetes/manifests$ tree
    .
    ├── etcd.yaml
    ├── kube-apiserver.yaml
    ├── kube-controller-manager.yaml
    └── kube-scheduler.yaml

2、贴出来给大家看一下初始的时候配置，其实从配置大家也就看出来kube-apiserver这个组件是以一个pod的方式在集群中存在的。

apiVersion: v1
    kind: Pod
    metadata:
      creationTimestamp: null
      labels:
        component: kube-apiserver
        tier: control-plane
      name: kube-apiserver
      namespace: kube-system
    spec:
      containers:
      - command:
        - kube-apiserver
        - --advertise-address=10.53.5.94
        - --allow-privileged=true
        - --authorization-mode=Node,RBAC
        - --client-ca-file=/etc/kubernetes/pki/ca.crt
        - --enable-admission-plugins=NodeRestriction
        - --enable-bootstrap-token-auth=true
        - --etcd-cafile=/etc/kubernetes/pki/etcd/ca.crt
        - --etcd-certfile=/etc/kubernetes/pki/apiserver-etcd-client.crt
        - --etcd-keyfile=/etc/kubernetes/pki/apiserver-etcd-client.key
        - --etcd-servers=https://127.0.0.1:2379
        - --insecure-port=0
        - --kubelet-client-certificate=/etc/kubernetes/pki/apiserver-kubelet-client.crt
        - --kubelet-client-key=/etc/kubernetes/pki/apiserver-kubelet-client.key
        - --kubelet-preferred-address-types=InternalIP,ExternalIP,Hostname
        - --proxy-client-cert-file=/etc/kubernetes/pki/front-proxy-client.crt
        - --proxy-client-key-file=/etc/kubernetes/pki/front-proxy-client.key
        - --requestheader-allowed-names=front-proxy-client
        - --requestheader-client-ca-file=/etc/kubernetes/pki/front-proxy-ca.crt
        - --requestheader-extra-headers-prefix=X-Remote-Extra-
        - --requestheader-group-headers=X-Remote-Group
        - --requestheader-username-headers=X-Remote-User
        - --secure-port=6443
        - --service-account-key-file=/etc/kubernetes/pki/sa.pub
        - --service-cluster-ip-range=10.96.0.0/12
        - --tls-cert-file=/etc/kubernetes/pki/apiserver.crt
        - --tls-private-key-file=/etc/kubernetes/pki/apiserver.key
        image: registry.aliyuncs.com/google_containers/kube-apiserver:v1.15.10
        imagePullPolicy: IfNotPresent
        livenessProbe:
          failureThreshold: 8
          httpGet:
            host: 10.53.5.94
            path: /healthz
            port: 6443
            scheme: HTTPS
          initialDelaySeconds: 15
          timeoutSeconds: 15
        name: kube-apiserver
        resources:
          requests:
            cpu: 250m
        volumeMounts:
        - mountPath: /etc/ssl/certs
          name: ca-certs
          readOnly: true
        - mountPath: /etc/ca-certificates
          name: etc-ca-certificates
          readOnly: true
        - mountPath: /etc/kubernetes/pki
          name: k8s-certs
          readOnly: true
        - mountPath: /usr/local/share/ca-certificates
          name: usr-local-share-ca-certificates
          readOnly: true
        - mountPath: /usr/share/ca-certificates
          name: usr-share-ca-certificates
          readOnly: true
      hostNetwork: true
      priorityClassName: system-cluster-critical
      volumes:
      - hostPath:
          path: /etc/ssl/certs
          type: DirectoryOrCreate
        name: ca-certs
      - hostPath:
          path: /etc/ca-certificates
          type: DirectoryOrCreate
        name: etc-ca-certificates
      - hostPath:
          path: /etc/kubernetes/pki
          type: DirectoryOrCreate
        name: k8s-certs
      - hostPath:
          path: /usr/local/share/ca-certificates
          type: DirectoryOrCreate
        name: usr-local-share-ca-certificates
      - hostPath:
          path: /usr/share/ca-certificates
          type: DirectoryOrCreate
        name: usr-share-ca-certificates
    status: {}

### 四、部署 ###

**1、安装 cfssl**

$ sudo wget https://pkg.cfssl.org/R1.2/cfssl_linux-amd64 -O /usr/local/bin/cfssl
    $ sudo wget https://pkg.cfssl.org/R1.2/cfssljson_linux-amd64 -O /usr/local/bin/cfssljson
    $ sudo wget https://pkg.cfssl.org/R1.2/cfssl-certinfo_linux-amd64 -O /usr/local/bin/cfssl-certinfo
    $ cd /usr/local/bin/
    $ sudo chmod +x cfssl cfssljson cfssl-certinfo

**2、创建 CA**

2.1、CA 配置文件

$ cat > aggregator-ca-config.json <<EOF
    {
      "signing": {
        "default": {
          "expiry": "87600h"
        },
        "profiles": {
          "aggregator": {
            "usages": [
                "signing",
                "key encipherment",
                "server auth",
                "client auth"
            ],
            "expiry": "87600h"
          }
        }
      }
    }
    EOF

*  `profiles` : 可以定义多个 profiles，分别指定不同的过期时间、使用场景等参数；后续在签名证书时使用某个 profile。
 *  `signing` ：表示该证书可用于签名其它证书；生成的 aggregator-ca.pem 证书中 `CA=TRUE`。
 *  `server auth` ：表示 Client 可以用该 CA 对 Server 提供的证书进行验证。
 *  `client auth` ：表示 Server 可以用该 CA 对 Client 提供的证书进行验证。

2.2、创建 CA 证书签名请求

cat > aggregator-ca-csr.json <<EOF
    {
      "CN": "aggregator",
      "key": {
        "algo": "rsa",
        "size": 2048
      },
      "names": [
        {
          "C": "CN",
          "ST": "BeiJing",
          "L": "BeiJing",
          "O": "k8s",
          "OU": "System"
        }
      ],
        "ca": {
           "expiry": "87600h"
        }
    }
    EOF

*  **“CN”** ：`Common Name`，kube-apiserver 从证书中提取该字段作为请求的用户名 (User Name)；浏览器使用该字段验证网站是否合法。
 *  **“O”** ：`Organization`，kube-apiserver 从证书中提取该字段作为请求用户所属的组 (Group)；

2.3、生成 CA 证书和私钥

cfssl gencert -initca aggregator-ca-csr.json | cfssljson -bare aggregator-ca

** 3、创建 kubernetes 证书**

3.1、创建 aggregator 证书签名请求

cat > aggregator-csr.json <<EOF
    {
        "CN": "aggregator",
        "hosts": [
          "127.0.0.1",
          "10.53.5.94",
          "10.96.0.1",
          "kubernetes",
          "kubernetes.default",
          "kubernetes.default.svc",
          "kubernetes.default.svc.cluster",
          "kubernetes.default.svc.cluster.local"
        ],
        "key": {
            "algo": "rsa",
            "size": 2048
        },
        "names": [
            {
                "C": "CN",
                "ST": "BeiJing",
                "L": "BeiJing",
                "O": "k8s",
                "OU": "System"
            }
        ]
    }
    EOF

如果 hosts 字段不为空则需要指定授权使用该证书的 IP 或域名列表，由于该证书后续kubernetes master 集群使用，所以上面指定`kubernetes master` 集群的主机 IP 和 kubernetes 服务的服务 IP（一般是 kube-apiserver 指定的 `service-cluster-ip-range` 网段的第一个 IP，如 10.96.0.1）。

3.2、生成 aggreagtor 证书和私钥

3.3、分发证书

将生成的证书和秘钥文件（后缀名为.pem）拷贝到 Master 节点的 `/etc/kubernetes/pki` 目录下备用。

**4、开启聚合层 API**

`kube-apiserver` 增加以下配置：

--requestheader-client-ca-file=/etc/kubernetes/pki/aggregator-ca.pem
    --requestheader-allowed-names=aggregator
    --requestheader-extra-headers-prefix=X-Remote-Extra-
    --requestheader-group-headers=X-Remote-Group
    --requestheader-username-headers=X-Remote-User
    --proxy-client-cert-file=/etc/kubernetes/pki/aggregator.pem
    --proxy-client-key-file=/etc/kubernetes/pki/aggregator-key.pem

> 前面创建的证书的 `CN` 字段的值必须和参数 `–requestheader-allowed-names` 指定的值 `aggregator` 相同。

重启 kube-apiserver：

$ systemctl daemon-reload
    $ systemctl restart kube-apiserver

如果 `kube-proxy` 没有在 Master 上面运行，`kube-proxy` 还需要添加配置：

--enable-aggregator-routing=true

【参考文章】

1、参考文章一：[kubeadm证数][kubeadm]

2、参考文章二：[详解kubeadm生成的证书][kubeadm]

[k8s]: https://blog.csdn.net/weixin_40449300/article/details/104758475
[CustomResourceDefinition _CRD]: https://feisky.gitbooks.io/kubernetes/concepts/customresourcedefinition.html
[https_k8smeetup.github.io_docs_tasks_access-kubernetes-api_configure-aggregation-layer]: https://k8smeetup.github.io/docs/tasks/access-kubernetes-api/configure-aggregation-layer/
[kubeadm]: https://docs.lvrui.io/2018/09/28/%E8%AF%A6%E8%A7%A3kubeadm%E7%94%9F%E6%88%90%E7%9A%84%E8%AF%81%E4%B9%A6/
[https_kubernetes.io_docs_reference_command-line-tools-reference_kube-apiserver]: https://kubernetes.io/docs/reference/command-line-tools-reference/kube-apiserver/
[https_kubernetes.io_docs_concepts_extend-kubernetes_api-extension_apiserver-aggregation]: https://kubernetes.io/docs/concepts/extend-kubernetes/api-extension/apiserver-aggregation/
[https_kubernetes.io_docs_tasks_access-kubernetes-api_configure-aggregation-layer]: https://kubernetes.io/docs/tasks/access-kubernetes-api/configure-aggregation-layer/