二进制安装K8S简书

最新推荐文章于 2024-08-06 10:07:07 发布

小数苗小数苗

最新推荐文章于 2024-08-06 10:07:07 发布

阅读量413

点赞数

分类专栏： Linux集

本文链接：https://blog.csdn.net/Doudou_Mylove/article/details/100160356

版权

Linux集专栏收录该内容

503 篇文章 21 订阅

订阅专栏

三台服务器基础环境安装
Master 192.168.20.50
Node1 192.168.20.234
Node2 192.168.20.238

安装docker

yum -y install yum-utils sshpass
yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
yum makecache
yum -y install docker-ce
systemctl start docker & systemctl enable docker
docker info

关闭swap

sed -i '/ swap / s/^/#/' /etc/fstab
swapoff -a
systemctl stop firewalld & systemctl disable firewalld
setenforce 0
sed -i 's/^SELINUX=enforcing$/SELINUX=permissive/' /etc/selinux/config

设置网络

cat << EOF > /etc/sysconfig/modules/ipvs.modules
 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

mkdir /k8s/{bin,cfg,ssl,data,addons} -p

添加到环境变量PATH

cat>>/etc/profile<<'EOF'
PATH=/k8s/bin:$PATH
EOF

source /etc/profile

以上内容三台同步操作。

下载安装相关软件（master先操作）

证书相关
yum -y install wget vim lrzsz zip unzip
wget https://pkg.cfssl.org/R1.2/cfssl_linux-amd64
wget https://pkg.cfssl.org/R1.2/cfssljson_linux-amd64
wget https://pkg.cfssl.org/R1.2/cfssl-certinfo_linux-amd64
chmod +x cfssl_linux-amd64 cfssljson_linux-amd64 cfssl-certinfo_linux-amd64
mv cfssl_linux-amd64 /usr/local/bin/cfssl
mv cfssljson_linux-amd64 /usr/local/bin/cfssljson
mv cfssl-certinfo_linux-amd64 /usr/bin/cfssl-certinfo
k8s相关

cd /usr/local/src/
wget https://github.com/etcd-io/etcd/releases/download/v3.3.11/etcd-v3.3.11-linux-amd64.tar.gz
wget https://github.com/coreos/flannel/releases/download/v0.11.0/flannel-v0.11.0-linux-amd64.tar.gz
wget https://dl.k8s.io/v1.15.0/kubernetes-server-linux-amd64.tar.gz

生成证书

生成ca证书

cd /k8s/ssl

cfssl print-defaults config > ca-config.json

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

#ca csr

cfssl print-defaults csr > ca-csr.json

cat << EOF >ca-csr.json
{
    "CN": "ca",
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
        {
            "C": "CN",
            "L": "Chengdu",
            "ST": "Sichuan"
        }
    ]
}
EOF

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

生成server证书

cat << EOF >server-csr.json
{
    "CN": "server",
    "hosts": [
    "127.0.0.1",
    "192.168.20.57",
    "192.168.20.234",
    "192.168.20.238",
    "10.254.0.1"
    ],
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
        {
            "C": "CN",
            "L": "Chengdu",
            "ST": "Sichuan"
        }
    ]
}
EOF

cfssl gencert -config=ca-config.json -profile=k8s  -ca=ca.pem -ca-key=ca-key.pem server-csr.json | cfssljson -bare server

生成kube-proxy证书
#内置system:node-proxier角色用户system:kube-proxy

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

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

生成kubectl(集群管理员）证书

cat << EOF >admin-csr.json
{
    "CN": "system:admin",
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
        {
            "C": "CN",
            "L": "Chengdu",
            "ST": "Sichuan"
        }
    ]
}
EOF

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

做集群服务器互信：
ssh-keygen
ssh-copy-id root@192.168.20.234
ssh-copy-id root@192.168.20.238

安装etcd(master先操作)

cd /usr/local/src
tar xf etcd-v3.3.13-linux-amd64.tar.gz 
cd etcd-v3.3.13-linux-amd64
mkdir /k8s/data/etcd
cp etcd etcdctl /k8s/bin/

vim /k8s/cfg/etcd

