Kubernetes集群部署及日常使用方式、常用命令

Kubeasz项目极大地简化了k8s集群的安装过程

项目地址：https://github.com/easzlab/kubeasz

有两个离线安装文件：ansible和easzup

将ansible目录上传到/etc/目录下
将easzup上传到/root目录下

安装k8s

环境为：CentOS7虚拟机

在线下载easzup，如果已经下载了离线包：easzup，则忽略此步骤

export release=2.2.0
curl -C- -fLO --retry 3 https://github.com/easzlab/kubeasz/releases/download/${release}/easzup

安装过程：

在主机上安装

#赋予执行权限
chmod +x ./easzup

#这个命令会自动下载ansible文件并执行配置
#文件默认下载位置：/etc/ansible
#如果已经把离线文件拷到etc中，则会直接执行配置docker
./easzup -D

#启动kubeasz工具使用的临时容器
./easzup -S

#进入该容器
docker exec -it kubeasz sh

#下面命令在容器内执行
#配置离线安装
cd /etc/ansible
sed -i 's/^INSTALL_SOURCE.*$/INSTALL_SOURCE: "offline"/g' roles/chrony/defaults/main.yml
sed -i 's/^INSTALL_SOURCE.*$/INSTALL_SOURCE: "offline"/g' roles/ex-lb/defaults/main.yml
sed -i 's/^INSTALL_SOURCE.*$/INSTALL_SOURCE: "offline"/g' roles/kube-node/defaults/main.yml
sed -i 's/^INSTALL_SOURCE.*$/INSTALL_SOURCE: "offline"/g' roles/prepare/defaults/main.yml
exit

#由于安装需要Python环境，所以需要安装一下Python,已安装则忽略这一步
yum install python -y

到此位置，该主机上的k8s就已经安装完成了，下面是集群的配置

工作节点的准备

需要另外准备从机，此处建立两台工作节点（从主机拷贝，工作节点也需要安装k8s）

目标是配置：一台master，另外两台作为工作节点

Master单独配置

在master继续配置单独的环境：

这步可以忽略：（目前测试执行了这一步安装会出错）

# 安装pip,已安装则忽略这一步
wget -O /etc/yum.repos.d/epel-7.repo https://mirrors.aliyun.com/repo/epel-7.repo
yum install git python-pip -y

# pip安装ansible(国内如果安装太慢可以直接用pip阿里云加速),已安装则忽略这一步
pip install pip --upgrade -i https://mirrors.aliyun.com/pypi/simple/
pip install ansible==2.6.12 netaddr==0.7.19 -i https://mirrors.aliyun.com/pypi/simple/

# 在ansible控制端配置免密码登陆其他节点服务器
ssh-keygen -t ed25519 -N '' -f ~/.ssh/id_ed25519

# 公钥复制到所有节点,包括master自己
# 按提示输入yes和root管理员的密码
ssh-copy-id 192.168.64.191
ssh-copy-id 192.168.64.192
ssh-copy-id 192.168.64.193

配置集群服务器的IP

cd /etc/ansible && cp example/hosts.multi-node hosts && vim hosts

这里是配置k8s集群的hosts关键配置

[etcd]
192.168.64.191 NODE_NAME=etcd1
192.168.64.192 NODE_NAME=etcd2
192.168.64.193 NODE_NAME=etcd3

# master node(s)
[kube-master]
192.168.64.191

# work node(s)
[kube-node]
192.168.64.192
192.168.64.193

这配置3台服务器的配置写法，如果服务器较差，可以配置2台

[etcd]
192.168.64.191 NODE_NAME=etcd1

# master node(s)
[kube-master]
192.168.64.191

# work node(s)
[kube-node]
192.168.64.191
192.168.64.192

这里可以减少etcd服务数量，这里的master可以当做工作节点使用

这里的配置完成后，记得做一次心跳检测，检测集群状态

# 检查集群状态
ansible all -m ping

集群没问题的时候，就可以执行集群配置了

cd /etc/ansible
ansible-playbook 90.setup.yml

