用Rancher RKE快速部署高可用k8s集群

用Rancher RKE部署高可用k8s集群

1. 主机配置

先配置4台最小化安装的主机，其中3台使用RKE配置k8s集群，然后在这个集群上配置高可用Rancher

主机IP	主机名	配置	角色
172.21.0.12	k8s-node01	4核8G	controlplane,etcd,worker
172.21.0.15	k8s-node02	4核8G	controlplane,etcd,worker
172.21.0.16	k8s-node03	4核8G	controlplane,etcd,worker
172.21.0.4	nginx	4核8G	nginx负载均衡

1.1 新建虚拟主机

系统：CentOS Linux release 7.7
直接在腾讯云上买的主机，4核8G。安装完之后开始一些初始化配置

1.2 主机初始化配置

下面这些操作，是在每台主机上都要进行的。

安装一些必要的安装包

yum -y install epel-release
yum -y install lrzsz vim gcc glibc openssl openssl-devel net-tools wget curl
yum -y update  # 更新一下软件包版本和内核版本

安全设置

在测试环境，先把firewalld和selinux关闭

systemctl stop firewalld
systemctl disable firewalld
setenforce 0
sed -i s@SELINUX=enforcing@SELINUX=disabled@g /etc/selinux/config

如果是在生产环境，建议关闭selinux，firewalld或iptables根据需要自定义

ntp时钟同步

安装ntp相关服务

yum -y install ntp
systemctl start ntpd  # 启动时钟同步服务
systemctl enable  ntpd # 设置开机启动
ntpq -p # 查看时钟同步状态

如果在局域网环境中有ntp时钟服务器，尽量用本地的

内核参数调优

Kernel参数调优，执行命令

cat >> /etc/sysctl.conf <<EOF
vm.swappiness=0
net.ipv4.ip_forward=1
net.bridge.bridge-nf-call-iptables=1
net.bridge.bridge-nf-call-ip6tables = 1
net.ipv4.neigh.default.gc_thresh1=4096
net.ipv4.neigh.default.gc_thresh2=6144
net.ipv4.neigh.default.gc_thresh3=8192
EOF

使内核参数生效执行

modprobe br_netfilter  # 要先执行这个命令，要不然会报错
sysctl -p

hostname修改

分别在4台主机上修改主机名

hostnamectl set-hostname nginx
hostnamectl set-hostname k8s-node01
hostnamectl set-hostname k8s-node02
hostnamectl set-hostname k8s-node03

在/etc/hosts文件中添加配置

cat >> /etc/hosts << EOF
172.21.0.4  nginx
172.21.0.12 k8s-node01
172.21.0.15 k8s-node02
172.21.0.16 k8s-node03
EOF

注意：下面的这些步骤在nginx主机上可以不操作。

关闭swap分区

swapoff -a

然后修改/etc/fstab，把swap分区相关的配置注释掉

加载ipvs相关模块

由于ipvs已经加入到了内核的主干，所以为kube-proxy开启ipvs的前提需要加载以下的内核模块：
在所有的Kubernetes节点执行以下脚本:

cat > /etc/sysconfig/modules/ipvs.modules <<EOF
#!/bin/bash
modprobe -- ip_vs
modprobe -- ip_vs_rr
modprobe -- ip_vs_wrr
modprobe -- ip_vs_sh
modprobe -- nf_conntrack_ipv4
EOF

#执行脚本
chmod 755 /etc/sysconfig/modules/ipvs.modules && bash /etc/sysconfig/modules/ipvs.modules && lsmod | grep -e ip_vs -e nf_conntrack_ipv4

上面脚本创建了/etc/sysconfig/modules/ipvs.modules文件，保证在节点重启后能自动加载所需模块。 使用

lsmod | grep -e ip_vs -e nf_conntrack_ipv4

命令查看是否已经正确加载所需的内核模块。
接下来还需要确保各个节点上已经安装了ipset软件包。 为了便于查看ipvs的代理规则，最好安装一下管理工具ipvsadm。

yum install ipset ipvsadm -y

2. docker配置

注意：下面的这些安装docker的步骤在nginx主机上不需要操作。

2.1 安装docker

参考：https://developer.aliyun.com/article/110806
使用阿里云的安装源