#[member]
ETCD_NAME="etcd01"
ETCD_DATA_DIR="/k8s/data/etcd"
ETCD_LISTEN_PEER_URLS="https://192.168.20.57:2380"
ETCD_LISTEN_CLIENT_URLS="https://192.168.20.57:2379"
#[Clustering]
ETCD_INITIAL_ADVERTISE_PEER_URLS="https://192.168.20.57:2380"
ETCD_ADVERTISE_CLIENT_URLS="https://192.168.20.57:2379"
ETCD_INITIAL_CLUSTER="etcd01=https://192.168.20.57:2380,etcd02=https://192.168.20.234:2380,etcd03=https://192.168.20.238:2380"
ETCD_INITIAL_CLUSTER_TOKEN="etcd-cluster"
ETCD_INITIAL_CLUSTER_STATE="new"

#创建启动文件
vim /usr/lib/systemd/system/etcd.service

[Unit]
Description=Etcd Server
After=network.target
After=network-online.target
Wants=network-online.target
[Service]
Type=notify
EnvironmentFile=-/k8s/cfg/etcd
ExecStart=/k8s/bin/etcd \
--name=${ETCD_NAME} \
--data-dir=${ETCD_DATA_DIR} \
--listen-client-urls=${ETCD_LISTEN_CLIENT_URLS} \
--listen-peer-urls=${ETCD_LISTEN_PEER_URLS} \
--advertise-client-urls=${ETCD_ADVERTISE_CLIENT_URLS} \
--initial-advertise-peer-urls=${ETCD_INITIAL_ADVERTISE_PEER_URLS} \
--initial-cluster=${ETCD_INITIAL_CLUSTER} \
--initial-cluster-token=${ETCD_INITIAL_CLUSTER} \
--initial-cluster-state=new \
--cert-file=/k8s/ssl/server.pem \
--key-file=/k8s/ssl/server-key.pem \
--peer-cert-file=/k8s/ssl/server.pem \
--peer-key-file=/k8s/ssl/server-key.pem \
--trusted-ca-file=/k8s/ssl/ca.pem \
--peer-trusted-ca-file=/k8s/ssl/ca.pem
Restart=on-failure
LimitNOFILE=65536
[Install]
WantedBy=multi-user.target

从master节点拷贝证书和配置文件到node节点（记得修改node节点etcd配置文件）

scp -r /k8s/bin/ root@192.168.20.234:/k8s/
scp -r /k8s/bin/ root@192.168.20.238:/k8s/
scp -r /k8s/cfg/ root@192.168.20.234:/k8s/
scp -r /k8s/cfg/ root@192.168.20.238:/k8s/
scp -r /k8s/ssl/ root@192.168.20.234:/k8s/
scp -r /k8s/ssl/ root@192.168.20.238:/k8s/
scp -r /k8s/data/ root@192.168.20.234:/k8s/
scp -r /k8s/data/ root@192.168.20.238:/k8s/

发送启动脚本到node节点：

scp /usr/lib/systemd/system/etcd.service root@192.168.20.234:/usr/lib/systemd/system/                                                                                                                                                                   
scp /usr/lib/systemd/system/etcd.service root@192.168.20.238:/usr/lib/systemd/system/

#设置etcd自启动

systemctl daemon-reload
systemctl enable etcd
systemctl start etcd

#检查etcd是否安装成功

etcdctl --ca-file=/k8s/ssl/ca.pem --cert-file=/k8s/ssl/server.pem --key-file=/k8s/ssl/server-key.pem --endpoints="https://192.168.20.57:2379,https://192.168.20.234:2379,https://192.168.20.238:2379" cluster-health

master安装apiserver

cd /usr/local/src/
tar xf kubernetes-server-linux-amd64.tar.gz 
cd kubernetes/server/bin/
cp kube-scheduler kube-apiserver kube-controller-manager kubectl /k8s/bin/

#生成bootstrap Token

echo `head -c 16 /dev/urandom | od -An -t x | tr -d ' '`',kubelet-bootstrap,10001,"system:kubelet-bootstrap"'>/k8s/cfg/token.csv

配置文件编写：
vim /k8s/cfg/kube-apiserver

