kubernetes 源码安装部署 1.12

2023-07-26 15:38:28

一. 前期准备

参考文档

https://jimmysong.io/kubernetes-handbook/practice/create-tls-and-secret-key.html

1. 安装golang编译环境, 官网(golang.org)下载安装

2. git clone https://github.com/kubernetes/kubernetes.git

3. 直接在clone的目录下编译 如何编译参考这个第一节

4. 将二进制文件上传到服务器上

二. 生成证书

1. 使用cfssl方式生成证书,参考地址

1.1 下载安装

curl -L https://pkg.cfssl.org/R1.2/cfssl_linux-amd64 -o cfssl

chmod +x cfssl

curl -L https://pkg.cfssl.org/R1.2/cfssljson_linux-amd64 -o cfssljson

chmod +x cfssljson

curl -L https://pkg.cfssl.org/R1.2/cfssl-certinfo_linux-amd64 -o cfssl-certinfo

chmod +x cfssl-certinfo
1.2 创建 ca-config.json 文件并填写内容
{

  "signing": {

    "default": {

      "expiry": "8760h"

    },

    "profiles": {

      "kubernetes": {

        "usages": [

          "signing",

          "key encipherment",

          "server auth",

          "client auth"

        ],

        "expiry": "8760h"

      }

    }

  }

}

备注：

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

1.3 创建 ca-csr.json 并填写内容
{

  "CN": "kubernetes",

  "key": {

    "algo": "rsa",

    "size": 2048

  },

  "names":[{

    "C": "<country>",

    "ST": "<state>",

    "L": "<city>",

    "O": "<organization>",

    "OU": "<organization unit>"

  }]

}

备注:

CN : Common Name，kube-apiserver从证书中提取该字段作为请求的用户名； O : Organization，kube-apiserver从证书中提取该字段作为请求用户所属的组；

1.4 生成证书秘钥
$ cfssl gencert -initca ca-csr.json | cfssljson -bare ca

2. 生成kubernetes证书

2.1
vim kubernetes-csr.json
{

  "CN": "kubernetes",

  "hosts": [

    "127.0.0.1",

    "<MASTER_IP>",

    "<MASTER_CLUSTER_IP>",

    "kubernetes",

    "kubernetes.default",

    "kubernetes.default.svc",

    "kubernetes.default.svc.cluster",

    "kubernetes.default.svc.cluster.local"

  ],

  "key": {

    "algo": "rsa",

    "size": 2048

  },

  "names": [{

    "C": "<country>",

    "ST": "<state>",

    "L": "<city>",

    "O": "<organization>",

    "OU": "<organization unit>"

  }]

}
2.2 生成kubernetes的证书和私钥
$ cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes kubernetes-csr.json | cfssljson -bare kubernetes

说明：

该证书后面可以提供给k8s集群和etcd集群使用。 hosts字段中制定授权使用该证书的IP和域名列表，因为现在要生成的证书需要被Kubernetes Master集群各个节点使用，所以这里指定了各个节点的IP和hostname。同时还要指定集群内部kube-apiserver的多个域名和IP地址10.254.0.1(后边kube-apiserver-service-cluster-ip-range=10.254.0.0/12参数的指定网段的第一个IP)。

2.3 创建kubernetes-admin证书配置文件
$ vim admin-csr.json

{

  "CN": "kubernetes-admin",

  "hosts": [

        "172.16.110.108",

        "172.16.110.105",

        "172.16.110.107"

  ],

  "key": {

    "algo": "rsa",

    "size": 2048

  },

  "names": [

    {

      "C": "CN",

      "ST": "HangZhou",

      "L": "HangZhou",

      "O": "system:masters",

      "OU": "system"

    }

  ]

}

说明：

kube-apiserver将提取CN作为客户端的用户名，这里是kubernetes-admin，将提取O作为用户所属的组，这里是system:master。 kube-apiserver预定义了一些 RBAC使用的ClusterRoleBindings，例如 cluster-admin将组system:masters与 ClusterRole cluster-admin绑定，而cluster-admin拥有访问kube-apiserver的所有权限，因此kubernetes-admin这个用户将作为集群的超级管理员。

