用Rancher RKE快速部署高可用k8s集群
用Rancher部署高可用k8s集群
- 用Rancher RKE部署高可用k8s集群
- 1. 主机配置
- 1.1 新建虚拟主机
- 1.2 主机初始化配置
- 安装一些必要的安装包
- 安全设置
- ntp时钟同步
- 内核参数调优
- hostname修改
- 关闭swap分区
- 加载ipvs相关模块
- 2. docker配置
- 2.1 安装docker
- 2.2 配置docker
- 2.3 配置普通用户加入docker组
- nginx主机操作
- k8s节点主机操作
- 3. 使用RKE搭建k8s集群
- 3.1 下载RKE
- 3.2 生成集群配置文件
- 3.3 启动集群
- 3.4 验证
- 4. 安装helm2
- 4.1 下载
- 4.2 安装tiller
- 5. helm安装Rancher
- 5.1 配置自签名证书
- 5.2 配置负载均衡器nginx
- 5.3 helm安装Rancher
- 5.4 解决异常问题
- 5.5 简单配置
- 5.1 配置应用商店
- 5.2 启用监控
- 6. 结语
用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安装完成以后，就可以分配账号、部署应用程序了。
上面的步骤、流程只是简略的。实际的环境中还需要考虑以下内容：
- 安全性问题，账号权限
- 主机磁盘空间大小，docker的/var/lib/docker空间是否能支撑后续的业务
- 持久化存储用哪种方案？
- Rancher集群配置参数的优化，比如：etcd的备份策略，k8s集群的备份与恢复，nginx ingress是否需要用DaemonSet（默认）的方式部署，还是只需要专门几台来做ingress的主机等。
- 未来的集群规模有多大？k8s是用单集群还是多集群？官方建议是Rancher集群只用来做管理，业务集群用Rancher来安装，这样就至少是两个集群（管理集群+业务集群）。
等等，上面的这些问题，只是一些方面，我没有提到的还有很多。有些是要根据实际的情况进行调整的。希望能用好k8s这个工具。