# 安装一些必要的系统工具
yum install -y yum-utils device-mapper-persistent-data lvm2
# 添加docker源
yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
# 更新并安装docker-ce
yum makecache fast
yum -y install docker-ce # 直接安装是安装的最新版本
systemctl start docker
systemctl enable docker

指定docker-ce版本安装

# 查看可以安装的版本
yum list docker-ce.x86_64  --showduplicates |sort -r
# 指定版本安装
yum install -y  docker-ce-18.09.7-3.el7 
systemctl start docker
systemctl enable docker

2.2 配置docker

指定镜像源，修改docker cgroup driver为systemd
根据文档CRI installation中的内容，对于使用systemd作为init system的Linux的发行版，使用systemd作为docker的cgroup driver可以确保服务器节点在资源紧张的情况更加稳定，因此这里修改各个节点上docker的cgroup driver为systemd。

mkdir /etc/docker/
cat <<EOF > /etc/docker/daemon.json
{
  "registry-mirrors": ["https://3x8fih0m.mirror.aliyuncs.com"],
  "exec-opts": ["native.cgroupdriver=systemd"]
}
EOF
systemctl restart docker
systemctl status docker # 确认docker是否正常启动
docker info # 确认镜像源配置是否生效

上面的操作，是在每台主机上都要执行的，如果想简单一些，可以做成脚本。

2.3 配置普通用户加入docker组

把nginx主机当做主控机，其它主机的ops用户互信它的ops用户。

nginx主机操作

useradd ops
usermod -G docker ops

ssh-keygen生成密钥对

k8s节点主机操作

在另外3台主机上配置

useradd ops
usermod -G docker ops
mkdir -pv /home/ops/.ssh/
chmod 700 /home/ops/.ssh/
chown -R ops.ops /home/ops/
chmod 600 /home/ops/.ssh/authorized_keys
vim /home/ops/.ssh/authorized_keys  # 添加第一个节点的密钥

测试用ssh连接。从nginx主机上，通过ops用户都能正常ssh连接到三台要部署k8s的主机。

配置参考：
https://www.kubernetes.org.cn/5551.html
https://www.cnblogs.com/tylerzhou/p/10971336.html

注意：完成以上全部操作之后，需要重启主机，有些配置参数重置主机后才会生效。

3. 使用RKE搭建k8s集群

3.1 下载RKE

首先从官网下载RKE，下载地址：https://github.com/rancher/rke/releases/tag/v1.0.11
下载好之后，上传到/home/ops/目录下，并添加执行权限

3.2 生成集群配置文件

配置文件生成可以用命令

cluster.yml配置如下：

nodes:
- address: 172.21.0.12
  port: "22"
  internal_address: ""
  role:
  - controlplane
  - worker
  - etcd
  hostname_override: ""
  user: ops
  docker_socket: /var/run/docker.sock
  ssh_key: ""
  ssh_key_path: ~/.ssh/id_rsa
  ssh_cert: ""
  ssh_cert_path: ""
  labels: {}
  taints: []
- address: 172.21.0.15
  port: "22"
  internal_address: ""
  role:
  - controlplane
  - worker
  - etcd
  hostname_override: ""
  user: ops
  docker_socket: /var/run/docker.sock
  ssh_key: ""
  ssh_key_path: ~/.ssh/id_rsa
  ssh_cert: ""
  ssh_cert_path: ""
  labels: {}
  taints: []
- address: 172.21.0.16
  port: "22"
  internal_address: ""
  role:
  - controlplane
  - worker
  - etcd
  hostname_override: ""
  user: ops
  docker_socket: /var/run/docker.sock
  ssh_key: ""
  ssh_key_path: ~/.ssh/id_rsa
  ssh_cert: ""
  ssh_cert_path: ""
  labels: {}
  taints: []