2.4 生成admin证书和私钥
$ cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes admin-csr.json | cfssljson -bare admin
2.5、创建kube-proxy证书

创建配置文件

$ vim kube-proxy-csr.json

{

     "CN": "system:kube-proxy",

     "hosts": [],

     "key": {

       "algo": "rsa",

       "size": 2048

     },

"names": [ {

         "C": "CN",

         "ST": "HangZhoue",

         "L": "HangZhoue",

         "O": "k8s",

         "OU": "System"

} ]

}

说明：

指定证书User为 system:kube-proxy kube-apiserver 预定义的RoleBinding cluster-admin将User system:kube-proxy与Role system:node-proxier绑定，将Role授予调用kube-apiserver Proxy相关API的权限；

生成证书和私钥

$ cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes  kube-proxy-csr.json | cfssljson -bare kube-proxy

最终生成的证书和秘钥规划如下：

组件 证书 说明
etcd ca.pem、kubernetes-key.pem、kubernetes.pem 和kube-apiserver通用
kube-apiserver ca.pem、kubernetes-key.pem、kubernetes.pem kube-controller、kube-scheduler和apiserver都是部署在master可以使用非安全通行，不再单独安装证书。
kube-proxy ca.pem、kube-proxy-key.pem、kube-proxy.pem  
kubectl ca.pem、admin-key.pem、admin.pem  

三. Etcd搭建

1. 安装etcd

2. 编写 etcd.service 文件并放置在service目录下(centos7 /usr/lib/systemd/system/)

[Unit]

Description=Etcd Server

[Service]

Type=notify

WorkingDirectory=/data/etcd/

EnvironmentFile=-/etc/etcd/etcd.conf

ExecStart=/usr/bin/etcd \\

  --name k8s-master \\

  --cert-file=/etc/kubernetes/ssl/kubernetes.pem \\

  --key-file=/etc/kubernetes/ssl/kubernetes-key.pem \\

  --peer-cert-file=/etc/kubernetes/ssl/kubernetes.pem \\

  --peer-key-file=/etc/kubernetes/ssl/kubernetes-key.pem \\

  --trusted-ca-file=/etc/kubernetes/ssl/ca.pem \\

  --peer-trusted-ca-file=/etc/kubernetes/ssl/ca.pem \\

  --initial-advertise-peer-urls https://172.16.110.108:2380 \\

  --listen-peer-urls https://172.16.110.108:2380 \\

  --listen-client-urls https://172.16.110.108:2379,https://127.0.0.1:2379 \\

  --advertise-client-urls https://172.16.110.108:2379 \\

  --initial-cluster-token etcd-cluster-0 \\

  --initial-cluster k8s-master=https://172.16.110.108:2380,k8s-node1=https://172.16.110.15:2380,k8s-node2=https://172.16.110.107:2380 \\

  --initial-cluster-state new \\

  --data-dir=/data/etcd

Restart=on-failure

RestartSec=5

LimitNOFILE=65536

[Install]

WantedBy=multi-user.target

注意：在不同的设备上要替换name、initial-advertise-peer-urls、listen-peer-urls、listen-client-urls、advertise-client-urls中的名称和IP。

创建etcd的数据目录

$ mkdir -p /data/etcd

3. 启动Etcd服务

$ systemctl daemon-reload

$ systemctl start etcd

$ systemctl enable etcd  //开机自动启动

启动的过程中，如果出现类似下面的错误

etcd[1109]: request cluster ID mismatch (got 67a2ce01fa646032 want f863541ccf739acf) 应该是date-dir引起的，清空该目录，重新启动。

4. 检查安装

在任意节点执行检查命令

$ etcdctl --ca-file=/etc/kubernetes/ssl/ca.pem \

    --cert-file=/etc/kubernetes/ssl/kubernetes.pem \

    --key-file=/etc/kubernetes/ssl/kubernetes-key.pem \

    --endpoints=https://172.16.110.108:2379,https://172.16.110.105:2379,https://172.16.110.107:2379   cluster-health

