k8s1.11.0安装、一个master、一个node、查看node名称是ip、node是扩容进来的、带cadvisor监控服务

一个master、一个node、查看node节点是ip


# 安装顺序：先在test1 上安装完必要组件后，就开始在 test2 上单独安装node组件，实现node功能，再返回来配置test1加入集群，实现node功能

# 本实验 test1 节点不做安装kubelet组件。只有安装启动了kubelet才会生成csr,kube-apiserver通过csr请求后才会成为一个node。所以是node节点单独安装

# 注意：准备了三台，这三台都做了环境准备，但是k8s集群只是使用了 test1、test2这两个节点，如果把test3扩容进来，随时都可以，

# 注意：本实验 test2 没有安装etcd，之前安装的etcd给剔除了

# 本实验 kubelet组件的参数中 --hostname-override= 写的ip地址，通过 kubectl get nodes 查看得到的name就是ip，如果填写主机名，得到的name就是主机名

实验架构：

# 注意：下面列出来的组件顺序就是本实验的组件安装顺序

test1: 192.168.0.91    etcd、kubectl工具、kube-apiserver、kube-controller-manager、kube-scheduler、kubelet组件、cni、kube-proxy

test2: 192.168.0.92    docker、kubectl工具、kubelet组件、cni、kube-proxy、flannel、coredns

test3：192.168.0.93    无


1、环境配置

如下操作在所有节点操作

配置hosts解析
[root@bogon ~]# hostnamectl set-hostname test1
[root@bogon~]# hostnamectl set-hostname test2
[root@bogon ~]# hostnamectl set-hostname test3

cat >>/etc/hosts<<EOF
192.168.0.91 test1
192.168.0.92 test2
192.168.0.93 test3
EOF


禁用selinux

sed -i 's/SELINUX=permissive/SELINUX=disabled/' /etc/sysconfig/selinux

sed -i 's/enforcing/disabled/g' /etc/selinux/config


关闭swap

# 注释/etc/fstab文件里swap相关的行

sed -i 's/\/dev\/mapper\/centos-swap/#\/dev\/mapper\/centos-swap/g' /etc/fstab


#关掉防火墙

systemctl stop firewalld && systemctl disable firewalld


配置免密登录


退出xshell重新登录，查主机名已改变


开启forward
iptables -P FORWARD ACCEPT


配置转发相关参数
cat >> /etc/sysctl.d/k8s.conf <<EOF
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
vm.swappiness=0
EOF
sysctl --system


加载ipvs相关内核模块
如果重新开机，需要重新加载
modprobe ip_vs
modprobe ip_vs_rr
modprobe ip_vs_wrr
modprobe ip_vs_sh
modprobe nf_conntrack_ipv4
lsmod | grep ip_vs


2、安装etcd
etcd安装请参照: https://www.cnblogs.com/effortsing/p/10295261.html

下面开始安装k8s组件，序号从6开始


6、分发二进制组件

# 只在 test1 上操作

# 提前分发k8s所有组件二进制文件、顺便安装kubectl工具

# 安装包解压后包括 kubectl 工具，所以不需要单独使用kubernetes-server-client-amd64.tar.gz 安装包分发 kubectl 工具


下载、解压安装包

cd /server/software/k8s

下载链接：https://pan.baidu.com/s/1DXahqP8nXWP1aw5pIunJrw 
提取码：9xfp

tar -xf kubernetes-server-linux-amd64.tar.gz



分发所有组件二进制文件，

# 后面配置 kube-apiserver 等各个组件启动文件里面需要带上各自二进制文件路径

mkdir -p /usr/local/kubernetes/bin
cd /server/software/k8s/kubernetes/server/bin
cp kube-apiserver kube-controller-manager kube-scheduler kube-proxy kubectl /usr/local/kubernetes/bin    #这一步很关键



安装kubectl工具

# 后面创建 admin kubeconfig等配置文件时候需要用到；

# admin.conf = ~/.kube/config，因为是复制过来的 ；

# kubectl作用：当kubelet组件通过bootstrap token 认证后，kubectl默认从 ~/.kube/config 文件读取 kube-apiserver 地址、证书、用户名等信息；

cp /usr/local/kubernetes/bin/kubectl /usr/local/bin/kubectl



查看 kubectl 版本，

# 出现下面的情况就是正确的。did you specify the right host or port? 这个报错忽略，因为还没有安装kubelet服务

kubectl version

[root@test1 bin]# kubectl version
Client Version: version.Info{Major:"1", Minor:"11", GitVersion:"v1.11.0", GitCommit:"91e7b4fd31fcd3d5f436da26c980becec37ceefe", GitTreeState:"clean", BuildDate:"2018-06-27T20:17:28Z", GoVersion:"go1.10.2", Compiler:"gc", Platform:"linux/amd64"}
The connection to the server localhost:8080 was refused - did you specify the right host or port?
 
cd $HOME




7、生成admin的ca证书和私钥 

# 只在 test1 上操作  

# kubectl 作为集群的管理工具，需要被授予最高权限。这里创建具有最高权限的 admin 证书、admin kubeconfig

# 注意：后面只有apiserver和kubelet这两个服务启动参数会用到admin的ca证书；kubectl工具和kubelet服务不是一回事

cd $HOME/ssl

cat >admin-csr.json<<EOF
{
    "CN": "admin",
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
        {
            "C": "CN",
            "ST": "BeiJing",
            "L": "BeiJing",
            "O": "system:masters",
            "OU": "System"
        }
    ]
}
EOF


生成证书

cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json \
-profile=kubernetes admin-csr.json | cfssljson -bare admin


查看生成的admin ca

ls admin*.pem




8、配置 kube-apiserver ca

# 只在 test1 上操作

# 10.96.0.1 是 kube-apiserver 指定的 service-cluster-ip-range 网段的第一个IP

cd $HOME/ssl

cat >kube-apiserver-csr.json<<EOF
{
    "CN": "kube-apiserver",
    "hosts": [
      "127.0.0.1",
      "192.168.0.91",
      "192.168.0.92",
      "192.168.0.93",
      "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

生成 kube-apiserver ca

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

查看生成的kube-apiserver ca

ls kube-apiserver*.pem




9、配置 kube-controller-manager ca

# 只在 test1 上操作

cd $HOME/ssl

cat >kube-controller-manager-csr.json<<EOF
{
    "CN": "system:kube-controller-manager",
    "hosts": [
      "127.0.0.1",
      "192.168.0.91"
    ],  
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
        {
            "C": "CN",
            "ST": "BeiJing",
            "L": "BeiJing",
            "O": "system:kube-controller-manager",
            "OU": "System"
        }
    ]
}
EOF

生成 kube-controller-manager ca

cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json \
-profile=kubernetes kube-controller-manager-csr.json | cfssljson -bare kube-controller-manager

查看生成的kube-controller-manager ca

ls kube-controller-manager*.pem






10、配置 kube-scheduler ca

# 只在 test1 上操作

cd $HOME/ssl

cat >kube-scheduler-csr.json<<EOF
{
    "CN": "system:kube-scheduler",
    "hosts": [
      "127.0.0.1",
      "192.168.0.91"
    ],
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
        {
            "C": "CN",
            "ST": "BeiJing",
            "L": "BeiJing",
            "O": "system:kube-scheduler",
            "OU": "System"
        }
    ]
}
EOF

生成 kube-scheduler ca

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

查看生成的kube-scheduler ca

ls kube-scheduler*.pem




11、配置 kube-proxy ca

# 只在 test1 上操作

# 注意：只是node节点需要用到kube-proxy ca

cd $HOME/ssl

cat >kube-proxy-csr.json<<EOF
{
    "CN": "system:kube-proxy",
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
        {
            "C": "CN",
            "ST": "BeiJing",
            "L": "BeiJing",
            "O": "system:kube-proxy",
            "OU": "System"
        }
    ]
}
EOF


生成 kube-proxy ca

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

查看生成的kube-proxy ca

ls kube-proxy*.pem



12、复制所有的ca 证书到一个目录里面，方便管理

# 只在 test1 上操作

cd $HOME/ssl
mkdir -p /etc/kubernetes/pki
cp ca*.pem admin*.pem kube-proxy*.pem kube-scheduler*.pem kube-controller-manager*.pem kube-apiserver*.pem /etc/kubernetes/pki



13、开启 bootstrap token 认证 ，kubelet TLS Boostrap机制 

# 只在 test1 上操作

# kube-apiserver、kubelet启动文件需要用到token，

# token中包含kubelet-bootstrap用户

# 后面kubelet组件启动参数中需要使用 kubelet-bootstrap.conf 文件向 kube-apiserver 发送 CSR 请求，

# 请求通过后，kubectl才会从 ~/.kube/config 文件读取 kube-apiserver 地址、证书、用户名等信息



静态获取token

# 还有一种是用 kubeadm 动态获取token，kubeadm token create,这样可以使用 TLS bootstrap 机制自动生成 client 和 server 证书，过期后自动轮转。

# 本实验采用静态获取，一天后过期

export BOOTSTRAP_TOKEN=$(head -c 16 /dev/urandom | od -An -t x | tr -d ' ')