services:
  etcd:
    image: ""
    extra_args: {}
    extra_binds: []
    extra_env: []
    external_urls: []
    ca_cert: ""
    cert: ""
    key: ""
    path: ""
    uid: 0
    gid: 0
    snapshot: null
    retention: ""
    creation: ""
    backup_config:
      enabled: true
      interval_hours: 12
      retention: 6
  kube-api:
    image: ""
    extra_args: {}
    extra_binds: []
    extra_env: []
    service_cluster_ip_range: 10.43.0.0/16
    service_node_port_range: ""
    pod_security_policy: false
    always_pull_images: false
    secrets_encryption_config: null
    audit_log: null
    admission_configuration: null
    event_rate_limit: null
  kube-controller:
    image: ""
    extra_args: {}
    extra_binds: []
    extra_env: []
    cluster_cidr: 10.42.0.0/16
    service_cluster_ip_range: 10.43.0.0/16
  scheduler:
    image: ""
    extra_args: {}
    extra_binds: []
    extra_env: []
  kubelet:
    image: ""
    extra_args: {}
    extra_binds: []
    extra_env: []
    cluster_domain: cluster.local
    infra_container_image: ""
    cluster_dns_server: 10.43.0.10
    fail_swap_on: false
    generate_serving_certificate: false
  kubeproxy:
    image: ""
    extra_args: {}
    extra_binds: []
    extra_env: []
network:
  plugin: canal
  options: {}
  mtu: 0
  node_selector: {}
authentication:
  strategy: x509
  sans: []
  webhook: null
addons: ""
addons_include: []
system_images:
  etcd: rancher/coreos-etcd:v3.4.3-rancher1
  alpine: rancher/rke-tools:v0.1.59
  nginx_proxy: rancher/rke-tools:v0.1.59
  cert_downloader: rancher/rke-tools:v0.1.59
  kubernetes_services_sidecar: rancher/rke-tools:v0.1.59
  kubedns: rancher/k8s-dns-kube-dns:1.15.0
  dnsmasq: rancher/k8s-dns-dnsmasq-nanny:1.15.0
  kubedns_sidecar: rancher/k8s-dns-sidecar:1.15.0
  kubedns_autoscaler: rancher/cluster-proportional-autoscaler:1.7.1
  coredns: rancher/coredns-coredns:1.6.5
  coredns_autoscaler: rancher/cluster-proportional-autoscaler:1.7.1
  nodelocal: rancher/k8s-dns-node-cache:1.15.7
  kubernetes: rancher/hyperkube:v1.17.9-rancher1
  flannel: rancher/coreos-flannel:v0.12.0
  flannel_cni: rancher/flannel-cni:v0.3.0-rancher6
  calico_node: rancher/calico-node:v3.13.4
  calico_cni: rancher/calico-cni:v3.13.4
  calico_controllers: rancher/calico-kube-controllers:v3.13.4
  calico_ctl: rancher/calico-ctl:v3.13.4
  calico_flexvol: rancher/calico-pod2daemon-flexvol:v3.13.4
  canal_node: rancher/calico-node:v3.13.4
  canal_cni: rancher/calico-cni:v3.13.4
  canal_flannel: rancher/coreos-flannel:v0.12.0
  canal_flexvol: rancher/calico-pod2daemon-flexvol:v3.13.4
  weave_node: weaveworks/weave-kube:2.6.4
  weave_cni: weaveworks/weave-npc:2.6.4
  pod_infra_container: rancher/pause:3.1
  ingress: rancher/nginx-ingress-controller:nginx-0.32.0-rancher1
  ingress_backend: rancher/nginx-ingress-controller-defaultbackend:1.5-rancher1
  metrics_server: rancher/metrics-server:v0.3.6
  windows_pod_infra_container: rancher/kubelet-pause:v0.1.4
ssh_key_path: ~/.ssh/id_rsa
ssh_cert_path: ""
ssh_agent_auth: false
authorization:
  mode: rbac
  options: {}
ignore_docker_version: false
kubernetes_version: ""
private_registries: []
ingress:
  provider: ""
  options: {}
  node_selector: {}
  extra_args: {}
  dns_policy: ""
  extra_envs: []
  extra_volumes: []
  extra_volume_mounts: []
cluster_name: ""
cloud_provider:
  name: ""
prefix_path: ""
addon_job_timeout: 0
bastion_host:
  address: ""
  port: ""
  user: ""
  ssh_key: ""
  ssh_key_path: ""
  ssh_cert: ""
  ssh_cert_path: ""
monitoring:
  provider: ""
  options: {}
  node_selector: {}
restore:
  restore: false
  snapshot_name: ""
dns: null

中间其实有一些是需要修改的，比如etcd的备份周期，备份保留时间，ingress是否安装等等，具体参数参考：
官方示例配置