输出

member 41793ee167c4a0b1 is healthy: got healthy result from https://172.16.110.105:2379

member d5e994c7ce1b8ced is healthy: got healthy result from https://172.16.110.107:2379

member e809b7931db45374 is healthy: got healthy result from https://172.16.110.108:2379

cluster is healthy

三. 安装Flannel 参考文档

四. 安装kubectl

kubectl 默认从 ~/.kube/config 配置文件获取访问 kube-apiserver 地址、证书、用户名等信息，如果没有配置该文件，执行命令时出错：

$ kubectl get componentstatuses

The connection to the server localhost:8080 was refused - did you specify the right host or port?

1. 安装admin证书和私钥

将前面创建的admin证书和私钥拷贝到/etc/kubernetes/ssl目录下

2. 创建kubectl kubeconfig文件

#设置集群参数

kubectl config set-cluster kubernetes \

  --certificate-authority=/etc/kubernetes/ssl/ca.pem \

  --embed-certs=true \

  --server="https://172.16.110.108:6443"

#设置客户端认证参数

kubectl config set-credentials admin \

  --client-certificate=/etc/kubernetes/ssl/admin.pem \

  --embed-certs=true \

  --client-key=/etc/kubernetes/ssl/admin-key.pem

#设置上下文参数

kubectl config set-context kubernetes \

  --cluster=kubernetes \

  --user=admin

#设置默认上下文

kubectl config use-context kubernetes

五. 部署master节点

1. 部署apiserver

1.1 配置 token 文件

k8s支持通过kube-apiserver为客户端生成TLS证书的TLS Bootstrapping功能，kubelet 首次启动时向 kube-apiserver 发送 TLS Bootstrapping 请求，kube-apiserver 验证 kubelet 请求中的 token 是否与它配置的 token.csv 一致，如果一致则自动为 kubelet生成证书和秘钥。 生成方法 请阅读RBAC文档 生成后

ZhqAdfUAmq6tRLTD5HxIOYBQg19fYQ38,kubelet-bootstrap,10001,"system:node"

移动到

$ mv token.csv /etc/kubernetes/
1.2 创建kube-apiserver的systemd unit文件

kube-apiserver.service

[Unit]

  Description=Kubernetes API Service

  Documentation=https://github.com/GoogleCloudPlatform/kubernetes

  After=network.target

  After=etcd.service

[Service]

  EnvironmentFile=-/etc/kubernetes/config

  EnvironmentFile=-/etc/kubernetes/apiserver

  ExecStart=/root/k8s/cmd/kube-apiserver \

          $KUBE_LOGTOSTDERR \

          $KUBE_LOG_LEVEL \

          $KUBE_ETCD_SERVERS \

          $KUBE_API_ADDRESS \

          $KUBE_API_PORT \

          $KUBELET_PORT \

          $KUBE_ALLOW_PRIV \

          $KUBE_SERVICE_ADDRESSES \

          $KUBE_ADMISSION_CONTROL \

          $KUBE_API_ARGS

  Restart=on-failure

  Type=notify

  LimitNOFILE=65536

[Install]

WantedBy=multi-user.target
1.3 创建config在前面创建的/etc/kubernetes目录下
KUBE_LOGTOSTDERR="--logtostderr=true"

KUBE_LOG_LEVEL="--v=0"

KUBE_ALLOW_PRIV="--allow-privileged=true"

KUBE_MASTER="--master=http://10.100.208.177:8080"
1.4 创建apiserver配置文件同样在/etc/kubernetes目录下，内容如下：
KUBE_API_ADDRESS="--advertise-address=10.100.208.177 --bind-address=10.100.208.177 --insecure-bind-address=10.100.208.177"

KUBE_ETCD_SERVERS="--etcd-servers=https://10.100.208.177:2379"

KUBE_SERVICE_ADDRESSES="--service-cluster-ip-range=10.254.0.0/16"

KUBE_ADMISSION_CONTROL="--admission-control=ServiceAccount,NamespaceLifecycle,NamespaceExists,LimitRanger,ResourceQuota"

