k8s手工安装

简介: k8s节点介绍 master:主要负责管理k8s的所有node etcd:保存了整个集群的状态 apiserver:提供了资源操作的唯一入口,并且提供认证、授权、访问控制、api注册和发现等机制 scheduler负责资源的调度,按照预定的调度策略将pod调度到相应的机器上 controller manager负责维护集群的状态,比如故障检测,自动扩展,滚动更新等 node:主要执行容器实例的节点,可视为工作节点。

k8s节点介绍

master:主要负责管理k8s的所有node 

  • etcd:保存了整个集群的状态
  • apiserver:提供了资源操作的唯一入口,并且提供认证、授权、访问控制、api注册和发现等机制
  • scheduler负责资源的调度,按照预定的调度策略将pod调度到相应的机器上
  • controller manager负责维护集群的状态,比如故障检测,自动扩展,滚动更新等

node:主要执行容器实例的节点,可视为工作节点。

  • kubelet: 负责维护容器的生命周期,同时也负责Volume(CVI)和网络(CNI)的管理;
  • kube-proxy负责为Service提供cluster内部的服务发现和负载均衡;

安装前

k8s在网上有许多的云端平台与操作系统的安装方式。如果通过手工安装来部署,将有利于我们更加了解k8s的流程。

IP address Role CPU Memory
192.168.0.102 master 1 2G
192.168.0.103 node1 1 2G
192.168.0.104 node2 1 2G
  • 这边master节点为主要的控制节点,同时它也是部署节点
  • node为应用程序工作节点

首先安装前要确认:

  • 所有节点之间实现免密码访问
  • 所有防火墙与selinux已关闭
  • 所有节点需要设定/etc/hosts 解析到所有主机
  • 所有节点需要安装docker并启用
  • 所有节点需要设定/etc/sysctl.d/k8s.conf的系统参数
    $ cat <<EOF > /etc/sysctl.d/k8s.conf
    net.ipv4.ip_forward = 1
    net.bridge.bridge-nf-call-ip6tables = 1
    net.bridge.bridge-nf-call-iptables = 1
    EOF
    
    $ sysctl -p /etc/sysctl.d/k8s.conf 
  • 在master节点需要安装CFSSL工具,这将会用来建立TLS certificate
    $ export CFSSL_URL="https://pkg.cfssl.org/R1.2" $ wget "${CFSSL_URL}/cfssl_linux-amd64" -O /usr/local/bin/cfssl $ wget "${CFSSL_URL}/cfssljson_linux-amd64" -O /usr/local/bin/cfssljson $ chmod +x /usr/local/bin/cfssl /usr/local/bin/cfssljson 

部署etcd

k8s会把大部分信息存储在Etcd上,来供其他节点索取,以确保这个集群运作与沟通正常。

创建集群 CA 与 Certificates

在这部分,将会需要产生 client 与 server 的各组件 certificates,并且替 Kubernetes admin user 产生 client 证书。

在master主机上建立/etc/etcd/ssl文件夹,然后进入目录完成以下操作。

$ mkdir -p /etc/etcd/ssl && cd /etc/etcd/ssl $ export PKI_URL="https://kairen.github.io/files/manual-v1.8/pki" 

下载ca-config.json与etcd-ca-csr.json文件,并产生 CA 密钥:

$ wget "${PKI_URL}/ca-config.json" "${PKI_URL}/etcd-ca-csr.json" $ cfssl gencert -initca etcd-ca-csr.json | cfssljson -bare etcd-ca $ ls etcd-ca*.pem
etcd-ca-key.pem etcd-ca.pem

下载etcd-csr.json文件,并产生 kube-apiserver certificate 证书:

$ wget "${PKI_URL}/etcd-csr.json" $ cfssl gencert \
 -ca=etcd-ca.pem \
 -ca-key=etcd-ca-key.pem \
 -config=ca-config.json \
 -profile=kubernetes \
 etcd-csr.json | cfssljson -bare etcd

$ ls etcd*.pem
etcd-ca-key.pem etcd-ca.pem etcd-key.pem etcd.pem

若节点 IP 不同,需要修改etcd-csr.json的hosts。

完成后删除不必要文件:

$ rm -rf *.json 