创建token.csv文件

# 只有kube-apiserver 启动文件中需要用到

cat > /etc/kubernetes/token.csv <<EOF
${BOOTSTRAP_TOKEN},kubelet-bootstrap,10001,"system:kubelet-bootstrap"
EOF



创建kubelet-bootstrap.conf

# 只有kubelet启动文件需要用到

cd /etc/kubernetes

export KUBE_APISERVER="https://192.168.0.91:6443"

kubectl config set-cluster kubernetes \
  --certificate-authority=/etc/kubernetes/pki/ca.pem \
  --embed-certs=true \
  --server=${KUBE_APISERVER} \
  --kubeconfig=kubelet-bootstrap.conf

kubectl config set-credentials kubelet-bootstrap \
  --token=${BOOTSTRAP_TOKEN} \
  --kubeconfig=kubelet-bootstrap.conf

kubectl config set-context default \
  --cluster=kubernetes \
  --user=kubelet-bootstrap \
  --kubeconfig=kubelet-bootstrap.conf

kubectl config use-context default --kubeconfig=kubelet-bootstrap.conf



给kubelet-bootstrap用户授权

# 创建一个 clusterrolebinding，将 bootstrap token 文件中的 kubelet-bootstrap 用户赋予 system:node-bootstrapper cluster 角色

# 默认情况下，bootstrap这个 user 和 group 没有创建 CSR 的权限，kubelet 会启动失败，所以要给kubelet-bootstrap角色授权

kubectl create clusterrolebinding kubelet-bootstrap --clusterrole=system:node-bootstrapper --user=kubelet-bootstrap

# 如果没有授权会出现下面错误：

[root@test2 kubernetes]# journalctl -u kubelet |tail
failed to run Kubelet: cannot create certificate signing request: certificatesigningrequests.certificates.k8s.io is forbidden: User "kubelet-bootstrap" cannot create certificatesigningrequests.certificates.k8s.io at the cluster scope



14、创建 admin kubeconfig 

只在 test1 上操作

# 只有kubelet服务启动参数需要用到admin kubeconfig，
# admin.conf = ~/.kube/config，因为复制过来的 ；kubectl 默认从 ~/.kube/config 文件读取 kube-apiserver 地址、证书、用户名等信息，

cd /etc/kubernetes

export KUBE_APISERVER="https://192.168.0.91:6443"

设置集群参数

kubectl config set-cluster kubernetes \
  --certificate-authority=/etc/kubernetes/pki/ca.pem \
  --embed-certs=true \
  --server=${KUBE_APISERVER} \
  --kubeconfig=admin.conf

设置客户端认证参数

kubectl config set-credentials admin \
  --client-certificate=/etc/kubernetes/pki/admin.pem \
  --client-key=/etc/kubernetes/pki/admin-key.pem \
  --embed-certs=true \
  --kubeconfig=admin.conf

设置上下文参数

kubectl config set-context default \
  --cluster=kubernetes \
  --user=admin \
  --kubeconfig=admin.conf

设置默认上下文

kubectl config use-context default --kubeconfig=admin.conf



15、创建 kube-controller-manager kubeconfig

只在 test1 上操作

cd /etc/kubernetes

export KUBE_APISERVER="https://192.168.0.91:6443"

kubectl config set-cluster kubernetes \
  --certificate-authority=/etc/kubernetes/pki/ca.pem \
  --embed-certs=true \
  --server=${KUBE_APISERVER} \
  --kubeconfig=kube-controller-manager.conf

kubectl config set-credentials kube-controller-manager \
  --client-certificate=/etc/kubernetes/pki/kube-controller-manager.pem \
  --client-key=/etc/kubernetes/pki/kube-controller-manager-key.pem \
  --embed-certs=true \
  --kubeconfig=kube-controller-manager.conf

kubectl config set-context default \
  --cluster=kubernetes \
  --user=kube-controller-manager \
  --kubeconfig=kube-controller-manager.conf

kubectl config use-context default --kubeconfig=kube-controller-manager.conf




16、创建 kube-scheduler kubeconfig

# 只在 test1 上操作

cd /etc/kubernetes

export KUBE_APISERVER="https://192.168.0.91:6443"

kubectl config set-cluster kubernetes \
  --certificate-authority=/etc/kubernetes/pki/ca.pem \
  --embed-certs=true \
  --server=${KUBE_APISERVER} \
  --kubeconfig=kube-scheduler.conf

kubectl config set-credentials kube-scheduler \
  --client-certificate=/etc/kubernetes/pki/kube-scheduler.pem \
  --client-key=/etc/kubernetes/pki/kube-scheduler-key.pem \
  --embed-certs=true \
  --kubeconfig=kube-scheduler.conf

kubectl config set-context default \
  --cluster=kubernetes \
  --user=kube-scheduler \
  --kubeconfig=kube-scheduler.conf

kubectl config use-context default --kubeconfig=kube-scheduler.conf




17、创建 kube-proxy kubeconfig

# 只在 test1 上操作

# 注意：只是node节点需要用到kube-proxy kubeconfig

cd /etc/kubernetes

export KUBE_APISERVER="https://192.168.0.91:6443"

kubectl config set-cluster kubernetes \
  --certificate-authority=/etc/kubernetes/pki/ca.pem \
  --embed-certs=true \
  --server=${KUBE_APISERVER} \
  --kubeconfig=kube-proxy.conf

kubectl config set-credentials kube-proxy \
  --client-certificate=/etc/kubernetes/pki/kube-proxy.pem \
  --client-key=/etc/kubernetes/pki/kube-proxy-key.pem \
  --embed-certs=true \
  --kubeconfig=kube-proxy.conf

kubectl config set-context default \
  --cluster=kubernetes \
  --user=kube-proxy \
  --kubeconfig=kube-proxy.conf

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

cd $HOME




18、配置启动kube-apiserver

# 只在 test1 上操作

复制 etcd ca

mkdir -pv /etc/kubernetes/pki/etcd
cd $HOME/ssl
cp etcd.pem etcd-key.pem ca-key.pem ca.pem /etc/kubernetes/pki/etcd



生成 service account key

cd /etc/kubernetes/pki/
openssl genrsa -out /etc/kubernetes/pki/sa.key 2048
openssl rsa -in /etc/kubernetes/pki/sa.key -pubout -out /etc/kubernetes/pki/sa.pub
ls /etc/kubernetes/pki/sa.*
cd $HOME



配置启动文件

cat >/etc/systemd/system/kube-apiserver.service<<EOF
[Unit]
Description=Kubernetes API Service
Documentation=https://github.com/kubernetes/kubernetes
After=network.target

[Service]
EnvironmentFile=-/etc/kubernetes/config
EnvironmentFile=-/etc/kubernetes/apiserver
ExecStart=/usr/local/kubernetes/bin/kube-apiserver \\
        \$KUBE_LOGTOSTDERR \\
        \$KUBE_LOG_LEVEL \\
        \$KUBE_ETCD_ARGS \\
        \$KUBE_API_ADDRESS \\
        \$KUBE_SERVICE_ADDRESSES \\
        \$KUBE_ADMISSION_CONTROL \\
        \$KUBE_APISERVER_ARGS
Restart=on-failure
Type=notify
LimitNOFILE=65536

[Install]
WantedBy=multi-user.target
EOF



配置参数变量文件

# 下面 kube-apiserver、kube-controller-manager、kube-scheduler、kube-proxy这些服务 都需要用到，这里只配置一次，以后重复利用，后面的也写了变量文件，只是为了知道怎么回事

cat >/etc/kubernetes/config<<EOF
KUBE_LOGTOSTDERR="--logtostderr=true"
KUBE_LOG_LEVEL="--v=2"
EOF



配置apiserver

# 注意参数--token-auth-file=/etc/kubernetes/token.csv 表示在 apiserver 中静态配置bootstrap token，和后面开启 bootstrap token 认证步骤相呼应，不是动态的，所以有过期时间，

# 后面kubelet组件启动参数中需要使用 kubelet-bootstrap.conf 文件向 kube-apiserver 发送 CSR 请求，--bootstrap-kubeconfig 文件里面包含token和apiserver里面的token是一样的，

cat >/etc/kubernetes/apiserver<<EOF
KUBE_API_ADDRESS="--advertise-address=192.168.0.91"
KUBE_ETCD_ARGS="--etcd-servers=https://192.168.0.91:2379 --etcd-cafile=/etc/kubernetes/pki/ca.pem --etcd-certfile=/etc/kubernetes/pki/etcd/etcd.pem --etcd-keyfile=/etc/kubernetes/pki/etcd/etcd-key.pem"
KUBE_SERVICE_ADDRESSES="--service-cluster-ip-range=10.96.0.0/12"
KUBE_ADMISSION_CONTROL="--enable-admission-plugins=NamespaceLifecycle,LimitRanger,ServiceAccount,DefaultStorageClass,DefaultTolerationSeconds,MutatingAdmissionWebhook,ValidatingAdmissionWebhook,ResourceQuota"
KUBE_APISERVER_ARGS="--allow-privileged=true --authorization-mode=Node,RBAC --enable-bootstrap-token-auth=true --token-auth-file=/etc/kubernetes/token.csv --service-node-port-range=0-32767 --tls-cert-file=/etc/kubernetes/pki/kube-apiserver.pem --tls-private-key-file=/etc/kubernetes/pki/kube-apiserver-key.pem --client-ca-file=/etc/kubernetes/pki/ca.pem --service-account-key-file=/etc/kubernetes/pki/sa.pub --enable-swagger-ui=true --secure-port=6443 --kubelet-preferred-address-types=InternalIP,ExternalIP,Hostname --anonymous-auth=false --kubelet-client-certificate=/etc/kubernetes/pki/admin.pem --kubelet-client-key=/etc/kubernetes/pki/admin-key.pem"
EOF