KUBE_API_ARGS="--authorization-mode=RBAC --runtime-config=rbac.authorization.k8s.io/v1beta1 --kubelet-https=true --token-auth-file=/etc/kubernetes/token.csv --service-node-port-range=30000-32767 --tls-cert-file=/etc/kubernetes/ssl/kubernetes.pem --tls-private-key-file=/etc/kubernetes/ssl/kubernetes-key.pem --client-ca-file=/etc/kubernetes/ssl/ca.pem --service-account-key-file=/etc/kubernetes/ssl/ca-key.pem --etcd-cafile=/etc/kubernetes/ssl/ca.pem --etcd-certfile=/etc/kubernetes/ssl/kubernetes.pem --etcd-keyfile=/etc/kubernetes/ssl/kubernetes-key.pem --enable-swagger-ui=true --apiserver-count=3 --audit-log-maxage=30 --audit-log-maxbackup=3 --audit-log-maxsize=100 --audit-log-path=/var/lib/audit.log --event-ttl=1h"

--authorization-mode=RBAC 指定在安全端口使用 RBAC 授权模式，拒绝未通过授权的请求；

kube-scheduler、kube-controller-manager 一般和 kube-apiserver 部署在同一台机器上，它们使用非安全端口和 kube-apiserver通信;

kubelet、kube-proxy、kubectl 部署在其它 Node 节点上，如果通过安全端口访问 kube-apiserver，则必须先通过 TLS 证书认证，再通过 RBAC 授权；

kube-proxy、kubectl 通过在使用的证书里指定相关的 User、Group 来达到通过 RBAC 授权的目的；

如果使用了 kubelet TLS Boostrap 机制，则不能再指定 --kubelet-certificate-authority、--kubelet-client-certificate 和 --kubelet-client-key 选项，否则后续 kube-apiserver 校验 kubelet 证书时出现 ”x509: certificate signed by unknown authority“ 错误；

--admission-control 值必须包含 ServiceAccount；

--bind-address 不能为 127.0.0.1；

runtime-config配置为rbac.authorization.k8s.io/v1beta1，表示运行时的apiVersion；

--service-cluster-ip-range 指定 Service Cluster IP 地址段，该地址段不能路由可达；

缺省情况下 kubernetes 对象保存在 etcd /registry 路径下，可以通过 --etcd-prefix参数进行调整；

启动服务

$ sudo systemctl daemon-reload

$ sudo systemctl enable kube-apiserver

$ sudo systemctl start kube-apiserver

$ sudo systemctl status kube-apiserver

2. 部署kube-controller-manager

2.1 创建kube-controller-manager的systemd unit文件

kube-controller-manager.service

[Unit]

Description=Kubernetes Controller Manager

Documentation=https://github.com/GoogleCloudPlatform/kubernetes

[Service]

EnvironmentFile=-/etc/kubernetes/config

EnvironmentFile=-/etc/kubernetes/controller-manager

ExecStart=/root/k8s/cmd/kube-controller-manager \

           $KUBE_LOGTOSTDERR \

           $KUBE_LOG_LEVEL \

           $KUBE_MASTER \

           $KUBE_CONTROLLER_MANAGER_ARGS

Restart=on-failure

RestartSec=5

[Install]

WantedBy=multi-user.target
2.2 创建controller-manager文件同样放在/etc/kubernetes/目录下，内容如下：
KUBE_CONTROLLER_MANAGER_ARGS="--address=127.0.0.1 --service-cluster-ip-range=10.254.0.0/16 --cluster-name=kubernetes --cluster-signing-cert-file=/etc/kubernetes/ssl/ca.pem --cluster-signing-key-file=/etc/kubernetes/ssl/ca-key.pem  --service-account-private-key-file=/etc/kubernetes/ssl/ca-key.pem --root-ca-file=/etc/kubernetes/ssl/ca.pem --leader-elect=true"

--service-cluster-ip-range 参数指定 Cluster 中 Service 的CIDR范围，该网络在各 Node 间必须路由不可达，必须和 kube-apiserver 中的参数一致；