确认/etc/etcd/ssl有以下文件:

$ ls /etc/etcd/ssl
etcd-ca.csr etcd-ca-key.pem etcd-ca.pem etcd.csr etcd-key.pem etcd.pem

Etcd 安装与设定

首先在master节点下载etcd,并解压缩放到/opt底下安装

$ export ETCD_URL="https://github.com/coreos/etcd/releases/download" $ cd && wget -qO- --show-progress "${ETCD_URL}/v3.2.9/etcd-v3.2.9-linux-amd64.tar.gz" | tar -zx $ mv etcd-v3.2.9-linux-amd64/etcd* /usr/local/bin/ && rm -rf etcd-v3.2.9-linux-amd64 

完成后新建 Etcd Group 与 User,并建立 Etcd 配置文件目录:

$ groupadd etcd && useradd -c "Etcd user" -g etcd -s /sbin/nologin -r etcd 

下载etcd相关文件,我们将来管理 Etcd:

$ export ETCD_CONF_URL="https://kairen.github.io/files/manual-v1.8/master" $ wget "${ETCD_CONF_URL}/etcd.conf" -O /etc/etcd/etcd.conf $ wget "${ETCD_CONF_URL}/etcd.service" -O /lib/systemd/system/etcd.service 

请用自己的ip填入

建立 var 存放信息,然后启动 Etcd 服务:

$ mkdir -p /var/lib/etcd && chown etcd:etcd -R /var/lib/etcd /etc/etcd $ systemctl enable etcd.service && systemctl start etcd.service 

通过简单指令验证:

$ export CA="/etc/etcd/ssl"
$ ETCDCTL_API=3 etcdctl \
 --cacert=${CA}/etcd-ca.pem \
 --cert=${CA}/etcd.pem \
 --key=${CA}/etcd-key.pem \
 --endpoints="https://192.168.0.102:2379" \
 endpoint health

https://192.168.0.102:2379 is healthy: successfully committed proposal: took = 641.36µs

Master

Master主要创建apiserver、Controller manager与Scheduler来组件管理所有 Node

下载 Kubernetes 组件

首先通过网络取得所有需要的执行文件:

# Download Kubernetes $ export KUBE_URL="https://storage.googleapis.com/kubernetes-release/release/v1.8.2/bin/linux/amd64" $ wget "${KUBE_URL}/kubelet" -O /usr/local/bin/kubelet $ wget "${KUBE_URL}/kubectl" -O /usr/local/bin/kubectl $ chmod +x /usr/local/bin/kubelet /usr/local/bin/kubectl 
# Download CNI $ mkdir -p /opt/cni/bin && cd /opt/cni/bin $ export CNI_URL="https://github.com/containernetworking/plugins/releases/download" $ wget -qO- --show-progress "${CNI_URL}/v0.6.0/cni-plugins-amd64-v0.6.0.tgz" | tar -xvf 

创建集群ca与certificates

生成 client 与 server 的各组件 certificates,并且替 Kubernetes admin user 生成 client 证书。

创建pki文件夹,然后进入目录完成以下操作。

$ mkdir -p /etc/kubernetes/pki && cd /etc/kubernetes/pki $ export PKI_URL="https://kairen.github.io/files/manual-v1.8/pki" $ export KUBE_APISERVER="https://1792.168.0.102:6443" 

下载ca-config.json与ca-csr.json文件,并生成 CA 密钥:

$ wget "${PKI_URL}/ca-config.json" "${PKI_URL}/ca-csr.json" $ cfssl gencert -initca ca-csr.json | cfssljson -bare ca $ ls ca*.pem
ca-key.pem ca.pem

下载apiserver-csr.json文件,并生成 kube-apiserver certificate 证书:

$ wget "${PKI_URL}/apiserver-csr.json" $ cfssl gencert \
 -ca=ca.pem \
 -ca-key=ca-key.pem \
 -config=ca-config.json \
 -hostname=10.96.0.1,192.168.0.102,127.0.0.1,kubernetes.default \
 -profile=kubernetes \
 apiserver-csr.json | cfssljson -bare apiserver

$ ls apiserver*.pem
apiserver-key.pem apiserver.pem

下载front-proxy-ca-csr.json文件,并生成 Front proxy CA 密钥,Front proxy 主要是用在 API aggregator 上:

$ wget "${PKI_URL}/front-proxy-ca-csr.json" $ cfssl gencert \
 -initca front-proxy-ca-csr.json | cfssljson -bare front-proxy-ca

$ ls front-proxy-ca*.pem
front-proxy-ca-key.pem front-proxy-ca.pem

下载front-proxy-client-csr.json文件,并生成 front-proxy-client 证书:

$ wget "${PKI_URL}/front-proxy-client-csr.json" $ cfssl gencert \
 -ca=front-proxy-ca.pem \
 -ca-key=front-proxy-ca-key.pem \
 -config=ca-config.json \
 -profile=kubernetes \
 front-proxy-client-csr.json | cfssljson -bare front-proxy-client

$ ls front-proxy-client*.pem
front-proxy-client-key.pem front-proxy-client.pem

由于通过手动创建 CA 方式太过繁杂,只适合少量机器,因为每次签证时都需要绑定 Node IP,随机器增加会带来很多困扰,因此这边使用 TLS Bootstrapping 方式进行授权,由 apiserver 自动给符合条件的 Node 发送证书来授权加入集群。

主要做法是 kubelet 启动时,向 kube-apiserver 传送 TLS Bootstrapping 请求,而 kube-apiserver 验证 kubelet 请求的 token 是否与设定的一样,若一样就自动产生 kubelet 证书与密钥。

首先建立一个变量来产生BOOTSTRAP_TOKEN,并建立 bootstrap.conf 的 kubeconfig 文件:

$ export BOOTSTRAP_TOKEN=$(head -c 16 /dev/urandom | od -An -t x | tr -d ' ') $ cat <<EOF > /etc/kubernetes/token.csv ${BOOTSTRAP_TOKEN},kubelet-bootstrap,10001,"system:kubelet-bootstrap"
EOF

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

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

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

# bootstrap set default context $ kubectl config use-context default --kubeconfig=../bootstrap.conf 

下载admin-csr.json文件,并生成 admin certificate 证书:

$ wget "${PKI_URL}/admin-csr.json" $ cfssl gencert \
 -ca=ca.pem \
 -ca-key=ca-key.pem \
 -config=ca-config.json \
 -profile=kubernetes \
 admin-csr.json | cfssljson -bare admin

$ ls admin*.pem
admin-key.pem admin.pem

接着通过以下指令生成名称为 admin.conf 的 kubeconfig 文件:

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

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

# admin set-context $ kubectl config set-context kubernetes-admin@kubernetes \
 --cluster=kubernetes \
 --user=kubernetes-admin \
 --kubeconfig=../admin.conf

# admin set default context $ kubectl config use-context kubernetes-admin@kubernetes \
 --kubeconfig=../admin.conf

下载manager-csr.json文件,并生成 kube-controller-manager certificate 证书:

$ wget "${PKI_URL}/manager-csr.json" $ cfssl gencert \
 -ca=ca.pem \
 -ca-key=ca-key.pem \
 -config=ca-config.json \
 -profile=kubernetes \
 manager-csr.json | cfssljson -bare controller-manager

若节点 IP 不同,需要修改manager-csr.json的hosts。

接着通过以下指令生成名称为controller-manager.conf的 kubeconfig 文件:

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

# controller-manager set-credentials $ kubectl config set-credentials system:kube-controller-manager \
 --client-certificate=controller-manager.pem \
 --client-key=controller-manager-key.pem \
 --embed-certs=true \
 --kubeconfig=../controller-manager.conf

# controller-manager set-context $ kubectl config set-context system:kube-controller-manager@kubernetes \
 --cluster=kubernetes \
 --user=system:kube-controller-manager \
 --kubeconfig=../controller-manager.conf
 
# controller-manager set default context $ kubectl config use-context system:kube-controller-manager@kubernetes \
 --kubeconfig=../controller-manager.conf

下载scheduler-csr.json文件,并生成 kube-scheduler certificate 证书:

$ wget "${PKI_URL}/scheduler-csr.json" $ cfssl gencert \
 -ca=ca.pem \
 -ca-key=ca-key.pem \
 -config=ca-config.json \
 -profile=kubernetes \
 scheduler-csr.json | cfssljson -bare scheduler