启动

systemctl daemon-reload
systemctl enable kube-apiserver
systemctl start kube-apiserver
systemctl status kube-apiserver



通过浏览器访问测试

# 401 报错正常，是因为没有权限，不影响，以后解决

curl https://192.168.0.91:6443/swaggerapi
[root@test1 ~]# curl https://192.168.0.91:6443/swaggerapi
curl: (60) Peer's Certificate issuer is not recognized.
More details here: http://curl.haxx.se/docs/sslcerts.html

curl performs SSL certificate verification by default, using a "bundle"
of Certificate Authority (CA) public keys (CA certs). If the default
bundle file isn't adequate, you can specify an alternate file
using the --cacert option.
If this HTTPS server uses a certificate signed by a CA represented in
the bundle, the certificate verification probably failed due to a
problem with the certificate (it might be expired, or the name might
not match the domain name in the URL).
If you'd like to turn off curl's verification of the certificate, use
the -k (or --insecure) option.


19、配置启动kube-controller-manager

# 只在 tes1 上操作

配置启动文件

cat >/etc/systemd/system/kube-controller-manager.service<<EOF
Description=Kubernetes Controller Manager
Documentation=https://github.com/kubernetes/kubernetes
After=network.target

[Service]
EnvironmentFile=-/etc/kubernetes/config
EnvironmentFile=-/etc/kubernetes/controller-manager
ExecStart=/usr/local/kubernetes/bin/kube-controller-manager \\
        \$KUBE_LOGTOSTDERR \\
        \$KUBE_LOG_LEVEL \\
        \$KUBECONFIG \\
        \$KUBE_CONTROLLER_MANAGER_ARGS
Restart=on-failure
LimitNOFILE=65536

[Install]
WantedBy=multi-user.target
EOF



配置参数变量文件

# 配置kube-apiserver启动文件时已经配置过参数变量文件，这里就不需要再做，写在这里只是为了知道下面配置文件里的参数怎么回事

cat >/etc/kubernetes/config<<EOF
KUBE_LOGTOSTDERR="--logtostderr=true"
KUBE_LOG_LEVEL="--v=2"
EOF



配置controller-manager文件

# 特别注意：这里的cluster-cidr地址要和 Kube-proxy里面的cluster-cidr、flannel 里面的Network 地址保持一致，这有这三个组件里面有 10.244.0.0

cat >/etc/kubernetes/controller-manager<<EOF
KUBECONFIG="--kubeconfig=/etc/kubernetes/kube-controller-manager.conf"
KUBE_CONTROLLER_MANAGER_ARGS="--address=127.0.0.1 --cluster-cidr=10.244.0.0/16 --cluster-name=kubernetes --cluster-signing-cert-file=/etc/kubernetes/pki/ca.pem --cluster-signing-key-file=/etc/kubernetes/pki/ca-key.pem --service-account-private-key-file=/etc/kubernetes/pki/sa.key --root-ca-file=/etc/kubernetes/pki/ca.pem --leader-elect=true --use-service-account-credentials=true --node-monitor-grace-period=10s --pod-eviction-timeout=10s --allocate-node-cidrs=true --controllers=*,bootstrapsigner,tokencleaner"
EOF



启动
systemctl daemon-reload
systemctl enable kube-controller-manager
systemctl start kube-controller-manager
systemctl status kube-controller-manager




20、配置启动kube-scheduler

# 只在 test1 上操作

配置启动文件

cat >/etc/systemd/system/kube-scheduler.service<<EOF
[Unit]
Description=Kubernetes Scheduler Plugin
Documentation=https://github.com/kubernetes/kubernetes

[Service]
EnvironmentFile=-/etc/kubernetes/config
EnvironmentFile=-/etc/kubernetes/scheduler
ExecStart=/usr/local/kubernetes/bin/kube-scheduler \\
            \$KUBE_LOGTOSTDERR \\
            \$KUBE_LOG_LEVEL \\
            \$KUBECONFIG \\
            \$KUBE_SCHEDULER_ARGS
Restart=on-failure
LimitNOFILE=65536

[Install]
WantedBy=multi-user.target
EOF



配置参数变量文件

# 配置kube-apiserver启动文件时已经配置过参数变量文件，这里就不需要再做，写在这里只是为了知道下面配置文件里的参数怎么回事

cat >/etc/kubernetes/config<<EOF
KUBE_LOGTOSTDERR="--logtostderr=true"
KUBE_LOG_LEVEL="--v=2"
EOF



配置scheduler文件

cat >/etc/kubernetes/scheduler<<EOF
KUBECONFIG="--kubeconfig=/etc/kubernetes/kube-scheduler.conf"
KUBE_SCHEDULER_ARGS="--leader-elect=true --address=127.0.0.1"
EOF



启动

systemctl daemon-reload
systemctl enable kube-scheduler
systemctl start kube-scheduler
systemctl status kube-scheduler


给kubelet-bootstrap用户授权
# 创建一个 clusterrolebinding，将 bootstrap token 文件中的 kubelet-bootstrap 用户赋予 system:node-bootstrapper cluster 角色

# 默认情况下，bootstrap这个 user 和 group 没有创建 CSR 的权限，kubelet 会启动失败，所以要给kubelet-bootstrap角色授权

kubectl create clusterrolebinding kubelet-bootstrap --clusterrole=system:node-bootstrapper --user=kubelet-bootstrap

# 如果没有授权会出现下面错误：

[root@test2 kubernetes]# journalctl -u kubelet |tail
failed to run Kubelet: cannot create certificate signing request: certificatesigningrequests.certificates.k8s.io is forbidden: User "kubelet-bootstrap" cannot create certificatesigningrequests.certificates.k8s.io at the cluster scope
 
查看组件状态

kubectl get componentstatuses

[root@test2 ~]# kubectl get componentstatuses
Unable to connect to the server: x509: certificate signed by unknown authority
# 报错原因：经过排查后发现前面操作的几个步骤中 ${KUBE_APISERVER} 这个变量写成了 ${KUBE_  又重做了一遍，正确的结果是下面

[root@test2 ~]# kubectl get componentstatuses
NAME                 STATUS    MESSAGE              ERROR
scheduler            Healthy   ok                   
controller-manager   Healthy   ok                   
etcd-0               Healthy   {"health": "true"}  
 

 # test1 节点安装到此结束，下面开始单独安装node节点

21、单独配置node 相关组件


test2上操作


环境配置

# 如下操作在所有节点操作


修改主机名

# 注意修改 各自节点对应的 主机名

sed -i '$a\hostname=test2' /etc/hostname
sed -i '$a\hostname=test2' /etc/sysconfig/network && hostnamectl set-hostname test2



配置hosts解析

cat >>/etc/hosts<<EOF
192.168.0.91 test1
192.168.0.92 test2
192.168.0.93 test3
EOF


禁用selinux

sed -i 's/SELINUX=permissive/SELINUX=disabled/' /etc/sysconfig/selinux

sed -i 's/enforcing/disabled/g' /etc/selinux/config


关闭swap

# 注释/etc/fstab文件里swap相关的行

sed -i 's/\/dev\/mapper\/centos-swap/#\/dev\/mapper\/centos-swap/g' /etc/fstab


关掉防火墙

systemctl stop firewalld && systemctl disable firewalld


重启

reboot


开启forward

iptables -P FORWARD ACCEPT



配置转发相关参数

cat >> /etc/sysctl.d/k8s.conf <<EOF
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
vm.swappiness=0
EOF



加载系统参数

sysctl --system



加载ipvs相关内核模块

# 如果重新开机，需要重新加载

modprobe ip_vs
modprobe ip_vs_rr
modprobe ip_vs_wrr
modprobe ip_vs_sh
modprobe nf_conntrack_ipv4
lsmod | grep ip_vs


21.1、安装docker

# 只在 test2 上操作

# 注意：docker和flannel是一体的，哪个节点上需要安装flannel,哪个节点上就需要安装docker

# docker 和kubelet组件、node状态有关系， 之前停掉docker后，kubelet组件会自动停掉；node节点会变成 NotReady 状态

# 但是停掉docker后，flanel、coredns 的pod 让然是 running 状态

# v1.11.0版本推荐使用docker v17.03, v1.11,v1.12,v1.13, 也可以使用，再高版本的docker可能无法正常使用。测试发现17.09无法正常使用，不能使用资源限制(内存CPU)