--cluster-signing-* 指定的证书和私钥文件用来签名为 TLS BootStrap 创建的证书和私钥；

--root-ca-file 用来对 kube-apiserver 证书进行校验，指定该参数后，才会在Pod 容器的 ServiceAccount 中放置该 CA 证书文件；

--address 值必须为 127.0.0.1，因为当前 kube-apiserver 期望 scheduler 和 controller-manager 在同一台机器

启动服务

$ sudo systemctl daemon-reload

$ sudo systemctl enable kube-controller-manager

$ sudo systemctl start kube-controller-manager

$ sudo systemctl status kube-controller-manager

3. kube-scheduler

3.1 创建kube-scheduler的systemd unit文件 文件为/etc/systemd/system/kube-scheduler.service,内容如下：
[Unit]

   Description=Kubernetes Scheduler Plugin

   Documentation=https://github.com/GoogleCloudPlatform/kubernetes

[Service]

   EnvironmentFile=-/etc/kubernetes/config

   EnvironmentFile=-/etc/kubernetes/scheduler

   ExecStart=/root/k8s/cmd/kube-scheduler \

               $KUBE_LOGTOSTDERR \

               $KUBE_LOG_LEVEL \

               $KUBE_MASTER \

               $KUBE_SCHEDULER_ARGS

   Restart=on-failure

   LimitNOFILE=65536

[Install]

WantedBy=multi-user.target
3.2 创建scheduler文件 文件同样是在/etc/kubernetes目录下，内容如下：
KUBE_SCHEDULER_ARGS="--leader-elect=true --address=127.0.0.1"

--address 值同样必须为 127.0.0.1，因为当前 kube-apiserver 期望 scheduler 和 controller-manager 在同一台机器；

启动服务

$ systemctl daemon-reload

$ systemctl enable kube-scheduler

$ systemctl start kube-scheduler

$ systemctl status kube-scheduler

4. 验证安装

$ kubectl get componentstatuses

NAME                 STATUS    MESSAGE              ERROR

scheduler            Healthy   ok

controller-manager   Healthy   ok

etcd-0               Healthy   {"health": "true"}

etcd-2               Healthy   {"health": "true"}

etcd-1               Healthy   {"health": "true"}

五. node节点安装参考

1. 安装证书和私钥

将之前生成admin-key.pem、admin.pem、ca-key.pem、ca.pem、kube-proxy-key.pem、kube-proxy.pem、kubernetes-key.pem、kubernetes.pem等证书拷贝到108、105、107三台设备的/etc/kubernetes/ssl目录下，将token.csv文件拷贝到/etc/kubernetes目录下。

2. 安装配置kubelet

2.1 创建角色绑定
kubectl create clusterrolebinding kubelet-bootstrap --clusterrole=system:node --user=kubelet-bootstrap

kubelet 启动时向 kube-apiserver 发送 TLS bootstrapping 请求，需要先将 bootstrap token 文件中的 kubelet-bootstrap 用户赋予 system:node 角色，然后 kubelet 才有权限创建认证请求(certificatesigningrequests)：

--user=kubelet-bootstrap 是文件 /etc/kubernetes/token.csv 中指定的用户名

2.2 创建bootstrapping kubeconfig文件
#设置集群参数

$ kubectl config set-cluster kubernetes \

  --certificate-authority=/etc/kubernetes/ssl/ca.pem \

  --embed-certs=true \

  --server="https://<MASTER_IP>:6443" \

  --kubeconfig=bootstrap.kubeconfig

#设置客户端认证参数

$ kubectl config set-credentials kubelet-bootstrap \

     --token=<Your token on the token.csv> \

     --kubeconfig=bootstrap.kubeconfig

#设置上下文参数

$ kubectl config set-context default \

     --cluster=kubernetes \

     --user=kubelet-bootstrap \

     --kubeconfig=bootstrap.kubeconfig

#设置默认上下文