这个步骤耗时较长，请耐心等待

为kubectl命令设置别名

# 设置 kubectl 命令别名 k
echo "alias k='kubectl'" >> ~/.bashrc

# 使设置生效
source ~/.bashrc

以后输入命令的时候只需要输入k即可代替kubectl

安装完成后，需要验证一下

k get cs 

k get node

k8s的启动命令

k run \
    --image=luksa/kubia \
    --port=8080 \
    --generator=run/v1 kubia

–image：指定镜像名，镜像名可以用docker images查看

–port：指定对外开放端口

----generator：创建一个ReplicationController

但是，实际上我们很少用命令直接启动，而是通过yml文件来启动

k8s的pod自动伸缩

通过ReplicationController修改pod数量

# 将pod数量增加到3个
k scale rc kubia --replicas=3
# 将pod数量减少到1个
k scale rc kubia --replicas=1

常用命令（重要）

# 可以查看pods详细信息，包括开放的端口，内部外部IP等信息
k get po -o wide

# 查看pods简单信息
k get po

# 查看pods的标签信息
k get po --show-labels

# 通过标签筛选pods
k get po -l manual=prod
k get po -l manual
k get po -l creation_method=manual
k get po -l '!creation_method' #查询不存在 creation_method 标签的 pod
k get po -l env in (prod,debug) #查询env为prod或者debug

# 覆盖pods已存在的标签
k label po kubia-manual-v2 env=debug --overwrite

# 为pods增加新的标签
k label po kubia-manual creation_method=manual env=debug
k label po kubia-5rz9h env=debug

# 查看ReplicationController内容
k get rc

# 查看ReplicationSet内容
k get rs

# 查看Service内容
k get svc

# 查看所有EndPoint
k get ep

# 查看持久卷
k get pv

# 查看持久卷声明
k get pvc

# 查看ConfigMap
k get cm

# 查看容器描述（包括重启次数，探针等信息）
k describe po kubia-gpu

# 为容器添加注解（可以在描述中查看，并没有其他作用）
k annotate pod kubia-manual tedu.cn/shuoming="foo bar"

# 从内部网络访问全限定类名（只能访问内部网络）
curl http://10.68.163.98

# 进入容器，并执行命令
k exec kubia-k66lz env #进入容器并查看环境变量

通过部署文件部署（重要）

以后部署基本都通过部署文件进行部署，这部分很重要

部署pod

cat <<EOF > kubia-manual.yml 
apiVersion: v1               # k8s api版本
kind: Pod                    # 该部署文件用来创建pod资源
metadata:                    # 头信息
  name: kubia-manual         # pod名称前缀,后面会追加随机字符串
spec:
  containers:                # 对pod中容器的配置
  - image: luksa/kubia       # 镜像名
    name: kubia              # 容器名
    ports:
    - containerPort: 8080    # 容器暴露的端口
      protocol: TCP
EOF

在当前目录下会创建kubia-manual.yml文件，并按照文件中的信息部署

执行部署：

k create -f kubia-manual.yml

部署完成后可以通过k get po查看部署信息

通过已部署的pod查看部署文件

# 查看pod的部署文件
k get po kubia-manual -o yaml

查看pod日志（重要）

这个命令可以查看容器中程序运行情况，报错信息等

k logs kubia-manual

pod端口转发（命令形式）

端口转发形式我们一般通过service进行转发，很少用这个命令

# 使用服务器的 8888 端口,映射到 pod 的 8080 端口
k port-forward kubia-manual --address localhost,192.168.64.191 8888:8080

# 或在所有网卡上暴露8888端口
k port-forward kubia-manual --address 0.0.0.0 8888:8080

pod标签（重要）

在pod管理中，我们一般只能通过标签来进行pod选择，所以为每个pod指定合适的标签就显得非常重要

cat <<EOF > kubia-manual-with-labels.yml
apiVersion: v1                  # api版本
kind: Pod                       # 部署的资源类型
metadata:
  name: kubia-manual-v2         # pod名
  labels:                       # 标签设置,键值对形式
    creation_method: manual     
    env: prod