$ ls scheduler*.pem
scheduler-key.pem scheduler.pem

若节点 IP 不同,需要修改scheduler-csr.json的hosts。

接着通过以下指令生成名称为 scheduler.conf 的 kubeconfig 文件:

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

# scheduler set-credentials $ kubectl config set-credentials system:kube-scheduler \
 --client-certificate=scheduler.pem \
 --client-key=scheduler-key.pem \
 --embed-certs=true \
 --kubeconfig=../scheduler.conf

# scheduler set-context $ kubectl config set-context system:kube-scheduler@kubernetes \
 --cluster=kubernetes \
 --user=system:kube-scheduler \
 --kubeconfig=../scheduler.conf

# scheduler set default context $ kubectl config use-context system:kube-scheduler@kubernetes \
 --kubeconfig=../scheduler.conf

下载kubelet-csr.json文件,并生成 master node certificate 证书:

$ wget "${PKI_URL}/kubelet-csr.json" $ sed -i 's/$NODE/master/g' kubelet-csr.json $ cfssl gencert \
 -ca=ca.pem \
 -ca-key=ca-key.pem \
 -config=ca-config.json \
 -hostname=master,192.168.0.102,192.168.0.102 \
 -profile=kubernetes \
 kubelet-csr.json | cfssljson -bare kubelet

$ ls kubelet*.pem
kubelet-key.pem kubelet.pem

这边$NODE需要随节点名称不同而改变。

接着通过以下指令生成名称为 kubelet.conf 的 kubeconfig 文件:

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

# kubelet set-credentials $ kubectl config set-credentials system:node:master1 \
 --client-certificate=kubelet.pem \
 --client-key=kubelet-key.pem \
 --embed-certs=true \
 --kubeconfig=../kubelet.conf

# kubelet set-context $ kubectl config set-context system:node:master1@kubernetes \
 --cluster=kubernetes \
 --user=system:node:master1 \
 --kubeconfig=../kubelet.conf

# kubelet set default context $ kubectl config use-context system:node:master1@kubernetes \
 --kubeconfig=../kubelet.conf

Service account 不是通过 CA 进行认证,因此不要通过 CA 来做 Service account key 的检查,这边建立一组 Private 与 Public 密钥提供给 Service account key 使用:

$ openssl genrsa -out sa.key 2048 $ openssl rsa -in sa.key -pubout -out sa.pub $ ls sa.*
sa.key sa.pub

完成后删除不必要文件:

$ rm -rf *.json *.csr 

确认/etc/kubernetes与/etc/kubernetes/pki有以下文件:

$ ls /etc/kubernetes/
admin.conf bootstrap.conf controller-manager.conf kubelet.conf pki scheduler.conf token.csv

$ ls /etc/kubernetes/pki
admin-key.pem apiserver-key.pem ca-key.pem controller-manager-key.pem front-proxy-ca-key.pem front-proxy-client-key.pem kubelet-key.pem sa.key scheduler-key.pem
admin.pem apiserver.pem ca.pem controller-manager.pem front-proxy-ca.pem front-proxy-client.pem kubelet.pem sa.pub scheduler.pem

安装k8s核心组件

首先下载 Kubernetes 核心组件 YAML 文件,这边我们不透过 Binary 方案来创建 Master 核心组件,而是利用 Kubernetes Static Pod 来创建,因此需下载所有核心组件的Static Pod文件到/etc/kubernetes/manifests目录:

$ export CORE_URL="https://kairen.github.io/files/manual-v1.8/master" $ mkdir -p /etc/kubernetes/manifests && cd /etc/kubernetes/manifests $ for FILE in apiserver manager scheduler; do
 wget "${CORE_URL}/${FILE}.yml.conf" -O ${FILE}.yml
 done

若IP与教程设定不同的话,请记得修改apiserver.yml、manager.yml、scheduler.yml。

生成一个用来加密 Etcd 的 Key:

$ head -c 32 /dev/urandom | base64
SUpbL4juUYyvxj3/gonV5xVEx8j769/99TSAf8YT/sQ=

在/etc/kubernetes/目录下,创建encryption.yml的加密 YAML 文件:

$ cat <<EOF > /etc/kubernetes/encryption.yml
kind: EncryptionConfig apiVersion: v1 resources:
 - resources:
 - secrets
 providers:
 - aescbc:
 keys:
 - name: key1
 secret: SUpbL4juUYyvxj3/gonV5xVEx8j769/99TSAf8YT/sQ=
 - identity: {}
EOF

在/etc/kubernetes/目录下,创建audit-policy.yml的进阶审核策略 YAML 文件:

$ cat <<EOF > /etc/kubernetes/audit-policy.yml
apiVersion: audit.k8s.io/v1beta1 kind: Policy rules:
- level: Metadata
EOF

下载kubelet.service相关文件来管理 kubelet:

$ export KUBELET_URL="https://kairen.github.io/files/manual-v1.8/master" $ mkdir -p /etc/systemd/system/kubelet.service.d $ wget "${KUBELET_URL}/kubelet.service" -O /lib/systemd/system/kubelet.service $ wget "${KUBELET_URL}/10-kubelet.conf" -O /etc/systemd/system/kubelet.service.d/10-kubelet.conf 

最后创建 var 存放信息,然后启动 kubelet 服务:

$ mkdir -p /var/lib/kubelet /var/log/kubernetes $ systemctl enable kubelet.service && systemctl start kubelet.service 

完成后会需要一段时间来下载镜像文件与启动组件,可以利用该指令来查看:

$ watch netstat -ntlp
tcp 0 0 127.0.0.1:10248 0.0.0.0:* LISTEN 23012/kubelet
tcp 0 0 127.0.0.1:10251 0.0.0.0:* LISTEN 22305/kube-schedule
tcp 0 0 127.0.0.1:10252 0.0.0.0:* LISTEN 22529/kube-controll
tcp6 0 0 :::6443 :::* LISTEN 22956/kube-apiserve

完成后,复制 admin kubeconfig 文件,并通过简单指令验证:

$ cp /etc/kubernetes/admin.conf ~/.kube/config $ kubectl get cs
NAME STATUS MESSAGE ERROR
etcd-0 Healthy {"health": "true"}
scheduler Healthy ok
controller-manager Healthy ok

$ kubectl get node
NAME STATUS ROLES AGE VERSION
master1 NotReady master 4m v1.8.2

$ kubectl -n kube-system get po
NAME READY STATUS RESTARTS AGE
kube-apiserver-master1 1/1 Running 0 4m
kube-controller-manager-master1 1/1 Running 0 4m
kube-scheduler-master1 1/1 Running 0 4m

确认服务能够执行 logs 等指令:

$ kubectl -n kube-system logs -f kube-scheduler-master1
Error from server (Forbidden): Forbidden (user=kube-apiserver, verb=get, resource=nodes, subresource=proxy) ( pods/log kube-apiserver-master1)

这边会发现出现 403 Forbidden 问题,这是因为 kube-apiserver user 并没有 nodes 的资源权限,属于正常。

由于上述权限问题,我们必需创建一个 apiserver-to-kubelet-rbac.yml 来定义权限,以供我们执行 logs、exec 等指令:

$ cd /etc/kubernetes/ $ export URL="https://kairen.github.io/files/manual-v1.8/master" $ wget "${URL}/apiserver-to-kubelet-rbac.yml.conf" -O apiserver-to-kubelet-rbac.yml $ kubectl apply -f apiserver-to-kubelet-rbac.yml 
# 测试 logs $ kubectl -n kube-system logs -f kube-scheduler-master
...
I1031 03:22:42.527697 1 leaderelection.go:184] successfully acquired lease kube-system/kube-scheduler

k8s node

在开始前,我们先在master1将需要的 ca 与 cert 复制到 Node 节点上:

$ for NODE in node1 node2; do
 ssh ${NODE} "mkdir -p /etc/kubernetes/pki/"
 ssh ${NODE} "mkdir -p /etc/etcd/ssl" # Etcd ca and cert for FILE in etcd-ca.pem etcd.pem etcd-key.pem; do
 scp /etc/etcd/ssl/${FILE} ${NODE}:/etc/etcd/ssl/${FILE}
 done
 # Kubernetes ca and cert for FILE in pki/ca.pem pki/ca-key.pem bootstrap.conf; do
 scp /etc/kubernetes/${FILE} ${NODE}:/etc/kubernetes/${FILE}
 done
 done