$ kubectl config use-context default --kubeconfig=bootstrap.kubeconfig
2.3 创建kubelet的systemd unit文件 文件为/etc/systemd/system/kubelet.service，内容如下：
[Unit]

   Description=Kubernetes Kubelet Server

   After=docker.service

   Requires=docker.service

[Service]

   WorkingDirectory=/var/lib/kubelet

   EnvironmentFile=-/etc/kubernetes/config

   EnvironmentFile=-/etc/kubernetes/kubelet

   ExecStart=/root/k8s/cmd/kubelet \

               $KUBE_LOGTOSTDERR \

               $KUBE_LOG_LEVEL \

               $KUBELET_API_SERVER \

               $KUBELET_ADDRESS \

               $KUBELET_PORT \

               $KUBELET_HOSTNAME \

               $KUBE_ALLOW_PRIV \

               $KUBELET_POD_INFRA_CONTAINER \

               $KUBELET_ARGS

Restart=on-failure

[Install]

WantedBy=multi-user.target

创建工作目录

$ mkdir -p /var/lib/kubelet
2.4 创建kubelet配置文件

/etc/kubernetes/kubelet

KUBELET_ADDRESS="--address=10.100.208.178"

KUBELET_HOSTNAME="--hostname-override=10.100.208.178"

KUBELET_POD_INFRA_CONTAINER="--pod-infra-container-image=registry.access.redhat.com/rhel7/pod-infrastructure:latest"

KUBELET_ARGS="--config=/etc/kubernetes/manifests/kubelet.yml --cluster_dns=10.254.0.2 --kubeconfig=/etc/kubernetes/bootstrap.kubeconfig --cert-dir=/etc/kubernetes/ssl --cluster_domain=cluster.local. --hairpin-mode promiscuous-bridge --serialize-image-pulls=false"

--address 不能设置为 127.0.0.1，否则后续 Pods 访问 kubelet 的 API 接口时会失败，因为 Pods 访问的 127.0.0.1指向自己而不是 kubelet，然后不同的节点根据实际IP来配置；

如果设置了 --hostname-override 选项，则 kube-proxy 也需要设置该选项，否则会出现找不到 Node 的情况；

--experimental-bootstrap-kubeconfig 指向 bootstrap kubeconfig 文件，kubelet 使用该文件中的用户名和 token 向 kube-apiserver 发送 TLS Bootstrapping 请求；

管理员通过了 CSR 请求后，kubelet 自动在 --cert-dir 目录创建证书和私钥文件(kubelet-client.crt 和 kubelet-client.key)，然后写入 --kubeconfig 文件(自动创建 --kubeconfig 指定的文件)；