卸载自带docker

yum remove -y docker-ce docker-ce-selinux container-selinux



下载Docker镜像

下载链接：https://pan.baidu.com/s/1whfkq5wDODIew5_eqP63gA 
提取码：xmqq 

下载链接：https://pan.baidu.com/s/1zZy_tbvuApZW2fsMPGv3Bg 
提取码：u3t3 




添加至镜像仓库

rpm -ivh docker-ce-17.03.2.ce-1.el7.centos.x86_64.rpm
rpm -ivh docker-ce-selinux-17.03.2.ce-1.el7.centos.noarch.rpm



用安装 Docker 和依赖包
 
yum install -y docker-ce-*.rpm 



开机启动 

systemctl enable docker 



启动 docker 服务 

systemctl start docker




21.2、部署 kubelet组件

# 只在 test2 上操作

# kubelet的作用：向 test1 发起csr请求。

# 初次安装完 kubelet，只要第一次启动kubelet，通过kubelet get csr 就会得到这串字符串：node-csr-Yiiv675wUCvQl3HH11jDr0cC9p3kbrXWrxvG3EjWGoE

下载、解压安装包

mkdir -p /server/software/k8s
cd /server/software/k8s
下载链接：https://pan.baidu.com/s/1DXahqP8nXWP1aw5pIunJrw 
提取码：9xfp
tar -xf kubernetes-server-linux-amd64.tar.gz



分发kubelet二进制文件

# 后面kubelet启动文件需要用到kubelet二进制文件路径

mkdir -p /usr/local/kubernetes/bin
cp /server/software/k8s/kubernetes/server/bin/kubelet /usr/local/kubernetes/bin    #这一步很关键



安装kubectl工具

# kubecctl工具和kubelet服务不是一回事。安装包解压后包括 kubectl 工具，所以不需要单独使用kubernetes-server-client-amd64.tar.gz 安装包分发 kubectl 工具

# kubectl作用：当kubelet组件通过bootstrap token 认证后，kubectl 默认会从 ~/.kube/config 文件读取 kube-apiserver 地址、证书、用户名等信息；

# admin.conf = ~/.kube/config，因为复制过来的 ；

cp /server/software/k8s/kubernetes/server/bin/kubectl /usr/local/bin/kubectl



查看 kubectl 版本，

# 出现下面的情况就是正确的。did you specify the right host or port? 这个报错忽略，因为还没有安装kubelet服务

kubectl version

[root@test1 bin]# kubectl version
Client Version: version.Info{Major:"1", Minor:"11", GitVersion:"v1.11.0", GitCommit:"91e7b4fd31fcd3d5f436da26c980becec37ceefe", GitTreeState:"clean", BuildDate:"2018-06-27T20:17:28Z", GoVersion:"go1.10.2", Compiler:"gc", Platform:"linux/amd64"}
The connection to the server localhost:8080 was refused - did you specify the right host or port?
 
cd $HOME



拷贝admin.conf

# 从test1上复制admin.conf到test2节点

test2上创建目录

mkdir -p /etc/kubernetes

test2上复制

scp /etc/kubernetes/admin.conf root@192.168.0.92:/etc/kubernetes/



配置 /.kube/config 并且授权

# kubectl 默认从 ~/.kube/config 文件读取 kube-apiserver 地址、证书、用户名等信息，如果没有配置，执行 kubectl 命令时可能会出错：
# /.kube/config 和 admin.conf 内容是一样的，/.kube/config 是 admin.conf 复制过来的，改了下名字而已

rm -rf $HOME/.kube
mkdir -p $HOME/.kube
cp /etc/kubernetes/admin.conf $HOME/.kube/config
chown $(id -u):$(id -g) $HOME/.kube/config



拷贝bootstrap.conf

#从test1 上复制 bootstrap.conf 到test2 节点

# 后面kubelet服务启动参数中需要使用 kubelet-bootstrap.conf 向 kube-apiserver 发送 CSR 请求，

# 当kubelet服务通过bootstrap token 认证后，kubectl 默认会从 ~/.kube/config 文件读取 kube-apiserver 地址、证书、用户名等信息；

scp /etc/kubernetes/kubelet-bootstrap.conf root@192.168.0.92:/etc/kubernetes/



安装cni

# kubelet 的启动参数需要用到

cd /server/software/k8s

下载链接：https://pan.baidu.com/s/1DL1v4cH2SHUfobICjKXm3Q 
提取码：puel
mkdir -p /opt/cni/bin
mkdir -p /etc/cni/net.d/
tar -xf cni-plugins-amd64-v0.7.1.tgz -C /opt/cni/bin
ls -l /opt/cni/bin

cd $HOME




配置启动kubelet

创建数据目录

mkdir -p /data/kubelet



配置kubelet启动文件

cat >/etc/systemd/system/kubelet.service<<EOF
[Unit]
Description=Kubernetes Kubelet Server
Documentation=https://github.com/kubernetes/kubernetes
After=docker.service
Requires=docker.service

[Service]
WorkingDirectory=/data/kubelet
EnvironmentFile=-/etc/kubernetes/config
EnvironmentFile=-/etc/kubernetes/kubelet
ExecStart=/usr/local/kubernetes/bin/kubelet \\
            \$KUBE_LOGTOSTDERR \\
            \$KUBE_LOG_LEVEL \\
            \$KUBELET_CONFIG \\
            \$KUBELET_HOSTNAME \\
            \$KUBELET_POD_INFRA_CONTAINER \\
            \$KUBELET_ARGS \\
            \$CADVISOR
Restart=on-failure

[Install]
WantedBy=multi-user.target
EOF



配置参数变量文件

cat >/etc/kubernetes/config<<EOF
KUBE_LOGTOSTDERR="--logtostderr=true"
KUBE_LOG_LEVEL="--v=2"
EOF



配置kubelet文件

# 注意修改kubelet文件里面的 --hostname-override= 要填写test1、test2、test3 这三个节点改成对应各自 ip ，或者各自的主机名。本实验写的ip

# 如果--hostname-override= 填写的是ip，那么kubectl get nodes 得到的name就显示ip,如果填写的是主机名，得到的name就显示主机名

# image=registry.cn-hangzhou.aliyuncs.com/google_containers/pause-amd64:3.1 这个镜像跟 kubectl get componentstatuses 获取不到资源没有关系,跟docker也没有关系

# 但是网上搜这个镜像，说这个镜像是基础镜像，目前被墙，最好下载放到本地 registry 上

# 注意 kubelet配置文件里面的参数kubelet.conf 是kubelet启动后生成的，不用管，就是这样写的

# 注意 /etc/kubernetes/pki 目录里面只放一个ca.pem 证书，

# 启动kubelet后/etc/kubernetes/pki 目录里面会自动生成四个文件 kubelet.crt、kubelet.key、kubelet-client-current.pem、kubelet-client-2019-01-22-10-07-06.pem

# CADVISOR 表明开启cadvisor监控，然后在启动文件中加上 ExecStart=$CADVISOR 就可以通过浏览器访问cadvisor监控，否则是无法访问的，

cat >/etc/kubernetes/kubelet<<EOF
KUBELET_HOSTNAME="--hostname-override=test2"
KUBELET_POD_INFRA_CONTAINER="--pod-infra-container-image=registry.cn-hangzhou.aliyuncs.com/google_containers/pause-amd64:3.1"
KUBELET_CONFIG="--config=/etc/kubernetes/kubelet-config.yml"
CADVISOR="--cadvisor-port=4194 --storage-driver-db='cadvisor' --storage-driver-host='localhost:8086'"
KUBELET_ARGS="--bootstrap-kubeconfig=/etc/kubernetes/kubelet-bootstrap.conf --kubeconfig=/etc/kubernetes/kubelet.conf --cert-dir=/etc/kubernetes/pki --network-plugin=cni --cni-bin-dir=/opt/cni/bin --cni-conf-dir=/etc/cni/net.d"
EOF


拷贝ca.pem 证书

# 从test1 节点复制复制ca.pem 证书到test2 节点，下面kubelet-config.yml 文件参数需要用到 ca.pem

tes2上创建目录

mkdir --p /etc/kubernetes/pki

test1上复制文件

scp $HOME/ssl/ca.pem 192.168.0.92:/etc/kubernetes/pki/


配置kubelet-config.yml文件

# 注意修改kubelet-config.yml相关ip，test1 test2 test3 使用各自ip

# 注意下面kubelet-config.yml里面的clusterDNS 地址要和coredns.yaml 里面的 clusterIP 地址保持一致。只有kubelet、coredns里面有 10.96.0.10，其他的组件都没有

cat >/etc/kubernetes/kubelet-config.yml<<EOF
kind: KubeletConfiguration
apiVersion: kubelet.config.k8s.io/v1beta1
address: 192.168.0.92
port: 10250
cgroupDriver: cgroupfs
clusterDNS:
  - 10.96.0.10
clusterDomain: cluster.local.
hairpinMode: promiscuous-bridge
serializeImagePulls: false
authentication:
  x509:
    clientCAFile: /etc/kubernetes/pki/ca.pem