下载 Kubernetes 组件

首先通过网络取得所有需要的执行文件:

# Download Kubernetes $ export KUBE_URL="https://storage.googleapis.com/kubernetes-release/release/v1.8.2/bin/linux/amd64" $ wget "${KUBE_URL}/kubelet" -O /usr/local/bin/kubelet $ chmod +x /usr/local/bin/kubelet 
# Download CNI $ mkdir -p /opt/cni/bin && cd /opt/cni/bin $ export CNI_URL="https://github.com/containernetworking/plugins/releases/download" $ wget -qO- --show-progress "${CNI_URL}/v0.6.0/cni-plugins-amd64-v0.6.0.tgz" | tar -zx 

接着下载 Kubernetes 相关文件,包含 drop-in file、systemd service 档案等:

$ export KUBELET_URL="https://kairen.github.io/files/manual-v1.8/node" $ mkdir -p /etc/systemd/system/kubelet.service.d $ wget "${KUBELET_URL}/kubelet.service" -O /lib/systemd/system/kubelet.service $ wget "${KUBELET_URL}/10-kubelet.conf" -O /etc/systemd/system/kubelet.service.d/10-kubelet.conf 

接着在所有node创建 var 存放信息,然后启动 kubelet 服务:

$ mkdir -p /var/lib/kubelet /var/log/kubernetes /etc/kubernetes/manifests $ systemctl enable kubelet.service && systemctl start kubelet.service 

用一样的动作来完成其他节点

当所有节点都完成后,在master节点,因为我们采用 TLS Bootstrapping,所需要创建一个 ClusterRoleBinding:

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

在master通过简单指令验证,会看到节点处于pending:

$ kubectl get csr
NAME AGE REQUESTOR CONDITION
node-csr-YWf97ZrLCTlr2hmXsNLfjVLwaLfZRsu52FRKOYjpcBE 2s kubelet-bootstrap Pending
node-csr-eq4q6ffOwT4yqYQNU6sT7mphPOQdFN6yulMVZeu6pkE 2s kubelet-bootstrap Pending

通过 kubectl 来允许节点加入集群:

$ kubectl get csr | awk '/Pending/ {print $1}' | xargs kubectl certificate approve
certificatesigningrequest "node-csr-YWf97ZrLCTlr2hmXsNLfjVLwaLfZRsu52FRKOYjpcBE" approved
certificatesigningrequest "node-csr-eq4q6ffOwT4yqYQNU6sT7mphPOQdFN6yulMVZeu6pkE" approved

$ kubectl get csr
NAME AGE REQUESTOR CONDITION
node-csr-YWf97ZrLCTlr2hmXsNLfjVLwaLfZRsu52FRKOYjpcBE 30s kubelet-bootstrap Approved,Issued
node-csr-eq4q6ffOwT4yqYQNU6sT7mphPOQdFN6yulMVZeu6pkE 30s kubelet-bootstrap Approved,Issued

$ kubectl get no
NAME STATUS ROLES AGE VERSION
master NotReady master 15m v1.8.2
node1 NotReady <none> 8m v1.8.2
node2 NotReady <none> 6s v1.8.2

这样就完成了k8s集群的部署

Kubernetes Core Addons 部署

当完成上面所有步骤后,接着我们需要安装一些插件,而这些有部分是非常重要跟好用的,如Kube-dns与Kube-proxy等。

Kube-proxy 是实现 Service 的关键组件,kube-proxy 会在每台节点上执行,然后监听 API Server 的 Service 与 Endpoint 资源对象的改变,然后来依据变化执行 iptables 来实现网络的转发。这边我们会需要建议一个 DaemonSet 来执行,并且创建一些需要的 certificate。

首先在master下载kube-proxy-csr.json文件,并产生 kube-proxy certificate 证书:

$ export PKI_URL="https://kairen.github.io/files/manual-v1.8/pki" $ cd /etc/kubernetes/pki $ wget "${PKI_URL}/kube-proxy-csr.json" "${PKI_URL}/ca-config.json" $ cfssl gencert \
 -ca=ca.pem \
 -ca-key=ca-key.pem \
 -config=ca-config.json \
 -profile=kubernetes \
 kube-proxy-csr.json | cfssljson -bare kube-proxy