建议在 --kubeconfig 配置文件中指定 kube-apiserver 地址，如果未指定 --api-servers 选项，则必须指定 --require-kubeconfig 选项后才从配置文件中读取 kue-apiserver 的地址，否则 kubelet 启动后将找不到 kube-apiserver (日志中提示未找到 API Server），kubectl get nodes 不会返回对应的 Node 信息;

--cluster_dns 指定 kubedns 的 Service IP(可以先分配，后续创建 kubedns 服务时指定该 IP)，--cluster_domain 指定域名后缀，这两个参数同时指定后才会生效；

可选配置 /etc/kubernetes/manifests/kubelet.yml 相关文档

kind: KubeletConfiguration

apiVersion: kubelet.config.k8s.io/v1beta1

failSwapOn: false

kubeletCgroups: /systemd/system.slice

evictionHard:

    memory.available: "200Mi"

启动服务

$ sudo systemctl daemon-reload

$ sudo systemctl enable kubelet

$ sudo systemctl start kubelet

$ sudo systemctl status kubelet

如果启动出现下面错误：

failed to create kubelet: misconfiguration: kubelet cgroup driver: "systemd" is different from docker cgroup driver: "systemd" is different from docker cgroup driver: "cgroupfs"

要么修改kubelet的配置要么修改docker的配置，我这里修改kubelet的配置如下：

KUBELET_ARGS="--cgroup-driver=cgroupfs --cluster_dns=10.254.0.2 --experimental-bootstrap-kubeconfig=/etc/kubernetes/bootstrap.kubeconfig --kubeconfig=/etc/kubernetes/kubelet.kubeconfig --require-kubeconfig --cert-dir=/etc/kubernetes/ssl --cluster_domain=cluster.local. --hairpin-mode promiscuous-bridge --serialize-image-pulls=false"

3. 安装配置kube-proxy

3.1 创建kube-proxy kubeconfig文件
# 设置集群参数

$ kubectl config set-cluster kubernetes \

  --certificate-authority=/etc/kubernetes/ssl/ca.pem \

  --embed-certs=true \

  --server="https://172.16.110.108:6443" \

  --kubeconfig=kube-proxy.kubeconfig

# 设置客户端认证参数

$ kubectl config set-credentials kube-proxy \

  --client-certificate=/etc/kubernetes/ssl/kube-proxy.pem \

  --client-key=/etc/kubernetes/ssl/kube-proxy-key.pem \

  --embed-certs=true \

  --kubeconfig=kube-proxy.kubeconfig

# 设置上下文参数

$ kubectl config set-context default \

  --cluster=kubernetes \

  --user=kube-proxy \

  --kubeconfig=kube-proxy.kubeconfig

# 设置默认上下文

$ kubectl config use-context default --kubeconfig=kube-proxy.kubeconfig

设置集群参数和客户端认证参数时 --embed-certs 都为 true，这会将 certificate-authority、client-certificate和 client-key 指向的证书文件内容写入到生成的 kube-proxy.kubeconfig 文件中；

kube-proxy.pem 证书中 CN 为 system:kube-proxy，kube-apiserver 预定义的 RoleBinding cluster-admin 将User system:kube-proxy 与 Role system:node-proxier 绑定，该 Role 授予了调用 kube-apiserver Proxy 相关 API 的权限；

3.2 创建kube-proxy文件在目录/etc/kubernetes，内容如下：
KUBE_PROXY_ARGS="--bind-address=10.100.208.178 --kubeconfig=/etc/kubernetes/kube-proxy.kubeconfig --cluster-cidr=10.254.0.0/16"

--hostname-override 参数值必须与 kubelet 的值一致，否则 kube-proxy 启动后会找不到该 Node，从而不会创建任何 iptables 规则；

--cluster-cidr 必须与 kube-apiserver 的 --service-cluster-ip-range 选项值一致；

kube-proxy 根据 --cluster-cidr 判断集群内部和外部流量，指定 --cluster-cidr 或 --masquerade-all 选项后 kube-proxy 才会对访问 Service IP 的请求做 SNAT；

--kubeconfig 指定的配置文件嵌入了 kube-apiserver 的地址、用户名、证书、秘钥等请求和认证信息；

预定义的 RoleBinding cluster-admin 将User system:kube-proxy 与 Role system:node-proxier 绑定，该 Role 授予了调用 kube-apiserver Proxy 相关 API 的权限；

3.2 创建kube-proxy的systemd unit文件
[Unit]

Description=Kubernetes Kube-Proxy Server

Documentation=https://github.com/GoogleCloudPlatform/kubernetes

After=network.target

[Service]

EnvironmentFile=-/etc/kubernetes/config

EnvironmentFile=-/etc/kubernetes/kube-proxy

ExecStart=/root/k8s/cmd/kube-proxy \

           $KUBE_LOGTOSTDERR \

           $KUBE_LOG_LEVEL \

           $KUBE_MASTER \

           $KUBE_PROXY_ARGS

Restart=on-failure

LimitNOFILE=65536

[Install]

WantedBy=multi-user.target

确定服务

$ sudo systemctl daemon-reload

$ sudo systemctl enable kube-proxy

$ sudo systemctl start kube-proxy

$ sudo systemctl status kube-proxy

4. 验证安装

$ kubectl get nodes

NAME             STATUS    ROLES     AGE       VERSION

xxx.xxx.xxx.xxx   Ready     <none>    2d17h     xxx

............
上一篇：java.lang.String小测试


下一篇：mongodb 创建更新语法