spec:
  containers:                   # 容器设置
  - image: luksa/kubia          # 镜像
    name: kubia                 # 容器命名
    ports:                      # 容器暴露的端口
    - containerPort: 8080
      protocol: TCP
EOF

这个pod创建出来就会得到一个 manual=prod的标签

创建yml文件后使用create命令进行创建

把pod部署到指定的节点服务器

我们不能直接指定服务器的ip去部署，需要为node设置标签，通过节点选择器去实现

# 为节点贴上标签
k label node \
    192.168.64.193 \
    gpu=true

cat <<EOF > kubia-gpu.yml
apiVersion: v1
kind: Pod
metadata:
  name: kubia-gpu          # pod名
spec:
  nodeSelector:            # 节点选择器,把pod部署到匹配的节点
    gpu: "true"            # 通过标签 gpu=true 来选择匹配的节点
  containers:              # 容器配置
  - image: luksa/kubia     # 镜像
    name: kubia            # 容器名
EOF

命名空间

cat <<EOF > custom-namespace.yml
apiVersion: v1
kind: Namespace
metadata:
  name: custom-namespace
EOF

# 创建命名空间
k create -f custom-namespace.yml 

k get ns
--------------------------------
NAME               STATUS   AGE
custom-namespace   Active   2s
default            Active   6d
kube-node-lease    Active   6d
kube-public        Active   6d
kube-system        Active   6d

将pod部署到指定命名空间中

# 创建 Pod 时指定命名空间
k create \
    -f kubia-manual.yml \
    -n custom-namespace

# 默认访问default命名空间,默认命名空间中不存在pod kubia-manual
k get po kubia-manual

# 访问custom-namespace命名空间中的pod
k get po kubia-manual -n custom-namespace
----------------------------------------------------------
NAME           READY   STATUS              RESTARTS   AGE
kubia-manual   0/1     ContainerCreating   0          59s

删除资源（重要）

你总得删点什么

# 按名称删除, 可以指定多个名称
# 例如: k delete po po1 po2 po3
k delete po kubia-gpu

# 按标签删除
k delete po -l creation_method=manual

# 删除命名空间和其中所有的pod
k delete ns custom-namespace

# 删除当前命名空间中所有pod
k delete po --all

# 由于有ReplicationController,所以会自动创建新的pod
[root@master1 ~]# k get po
NAME          READY   STATUS    RESTARTS   AGE
kubia-m6k4d   1/1     Running   0          2m20s
kubia-rkm58   1/1     Running   0          2m15s
kubia-v4cmh   1/1     Running   0          2m15s

# 删除工作空间中所有类型中的所有资源
# 这个操作会删除一个系统Service kubernetes,它被删除后会立即被自动重建
k delete all --all

存活探针

存活探针的作用是帮助我们在服务出错的时候自动重启服务

有三种存活探针:

• HTTP GET

  返回 2xx 或 3xx 响应码则认为探测成功

• TCP

  与指定端口建立 TCP 连接,连接成功则为成功

• Exec

  在容器内执行任意的指定命令,并检查命令的退出码,退出码为0则为探测成功

HTTP GET 存活探针

探针默认每10秒探测一次,连续三次探测失败后重启容器

在创建容器的时候需要指定探针

cat <<EOF > kubia-liveness-probe.yml
apiVersion: v1
kind: Pod
metadata:
  name: kubia-liveness               # pod名称
spec:
  containers:
  - image: luksa/kubia-unhealthy     # 镜像
    name: kubia                      # 容器名
    livenessProbe:                   # 存活探针配置
      httpGet:                       # HTTP GET 类型的存活探针
        path: /                      # 探测路径
        port: 8080                   # 探测端口
EOF

可以加入Delay，避免在容器启动过程中自动重启

cat <<EOF > kubia-liveness-probe-initial-delay.yml
apiVersion: v1
kind: Pod
metadata:
  name: kubia-liveness