KUBE_APISERVER_OPTS="--logtostderr=true \
--v=4 \
--etcd-servers=https://192.168.20.57:2379,https://192.168.20.234:2379,https://192.168.20.238:2379 \
--bind-address=192.168.20.57 \
--secure-port=6443 \
--advertise-address=192.168.20.57 \
--allow-privileged=true \
--service-cluster-ip-range=10.254.0.0/16 \
--enable-admission-plugins=NamespaceLifecycle,LimitRanger,SecurityContextDeny,ServiceAccount,ResourceQuota,NodeRestriction \
--authorization-mode=RBAC,Node \
--enable-bootstrap-token-auth \
--token-auth-file=/k8s/cfg/token.csv \
--service-node-port-range=30000-50000 \
--tls-cert-file=/k8s/ssl/server.pem  \
--tls-private-key-file=/k8s/ssl/server-key.pem \
--client-ca-file=/k8s/ssl/ca.pem \
--service-account-key-file=/k8s/ssl/ca-key.pem \
--kubelet-client-certificate=/k8s/ssl/admin.pem \
--kubelet-client-key=/k8s/ssl/admin-key.pem \
--etcd-cafile=/k8s/ssl/ca.pem \
--etcd-certfile=/k8s/ssl/server.pem \
--etcd-keyfile=/k8s/ssl/server-key.pem"

#创建启动文件
vim /usr/lib/systemd/system/kube-apiserver.service

[Unit]
Description=Kubernetes API Server
Documentation=https://github.com/kubernetes/kubernetes
 
[Service]
EnvironmentFile=-/k8s/cfg/kube-apiserver
ExecStart=/k8s/bin/kube-apiserver $KUBE_APISERVER_OPTS
Restart=on-failure
 
[Install]
WantedBy=multi-user.target

#设置自启动

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

master安装scheduler

#创建配置文件

cat>/k8s/cfg/kube-scheduler<<EOF
KUBE_SCHEDULER_OPTS="--logtostderr=true --v=4 --master=127.0.0.1:8080 --leader-elect"
EOF

#创建启动文件

cat>/usr/lib/systemd/system/kube-scheduler.service<<'EOF'
 
[Unit]
Description=Kubernetes Scheduler
Documentation=https://github.com/kubernetes/kubernetes
 
[Service]
EnvironmentFile=-/k8s/cfg/kube-scheduler
ExecStart=/k8s/bin/kube-scheduler $KUBE_SCHEDULER_OPTS
Restart=on-failure
 
[Install]
WantedBy=multi-user.target

#设置自启动

systemctl daemon-reload
systemctl enable kube-scheduler.service
systemctl start kube-scheduler.service

master安装controller manager

#创建配置文件

cat>/k8s/cfg/kube-controller-manager<<EOF
KUBE_CONTROLLER_MANAGER_OPTS="--logtostderr=true \
--v=4 \
--master=127.0.0.1:8080 \
--leader-elect=true \
--address=127.0.0.1 \
--service-cluster-ip-range=10.254.0.0/16 \
--cluster-name=kubernetes \
--cluster-signing-cert-file=/k8s/ssl/ca.pem \
--cluster-signing-key-file=/k8s/ssl/ca-key.pem  \
--root-ca-file=/k8s/ssl/ca.pem \
--service-account-private-key-file=/k8s/ssl/ca-key.pem"
EOF

#创建启动文件

cat>/usr/lib/systemd/system/kube-controller-manager.service<<'EOF'
 
[Unit]
Description=Kubernetes Controller Manager
Documentation=https://github.com/kubernetes/kubernetes
 
[Service]
EnvironmentFile=-/k8s/cfg/kube-controller-manager
ExecStart=/k8s/bin/kube-controller-manager $KUBE_CONTROLLER_MANAGER_OPTS
Restart=on-failure
 
[Install]
WantedBy=multi-user.target
EOF

#设置自启动

systemctl daemon-reload
systemctl enable kube-controller-manager.service
systemctl start kube-controller-manager.service

验证集群安装
kubectl get cs,nodes -s=http://localhost:8080
这一步一定要先于kubelet启动

kubectl create clusterrolebinding admin --clusterrole=cluster-admin --user=system:admin

为kubelet授权，为admin授权

kubectl create clusterrolebinding admin --clusterrole=cluster-admin --user=system:admin

node机准备工作

从master节点拷贝可执行程序文件

cd /usr/local/src/kubernetes/server/bin
scp kube-proxy kubelet kubectl root@192.168.20.234:/k8s/bin
scp kube-proxy kubelet kubectl root@192.168.20.238:/k8s/bin

生成kubelet启动权限配置

export KUBE_APISERVER="https://192.168.20.57:6443"
export BOOTSTRAP_TOKEN="3da1554113bb919292996c3f741f8262"

cat>/k8s/cfg/environment.sh<<EOF
#!/bin/bash
#创建kubelet bootstrapping kubeconfig 
#设置集群参数
kubectl config set-cluster kubernetes \
  --certificate-authority=/k8s/ssl/ca.pem \
  --embed-certs=true \
  --server=${KUBE_APISERVER} \
  --kubeconfig=/k8s/cfg/bootstrap.kubeconfig
 