3.3 启动集群

启动集群很简单，一个命令就可以

./rke_linux-amd64 up

嗯，第一遍还是有报错的情况

可能是有超时的情况。
我们先把这三台主机上已经启动的docker容器清理了，以免影响再次的操作。
在三台主机上用root权限执行下面命令：

# 防火墙规则清理
/sbin/iptables -P INPUT ACCEPT
/sbin/iptables -F
# 容器清理
docker rm -f $(sudo docker ps -aq);
docker volume rm $(sudo docker volume ls -q);
# 重启服务
systemctl restart docker
docker ps -a

在nginx节点再执行一次部署

这一次可以了。

3.4 验证

验证之前，需要先安装kubectl命令
在nginx节点上，先切换到root用户，执行下面命令

cat <<EOF > /etc/yum.repos.d/kubernetes.repo
[kubernetes]
name=Kubernetes
baseurl=https://mirrors.aliyun.com/kubernetes/yum/repos/kubernetes-el7-x86_64/
enabled=1
gpgcheck=1
repo_gpgcheck=1
gpgkey=https://mirrors.aliyun.com/kubernetes/yum/doc/yum-key.gpg https://mirrors.aliyun.com/kubernetes/yum/doc/rpm-package-key.gpg
EOF

yum install -y kubectl

然后切回到ops用户，执行如下操作

kube_config_cluster.yml这个配置文件，是配置完集群之后生成的，相当于是我们管理k8s集群的钥匙。
在进行下面的操作之前，先确认上面几个节点的状态都是“ready”的，如果不是，先等一会儿，应该是有一些服务还没有自动配置完成。
看下pod状态是否都正常：

4. 安装helm2

我们用helm2来安装rancher，官方参考文档地址
在nginx主机上安装helm2。

4.1 下载

在官网下载指定2.16.6版本的helm并传入服务器：
下载地址：https://get.helm.sh/helm-v2.16.6-linux-amd64.tar.gz。

tar -xvf helm-v2.16.6-linux-amd64.tar.gz
 mv linux-amd64/helm /usr/local/bin/
helm version #查看helm client版本

helm2是客户端、服务端分离的，所以还需要安装tiller

4.2 安装tiller

创建rbac-config.yaml，并输入以下内容：

apiVersion: v1
kind: ServiceAccount
metadata:
  name: tiller
  namespace: kube-system
---
apiVersion: rbac.authorization.k8s.io/v1beta1
kind: ClusterRoleBinding
metadata:
  name: tiller
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: cluster-admin
subjects:
  - kind: ServiceAccount
    name: tiller
    namespace: kube-system

然后执行

kubectl create -f rbac-config.yaml

报错了，因为现在是用root用户执行的，没有kube_config文件，复制一下

这样就可以了。
以上步骤配置成功后，安装tiller。
初始化，用阿里云的源，注意版本也是2.16.6

# 阿里源
helm init --service-account tiller --upgrade -i registry.cn-hangzhou.aliyuncs.com/google_containers/tiller:v2.16.6 --stable-repo-url https://kubernetes.oss-cn-hangzhou.aliyuncs.com/charts

可以看到，helm version能显示出来客户端和服务端了，这就可以了。

5. helm安装Rancher

5.1 配置自签名证书

参考：https://docs.rancher.cn/rancher2x/install-prepare/self-signed-ssl.html#_1-http-over-ssl
下面是脚本：

#!/bin/bash -e

help ()
{
    echo  ' ================================================================ '
    echo  ' --ssl-domain: 生成ssl证书需要的主域名，如不指定则默认为www.rancher.local，如果是ip访问服务，则可忽略；'
    echo  ' --ssl-trusted-ip: 一般ssl证书只信任域名的访问请求，有时候需要使用ip去访问server，那么需要给ssl证书添加扩展IP，多个IP用逗号隔开；'
    echo  ' --ssl-trusted-domain: 如果想多个域名访问，则添加扩展域名（SSL_TRUSTED_DOMAIN）,多个扩展域名用逗号隔开；'
    echo  ' --ssl-size: ssl加密位数，默认2048；'
    echo  ' --ssl-cn: 国家代码(2个字母的代号),默认CN;'
    echo  ' 使用示例:'
    echo  ' ./create_self-signed-cert.sh --ssl-domain=www.test.com --ssl-trusted-domain=www.test2.com \ '
    echo  ' --ssl-trusted-ip=1.1.1.1,2.2.2.2,3.3.3.3 --ssl-size=2048 --ssl-date=3650'
    echo  ' ================================================================'
}