EOF



启动
systemctl daemon-reload
systemctl enable kubelet
systemctl start kubelet            # 启动后就会生成 csr
systemctl status kubelet



查看日志

# 启动 kubelet后查看日志会有报错

# 报错原因是因为kubelet配置了network-plugin=cni，但是还没安装网络插件 flannel，所以状态会是NotReady,会报上面的错误，不想看这个报错或者不需要网络，就修改kubelet配置文件，去掉network-plugin=cni 就可以了

[root@test2 ~]# journalctl -u kubelet |tail
network plugin is not ready: cni config uninitialized



21.3、通过csr请求

# 在 test2 上操作，也可以在test1 上操作

# 通过csr请求的目的就是要生成一个nodes 节点

# 注意：node-csr-Yiiv675wUCvQl3HH11jDr0cC9p3kbrXWrxvG3EjWGoE  这个长字符串是kubelet 初次启动后生成的，

# 在test2 节点上操作就可以

# 查看csr

# 如果获取不到csr看日志会出现下面错误：

[root@test2 kubernetes]# journalctl -u kubelet |tail
failed to run Kubelet: cannot create certificate signing request: certificatesigningrequests.certificates.k8s.io is forbidden: User "kubelet-bootstrap" cannot create certificatesigningrequests.certificates.k8s.io at the cluster scope

# 原因是因为没有给kubelet-bootstrap授权，授权即可

kubectl create clusterrolebinding kubelet-bootstrap --clusterrole=system:node-bootstrapper --user=kubelet-bootstrap

kubectl get csr


执行结果

[root@test2 ~]# kubectl get csr
NAME                                                   AGE       REQUESTOR           CONDITION
node-csr-Yiiv675wUCvQl3HH11jDr0cC9p3kbrXWrxvG3EjWGoE   18s       kubelet-bootstrap   Pending
You have new mail in /var/spool/mail/root



通过csr请求，下面的长字符串填写上一步的结果，

kubectl certificate approve node-csr-Yiiv675wUCvQl3HH11jDr0cC9p3kbrXWrxvG3EjWGoE


执行结果：

[root@test2 ~]# kubectl certificate approve node-csr-Yiiv675wUCvQl3HH11jDr0cC9p3kbrXWrxvG3EjWGoE
certificatesigningrequest.certificates.k8s.io/node-csr-Yiiv675wUCvQl3HH11jDr0cC9p3kbrXWrxvG3EjWGoE approved


查看kubelet启动后生成的文件

说明：kubelet 启动后使用 --bootstrap-kubeconfig 向 kube-apiserver 发送 CSR 请求，当这个 CSR 被 approve 后，kube-controller-manager 为 kubelet 创建 TLS 客户端证书、私钥和 --kubeletconfig 文件。

kubelet.conf文件决定了csr的存在，如果要想重新获取csr,可以停掉kubelet，删除kubelet.conf文件，重启kubelet就可以获得csr

ls -l /etc/kubernetes/kubelet.conf
ls -l /etc/kubernetes/pki/kubelet*

查看结果

[root@test2 ~]# ls -l /etc/kubernetes/kubelet.conf
-rw------- 1 root root 2295 Jan 22 10:07 /etc/kubernetes/kubelet.conf

[root@test2 ~]# ls -l /etc/kubernetes/pki/kubelet*
-rw------- 1 root root 1273 Jan 22 10:07 /etc/kubernetes/pki/kubelet-client-2019-01-22-10-07-06.pem
lrwxrwxrwx 1 root root   58 Jan 22 10:07 /etc/kubernetes/pki/kubelet-client-current.pem -> /etc/kubernetes/pki/kubelet-client-2019-01-22-10-07-06.pem
-rw-r--r-- 1 root root 2181 Jan 22 02:10 /etc/kubernetes/pki/kubelet.crt
-rw------- 1 root root 1675 Jan 22 02:10 /etc/kubernetes/pki/kubelet.key


查看节点

# 此时节点状态为 NotReady，需要安装flannel网络后才可以ready；

# 但是此时就可以设置集群角色

# 此时查看只有一个node节点是因为test1 上并没有安装 kubelet 组件，只要 test1 安装上kubelet并且启动成功，就会生成csr,通过csr后，就会成为node节点

# 如果 test1 上也安装了kubelet,就可以把 test1 节点设置为master,因为 test1 节点上面安装了 kube-apiserver、 kube-controller-manager、kube-scheduler

# tes2 节点必须是node 节点，因为它没有安装  kube-apiserver、 kube-controller-manager、kube-scheduler 这几个组件

kubectl get nodes

[root@test2 ~]# kubectl get nodes
NAME           STATUS     ROLES     AGE       VERSION
192.168.0.92   NotReady   <none>    9h        v1.11.0



设置集群角色

# 在test2 节点上操作就可以

# 设置 test2 为 node 角色

kubectl label nodes 192.168.0.92 node-role.kubernetes.io/node=

[root@test2 ~]# kubectl label nodes 192.168.0.92 node-role.kubernetes.io/node=
node/test2 labeled


再次查看节点

[root@test2 ~]# kubectl get nodes
NAME  STATUS    ROLES  AGE  VERSION
test2 NotReady  node   2m   v1.11.0


 21.4、配置启动kube-proxy 


# 只在 test2 上操作

# 注意：关掉 kube-proxy 后仍然可以访问 svc curl "10.103.38.143:80" ，kube-proxy 的作用目前还没有发现

下载、解压安装包（省略）

cd /server/software/k8s

下载链接：https://pan.baidu.com/s/1DXahqP8nXWP1aw5pIunJrw 
提取码：9xfp

tar -xf kubernetes-server-linux-amd64.tar.gz



分发kube-proxy二进制文件

# 后面kube-proxy.service启动文件需要用到kube-proxy二进制文件路径

mkdir -p /usr/local/kubernetes/bin
cp /server/software/k8s/kubernetes/server/bin/kube-proxy /usr/local/kubernetes/bin    #这一步很关键



安装依赖包

yum install -y conntrack-tools



拷贝kube-proxy.conf文件

把 test1 节点上的kube-proxy.conf复制到/etc/kubernetes/ 目录下，kube-proxy.service启动参数中proxy文件需要用到kube-proxy.conf

scp /etc/kubernetes/kube-proxy.conf 192.168.0.92:/etc/kubernetes/



配置启动文件
cat >/etc/systemd/system/kube-proxy.service<<EOF
[Unit]
Description=Kubernetes Kube-Proxy Server
Documentation=https://github.com/kubernetes/kubernetes
After=network.target

[Service]
EnvironmentFile=-/etc/kubernetes/config
EnvironmentFile=-/etc/kubernetes/proxy
ExecStart=/usr/local/kubernetes/bin/kube-proxy \\
        \$KUBE_LOGTOSTDERR \\
        \$KUBE_LOG_LEVEL \\
        \$KUBECONFIG \\
        \$KUBE_PROXY_ARGS
Restart=on-failure
LimitNOFILE=65536

[Install]
WantedBy=multi-user.target
EOF



配置参数变量文件

# 前面配置kubelet组件时已经配置过参数变量文件，这里就不需要配置，写在这里这是知道是怎么回事

cat >/etc/kubernetes/config<<EOF
KUBE_LOGTOSTDERR="--logtostderr=true"
KUBE_LOG_LEVEL="--v=2"
EOF



配置proxy文件

# 注意修改相关ip，test1 test2 test3 使用各自ip

# 看下面proxy文件'--proxy-mode=iptables',由于采用iptables模式，因为 ipvs 模式在centos7上有bug无法正常使用，1.11.0 以后的版本就可使用 ipvs 模式了，

# 本实验采用centos7.5、kubernetes 1.11.0 版本，所以使用iptables模式，



# 特别注意：下面的cluster-cidr地址要和controller-manager里面的cluster-cidr、flannel 里面的Network 地址保持一致，这有这三个组件里面有 10.244.0.0

cat >/etc/kubernetes/proxy<<EOF
KUBECONFIG="--kubeconfig=/etc/kubernetes/kube-proxy.conf"
KUBE_PROXY_ARGS="--bind-address=192.168.0.92 --proxy-mode=iptables --hostname-override=192.168.0.92 --cluster-cidr=10.244.0.0/16"
EOF



启动
systemctl daemon-reload
systemctl enable kube-proxy
systemctl start kube-proxy
systemctl status kube-proxy





21.5、安装flannel网络

# 只在 test2 上操作

# flannel 作用之一： 让 node节点从 NotReady状态变为ready状态

# 注意： flanel 只需要安装一次，不需要再往 test1 节点或者test2 节点上安装 flanel

# 只有在安装了docker的节点上才可以安装flannel

# 注意下面的网卡名称要填写对应的网卡名称



下载配置文件

mkdir flannel && cd flannel

下载链接：https://pan.baidu.com/s/1kdrYzXYzURTzO_tXtv_R1A 
提取码：3kgd 




查看下载的文件

[root@test2 flannel]# ls
kube-flannel.yml



修改ip地址

# flannel网络 分三种网络 node network、service network、flannel network