#设置客户端认证参数
kubectl config set-credentials kubelet-bootstrap \
  --token=${BOOTSTRAP_TOKEN} \
  --kubeconfig=/k8s/cfg/bootstrap.kubeconfig
  
# 设置上下文参数
kubectl config set-context default --cluster=kubernetes --user=kubelet-bootstrap --kubeconfig=/k8s/cfg/bootstrap.kubeconfig
kubectl config use-context default --kubeconfig=/k8s/cfg/bootstrap.kubeconfig

#----------------------
 
# 创建kube-proxy kubeconfig文件
 
kubectl config set-cluster kubernetes --certificate-authority=/k8s/ssl/ca.pem --embed-certs=true --server=${KUBE_APISERVER} --kubeconfig=/k8s/cfg/kube-proxy.kubeconfig
 
kubectl config set-credentials kube-proxy --client-certificate=/k8s/ssl/kube-proxy.pem --client-key=/k8s/ssl/kube-proxy-key.pem --embed-certs=true --kubeconfig=/k8s/cfg/kube-proxy.kubeconfig
 
kubectl config set-context default --cluster=kubernetes --user=kube-proxy --kubeconfig=/k8s/cfg/kube-proxy.kubeconfig
 
# 设置默认上下文
kubectl config use-context default --kubeconfig=/k8s/cfg/kube-proxy.kubeconfig

#----------------------
 
# 创建kubectl kubeconfig文件
 
kubectl config set-cluster kubernetes --certificate-authority=/k8s/ssl/ca.pem --embed-certs=true --server=${KUBE_APISERVER} --kubeconfig=/etc/kubernetes/admin.conf
 
kubectl config set-credentials admin --client-certificate=/k8s/ssl/admin.pem --client-key=/k8s/ssl/admin-key.pem --embed-certs=true --kubeconfig=/etc/kubernetes/admin.conf
 
kubectl config set-context default --cluster=kubernetes --user=admin --kubeconfig=/etc/kubernetes/admin.conf
 
# 设置默认上下文
kubectl config use-context default --kubeconfig=/etc/kubernetes/admin.conf
EOF

sh /k8s/cfg/environment.sh

从master节点拷贝权限配置到node

scp /k8s/cfg/bootstrap.kubeconfig root@192.168.20.234:/k8s/cfg/
scp /k8s/cfg/kube-proxy.kubeconfig root@192.168.20.234:/k8s/cfg/
scp /k8s/cfg/kube-proxy.kubeconfig root@192.168.20.238:/k8s/cfg/
scp /k8s/cfg/bootstrap.kubeconfig root@192.168.20.238:/k8s/cfg/

kubelet安装(node机操作)

#创建参数模板配置文件

cat>/k8s/cfg/kubelet.config<<EOF
kind: KubeletConfiguration
apiVersion: kubelet.config.k8s.io/v1beta1
address: "192.168.20.238"
port: 10250
readOnlyPort: 10255
cgroupDriver: cgroupfs
clusterDNS: ["10.254.0.10"]
clusterDomain: cluster.local.
failSwapOn: false
authentication:
  anonymous:
    enabled: true
EOF

#创建配置文件

cat>/k8s/cfg/kubelet<<EOF
 KUBELET_OPTS="--logtostderr=true \
--v=4 \
--hostname-override=192.168.20.238 \
--kubeconfig=/k8s/cfg/kubelet.kubeconfig \
--bootstrap-kubeconfig=/k8s/cfg/bootstrap.kubeconfig \
--config=/k8s/cfg/kubelet.config \
--cert-dir=/k8s/ssl \
--pod-infra-container-image=registry.cn-hangzhou.aliyuncs.com/google-containers/pause-amd64:3.0"
EOF

#创建启动文件

cat>/usr/lib/systemd/system/kubelet.service<<'EOF'
 
[Unit]
Description=Kubernetes Kubelet
After=docker.service
Requires=docker.service
 
[Service]
EnvironmentFile=/k8s/cfg/kubelet
ExecStart=/k8s/bin/kubelet $KUBELET_OPTS
Restart=on-failure
KillMode=process
 
[Install]
WantedBy=multi-user.target
EOF

#设置自启动

systemctl daemon-reload
systemctl enable kubelet
systemctl start kubelet

从master节点拷贝kuble配置到node(记得修改)
scp /k8s/cfg/kubectl root@192.168.20.234:/k8s/cfg/
注意：kubelet启动之后需要等会才能看到端口