case "$1" in
    -h|--help) help; exit;;
esac

if [[ $1 == '' ]];then
    help;
    exit;
fi

CMDOPTS="$*"
for OPTS in $CMDOPTS;
do
    key=$(echo ${OPTS} | awk -F"=" '{print $1}' )
    value=$(echo ${OPTS} | awk -F"=" '{print $2}' )
    case "$key" in
        --ssl-domain) SSL_DOMAIN=$value ;;
        --ssl-trusted-ip) SSL_TRUSTED_IP=$value ;;
        --ssl-trusted-domain) SSL_TRUSTED_DOMAIN=$value ;;
        --ssl-size) SSL_SIZE=$value ;;
        --ssl-date) SSL_DATE=$value ;;
        --ca-date) CA_DATE=$value ;;
        --ssl-cn) CN=$value ;;
    esac
done

# CA相关配置
CA_DATE=${CA_DATE:-3650}
CA_KEY=${CA_KEY:-cakey.pem}
CA_CERT=${CA_CERT:-cacerts.pem}
CA_DOMAIN=cattle-ca

# ssl相关配置
SSL_CONFIG=${SSL_CONFIG:-$PWD/openssl.cnf}
SSL_DOMAIN=${SSL_DOMAIN:-'www.rancher.local'}
SSL_DATE=${SSL_DATE:-3650}
SSL_SIZE=${SSL_SIZE:-2048}

## 国家代码(2个字母的代号),默认CN;
CN=${CN:-CN}

SSL_KEY=$SSL_DOMAIN.key
SSL_CSR=$SSL_DOMAIN.csr
SSL_CERT=$SSL_DOMAIN.crt

echo -e "\033[32m ---------------------------- \033[0m"
echo -e "\033[32m       | 生成 SSL Cert |       \033[0m"
echo -e "\033[32m ---------------------------- \033[0m"

if [[ -e ./${CA_KEY} ]]; then
    echo -e "\033[32m ====> 1. 发现已存在CA私钥，备份"${CA_KEY}"为"${CA_KEY}"-bak，然后重新创建 \033[0m"
    mv ${CA_KEY} "${CA_KEY}"-bak
    openssl genrsa -out ${CA_KEY} ${SSL_SIZE}
else
    echo -e "\033[32m ====> 1. 生成新的CA私钥 ${CA_KEY} \033[0m"
    openssl genrsa -out ${CA_KEY} ${SSL_SIZE}
fi

if [[ -e ./${CA_CERT} ]]; then
    echo -e "\033[32m ====> 2. 发现已存在CA证书，先备份"${CA_CERT}"为"${CA_CERT}"-bak，然后重新创建 \033[0m"
    mv ${CA_CERT} "${CA_CERT}"-bak
    openssl req -x509 -sha256 -new -nodes -key ${CA_KEY} -days ${CA_DATE} -out ${CA_CERT} -subj "/C=${CN}/CN=${CA_DOMAIN}"
else
    echo -e "\033[32m ====> 2. 生成新的CA证书 ${CA_CERT} \033[0m"
    openssl req -x509 -sha256 -new -nodes -key ${CA_KEY} -days ${CA_DATE} -out ${CA_CERT} -subj "/C=${CN}/CN=${CA_DOMAIN}"
fi

echo -e "\033[32m ====> 3. 生成Openssl配置文件 ${SSL_CONFIG} \033[0m"
cat > ${SSL_CONFIG} <<EOM
[req]
req_extensions = v3_req
distinguished_name = req_distinguished_name
[req_distinguished_name]
[ v3_req ]
basicConstraints = CA:FALSE
keyUsage = nonRepudiation, digitalSignature, keyEncipherment
extendedKeyUsage = clientAuth, serverAuth
EOM

if [[ -n ${SSL_TRUSTED_IP} || -n ${SSL_TRUSTED_DOMAIN} ]]; then
    cat >> ${SSL_CONFIG} <<EOM
