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}')
Logo

K8S/Kubernetes社区为您提供最前沿的新闻资讯和知识内容

更多推荐