批准证书（master操作）

kubectl certificate approve `kubectl get csr|sed '1d'|awk '{print $1}'`

kube-proxy安装(node机操作)

#创建配置文件

cat>/k8s/cfg/kube-proxy<<EOF
KUBE_PROXY_OPTS="--logtostderr=true \
--v=4 \
--hostname-override=192.168.20.234 \
--cluster-cidr=10.254.0.0/16 \
--kubeconfig=/k8s/cfg/kube-proxy.kubeconfig"
EOF

#创建启动文件

cat>/usr/lib/systemd/system/kube-proxy.service<<'EOF'
 
[Unit]
Description=Kubernetes Proxy
After=network.target
 
[Service]
EnvironmentFile=-/k8s/cfg/kube-proxy
ExecStart=/k8s/bin/kube-proxy $KUBE_PROXY_OPTS
Restart=on-failure
 
[Install]
WantedBy=multi-user.target
EOF

#设置自启动

systemctl daemon-reload
systemctl enable kube-proxy
systemctl start kube-proxy

flanneld安装

#etcd注册网段（master节点上运行）

etcdctl --ca-file=/k8s/ssl/ca.pem --cert-file=/k8s/ssl/server.pem --key-file=/k8s/ssl/server-key.pem --endpoints="https://192.168.20.57:2379,https://192.168.20.234:2379,https://192.168.20.238:2379"  set /k8s/network/config  '{ "Network": "'10.254.0.0/16'", "Backend": {"Type": "vxlan"}}'

node节点上运行(三台机器同步)

#创建bin文件

cd /usr/lcoal/src
tar xzf flannel-v0.11.0-linux-amd64.tar.gz
mv flanneld mk-docker-opts.sh /k8s/bin
scp /k8s/bin/flanneld mk-docker-opts.sh root@192.168.20.234:/k8s/bin/
scp /k8s/bin/flanneld mk-docker-opts.sh root@192.168.20.238:/k8s/bin/

#创建flanneld配置文件

cat>/k8s/cfg/flanneld<<EOF
FLANNEL_OPTIONS="--etcd-endpoints=https://192.168.20.57:2379,https://192.168.20.234:2379,https://192.168.20.238:2379 -etcd-cafile=/k8s/ssl/ca.pem -etcd-certfile=/k8s/ssl/server.pem -etcd-keyfile=/k8s/ssl/server-key.pem -etcd-prefix=/k8s/network"
EOF

#创建启动文件

cat>/usr/lib/systemd/system/flanneld.service<<'EOF'
[Unit]
Description=Flanneld overlay address etcd agent
After=network-online.target network.target
Before=docker.service
 
[Service]
Type=notify
EnvironmentFile=/k8s/cfg/flanneld
ExecStart=/k8s/bin/flanneld --ip-masq $FLANNEL_OPTIONS
ExecStartPost=/k8s/bin/mk-docker-opts.sh -k DOCKER_NETWORK_OPTIONS -d /run/flannel/subnet.env
Restart=on-failure

[Install]
WantedBy=multi-user.target
EOF

#设置自启动，etcd优先启动，flanneld优先docker启动

systemctl daemon-reload
systemctl stop docker

#在docker启动前添加环境变量

sed -i s#^ExecStart=.*\$#EnvironmentFile=/run/flannel/subnet.env\\nExecStart=/usr/bin/dockerd\ \$DOCKER_NETWORK_OPTIONS# /usr/lib/systemd/system/docker.service

systemctl start flanneld
systemctl enable flanneld
systemctl start docker
systemctl restart kubelet
systemctl restart kube-proxy

#检查docker0网桥和flanneld是否在同一网段
ip a
开启一个pod,也可以说容器和应用
kubectl run nginx --image=nginx --replicas=3
查看运行结果：
kubectl get pod -o wide
开放对外访问端口：
kubectl expose deployment nginx --port=88 --target-port=80 --type=NodePort
查看详细pod信息：
kubectl describe service 
node节点访问：curl -I 10.254.151.119:88

删除:
kubectl delete services nginx
kubectl delete deployment nginx

重启顺序：

master
systemctl restart etcd
systemctl restart flanneld
systemctl restart docker
systemctl restart kube-apiserver
systemctl restart kube-controller-manager
systemctl restart kube-scheduler

node
systemctl restart etcd
systemctl restart flanneld
systemctl restart docker
systemctl restart kubelet
systemctl restart kube-proxy