subjectAltName = @alt_names
[alt_names]
EOM
    IFS=","
    dns=(${SSL_TRUSTED_DOMAIN})
    dns+=(${SSL_DOMAIN})
    for i in "${!dns[@]}"; do
      echo DNS.$((i+1)) = ${dns[$i]} >> ${SSL_CONFIG}
    done

    if [[ -n ${SSL_TRUSTED_IP} ]]; then
        ip=(${SSL_TRUSTED_IP})
        for i in "${!ip[@]}"; do
          echo IP.$((i+1)) = ${ip[$i]} >> ${SSL_CONFIG}
        done
    fi
fi

echo -e "\033[32m ====> 4. 生成服务SSL KEY ${SSL_KEY} \033[0m"
openssl genrsa -out ${SSL_KEY} ${SSL_SIZE}

echo -e "\033[32m ====> 5. 生成服务SSL CSR ${SSL_CSR} \033[0m"
openssl req -sha256 -new -key ${SSL_KEY} -out ${SSL_CSR} -subj "/C=${CN}/CN=${SSL_DOMAIN}" -config ${SSL_CONFIG}

echo -e "\033[32m ====> 6. 生成服务SSL CERT ${SSL_CERT} \033[0m"
openssl x509 -sha256 -req -in ${SSL_CSR} -CA ${CA_CERT} \
    -CAkey ${CA_KEY} -CAcreateserial -out ${SSL_CERT} \
    -days ${SSL_DATE} -extensions v3_req \
    -extfile ${SSL_CONFIG}

echo -e "\033[32m ====> 7. 证书制作完成 \033[0m"
echo
echo -e "\033[32m ====> 8. 以YAML格式输出结果 \033[0m"
echo "----------------------------------------------------------"
echo "ca_key: |"
cat $CA_KEY | sed 's/^/  /'
echo
echo "ca_cert: |"
cat $CA_CERT | sed 's/^/  /'
echo
echo "ssl_key: |"
cat $SSL_KEY | sed 's/^/  /'
echo
echo "ssl_csr: |"
cat $SSL_CSR | sed 's/^/  /'
echo
echo "ssl_cert: |"
cat $SSL_CERT | sed 's/^/  /'
echo

echo -e "\033[32m ====> 9. 附加CA证书到Cert文件 \033[0m"
cat ${CA_CERT} >> ${SSL_CERT}
echo "ssl_cert: |"
cat $SSL_CERT | sed 's/^/  /'
echo

echo -e "\033[32m ====> 10. 重命名服务证书 \033[0m"
echo "cp ${SSL_DOMAIN}.key tls.key"
cp ${SSL_DOMAIN}.key tls.key
echo "cp ${SSL_DOMAIN}.crt tls.crt"
cp ${SSL_DOMAIN}.crt tls.crt

执行脚本：

生成如下文件：

5.2 配置负载均衡器nginx

在nginx主机上安装nginx，为了简单，我直接用yum了。生产环境一般使用编译安装的方式，便于管理。
nginx主要配置如下：

    upstream rancher {
        server 172.21.0.12:443;
        server 172.21.0.15:443;
        server 172.21.0.16:443;
    }

    map $http_upgrade $connection_upgrade {
        default Upgrade;
        ''      close;
    }

    server {
        listen 443 ssl http2; # 如果是升级或者全新安装v2.2.2,需要禁止http2，其他版本不需修改。
        server_name rancher.test.com;
        ssl_certificate /root/ssl/rancher.test.com.crt;
        ssl_certificate_key /root/ssl/rancher.test.com.key;

        location / {
            proxy_set_header Host $host;
            proxy_set_header X-Forwarded-Proto $scheme;
            proxy_set_header X-Forwarded-Port $server_port;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_pass https://rancher;
            proxy_http_version 1.1;
            proxy_set_header Upgrade $http_upgrade;
            proxy_set_header Connection $connection_upgrade;
            # This allows the ability for the execute shell window to remain open for up to 15 minutes. 
            ## Without this parameter, the default is 1 minute and will automatically close.
            proxy_read_timeout 900s;
            proxy_buffering off;
        }
    }

    server {
        listen 80;
        server_name rancher.test.com;
        return 301 https://$server_name$request_uri;
    }

配置本地hosts，用https://rancher.test.com访问试试
因为是自签名证书，浏览器会提示风险