# node network：承载kubernetes集群中各个“物理”Node(master和node)通信的网络

# 下面Network 就是 node network，因为当前还没有安装 flannel，test2 节点为 NotReady 状态；安装完 flannel后就是ready状态，

# 特别注意：下面的Network 地址要和controller-manager里面的cluster-cidr、kube-proxy里面的 cluster-cidr地址保持一致，这有这三个组件里面有 10.244.0.0


[root@test2 flannel]# vi kube-flannel.yml 

  net-conf.json: |
    {
      "Network": "10.244.0.0/16",
      "Backend": {
        "Type": "vxlan"
      }
    }



修改镜像

# 由于自带的镜像被墙，无法下载，所以修改镜像为国内源 image: registry.cn-shanghai.aliyuncs.com/gcr-k8s/flannel:v0.10.0-amd64

# 注意 kube-flannel.yml 文件里面有两个 镜像都需要改


[root@test2 flannel]# vi kube-flannel.yml 
    containers:
      - name: kube-flannel
        image: registry.cn-shanghai.aliyuncs.com/gcr-k8s/flannel:v0.10.0-amd64
        command:
        - /opt/bin/flanneld
        args:
        - --ip-masq
        - --kube-subnet-mgr
        - --iface=ens33



添加网卡参数

# 注意 - --iface=ens33 这个ens33 是 192.168.0.92 这台虚拟机的网卡信息

# 如果Node有多个网卡的话，参考flannel issues 39701，https://github.com/kubernetes/kubernetes/issues/39701

# 目前需要在kube-flannel.yml中使用--iface参数指定集群主机内网网卡的名称，否则可能会出现dns无法解析。容器无法通信的情况，

# flanneld启动参数加上--iface=<iface-name>


[root@test2 flannel]# vi kube-flannel.yml 
    containers:
      - name: kube-flannel
        image: registry.cn-shanghai.aliyuncs.com/gcr-k8s/flannel:v0.10.0-amd64
        command:
        - /opt/bin/flanneld
        args:
        - --ip-masq
        - --kube-subnet-mgr
        - --iface=ens33


启动flanel

kubectl apply -f kube-flannel.yml



查看pod

# 如果flanel启动失败，很有可能镜像拉取失败，所以最好还是自建一个镜像仓库。有点慢，等一会

kubectl get pods -n kube-system
kubectl get svc

[root@test2 flannel]# kubectl get pods -n kube-system
NAME                    READY     STATUS    RESTARTS   AGE
kube-flannel-ds-zb2r2   1/1       Running   0          18s

[root@test2 flannel]# kubectl get svc
NAME         TYPE        CLUSTER-IP   EXTERNAL-IP   PORT(S)   AGE
kubernetes   ClusterIP   10.96.0.1    <none>        443/TCP   22h



查看节点状态

# 当 flannel pod 全部启动之后，节点状态才为 Ready

kubectl get no

[root@test2 flannel]# kubectl get no
NAME           STATUS    ROLES     AGE       VERSION
test2          Ready     node      11h       v1.11.0




21.6、安装coredns

# 只在 test2 上操作

# coredns的作用：是实现pod里面的DNS解析，就是可以通过svc(service)来访问服务，例如：curl nginx-service ，curl + svc

# 注意：coredns 只安装一次就可以，不需要再往master角色或 其他node角色上安装

# 注意下面用的 coredns 1.2.0 版本 



安装jq工具

# 之前安装coredns报错找不到jq, 所以配置jq 源，然后用yum安装，安装jq 参照：https://www.cnblogs.com/effortsing/p/10307424.html

yum install jq -y



下载coredns安装文件

cd $HOME && mkdir coredns && cd coredns

下载链接：https://pan.baidu.com/s/1z7x4z2k2w3rdhOt89FDPww 
提取码：7vkf 




查看下载的文件

[root@test2 coredns]# ls
coredns.yaml



修改配置文件

# 把文件里面的ip地址修改为10.96.0.10， 

# 注意：下面coredns.yaml里面的clusterIP 地址要和 kubelet组件中kubelet-config.yml 配置文件里面的 clusterDNS 地址保持一致。只有kubelet、coredns里面有 10.96.0.10
 
[root@test2 coredns]# vi coredns.yaml 
spec:
  selector:
    k8s-app: kube-dns
  clusterIP: 10.96.0.10
  ports:



启动coredns

kubectl apply -f coredns.yaml



查看coredns

# 过几分钟才会running ,有点慢

kubectl get pods -n kube-system
kubectl get svc -n kube-system

[root@test2 coredns]# kubectl get pods -n kube-system
NAME                       READY     STATUS    RESTARTS   AGE
coredns-6c65fc5cbb-8ntpv   1/1       Running   0          34m
coredns-6c65fc5cbb-sj65c   1/1       Running   0          34m
kube-flannel-ds-zb2r2      1/1       Running   0          2h

[root@test2 coredns]# kubectl get svc -n kube-system
NAME       TYPE        CLUSTER-IP   EXTERNAL-IP   PORT(S)         AGE
kube-dns   ClusterIP   10.96.0.10   <none>        53/UDP,53/TCP   34m




测试coredns功能

# 启动一个nginx容器，然后进行访问nginx服务进行测试看是否能访问

下载nginx.yaml文件

下载链接：https://pan.baidu.com/s/1PV8jyDhb8yBy6uyaeMMpSQ 
提取码：xt5f 



查看下载的文件

[root@test2 ~]# ls
nginx.yaml



配置nginx镜像

# 用docker 找一个简单的nginx镜像，替换 nginx.yaml 里面的镜像，因为nginx.yaml里面的镜像都已经过时，无法下载

docker search nginx

[root@test2 ~]# docker search nginx
nginxdemos/hello         NGINX webserver that serves a simple page ...   9                    [OK]

[root@test2 ~]# vi nginx.yaml 
    spec:
      containers:
      - name: http-test-con
        image: nginxdemos/hello
        ports:
        - containerPort: 80



创建nginx实例

# 需要过几分钟，拉取镜像很慢的，

kubectl create -f nginx.yaml 



查看pod状态

# 注意：使用kubectl工具养成带上命名空间的习惯，虽然不带default命名空间默认带着的，但是这是个习惯，之前总是因为没有带命名空间出错，排查半天，单耽误时间，

kubectl get deploy -o wide -n default
kubectl get pods -o wide -n default
kubectl get svc -o wide -n default
kubectl describe svc example-service -n default

[root@test2 ~]# kubectl get deploy -o wide -n default
NAME            DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE       CONTAINERS      IMAGES             SELECTOR
http-test-dm2   1         1         1            1           52m       http-test-con   nginxdemos/hello   name=http-test-dm2


[root@test2 ~]# kubectl get pods -o wide -n default
NAME                             READY     STATUS    RESTARTS   AGE       IP            NODE
http-test-dm2-76d4b58b47-f4pqm   1/1       Running   0          52m       10.244.0.12   192.168.0.92


[root@test2 ~]# kubectl get svc -o wide -n default
NAME             TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)        AGE       SELECTOR
http-nginx-ser   NodePort    10.103.38.143   <none>        80:31000/TCP   5m        name=http-test-dm2
kubernetes       ClusterIP   10.96.0.1       <none>        443/TCP        1d        <none>


[root@test2 ~]# kubectl describe pod http-test-dm2-76d4b58b47-f4pqm -n default



容器内测试coredns解析 

# 启动一个具有解析功能的 dns 实例，然后进到 pod 里面用 nslookup、curl 工具进行访问测试，下面这个实例启动慢，等几分钟，

# 如果启动失败，通过看日志得知无法拉取镜像 infoblox/dnstools，很可能这个镜像不存在了，那就通过 docker search dns 找一个dns镜像代替infoblox/dnstools镜像

kubectl run -it --rm --image=infoblox/dnstools dns-client
nslookup kubernetes
nslookup nginx-service
curl nginx-service

执行结果：

[root@test2 ~]# kubectl run -it --rm --image=infoblox/dnstools dns-client
If you don't see a command prompt, try pressing enter.


dnstools# nslookup kubernetes
Server:        10.96.0.10
Address:    10.96.0.10#53

Name:    kubernetes.default.svc.cluster.local
Address: 10.96.0.1


dnstools# nslookup http-nginx-ser
Server:        10.96.0.10
Address:    10.96.0.10#53

Name:    http-nginx-ser.default.svc.cluster.local
Address: 10.103.38.143


dnstools# curl http-nginx-ser
<!DOCTYPE html>
<html>
<head>
<title>Hello World</title>



容器外测试coredns解析

# 注意：是在 test2 节点进行访问访测试的，

# 如果此时 去 test1 节点上访问，是无法访问的，因为test1 节点上还没有安装kubelet，什么角色也不是，只要成为node或master角色 就可以访问，测试过

# 如果test1节点安装了 kubelet，并且是ready状态，就一定能通过 curl "10.103.38.143:80"  访问到，已经测试过，

# coredns 可能是节点内部域名解析，Traefik-ingress是节点外部域名解析

# 10.103.38.143 是查看svc时获取到的clusterip，svc是service的缩写