$ ls kube-proxy*.pem
kube-proxy-key.pem kube-proxy.pem

接着透过以下指令生成名称为 kube-proxy.conf 的 kubeconfig 文件:

# kube-proxy set-cluster $ kubectl config set-cluster kubernetes \
 --certificate-authority=ca.pem \
 --embed-certs=true \
 --server="https://172.16.35.12:6443" \
 --kubeconfig=../kube-proxy.conf

# kube-proxy set-credentials $ kubectl config set-credentials system:kube-proxy \
 --client-key=kube-proxy-key.pem \
 --client-certificate=kube-proxy.pem \
 --embed-certs=true \
 --kubeconfig=../kube-proxy.conf

# kube-proxy set-context $ kubectl config set-context system:kube-proxy@kubernetes \
 --cluster=kubernetes \
 --user=system:kube-proxy \
 --kubeconfig=../kube-proxy.conf

# kube-proxy set default context $ kubectl config use-context system:kube-proxy@kubernetes \
 --kubeconfig=../kube-proxy.conf

完成后删除不必要文件:

$ rm -rf *.json 

确认/etc/kubernetes有以下文件:

$ ls /etc/kubernetes/
admin.conf bootstrap.conf encryption.yml kube-proxy.conf pki token.csv
audit-policy.yml controller-manager.conf kubelet.conf manifests scheduler.conf

在master将kube-proxy相关文件复制到 Node 节点上:

$ for NODE in node1 node2; do for FILE in pki/kube-proxy.pem pki/kube-proxy-key.pem kube-proxy.conf; do
 scp /etc/kubernetes/${FILE} ${NODE}:/etc/kubernetes/${FILE}
 done
 done

完成后,在master1通过 kubectl 来创建 kube-proxy daemon:

$ export ADDON_URL="https://kairen.github.io/files/manual-v1.8/addon" $ mkdir -p /etc/kubernetes/addons && cd /etc/kubernetes/addons $ wget "${ADDON_URL}/kube-proxy.yml.conf" -O kube-proxy.yml $ kubectl apply -f kube-proxy.yml $ kubectl -n kube-system get po -l k8s-app=kube-proxy
NAME READY STATUS RESTARTS AGE
kube-proxy-bpp7q 1/1 Running 0 47s
kube-proxy-cztvh 1/1 Running 0 47s
kube-proxy-q7mm4 1/1 Running 0 47s

Kube DNS 是 Kubernetes 集群内部 Pod 之间互相沟通的重要 Addon,它允许 Pod 可以通过 Domain Name 方式来连接 Service,其主要由 Kube DNS 与 Sky DNS 组合而成,通过 Kube DNS 监听 Service 与 Endpoint 变化,来提供给 Sky DNS 信息,已更新解析地址。

安装只需要在master通过 kubectl 来创建 kube-dns deployment 即可:

$ export ADDON_URL="https://kairen.github.io/files/manual-v1.8/addon" $ wget "${ADDON_URL}/kube-dns.yml.conf" -O kube-dns.yml $ kubectl apply -f kube-dns.yml $ kubectl -n kube-system get po -l k8s-app=kube-dns
NAME READY STATUS RESTARTS AGE
kube-dns-6cb549f55f-h4zr5 0/3 Pending 0 40s

部署

k8s可以通过指令直接创建应用程序和服务,也可以通过YAML或JSON档案来描述部署应用程序的配置。

以下将创建一个简单的 Nginx 服务:

$ kubectl run nginx --image=nginx --port=80 $ kubectl expose deploy nginx --port=80 --type=LoadBalancer --external-ip=192.168.0.102 $ kubectl get svc,po
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
svc/kubernetes ClusterIP 10.96.0.1 <none> 443/TCP 1h
svc/nginx LoadBalancer 10.97.121.243 192.168.0.102 80:30344/TCP 22s

NAME READY STATUS RESTARTS AGE
po/nginx-7cbc4b4d9c-7796l 1/1 Running 0 28s 192.160.57.181 ,192.168.0.102 80:32054/TCP 21s