spec:
  containers:
  - image: luksa/kubia-unhealthy
    name: kubia
    livenessProbe:
      httpGet:
        path: /
        port: 8080
      initialDelaySeconds: 15        # 第一次探测的延迟时间
EOF

控制器（非常重要）

控制器可以自动维护pods，实现自动扩容和缩容，当一个pod宕机的时候可以自动关闭pod并启动一个新的pod

ReplicationController（已经被淘汰）

cat <<EOF > kubia-rc.yml
apiVersion: v1
kind: ReplicationController        # 资源类型
metadata:   
  name: kubia                      # 为RC命名
spec:
  replicas: 3                      # pod副本的数量
  selector:                        # 选择器,用来选择RC管理的pod
    app: kubia                     # 选择标签'app=kubia'的pod,由当前RC进行管理
  template:                        # pod模板,用来创建新的pod
    metadata:
      labels:
        app: kubia                 # 指定pod的标签
    spec:
      containers:                  # 容器配置
      - name: kubia                # 容器名
        image: luksa/kubia         # 镜像
        ports:
        - containerPort: 8080      # 容器暴露的端口
EOF

写好配置文件后，也是通过以下命令启动rc

k create -f kubia-rc.yml

如果改变了pod的标签：app=kubia，则会使该容器脱离RC的控制，RC会自动再起一个新的容器

当RC的yml文件被修改时，只需要删除原来的容器，新创建的容器就会按照新的yml文件配置

ReplicaSet（重要）

RS相比RC来说，可以使用更强大的标签选择器

cat <<EOF > kubia-replicaset.yml
apiVersion: apps/v1
kind: ReplicaSet
metadata:
  name: kubia
spec:
  replicas: 4
  selector:
    matchExpressions:       # 表达式匹配选择器
      - key: app            # label 名是 app
        operator: In        # in 运算符
        values:             # label 值列表
          - kubia
          - foo
  template:
    metadata:
      labels:
        app: kubia
    spec:
      containers:
      - name: kubia
        image: luksa/kubia
EOF

可使用的运算符:

• In: label与其中一个值匹配
• NotIn: label与任何一个值都不匹配
• Exists: 包含指定label名称(值任意)
• DoesNotExists: 不包含指定的label

DaemonSet

在每个节点上运行一个pod，可以做监控等

也可以通过节点上的标签来选择节点部署

当该DaemonSet执行的时候，如果我们给新的节点添加了标签，则它会立即在新的节点上创建pod

cat <<EOF > ssd-monitor-daemonset.yml
apiVersion: apps/v1
kind: DaemonSet                       
metadata:
  name: ssd-monitor                   
spec:
  selector:
    matchLabels:                      
      app: ssd-monitor                
  template:
    metadata:
      labels:
        app: ssd-monitor              
    spec:
      nodeSelector:                   # 节点选择器
        disk: ssd                     # 选择的节点上具有标签: 'disk=ssd'
      containers:                     
        - name: main                  
          image: luksa/ssd-monitor   
EOF

Job

Job时用来运行一次性的任务，pod结束后就不再重启了

cat <<EOF > exporter.yml
apiVersion: batch/v1                 # Job资源在batch/v1版本中提供
kind: Job                            # 资源类型
metadata: 
  name: batch-job                    # 资源命名
spec:
  template: 
    metadata:
      labels:
        app: batch-job               # pod容器标签
    spec:
      restartPolicy: OnFailure       # 任务失败时重启
      containers:
        - name: main                 # 容器名
          image: luksa/batch-job     # 镜像
EOF

可以在spec下加入completions: 5，指定完整的数量

Cronjob

定时和重复执行的任务

cat <<EOF > cronjob.yml
apiVersion: batch/v1beta1                # api版本
kind: CronJob                            # 资源类型
metadata:
  name: batch-job-every-fifteen-minutes