curl "10.103.38.143:80"

执行结果：

[root@test2 ~]# curl "10.103.38.143:80" -n default
<!DOCTYPE html>
<html>
<head>
<title>Hello World</title>



通过浏览器访问测试

# 31000 是查看svc时获取到的 nodeport

http://192.168.0.92:31000/




22、关机重启验证

# test1、test2 节点都关机重启，重新执行上面的过程验证是否完好。本实验重启这两个节点后一切是正常的



清理

kubectl delete -f nginx.yaml




23、回头配置 test1 节点加入集群

# 只在 test1 上操作

# 目的是 在 test1 节点上安装node组件，设置test1节点为master节点。

# 注意：不管要设置master角色 还是设置为node角色，前提必须先安装node组件，主要是kubelet 组件。就是说先把节点加入集群，才能设置角色，

# 加入集群就是安装启动 kubelet 组件，通过csr请求后，就可以加入集群，然后才可以设置集群角色


23.1、安装docker

# 只在 test1 上操作

# 注意：docker和flannel是一体的，哪个节点上需要安装flannel,哪个节点上就需要安装docker

# docker 和kubelet组件、node状态有关系， 之前停掉docker后，kubelet组件会自动停掉；node节点会变成 NotReady 状态

# 但是停掉docker后，flanel、coredns 的pod 让然是 running 状态

# v1.11.0版本推荐使用docker v17.03, v1.11,v1.12,v1.13, 也可以使用，再高版本的docker可能无法正常使用。测试发现17.09无法正常使用，不能使用资源限制(内存CPU)



卸载自带docker

yum remove -y docker-ce docker-ce-selinux container-selinux



下载Docker镜像

下载链接：https://pan.baidu.com/s/1whfkq5wDODIew5_eqP63gA 
提取码：xmqq 

下载链接：https://pan.baidu.com/s/1zZy_tbvuApZW2fsMPGv3Bg 
提取码：u3t3 




添加至镜像仓库

rpm -ivh docker-ce-17.03.2.ce-1.el7.centos.x86_64.rpm
rpm -ivh docker-ce-selinux-17.03.2.ce-1.el7.centos.noarch.rpm



用安装 Docker 和依赖包
 
yum install -y docker-ce-*.rpm 



开机启动 

systemctl enable docker 



启动 docker 服务 

systemctl start docker




23.2、部署 kubelet组件

# 只在 test1 上操作

# kubelet的作用：向 test1 发起csr请求。

# 初次安装完 kubelet，只要第一次启动kubelet，通过kubelet get csr 就会得到这串字符串：node-csr-Yiiv675wUCvQl3HH11jDr0cC9p3kbrXWrxvG3EjWGoE

下载、解压安装包

mkdir -p /server/software/k8s
cd /server/software/k8s
下载链接：https://pan.baidu.com/s/1DXahqP8nXWP1aw5pIunJrw 
提取码：9xfp
tar -xf kubernetes-server-linux-amd64.tar.gz



分发kubelet二进制文件

# 后面kubelet启动文件需要用到kubelet二进制文件路径

mkdir -p /usr/local/kubernetes/bin
cp /server/software/k8s/kubernetes/server/bin/kubelet /usr/local/kubernetes/bin    #这一步很关键


查看组件状态

kubectl get componentstatuses

[root@test1 ~]# kubectl get componentstatuses
Unable to connect to the server: x509: certificate signed by unknown authority
# 报错原因：经过排查后发现前面操作的几个步骤中 ${KUBE_APISERVER} 这个变量写成了 ${KUBE_  又重做了一遍，正确的结果是下面

[root@test2 ~]# kubectl get componentstatuses
NAME                 STATUS    MESSAGE              ERROR
scheduler            Healthy   ok                   
controller-manager   Healthy   ok                   
etcd-0               Healthy   {"health": "true"}  




配置 /.kube/config 并且授权

# kubectl 默认从 ~/.kube/config 文件读取 kube-apiserver 地址、证书、用户名等信息，如果没有配置，执行 kubectl 命令时可能会出错：
# /.kube/config 和 admin.conf 内容是一样的，/.kube/config 是 admin.conf 复制过来的，改了下名字而已

rm -rf $HOME/.kube
mkdir -p $HOME/.kube
cp /etc/kubernetes/admin.conf $HOME/.kube/config
chown $(id -u):$(id -g) $HOME/.kube/config


安装cni

# kubelet 的启动参数需要用到

cd /server/software/k8s

下载链接：https://pan.baidu.com/s/1DL1v4cH2SHUfobICjKXm3Q 
提取码：puel
mkdir -p /opt/cni/bin
tar -xf cni-plugins-amd64-v0.7.1.tgz -C /opt/cni/bin
ls -l /opt/cni/bin

cd $HOME



配置启动kubelet

创建数据目录

mkdir -p /data/kubelet


配置kubelet启动文件

cat >/etc/systemd/system/kubelet.service<<EOF
[Unit]
Description=Kubernetes Kubelet Server
Documentation=https://github.com/kubernetes/kubernetes
After=docker.service
Requires=docker.service

[Service]
WorkingDirectory=/data/kubelet
EnvironmentFile=-/etc/kubernetes/config
EnvironmentFile=-/etc/kubernetes/kubelet
ExecStart=/usr/local/kubernetes/bin/kubelet \\
            \$KUBE_LOGTOSTDERR \\
            \$KUBE_LOG_LEVEL \\
            \$KUBELET_CONFIG \\
            \$KUBELET_HOSTNAME \\
            \$KUBELET_POD_INFRA_CONTAINER \\
            \$KUBELET_ARGS \\
            \$CADVISOR
Restart=on-failure

[Install]
WantedBy=multi-user.target
EOF



配置参数变量文件

cat >/etc/kubernetes/config<<EOF
KUBE_LOGTOSTDERR="--logtostderr=true"
KUBE_LOG_LEVEL="--v=2"
EOF



配置kubelet文件

# 注意修改kubelet文件里面的 --hostname-override= 要填写test1、test2、test3 这三个节点改成对应各自 ip ，或者各自的主机名。本实验写的是ip

# 如果--hostname-override= 填写的是ip，那么kubectl get nodes 得到的name就显示ip,如果填写的是主机名，得到的name就显示主机名

# image=registry.cn-hangzhou.aliyuncs.com/google_containers/pause-amd64:3.1 这个镜像跟 kubectl get componentstatuses 获取不到资源没有关系,跟docker也没有关系

# 但是网上搜这个镜像，说这个镜像是基础镜像，目前被墙，最好下载放到本地 registry 上

# 注意 kubelet配置文件里面的参数kubelet.conf 是kubelet启动后生成的，不用管，就是这样写的

# 注意 /etc/kubernetes/pki 目录里面只放一个ca.pem 证书，

# 启动kubelet后/etc/kubernetes/pki 目录里面会自动生成四个文件 kubelet.crt、kubelet.key、kubelet-client-current.pem、kubelet-client-2219-01-22-10-07-06.pem

# CADVISOR 表明开启cadvisor监控，然后在启动文件中加上 ExecStart=$CADVISOR 就可以通过浏览器访问cadvisor监控，否则是无法访问的，

cat >/etc/kubernetes/kubelet<<EOF
KUBELET_HOSTNAME="--hostname-override=test2"
KUBELET_POD_INFRA_CONTAINER="--pod-infra-container-image=registry.cn-hangzhou.aliyuncs.com/google_containers/pause-amd64:3.1"
KUBELET_CONFIG="--config=/etc/kubernetes/kubelet-config.yml"
CADVISOR="--cadvisor-port=4194 --storage-driver-db='cadvisor' --storage-driver-host='localhost:8086'"
KUBELET_ARGS="--bootstrap-kubeconfig=/etc/kubernetes/kubelet-bootstrap.conf --kubeconfig=/etc/kubernetes/kubelet.conf --cert-dir=/etc/kubernetes/pki --network-plugin=cni --cni-bin-dir=/opt/cni/bin --cni-conf-dir=/etc/cni/net.d"
EOF


配置kubelet-config.yml文件

# 注意修改kubelet-config.yml相关ip，test1 test2 test3 使用各自ip

# 注意下面kubelet-config.yml里面的clusterDNS 地址要和coredns.yaml 里面的 clusterIP 地址保持一致。只有kubelet、coredns里面有 10.96.0.10，其他的组件都没有

cat >/etc/kubernetes/kubelet-config.yml<<EOF
kind: KubeletConfiguration
apiVersion: kubelet.config.k8s.io/v1beta1
address: 192.168.0.91
port: 10250
cgroupDriver: cgroupfs
clusterDNS:
  - 10.96.0.10
clusterDomain: cluster.local.
hairpinMode: promiscuous-bridge
serializeImagePulls: false
authentication:
  x509:
    clientCAFile: /etc/kubernetes/pki/ca.pem
EOF



启动
systemctl daemon-reload
systemctl enable kubelet
systemctl start kubelet            # 启动后就会生成 csr
systemctl status kubelet



查看日志

# 启动 kubelet后查看日志会有报错