这边type可以选择 NodePort 与 LoadBalancer,在本地裸机部署,两者差异在于NodePort只映射 Host port 到 Container port,而LoadBalancer则继承NodePort额外多出映射 Host target port 到 Container port。

若集群node节点增加了,而想让 Nginx 服务提供可靠性的话,可以通过以下方式来扩展服务的副本:

$ kubectl scale deploy nginx --replicas=2
本文转移开源中国- k8s手工安装
相关实践学习
容器服务Serverless版ACK Serverless 快速入门:在线魔方应用部署和监控
通过本实验,您将了解到容器服务Serverless版ACK Serverless 的基本产品能力,即可以实现快速部署一个在线魔方应用,并借助阿里云容器服务成熟的产品生态,实现在线应用的企业级监控,提升应用稳定性。
云原生实践公开课
课程大纲 开篇:如何学习并实践云原生技术 基础篇: 5 步上手 Kubernetes 进阶篇:生产环境下的 K8s 实践 相关的阿里云产品:容器服务&nbsp;ACK 容器服务&nbsp;Kubernetes&nbsp;版(简称&nbsp;ACK)提供高性能可伸缩的容器应用管理能力,支持企业级容器化应用的全生命周期管理。整合阿里云虚拟化、存储、网络和安全能力,打造云端最佳容器化应用运行环境。 了解产品详情:&nbsp;https://www.aliyun.com/product/kubernetes
相关文章
|
8天前
|
Kubernetes 数据安全/隐私保护 Docker
|
8天前
|
Kubernetes Linux 网络安全
kubeadm安装k8s
该文档提供了一套在CentOS 7.6上安装Docker和Kubernetes(kubeadm)的详细步骤,包括安装系统必备软件、关闭防火墙和SELinux、禁用swap、开启IP转发、设置内核参数、配置Docker源和加速器、安装指定版本Docker、启动Docker、设置kubelet开机启动、安装kubelet、kubeadm、kubectl、下载和配置Kubernetes镜像、初始化kubeadm、创建kubeconfig文件、获取节点加入集群命令、下载Calico YAML文件以及安装Calico。这些步骤不仅适用于v1.19.14,也适用于更高版本。
102 1
|
8天前
|
Kubernetes 容器
安装ipvsadm并且k8s开启IPVS模式
安装ipvsadm并且k8s开启IPVS模式
16 0
|
8天前
|
Kubernetes Linux Docker
kubeadm安装Kubernetes
kubeadm安装Kubernetes
38 0
|
8天前
|
Kubernetes 关系型数据库 Linux
linux安装centos7 kubenetes 单机版安装k8s
linux安装centos7 kubenetes 单机版安装k8s
53 0
|
8天前
|
Kubernetes 测试技术 API
ChaosBlade常见问题之安装K8S探针心跳检测失败如何解决
ChaosBlade 是一个开源的混沌工程实验工具,旨在通过模拟各种常见的硬件、软件、网络、应用等故障,帮助开发者在测试环境中验证系统的容错和自动恢复能力。以下是关于ChaosBlade的一些常见问题合集:
35 0
|
8天前
|
Kubernetes 应用服务中间件 nginx
Kubernetes服务网络Ingress网络模型分析、安装和高级用法
Kubernetes服务网络Ingress网络模型分析、安装和高级用法
54 5
|
8天前
|
存储 Kubernetes 监控
KubeSphere平台安装系列之一【Kubernetes上安装KubeSphere(亲测--实操完整版)】(1/3)
KubeSphere平台安装系列之一【Kubernetes上安装KubeSphere(亲测--实操完整版)】(1/3)
45 0
|
8天前
|
存储 Kubernetes 监控
K8S集群上安装KubeSphere的详细过程
K8S集群上安装KubeSphere的详细过程
46 0
|
8天前
|
Kubernetes Linux Docker
深度解析:Kubernetes 1.28.2集群安装过程中的关键步骤
本文旨在为读者提供一份详尽的Kubernetes 1.28.2集群安装指南,帮助您从零开始构建稳定、高效的Kubernetes集群。我们将从环境准备、软件安装、集群初始化到节点添加等各个环节进行逐步讲解,确保您能够顺利完成集群的搭建。

推荐镜像

更多