spec:
  # 0,15,30,45  - 分钟
  # 第一个*  -  每个小时
  # 第二个*  -  每月的每一天
  # 第三个*  -  每月
  # 第四个*  -  每一周中的每一天
  schedule: "0,15,30,45 * * * *"
  jobTemplate:
    spec:
      template:
        metadata:
          labels:
            app: periodic-batch-job
        spec:
          restartPolicy: OnFailure
          containers: 
          - name: main
            image: luksa/batch-job
EOF

Service(非常重要)

Service可以为pod提供一个不变的接入地址，pods重启，新增等均不会影响外部访问

cat <<EOF > kubia-svc.yml
apiVersion: v1
kind: Service                # 资源类型
metadata:
  name: kubia                # 资源命名
spec:
  type: NodePort           # 在每个节点上开放访问端口
  ports:
  - port: 80                 # 集群内部访问的端口
    targetPort: 8080         # 容器的端口
    nodePort: 30123        # 外部访问端口
  selector:
    app: kubia               # 通过标签,选择名为kubia的所有pod
EOF

如果需要为每个IP指定会话亲和性（固定IP访问固定pod）

可以在spec下加入：sessionAffinity: ClientIP

EndPoint

endpoint是在Service和pod之间的一种资源

一个endpoint资源,包含一组pod的地址列表

我们可以通过describe查看svc的endpoint

注意，如果svc下没有pod，就不会创建EndPoint

我们可以为一个svc指定EndPoint

cat <<EOF > external-service-endpoints.yml
apiVersion: v1
kind: Endpoints                 # 资源类型
metadata:
  name: external-service        # 名称要与Service名相匹配
subsets:
- addresses:                    # 包含的地址列表
  - ip: 120.52.99.224           # 中国联通的ip地址
  - ip: 117.136.190.162         # 中国移动的ip地址
  ports:
  - port: 80                    # 目标服务的的端口
EOF

当我们访问该svc的时候，会访问中国联通和移动的ip

查看EP可以通过

k get ep [service]

磁盘挂载到容器卷（重要）

卷的类型:

• emptyDir: 简单的空目录
• hostPath: 工作节点中的磁盘路径
• gitRepo: 从git克隆的本地仓库
• nfs: nfs共享文件系统

下面是一个简单的空目录挂载实例

cat <<EOF > fortune-pod.yml
apiVersion: v1
kind: Pod
metadata:
  name: fortune
  labels:
    app: fortune
spec:
  containers:
  - image: luksa/fortune                 # 镜像名
    name: html-genrator                  # 容器名
    volumeMounts:
    - name: html                         # 卷名为 html
      mountPath: /var/htdocs             # 容器中的挂载路径
  - image: nginx:alpine                  # 第二个镜像名
    name: web-server                     # 第二个容器名
    volumeMounts:
    - name: html                         # 相同的卷 html
      mountPath: /usr/share/nginx/html   # 在第二个容器中的挂载路径
      readOnly: true                     # 设置为只读
    ports:
    - containerPort: 80
      protocol: TCP
  volumes:                               # 卷
  - name: html                           # 为卷命名
    emptyDir: {}                         # emptyDir类型的卷
EOF

下面是主要使用的EFS文件挂载系统

持久卷

需要在master上先准备一个文件夹，并允许 192.168.64 网段的主机共享访问这个目录

# 创建文件夹
mkdir /etc/nfs_data

# 在exports文件夹中写入配置
# no_root_squash: 服务器端使用root权限
cat <<EOF > /etc/exports
/etc/nfs_data    192.168.64.0/24(rw,async,no_root_squash)
EOF

systemctl enable nfs
systemctl enable rpcbind
systemctl start nfs
systemctl start rpcbind

下面在客户机（192.168.64.192）上挂载远程nfs目录

# 新建挂载目录
mkdir /etc/web_dir/

# 在客户端, 挂载服务器的 nfs 目录
mount -t nfs 192.168.64.191:/etc/nfs_data /etc/web_dir/

在客户机上创建PersistentVolume

cat <<EOF > mongodb-pv.yml
apiVersion: v1
kind: PersistentVolume
metadata: 
  name: mongodb-pv