# 报错原因是因为kubelet配置了network-plugin=cni，但是还没安装网络插件 flannel，所以状态会是NotReady,会报上面的错误，不想看这个报错或者不需要网络，就修改kubelet配置文件，去掉network-plugin=cni 就可以了

[root@test2 ~]# journalctl -u kubelet |tail
network plugin is not ready: cni config uninitialized




23.3、通过csr请求

# 在test1 上操作，也可以在 test2 上操作

# 通过csr请求的目的就是要加入集群

# 注意：node-csr-Yiiv675wUCvQl3HH11jDr0cC9p3kbrXWrxvG3EjWGoE  这个长字符串是kubelet 初次启动后生成的，

# 在test2 节点上操作就可以

# 查看csr

# 如果获取不到csr看日志会出现下面错误：

[root@test2 kubernetes]# journalctl -u kubelet |tail
failed to run Kubelet: cannot create certificate signing request: certificatesigningrequests.certificates.k8s.io is forbidden: User "kubelet-bootstrap" cannot create certificatesigningrequests.certificates.k8s.io at the cluster scope

# 原因是因为没有给kubelet-bootstrap授权，授权即可

kubectl create clusterrolebinding kubelet-bootstrap --clusterrole=system:node-bootstrapper --user=kubelet-bootstrap


kubectl get csr

执行结果

[root@test1 ~]# kubectl get csr
NAME                                                   AGE       REQUESTOR           CONDITION
node-csr-0BVhjayOeu96EHndLS4vC4bijfh9zr2gH6iJCsmfOvQ   18s       kubelet-bootstrap   Pending



通过csr请求，下面的长字符串填写上一步的结果，

kubectl certificate approve node-csr-0BVhjayOeu96EHndLS4vC4bijfh9zr2gH6iJCsmfOvQ

[root@test1 ~]# kubectl certificate approve node-csr-0BVhjayOeu96EHndLS4vC4bijfh9zr2gH6iJCsmfOvQ
certificatesigningrequest.certificates.k8s.io/node-csr-0BVhjayOeu96EHndLS4vC4bijfh9zr2gH6iJCsmfOvQ approved


查看kubelet启动后生成的文件

说明：kubelet 启动后使用 --bootstrap-kubeconfig 向 kube-apiserver 发送 CSR 请求，当这个 CSR 被 approve 后，kube-controller-manager 为 kubelet 创建 TLS 客户端证书、私钥和 --kubeletconfig 文件。

kubelet.conf文件决定了csr的存在，如果要想重新获取csr,可以停掉kubelet，删除kubelet.conf文件，重启kubelet就可以获得csr

ls -l /etc/kubernetes/kubelet.conf
ls -l /etc/kubernetes/pki/kubelet*

查看结果

[root@test2 ~]# ls -l /etc/kubernetes/kubelet.conf
-rw------- 1 root root 2295 Jan 22 10:07 /etc/kubernetes/kubelet.conf

[root@test2 ~]# ls -l /etc/kubernetes/pki/kubelet*
-rw------- 1 root root 1273 Jan 22 10:07 /etc/kubernetes/pki/kubelet-client-2019-01-22-10-07-06.pem
lrwxrwxrwx 1 root root   58 Jan 22 10:07 /etc/kubernetes/pki/kubelet-client-current.pem -> /etc/kubernetes/pki/kubelet-client-2019-01-22-10-07-06.pem
-rw-r--r-- 1 root root 2181 Jan 22 02:10 /etc/kubernetes/pki/kubelet.crt
-rw------- 1 root root 1675 Jan 22 02:10 /etc/kubernetes/pki/kubelet.key
 



查看节点状态

# 之前做完上一步，就去吃饭了，饭后回来正想安装 flanel,突然一看 192.168.0.91是Ready状态，所以等一会状态就会发生改变

# 解释：此时节点状态为Ready，因为test2 节点已经安装过 flannel,这里就不需要再安装。所以只要通过csr就是ready状态，


[root@test1 ~]# kubectl get nodes
NAME           STATUS    ROLES         AGE       VERSION
192.168.0.91   Ready     <none>        2h        v1.11.0
192.168.0.92   Ready     node          21h       v1.11.0




设置集群角色

# 在test1 节点上操作

# 设置 test1 为 master 角色

kubectl label nodes 192.168.0.91 node-role.kubernetes.io/master=

# 设置 master 一般情况下不接受负载
kubectl taint nodes 192.168.0.91 node-role.kubernetes.io/master=true:NoSchedule

master运行pod

kubectl taint nodes master.k8s node-role.kubernetes.io/master-

master不运行pod

kubectl taint nodes master.k8s node-role.kubernetes.io/master=:NoSchedule


执行结果：

[root@test1 ~]# kubectl label nodes 192.168.0.91 node-role.kubernetes.io/master=
node/192.168.0.91 labeled

[root@master ~]# kubectl get nodes
NAME           STATUS    ROLES         AGE       VERSION
192.168.0.91   Ready     master        2h        v1.11.0
192.168.0.92   Ready     node           21h       v1.11.0

[root@test1 k8s]# kubectl taint nodes 192.168.0.91 node-role.kubernetes.io/master=true:NoSchedule
node/test1 tainted

23.4、配置启动kube-proxy 

# 只在 tes1 上操作

# 注意：关掉 kube-proxy 后仍然可以访问 svc curl "10.103.38.143:80" ，kube-proxy 的作用目前还没有发现

下载、解压安装包

mkdir -p /server/software/k8s

cd /server/software/k8s

下载链接：https://pan.baidu.com/s/1DXahqP8nXWP1aw5pIunJrw 
提取码：9xfp

tar -xf kubernetes-server-linux-amd64.tar.gz



分发kube-proxy二进制文件

# 后面kube-proxy.service启动文件需要用到kube-proxy二进制文件路径

mkdir -p /usr/local/kubernetes/bin
cp /server/software/k8s/kubernetes/server/bin/kube-proxy /usr/local/kubernetes/bin    #这一步很关键



安装依赖包

yum install -y conntrack-tools



拷贝kube-proxy.conf文件

把 test1 节点上的kube-proxy.conf复制到/etc/kubernetes/ 目录下，kube-proxy.service启动参数中proxy文件需要用到kube-proxy.conf

cp /etc/kubernetes/kube-proxy.conf /etc/kubernetes/



配置启动文件
cat >/etc/systemd/system/kube-proxy.service<<EOF
[Unit]
Description=Kubernetes Kube-Proxy Server
Documentation=https://github.com/kubernetes/kubernetes
After=network.target

[Service]
EnvironmentFile=-/etc/kubernetes/config
EnvironmentFile=-/etc/kubernetes/proxy
ExecStart=/usr/local/kubernetes/bin/kube-proxy \\
        \$KUBE_LOGTOSTDERR \\
        \$KUBE_LOG_LEVEL \\
        \$KUBECONFIG \\
        \$KUBE_PROXY_ARGS
Restart=on-failure
LimitNOFILE=65536

[Install]
WantedBy=multi-user.target
EOF



配置参数变量文件

# 前面配置kubelet组件时已经配置过参数变量文件，这里就不需要配置，写在这里这是知道是怎么回事

cat >/etc/kubernetes/config<<EOF
KUBE_LOGTOSTDERR="--logtostderr=true"
KUBE_LOG_LEVEL="--v=2"
EOF



配置proxy文件

# 注意修改相关ip，test1 test2 test3 使用各自ip

# 看下面proxy文件'--proxy-mode=iptables',由于采用iptables模式，因为 ipvs 模式在centos7上有bug无法正常使用，1.11.0 以后的版本就可使用 ipvs 模式了，

# 本实验采用centos7.5、kubernetes 1.11.0 版本，所以使用iptables模式，



# 特别注意：下面的cluster-cidr地址要和controller-manager里面的cluster-cidr、flannel 里面的Network 地址保持一致，这有这三个组件里面有 10.244.0.0

cat >/etc/kubernetes/proxy<<EOF
KUBECONFIG="--kubeconfig=/etc/kubernetes/kube-proxy.conf"
KUBE_PROXY_ARGS="--bind-address=192.168.0.91 --proxy-mode=iptables --hostname-override=192.168.0.91 --cluster-cidr=10.244.0.0/16"
EOF



启动
systemctl daemon-reload
systemctl enable kube-proxy
systemctl start kube-proxy
systemctl status kube-proxy




23.5、容器外测试coredns解析

# 只在 test1 上操作

# 由于之前 test2节点已经安装过coredns，所以 test1节点就不需要安装了，直接测试

# 这里的 10.103.38.143:80 是之前在 test2 节点上查询svc 得到的结果

# 访问成功，

[root@master k8s]# curl "10.103.38.143:80"
<!DOCTYPE html>
<html>
<head>
<title>Hello World</title>


23.6、浏览器访问 cadvisor监控服务

浏览器访问http://192.168.0.91:4194/

 

参照文档：
http://www.maogx.win/posts/35/
http://www.maogx.win/
https://juejin.im/user/59ffa2836fb9a0451c39c64f/posts
http://blog.itpub.net/10995764/viewspace-2124022/