看看证书信息：

10年的。

5.3 helm安装Rancher

切换到刚才生成了CA证书相关文件的目录下，执行如下命令

cd /root/ssl
# 添加rancher的repo
helm repo add rancher-stable https://releases.rancher.com/server-charts/stable
# 创建namespace
kubectl create ns cattle-system
# ca证书密文
kubectl -n cattle-system create secret generic tls-ca --from-file=cacerts.pem
# 安装Rancher Server
helm install rancher-stable/rancher \
    --name rancher --namespace cattle-system \
    --set hostname=rancher.test.com \
    --set privateCA=true \
	--set ingress.tls.source=secret

看一下

OK。
刚才的页面在访问试试，如果能够看到下面的，就说明安装成功了。

进入控制台：

修改一下语言。现在可以看到状态还是异常的，还需要进一步的配置。

5.4 解决异常问题

官方解释是：如果您没有内部DNS服务器而是通过添加/etc/hosts主机别名的方式指定的Rancher Server域名，那么不管通过哪种方式(自定义、导入、Host驱动等)创建K8S集群，K8S集群运行起来之后，因为cattle-cluster-agent Pod和cattle-node-agent pod无法通过DNS记录找到Rancher Server URL,最终导致无法通信。

官方参考方案
执行下面三个命令：

kubectl --kubeconfig=$kubeconfig -n cattle-system \
    patch deployments rancher --patch '{
        "spec": {
            "template": {
                "spec": {
                    "hostAliases": [
                        {
                            "hostnames":
                            [
                                "rancher.test.com"
                            ],
                                "ip": "140.143.227.211"
                        }
                    ]
                }
            }
        }
    }'

kubectl --kubeconfig=$kubeconfig -n cattle-system \
patch deployments cattle-cluster-agent --patch '{
    "spec": {
        "template": {
            "spec": {
                "hostAliases": [
                    {
                        "hostnames":
                        [
                            "rancher.test.com"
                        ],
                            "ip": "140.143.227.211"
                    }
                ]
            }
        }
    }
}'

kubectl --kubeconfig=$kubeconfig -n cattle-system \
patch  daemonsets cattle-node-agent --patch '{
    "spec": {
        "template": {
            "spec": {
                "hostAliases": [
                    {
                        "hostnames":
                        [
                            "rancher.test.com"
                        ],
                            "ip": "140.143.227.211"
                    }
                ]
            }
        }
    }
}'

注意：域名和IP的对应关系，保持跟刚才hosts配置文件里的一致就可以。
执行完之后，可以看到pod开始重建了

等到状态全部变成“Running”的时候，刷新再看一下web控制台
状态已经正常了

5.5 简单配置

5.1 配置应用商店

点击“应用商店”进行配置

添加了常用的两个

应用商店实际就是helm仓库。

# 官方镜像
https://kubernetes.oss-cn-hangzhou.aliyuncs.com/charts
# 阿里云apphub
https://apphub.aliyuncs.com/

通过应用商店可以很方便的安装一些常用服务。

5.2 启用监控

右上角点击“启用监控并查看实时监控指标”

Garfana持久化，需要先配置好存储。没有配置存储的时候，不需要选。
安装完成之后，如下：

想看哪个指标，直接点击Grafana的图标即可。
点开之后，如下：

以上就完成安装部署了。

6. 结语

Rancher安装完成以后，就可以分配账号、部署应用程序了。
上面的步骤、流程只是简略的。实际的环境中还需要考虑以下内容：

1. 安全性问题，账号权限
2. 主机磁盘空间大小，docker的/var/lib/docker空间是否能支撑后续的业务
3. 持久化存储用哪种方案？
4. Rancher集群配置参数的优化，比如：etcd的备份策略，k8s集群的备份与恢复，nginx ingress是否需要用DaemonSet（默认）的方式部署，还是只需要专门几台来做ingress的主机等。
5. 未来的集群规模有多大？k8s是用单集群还是多集群？官方建议是Rancher集群只用来做管理，业务集群用Rancher来安装，这样就至少是两个集群（管理集群+业务集群）。
   等等，上面的这些问题，只是一些方面，我没有提到的还有很多。有些是要根据实际的情况进行调整的。希望能用好k8s这个工具。