spec:
  capacity:
    storage: 1Gi                    # 定义持久卷大小
  accessModes:
    - ReadWriteOnce                 # 只允许被一个客户端挂载为读写模式
    - ReadOnlyMany                  # 可以被多个客户端挂载为只读模式
  persistentVolumeReclaimPolicy: Retain   # 当声明被释放,持久卷将被保留
  nfs:                              # nfs远程目录定义
    path: /etc/nfs_data
    server: 192.168.64.191
EOF

持久卷声明

主要是为了和底层数据层解耦

cat <<EOF > mongodb-pvc.yml
apiVersion: v1
kind: PersistentVolumeClaim
metadata: 
  name: mongodb-pvc
spec:
  resources:
    requests:
      storage: 1Gi           # 申请1GiB存储空间
  accessModes:
    - ReadWriteOnce          # 允许单个客户端读写
  storageClassName: ""       # 参考动态配置章节
EOF

cat <<EOF > mongodb-pod-pvc.yml
apiVersion: v1
kind: Pod
metadata:
  name: mongodb
spec:
  containers:
  - image: mongo
    name: mongodb
    securityContext:
      runAsUser: 0
    volumeMounts:
    - name: mongodb-data
      mountPath: /data/db
    ports:
    - containerPort: 27017
      protocol: TCP
  volumes:
  - name: mongodb-data
    persistentVolumeClaim:
      claimName: mongodb-pvc     # 引用之前创建的"持久卷声明"
EOF

Docker的启动参数（重要）

Dockerfile中定义命令和参数的指令

• ENTRYPOINT 启动容器时,在容器内执行的命令
• CMD 对启动命令传递的参数

CMD可以在docker run命令中进行覆盖

......
ENTRYPOINT ["java", "-jar", "/opt/sp05-eureka-0.0.1-SNAPSHOT.jar"]
CMD ["--spring.profiles.active=eureka1"]

#docker启动时覆盖命令（命令行形式）
docker run <image> --spring.profiles.active=eureka2

也可以通过yml文件中的args来覆盖docker的cmd

cat <<EOF > fortune-pod-args.yml
apiVersion: v1
kind: Pod
metadata:
  name: fortune
  labels:
    app: fortune
spec:
  containers:
  - image: luksa/fortune:args
    args: ["2"]                  # docker镜像中配置的CMD是10,这里用args把这个值覆盖成2
    name: html-genrator
    volumeMounts:
    - name: html
      mountPath: /var/htdocs

  - image: nginx:alpine
    name: web-server
    volumeMounts:
    - name: html
      mountPath: /usr/share/nginx/html
      readOnly: true
    ports:
    - containerPort: 80
      protocol: TCP

  volumes:
  - name: html
    emptyDir: {}
EOF

也可以在yml文件的env中指定环境变量

cat <<EOF > fortune-pod-env.yml
apiVersion: v1
kind: Pod
metadata:
  name: fortune
  labels:
    app: fortune
spec:
  containers:
  - image: luksa/fortune:env
    env:                        # 设置环境变量 INTERVAL=5
    - name: INTERVAL
      value: "5"
    name: html-genrator
    volumeMounts:
    - name: html
      mountPath: /var/htdocs
  - image: nginx:alpine
    name: web-server
    volumeMounts:
    - name: html
      mountPath: /usr/share/nginx/html
      readOnly: true
    ports:
    - containerPort: 80
      protocol: TCP
  volumes:
  - name: html
    emptyDir: {}
EOF

ConfigMap（重要）

通过ConfigMap资源,可以从pod中把环境变量配置分离出来,是环境变量配置与pod解耦

命令行形式：

# 直接命令行创建
k create configmap fortune-config --from-literal=sleep-interval=20

yml形式：

# 或从文件创建
cat <<EOF > fortune-config.yml
apiVersion: v1
kind: ConfigMap
metadata:
  name: fortune-config
data:
  sleep-interval: "10"
EOF

在启动ConfigMap后，在需要使用该ConfigMap的pod中都需要配置

cat <<EOF > fortune-pod-env-configmap.yml
apiVersion: v1
kind: Pod
metadata:
  name: fortune
  labels:
    app: fortune
spec:
  containers:
  - image: luksa/fortune:env
    env:
    - name: INTERVAL              # 环境变量名
      valueFrom:
        configMapKeyRef:          # 环境变量的值从ConfigMap获取
          name: fortune-config    # 使用的ConfigMap名称
          key: sleep-interval     # 用指定的键从ConfigMap取数据
    name: html-genrator
    volumeMounts:
    - name: html
      mountPath: /var/htdocs
  - image: nginx:alpine
    name: web-server
    volumeMounts:
    - name: html
      mountPath: /usr/share/nginx/html
      readOnly: true
    ports:
    - containerPort: 80
      protocol: TCP
  volumes:
  - name: html
    emptyDir: {}
EOF

从磁盘创建ConfigMap

先创建一个文件夹：configmap-files，存放配置文件

cat <<EOF > my-nginx-config.conf
server {
    listen           80;
    server_name      www.kubia-example.com;
    
    gzip             on;
    gzip_types       text/plain application/xml;
    
    location / {
        root         /ur/share/nginx/html;
        index        index.html index.htm;
    }
}
EOF

cat <<EOF > sleep-interval
25
EOF

然后从这两个文件创建ConfigMap

k create configmap fortune-config \
--from-file=configmap-files 

Deployment（重要）

Deployment主要用于资源的部署或者升级

Deployment可以在应用滚动升级过程中, 引入另一个RepliaSet, 并协调两个ReplicaSet.

结构是：Deployment–>ReplicaSet–>pod

rs 和 pod 名称中的数字,是 pod 模板的哈希值

cat <<EOF > kubia-deployment-v3-with-readinesscheck.yml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: kubia
spec:
  replicas: 3
  selector: 
    matchLabels:
      app: kubia
  minReadySeconds: 10
  strategy:
    rollingUpdate:
      maxSurge: 1			#默认为25%允许超出的pod数量，这里的1表示如果部署4个应用，如果部署出错，也最多只会出现5个应用
      maxUnavailable: 0		#默认为25%，允许有多少个pod处于不可用状态，如果为1，部署了4个应用，如果有1个不可用，则不操作，如果2个不可用，则会起新的应用
    type: RollingUpdate
  template:
    metadata:
      name: kubia
      labels:
        app: kubia
    spec:
      containers:
      - image: luksa/kubia:v3
        name: nodejs
        readinessProbe:		#就绪探针
          periodSeconds: 1	#时间间隔设置为1秒
          httpGet:
            path: /
            port: 8080
EOF

Deployment的升级策略

• 滚动升级 Rolling Update - 渐进的删除旧的pod, 同时创建新的pod, 这是默认的升级策略
• 重建 Recreate - 一次删除所有旧的pod, 再重新创建新的pod

回滚Deployment

k rollout undo deploy kubia

暂停

# 暂停
k rollout pause deploy kubia
# 继续
k rollout resume deploy kubia

Dashboard

查看Dashboard

# 查看pod
k get pod -n kube-system | grep dashboard

# 查看service
k get svc -n kube-system | grep dashboard

# 查看集群信息
k cluster-info | grep dashboard

这里就可以得到Dashboard的访问地址

由于安全策略，我们需要CA证书

cd /etc/kubernetes/ssl

# 导出证书文件
openssl pkcs12 -export -in admin.pem -inkey admin-key.pem -out kube-admin.p12

这里的安全证书需要设置一个密码

导入证书后，登录仪表盘网址，选择令牌登录

获取令牌：

# 创建Service Account 和 ClusterRoleBinding
k apply -f /etc/ansible/manifests/dashboard/admin-user-sa-rbac.yaml

# 获取 Bearer Token，复制输出中 ‘token:’ 开头那一行
k -n kube-system describe secret $(kubectl -n kube-system get secret | grep admin-user | awk '{print $1}')