k8s的部署及入门-526互联

lucykubeadm是官方社区推出的一个用于快速部署kubernetes集群的工具。

这个工具能通过两条指令完成一个kubernetes集群的部署：

1. 安装要求

在开始之前，部署Kubernetes集群机器需要满足以下几个条件：

一台或多台机器，操作系统 CentOS7.x-86_x64
硬件配置：2GB或更多RAM，2个CPU或更多CPU，硬盘30GB或更多
可以访问外网，需要拉取镜像，如果服务器不能上网，需要提前下载镜像并导入节点
禁止swap分区

2. 准备环境

角色	IP
master	192.158.195.193
node1	192.158.195.198
node2	192.158.195.199

# 关闭防火墙
systemctl stop firewalld
systemctl disable firewalld

# 每个节点分别设置对应主机名

hostnamectl set-hostname master
hostnamectl set-hostname node1
hostnamectl set-hostname node2

# 所有节点都修改 hosts
vim /etc/hosts
192.158.195.193 master
192.158.195.198 node1
192.158.195.199 node1

# 所有节点关闭 SELinux
setenforce 0
sed -i --follow-symlinks 's/SELINUX=enforcing/SELINUX=disabled/g' /etc/sysconfig/selinux

关闭swap分区:
swapoff -a
修改配置文件 - /etc/fstab
删除 /mnt/swap swap swap defaults 0 0 这一行或者注释掉这一行
确认swap已经关闭
free -m
若都显示 0 则表示关闭成功

# 时间同步
yum install ntpdate -y
ntpdate time.windows.com

3. 所有节点安装Docker/kubeadm/kubelet

Kubernetes默认CRI（容器运行时）为Docker，因此先安装Docker。

3.1 安装Docker

$ wget https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo -O /etc/yum.repos.d/docker-ce.repo
$ yum -y install docker-ce-18.06.1.ce-3.el7
$ systemctl enable docker && systemctl start docker
$ docker --version
Docker version 18.06.1-ce, build e68fc7a

$ cat > /etc/docker/daemon.json << EOF
{
  "registry-mirrors": ["https://b9pmyelo.mirror.aliyuncs.com"],
  "exec-opts": ["native.cgroupdriver=systemd"]
}
EOF

# 重启生效
systemctl daemon-reload
systemctl restart docker

3.2 添加阿里云YUM软件源

cat <<EOF > kubernetes.repo
[kubernetes]
name=Kubernetes
baseurl=https://mirrors.aliyun.com/kubernetes/yum/repos/kubernetes-el7-x86_64
enabled=1
gpgcheck=0
repo_gpgcheck=0
gpgkey=https://mirrors.aliyun.com/kubernetes/yum/doc/yum-key.gpg https://mirrors.aliyun.com/kubernetes/yum/doc/rpm-package-key.gpg
EOF
mv kubernetes.repo /etc/yum.repos.d/

3.3 安装kubeadm，kubelet和kubectl

由于版本更新频繁，这里指定版本号部署：

yum install -y kubelet-1.22.4 kubectl-1.22.4 kubeadm-1.22.4
systemctl enable kubelet
systemctl start kubelet
systemctl enable docker
systemctl start docker

4. 部署Kubernetes Master

在192.168.195.190（Master）执行。

初始化集群控制台 Control plane

失败了可以用 kubeadm reset 重置

kubeadm init --image-repository=registry.aliyuncs.com/google_containers --apiserver-advertise-address=192.168.195.193 --kubernetes-version v1.22.4 --service-cidr=10.96.0.0/12 --pod-network-cidr=10.244.0.0/16 --ignore-preflight-errors=all


或者直接
kubeadm init --image-repository=registry.aliyuncs.com/google_containers也可以，其他值是有默认值
 参数说明
--apiserver-advertise-address=192.168.195.190   这个参数就是master主机的IP地址，例如我的Master主机的IP是：192.168.181.131

--image-repository=registry.aliyuncs.com/google_containers  这个是镜像地址，由于国外地址无法访问，故使用的阿里云仓库地址：registry.aliyuncs.com/google_containers

--kubernetes-version=v1.22.4   这个参数是下载的k8s软件版本号

--service-cidr=10.96.0.0/12       这个参数后的IP地址直接就套用10.96.0.0/12 ,以后安装时也套用即可，不要更改

--pod-network-cidr=10.244.0.0/16       k8s内部的pod节点之间网络可以使用的IP段，不能和service-cidr写一样，如果不知道怎么配，就先用这个10.244.0.0/16

总之，粉色区不做任何更改，只修改红色区的两个地方(master主机IP，k8s软件版本)


kubeadm join 192.168.195.190:6443 --token zwqlu7.4tq40kkcmph1phwt --discovery-token-ca-cert-hash sha256:8410fdd6d9e77856345240d9e9eafc754248f3913be79753610ade39cfd44445

这边如果初始化失败，第一时间应该考虑docker的版本问题，因为k8s和docker是有版本依赖关系的

查看当前支持的版本：yum list docker-ce --showduplicates | sort -r

降低到当前支持的最高版本：yum downgrade --setopt=obsoletes=0 -y docker-ce-18.09.9-3.el7 docker-ce-cli-18.09.9-3.el7 containerd.io

由于默认拉取镜像地址k8s.gcr.io国内无法访问，这里指定阿里云镜像仓库地址。

使用kubectl工具：

mkdir -p $HOME/.kube
sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
sudo chown $(id -u):$(id -g) $HOME/.kube/config
kubectl get nodes

5. 加入Kubernetes Node

在192.168.1.12/13（Node）执行。

向集群添加新节点，执行在kubeadm init输出的kubeadm join命令：

kubeadm join 192.168.1.11:6443 --token esce21.q6hetwm8si29qxwn \
    --discovery-token-ca-cert-hash sha256:00603a05805807501d7181c3d60b478788408cfe6cedefedb1f97569708be9c5

默认token有效期为24小时，当过期之后，该token就不可用了。这时就需要重新创建token，操作如下：

kubeadm token create --print-join-command

6. 部署CNI网络插件

wget https://raw.githubusercontent.com/coreos/flannel/master/Documentation/kube-flannel.yml

默认镜像地址无法访问，sed命令修改为docker hub镜像仓库。

kubectl apply -f https://raw.githubusercontent.com/coreos/flannel/master/Documentation/kube-flannel.yml

kubectl get pods -n kube-system
NAME                          READY   STATUS    RESTARTS   AGE
kube-flannel-ds-amd64-2pc95   1/1     Running   0          72s

7. 测试kubernetes集群

在Kubernetes集群中创建一个pod，验证是否正常运行：

 kubectl create deployment nginx --image=nginx
 kubectl expose deployment nginx --port=80 --type=NodePort
 kubectl get pod,svc

访问地址：http://NodeIP:Port

二、安装Kuboard图形化界面

2.1 安装方式一：

kubectl apply -f https://kuboard.cn/install-script/kuboard.yaml

2.2 安装方式二：

准备kuboard.yaml文件
以下只有一个地方需要更改，就是需要根据实际情况更改，为主机节点名称
vim kuboard-offline.yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: kuboard
  namespace: kube-system
  annotations:
    k8s.kuboard.cn/displayName: kuboard
    k8s.kuboard.cn/ingress: "true"
    k8s.kuboard.cn/service: NodePort
    k8s.kuboard.cn/workload: kuboard
  labels:
    k8s.kuboard.cn/layer: monitor
    k8s.kuboard.cn/name: kuboard
spec:
  replicas: 1
  selector:
    matchLabels:
      k8s.kuboard.cn/layer: monitor
      k8s.kuboard.cn/name: kuboard
  template:
    metadata:
      labels:
        k8s.kuboard.cn/layer: monitor
        k8s.kuboard.cn/name: kuboard
    spec:
      nodeName: k8s-master  # ----------------------------------需要根据实际情况更改，为主机节点名称
      containers:
      - name: kuboard
        image: eipwork/kuboard:latest
        imagePullPolicy: IfNotPresent
      tolerations:
      - key: node-role.kubernetes.io/master
        effect: NoSchedule

---
apiVersion: v1
kind: Service
metadata:
  name: kuboard
  namespace: kube-system
spec:
  type: NodePort
  ports:
  - name: http
    port: 80
    targetPort: 80
    nodePort: 32567
  selector:
    k8s.kuboard.cn/layer: monitor
    k8s.kuboard.cn/name: kuboard

---
apiVersion: v1
kind: ServiceAccount
metadata:
  name: kuboard-user
  namespace: kube-system

---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: kuboard-user
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: cluster-admin
subjects:
- kind: ServiceAccount
  name: kuboard-user
  namespace: kube-system

---
apiVersion: v1
kind: ServiceAccount
metadata:
  name: kuboard-viewer
  namespace: kube-system

---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: kuboard-viewer
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: view
subjects:
- kind: ServiceAccount
  name: kuboard-viewer
  namespace: kube-system

2.4 执行安装命令
kubectl apply -f kuboard-offline.yaml

三、启动观察

3.1 获取token
echo $(kubectl -n kube-system get secret $(kubectl -n kube-system get secret | grep kuboard-user | awk '{print $1}') -o go-template='{{.data.token}}' | base64 -d)

运行结果

3.2 打开浏览器，享受飞一般的感觉
输入token

三、yaml生成

一、命令式：会直接生成yaml，进行修改就行

案例：

kubectl create deployment web --image=nginx -o yaml --dry-run >m1.yaml

二、使用kubectl get 命令导出yaml文件

四、pod

一、介绍

Pod 是 k8s 系统中可以创建和管理的最小单元，是资源对象模型中由用户创建或部署的最小资源对象模型，也是在 k8s 上运行容器化应用的资源对象，其他的资源对象都是用来支撑或者扩展 Pod 对象功能的，比如控制器对象是用来管控 Pod 对象的，Service 或者 Ingress 资源对象是用来暴露 Pod 引用对象的，PersistentVolume 资源对象是用来为 Pod 提供存储等等，k8s 不会直接处理容器，而是 Pod，Pod 是由一个或多个 container 组成 Pod 是 Kubernetes 的最重要概念，每一个 Pod 都有一个特殊的被称为”根容器“的 Pause 容器。Pause 容器对应的镜像属于 Kubernetes 平台的一部分，除了 Pause 容器，每个 Pod 还包含一个或多个紧密相关的用户业务容器

二、pod的特性

三、pod的实现机制

四、pod的拉去镜像的策略

五、pod的重启策略 restartPolicy

六、pod的资源限制

七、pod的健康检查

八、pod的创建

1、通过yaml命令创建：kubectl apply -f [pod文件名]

2、创建命令：kubectl run [pod名称]--image=[镜像名]:[镜像版本]

3、删除：

（1）kubectl delete pod [pod名]

（2）kubectl delete pods

(3) kubectl delete -f [pod文件名]

九、pod的调度

1、影响的属性

2、节点选择器nodeSelector

给节点打上标签

标签的查询和删除

选择dev作为创建pod的节点

3、节点亲和性调度nodsAffinity

比nodeSelector更加强大

4、反亲和性调度

1、介绍

2、场景

3、具体演示

（1）查看污点情况

（2）为节点添加污点

（3）删除污点

（4）污点容忍

效果：

增加、查询、删除效果

五、contorller

一、介绍

在集群中管理和运行容器的对象

二、deployment

Deployment 是 Kubenetes v1.2 引入的新概念，引入的目的是为了更好的解决 Pod 的编排问题，Deployment 内部使用了 Replica Set 来实现。Deployment 的定义与 Replica Set 的定义很类似，除了 API 声明与 Kind 类型有所区别：

（1）场景

（2）部署

控制器通过标签来确定需要控制的pod，在下面的截图中可以看到，两个选择的标签为相同的

（3）创建服务并运行

image

（4）创建对外发布的文件

（5）发布

（6）查看发布结果

后面通过任何节点的ip都可以访问到此应用了

Welcome to nginx!

（7）修改镜像版本

（8）镜像的应用升级

格式：kubectl set image deployment 【应用名称】【镜像 = 镜像名+版本】

案例：

kubectl set image deployment web nginx=nginx:1.15

查看升级状态

查看历史版本

kubectl rollout history deployment web

还原到上一个版本

kubectl rollout undo deployment web

还原到指定版本

kubectl rollout undo deployment web --to-revision=1

弹性收缩

kubectl scale deployment web --replicas=10

二、Service

1、概念

Service 概述 Service 是 Kubernetes 最核心概念，通过创建 Service,可以为一组具有相同功能的容器应用提供一个统一的入口地址，并且将请求负载分发到后端的各个容器应用上。

2、作用

服务发现：防止pod失联（服务发现）

负载均衡：定义一组pod访问策略（负载均衡）

2、pod与service的关系

通过label和selector标签来建立联系的

3、service的常用类型

（1）ClusterIP:集群内部使用

（2）NodePort:对外访问应用使用

（3）LoadBalancer:对外访问使用，公有云

4、创建service

kubectl expose deployment web --port=80 --type=NodePort --target-port=80 --dry-run -o yaml > service.yaml

5、运行和查询

三、StatefulSet

1、无状态和有状态说明

2、部署有状态服务

apiVersion: v1
kind: Service
metadata:
  name: nginx
  labels:
    app: nginx
spec:
  ports:
  - port: 80
    name: web
  clusterIP: None
  selector:
    app: nginx

---

apiVersion: apps/v1beta1
kind: StatefulSet
metadata:
  name: nginx-statefulset
  namespace: default
spec:
  serviceName: nginx
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:latest
        ports:
        - containerPort: 80

3、部署守护进程DasemonSet

作用，使得每个加入的节点，都会进入到同一个pod中

apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: ds-test 
  labels:
    app: filebeat
spec:
  selector:
    matchLabels:
      app: filebeat
  template:
    metadata:
      labels:
        app: filebeat
    spec:
      containers:
      - name: logs
        image: nginx
        ports:
        - containerPort: 80
        volumeMounts:
        - name: varlog
          mountPath: /tmp/log
      volumes:
      - name: varlog
        hostPath:
          path: /var/log

四、job

1、概念

执行一次任务，执行之后不再执行

2、创建

apiVersion: batch/v1
kind: Job
metadata:
  name: pi
spec:
  template:
    spec:
      containers:
      - name: pi
        image: perl
        command: ["perl",  "-Mbignum=bpi", "-wle", "print bpi(2000)"]
      restartPolicy: Never
  backoffLimit: 4

3、查看

直接查看该pod的日志就可以了 kubectl logs [pod名称]

五、cronjob

1、概念

定时的执行任务，

2、创建

apiVersion: batch/v1beta1
kind: CronJob
metadata:
  name: hello
spec:
  schedule: "*/1 * * * *"
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: hello
            image: busybox
            args:
            - /bin/sh
            - -c
            - date; echo Hello from the Kubernetes cluster
          restartPolicy: OnFailure

3、查看

直接查看该pod的日志就可以了 kubectl logs [pod名称]

六、Secret

作用：加密数据进行存储在etcd中，让pod容器挂载到Volume方式进行访问（是以base64的加密方式进行加密）

场景：凭证（密码等）

1、创建Secret加密数据

apiVersion: v1
kind: Secret
metadata:
  name: mysecret
type: Opaque
data:
  username: YWRtaW4=
  password: MWYyZDFlMmU2N2Rm

创建：kubectl apply -f secret.yaml

查询：kubectl get Secret

2、使用

以变量的形式进行挂载到pod容器中

apiVersion: v1
kind: Pod
metadata:
  name: mypod
spec:
  containers:
  - name: nginx
    image: nginx
    env:
      - name: SECRET_USERNAME
        valueFrom:
          secretKeyRef:
            name: mysecret
            key: username
      - name: SECRET_PASSWORD
        valueFrom:
          secretKeyRef:
            name: mysecret
            key: password

进入容器中，查看

kubectl exec -it [pod名] bash

3、以数据卷的形式挂载到pod容器中

apiVersion: v1
kind: Pod
metadata:
  name: mypod
spec:
  containers:
  - name: nginx
    image: nginx
    volumeMounts:
    - name: foo
      mountPath: "/etc/foo"
      readOnly: true
  volumes:
  - name: foo
    secret:
      secretName: mysecret

七、ConfigMap

作用：存储不加密数据到etcd，让Pod以变量或者Volume挂载到容器中

场景：配置文件

1、创建和查询

（1）编写配置文件

redis.host=127.0.0.1
redis.port=6379
redis.password=123456

（2）以配置文件创建configmap并且查看

（4）查看详细信息

kubectl describe cm redis-config

（5）以volume形式挂载到容器中

apiVersion: v1
kind: Pod
metadata:
  name: mypod
spec:
  containers:
    - name: busybox
      image: busybox
      command: [ "/bin/sh","-c","cat /etc/config/redis.properties" ]
      volumeMounts:
      - name: config-volume
        mountPath: /etc/config
  volumes:
    - name: config-volume
      configMap:
        name: redis-config
  restartPolicy: Never

运行这个容器

因为做了输出，所以可以以这个命令查看：

（6）、以变量形式挂载

a、创建变量，创建configMap文件

apiVersion: v1
kind: ConfigMap
metadata:
  name: myconfig
  namespace: default
data:
  special.level: info
  special.type: hello

b、执行文件并且查看文件

c、获取配置

apiVersion: v1
kind: Pod
metadata:
  name: mypod
spec:
  containers:
    - name: busybox
      image: busybox
      command: [ "/bin/sh", "-c", "echo $(LEVEL) $(TYPE)" ]
      env:
        - name: LEVEL
          valueFrom:
            configMapKeyRef:
              name: myconfig
              key: special.level
        - name: TYPE
          valueFrom:
            configMapKeyRef:
              name: myconfig
              key: special.type
  restartPolicy: Never

八、k8s集群的安全机制

1、概述

（1）访问k8s集群时需要经过三个不走完成具体操作

第一步：认证

第二步：鉴权（授权）

第三步：准入控制

（2）进行访问的时候，过程中都需要经过apiserver，apiserver进行统一协调，比如门卫

访问过程中需要证书、token、或者用户名+密码

如果访问pod，需要serviceAccount

第一步：认证

第二步：鉴权（授权）

第三步：准入控制

2、RBAC

RBAC(Role-Based Access Control，基于角色的访问控制)在 k8s v1.5 中引入，在 v1.6 版本时升级为 Beta 版本，并成为 kubeadm 安装方式下的默认选项，相对于其他访问控制方式，新的 RBAC 具有如下优势：

（1）对集群中的资源和非资源权限均有完整的覆盖

（2）整个 RBAC 完全由几个 API 对象完成，同其他 API 对象一样，可以用 kubectl 或 API 进行操作

（3）可以在运行时进行调整，无需重启 API Server 要使用 RBAC 授权模式，需要在 API Server 的启动参数中加上--authorization-mode=RBA

原理：

k8s中的角色

3、使用

（1）创建命名空间

kubectl create namespace [命名空间名称]

（2）在新建的命名空间下创建pod

（3）创建角色

apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  namespace: pop
  name: pod-reader
rules:
- apiGroups: [""] # "" indicates the core API group
  resources: ["pods"]
  verbs: ["get", "watch", "list"]

对这个命名空间中，改用户设置了拥有verbs中的权限

查询该角色

（4）创建角色绑定

apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: read-pods
  namespace: pop
subjects:
- kind: User
  name: lucy # Name is case sensitive
  apiGroup: rbac.authorization.k8s.io
roleRef:
  kind: Role #this must be Role or ClusterRole
  name: pod-reader # this must match the name of the Role or ClusterRole you wish to bind to
  apiGroup: rbac.authorization.k8s.io

查看

（5）授权

cat > lucy-csr.json <<EOF
{
  "CN": "lucy",#创建的用户
  "hosts": [],
  "key": {
    "algo": "rsa",
    "size": 2048
  },
  "names": [
    {
      "C": "CN",
      "L": "BeiJing",
      "ST": "BeiJing"
    }
  ]
}
EOF

cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes lucy-csr.json | cfssljson -bare lucy #创建的用户

kubectl config set-cluster kubernetes \
  --certificate-authority=ca.pem \
  --embed-certs=true \
  --server=https://192.168.195.190:6443 \#修改成自己的主机ip
  --kubeconfig=lucy-kubeconfig
  
kubectl config set-credentials lucy \
  --client-key=lucy-key.pem \
  --client-certificate=lucy.pem \
  --embed-certs=true \
  --kubeconfig=lucy-kubeconfig

kubectl config set-context default \
  --cluster=kubernetes \
  --user=lucy \
  --kubeconfig=lucy-kubeconfig

kubectl config use-context default --kubeconfig=lucy-kubeconfig

此文件使用时需要删除掉上面的注释

九、Ingress

不是k8s的组件，需要单独的部署

3、逻辑

4、ingress工作流程

5、使用ingress

第一步：部署ingress Controller（这里选择官方提供的nginx控制器）

第二步：创建ingress规则

6、使用ingress对外暴露应用

（1）这边选择创建nginx应用，对外暴露端口使用NodePort

创建容器：kubectl create deployment web --image=nginx

对外暴露端口：kubectl expose deployment web --port=80 --target-port=80 --type=NodePort

(2)部署ingresscontorller

apiVersion: v1
kind: Namespace
metadata:
  name: ingress-nginx
  labels:
    app.kubernetes.io/name: ingress-nginx
    app.kubernetes.io/part-of: ingress-nginx

---

kind: ConfigMap
apiVersion: v1
metadata:
  name: nginx-configuration
  namespace: ingress-nginx
  labels:
    app.kubernetes.io/name: ingress-nginx
    app.kubernetes.io/part-of: ingress-nginx

---
kind: ConfigMap
apiVersion: v1
metadata:
  name: tcp-services
  namespace: ingress-nginx
  labels:
    app.kubernetes.io/name: ingress-nginx
    app.kubernetes.io/part-of: ingress-nginx

---
kind: ConfigMap
apiVersion: v1
metadata:
  name: udp-services
  namespace: ingress-nginx
  labels:
    app.kubernetes.io/name: ingress-nginx
    app.kubernetes.io/part-of: ingress-nginx

---
apiVersion: v1
kind: ServiceAccount
metadata:
  name: nginx-ingress-serviceaccount
  namespace: ingress-nginx
  labels:
    app.kubernetes.io/name: ingress-nginx
    app.kubernetes.io/part-of: ingress-nginx

---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: nginx-ingress-clusterrole
  labels:
    app.kubernetes.io/name: ingress-nginx
    app.kubernetes.io/part-of: ingress-nginx
rules:
  - apiGroups:
      - ""
    resources:
      - configmaps
      - endpoints
      - nodes
      - pods
      - secrets
    verbs:
      - list
      - watch
  - apiGroups:
      - ""
    resources:
      - nodes
    verbs:
      - get
  - apiGroups:
      - ""
    resources:
      - services
    verbs:
      - get
      - list
      - watch
  - apiGroups:
      - ""
    resources:
      - events
    verbs:
      - create
      - patch
  - apiGroups:
      - "extensions"
      - "networking.k8s.io"
    resources:
      - ingresses
    verbs:
      - get
      - list
      - watch
  - apiGroups:
      - "extensions"
      - "networking.k8s.io"
    resources:
      - ingresses/status
    verbs:
      - update

---
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  name: nginx-ingress-role
  namespace: ingress-nginx
  labels:
    app.kubernetes.io/name: ingress-nginx
    app.kubernetes.io/part-of: ingress-nginx
rules:
  - apiGroups:
      - ""
    resources:
      - configmaps
      - pods
      - secrets
      - namespaces
    verbs:
      - get
  - apiGroups:
      - ""
    resources:
      - configmaps
    resourceNames:
      # Defaults to "<election-id>-<ingress-class>"
      # Here: "<ingress-controller-leader>-<nginx>"
      # This has to be adapted if you change either parameter
      # when launching the nginx-ingress-controller.
      - "ingress-controller-leader-nginx"
    verbs:
      - get
      - update
  - apiGroups:
      - ""
    resources:
      - configmaps
    verbs:
      - create
  - apiGroups:
      - ""
    resources:
      - endpoints
    verbs:
      - get

---
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: nginx-ingress-role-nisa-binding
  namespace: ingress-nginx
  labels:
    app.kubernetes.io/name: ingress-nginx
    app.kubernetes.io/part-of: ingress-nginx
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: Role
  name: nginx-ingress-role
subjects:
  - kind: ServiceAccount
    name: nginx-ingress-serviceaccount
    namespace: ingress-nginx

---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: nginx-ingress-clusterrole-nisa-binding
  labels:
    app.kubernetes.io/name: ingress-nginx
    app.kubernetes.io/part-of: ingress-nginx
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: nginx-ingress-clusterrole
subjects:
  - kind: ServiceAccount
    name: nginx-ingress-serviceaccount
    namespace: ingress-nginx

---

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-ingress-controller
  namespace: ingress-nginx
  labels:
    app.kubernetes.io/name: ingress-nginx
    app.kubernetes.io/part-of: ingress-nginx
spec:
  replicas: 1
  selector:
    matchLabels:
      app.kubernetes.io/name: ingress-nginx
      app.kubernetes.io/part-of: ingress-nginx
  template:
    metadata:
      labels:
        app.kubernetes.io/name: ingress-nginx
        app.kubernetes.io/part-of: ingress-nginx
      annotations:
        prometheus.io/port: "10254"
        prometheus.io/scrape: "true"
    spec:
      hostNetwork: true
      # 需要将此改成true，否则不对外暴露
      terminationGracePeriodSeconds: 300
      serviceAccountName: nginx-ingress-serviceaccount
      nodeSelector:
        kubernetes.io/os: linux
      containers:
        - name: nginx-ingress-controller
          image: lizhenliang/nginx-ingress-controller:0.30.0
          args:
            - /nginx-ingress-controller
            - --configmap=$(POD_NAMESPACE)/nginx-configuration
            - --tcp-services-configmap=$(POD_NAMESPACE)/tcp-services
            - --udp-services-configmap=$(POD_NAMESPACE)/udp-services
            - --publish-service=$(POD_NAMESPACE)/ingress-nginx
            - --annotations-prefix=nginx.ingress.kubernetes.io
          securityContext:
            allowPrivilegeEscalation: true
            capabilities:
              drop:
                - ALL
              add:
                - NET_BIND_SERVICE
            # www-data -> 101
            runAsUser: 101
          env:
            - name: POD_NAME
              valueFrom:
                fieldRef:
                  fieldPath: metadata.name
            - name: POD_NAMESPACE
              valueFrom:
                fieldRef:
                  fieldPath: metadata.namespace
          ports:
            - name: http
              containerPort: 80
              protocol: TCP
            - name: https
              containerPort: 443
              protocol: TCP
          livenessProbe:
            failureThreshold: 3
            httpGet:
              path: /healthz
              port: 10254
              scheme: HTTP
            initialDelaySeconds: 10
            periodSeconds: 10
            successThreshold: 1
            timeoutSeconds: 10
          readinessProbe:
            failureThreshold: 3
            httpGet:
              path: /healthz
              port: 10254
              scheme: HTTP
            periodSeconds: 10
            successThreshold: 1
            timeoutSeconds: 10
          lifecycle:
            preStop:
              exec:
                command:
                  - /wait-shutdown

---

apiVersion: v1
kind: LimitRange
metadata:
  name: ingress-nginx
  namespace: ingress-nginx
  labels:
    app.kubernetes.io/name: ingress-nginx
    app.kubernetes.io/part-of: ingress-nginx
spec:
  limits:
  - min:
      memory: 90Mi
      cpu: 100m
    type: Container

（3）创建ingress控制器

（4）查看创建的结果

创建访问规则格式：

apiVersion: networking.k8s.io/v1beta1
kind: Ingress
metadata:
  name: example-ingress
spec:
  rules:
  - host: example.ingredemo.com
    http:
      paths:
      - path: /
        backend:
          serviceName: web
          servicePort: 80

十、helm

1、引入

K8S 上的应用对象，都是由特定的资源描述组成，包括 deployment、service 等。都保存各自文件中或者集中写到一个配置文件。然后 kubectl apply –f 部署。如果应用只由一个或几个这样的服务组成，上面部署方式足够了。而对于一个复杂的应用，会有很多类似上面的资源描述文件，例如微服务架构应用，组成应用的服务可能多达十个，几十个。如果有更新或回滚应用的需求，可能要修改和维护所涉及的大量资源文件，而这种组织和管理应用的方式就显得力不从心了。且由于缺少对发布过的应用版本管理和控制，使 Kubernetes 上的应用维护和更新等面临诸多的挑战，主要面临以下问题：

（1）如何将这些服务作为一个整体管理

（2）这些资源文件如何高效复用

（3）不支持应用级别的版本管理

2、helm介绍

Helm 是一个 Kubernetes 的包管理工具，就像 Linux 下的包管理器，如 yum/apt 等，可以很方便的将之前打包好的 yaml 文件部署到 kubernetes 上。

Helm 有 3 个重要概念：

（1）helm：一个命令行客户端工具，主要用于 Kubernetes 应用 chart 的创建、打包、发布和管理。

（2）Chart：应用描述，一系列用于描述 k8s 资源相关文件的集合。

（3）Release：基于 Chart 的部署实体，一个 chart 被 Helm 运行后将会生成对应的一个 release；将在 k8s 中创建出真实运行的资源对象（基于chart部署实体，应用级别的版本管理）

3、解决了哪些问题

4、Helm v3 变化

2019 年 11 月 13 日， Helm 团队发布 Helm v3 的第一个稳定版本。

该版本主要变化如下：

架构变化：

1、最明显的变化是 Tiller 的删除

2、Release 名称可以在不同命名空间重用

3、支持将 Chart 推送至 Docker 镜像仓库中

4、使用 JSONSchema 验证 chart values

5、其他

5、helm安装

（1）下载heml安装包

（2）解压helm压缩包，将helm移动到/usr/bin目录中

6、配置helm仓库

（1）添加仓库

helm repo add 仓库名称仓库地址

例：1 微软的仓库

helm repo add stable http://mirror.azure.cn/kubernetes/charts

例：2 阿里的仓库

helm repo add aliyun https://kubernetes.oss-cn-hangzhou.aliyuncs.com/charts

（2）查看：

命令：helm repo list

（3）更新：

命令：helm repo update

（4）删除：

helm repo remove [仓库名]

7、使用

第一步：使用命令搜索应用

helm search repo 名称（weave）

第二步：根据搜索内容，选择进行安装

helm install 【安装之后的名称】【搜索之后应用的名称】

直接安装时报错，版本问题，需要修改版本

使用如下步骤：

helm pull stable/weave-scope
tar -zxvf weave-scope-1.1.12.tgz
cd weave-scope/
grep -r rbac.authorization

之后把对应文件里的rbac.authorization.k8s.io/v1beta1替换成rbac.authorization.k8s.io/v1 即可

再次执行安装 helm install ui weave-scope

查看安装之后的状态

helm list

helm status [安装之后的名称]

实际上执行的过程是：通过helm下载一个chart的一个yaml的集合，然后对这个集合进行安装

第三步：修改对外提供的端口

因为该应用在安装的时候，没有提供对外的端口，需要我们后期添加

执行：kubectl edit svc ui-weave-scope

之后就可以通过任意节点加端口进行访问

8、自己创建chart

(1)使用命令创建chart

helm create [chart名称]

charts:只是普通文件夹

Chart.yaml:当前chart的基本信息

templates：将自己写的yaml文件放到这里

values.yaml：定义yaml的全局变量配置

（2）在templates中创建两个文件

deployment.yaml 创建deployment和pod

kubectl create deployment web1 --image=nginx --dry-run -o yaml > deployment.yaml

service.yaml 创建对外暴露的端口

kubectl expose deployment web1 --port= 服务端口 --target-port= 镜像端口 --type=NodePort --dry-run -o yaml > service.yaml

需要先执行deployment.yaml,否则没有这个应用，无法创建service.yaml

(3)安装mychart

helm install web1 mychart/

已经显示创建成功，直接可以通过ip和端口号就可以进行访问了

（4）升级更新

helm upgrade 【chart名称】【文件夹】

9、实现yaml高效复用

通过传递参数动态渲染模板，yaml内容动态传入参数生成

（1）在values.yaml定义变量和值

（2）在具体的values.yaml中获取变量值

通过表达式的形式使用全局变量

也可以使用这个形式

运行既可

helm install web1 mychart/

10、卸载安装的应用

1. 列出 Helm 部署

列出当前命名空间中的 Helm 部署：

helm list

要列出特定命名空间中的部署，请使用：

helm list --namespace <namespace_name>

通过运行以下命令列出所有命名空间中的所有 Helm 部署：

helm list --all-namespaces

2. 删除 Helm 部署

要删除已安装的 Helm 部署，请运行：

helm uninstall <deployment name> --namespace <namespace_name>

或者，使用别名：

helm delete <deployment name> --namespace <namespace_name>

终端输出移除确认。例如，下面的命令删除命名空间other上名为phoenix-chart的部署：

helm uninstall phoenix-chart --namespace other

在 Helm 2 中，使用--purge删除发布和相关 Kubernetes 组件的选项：

helm delete <deployment name> --purge

列出 Helm 部署helm list以确认版本不再存在。

十一、nfs

1、nfs，网络存储，pod重启，数据依然存在

yum install -y nfs-utils

vim /etc/exports

systemctl start nfs

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-dep1
spec:
  replicas: 1
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx
        volumeMounts:
        - name: wwwroot
          mountPath: /usr/share/nginx/html
        ports:
        - containerPort: 80
      volumes:
        - name: wwwroot
          nfs:
            server: 192.168.44.134
            path: /data/nfs

当进入到nfs服务器中的文件夹创建和删除文件时，会自动在pod容器内部中进行操作（相互的）

2、pv和pvc

pv文件

apiVersion: v1
kind: PersistentVolume
metadata:
  name: my-pv
spec:
  capacity:
    storage: 5Gi
  accessModes:
    - ReadWriteMany
  nfs:
    path: /k8s/nfs
    server: 192.168.44.134

pvc文件

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-dep1
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx
        volumeMounts:
        - name: wwwroot
          mountPath: /usr/share/nginx/html
        ports:
        - containerPort: 80
      volumes:
      - name: wwwroot
        persistentVolumeClaim:
          claimName: my-pvc

---

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: my-pvc
spec:
  accessModes:
    - ReadWriteMany
  resources:
    requests:
      storage: 5Gi

pv和pvc是通过名字进行绑定的

十二、kubernetes监控

1、概述

Kubernetes 作为容器集群系统，通过健康检查+重启策略实现了 Pod 故障自我修复能力，通过调度算法实现将 Pod 分布式部署，监控其预期副本数，并根据 Node 失效状态自动在正常 Node 启动 Pod，实现了应用层的高可用性。针对 Kubernetes 集群，高可用性还应包含以下两个层面的考虑：Etcd 数据库的高可用性和 Kubernetes Master 组件的高可用性。而 Etcd 我们已经采用 3 个节点组建集群实现高可用，本节将对 Master 节点高可用进行说明和实施。 Master 节点扮演着总控中心的角色，通过不断与工作节点上的 Kubelet 和 kube-proxy 进行通信来维护整个集群的健康工作状态。如果 Master 节点故障，将无法使用 kubectl 工具或者 API 任何集群管理。 Master 节点主要有三个服务 kube-apiserver、kube-controller-mansger 和 kubescheduler，其中 kube-controller-mansger 和 kube-scheduler 组件自身通过选择机制已经实现了高可用，所以 Master 高可用主要针对 kube-apiserver 组件，而该组件是以 HTTP API 提供服务，因此对他高可用与 Web 服务器类似，增加负载均衡器对其负载均衡即可，并且可水平扩容。

架构图：

VIP指的是虚拟ip

十三、卸载

yum remove -y kubelet kubeadm kubectl

kubeadm reset -f
modprobe -r ipip
lsmod
rm -rf ~/.kube/
rm -rf /etc/kubernetes/
rm -rf /etc/systemd/system/kubelet.service.d
rm -rf /etc/systemd/system/kubelet.service
rm -rf /usr/bin/kube*
rm -rf /etc/cni
rm -rf /opt/cni
rm -rf /var/lib/etcd
rm -rf /var/etcd

k8s

k8s k8 8s

centos7 centos k8s 8s

ingress k8s k8 8s

k8s pvc k8 8s

docker k8s 8s k8

ingress-nginx ingress nginx k8s

kubeadm k8s k8 8s

k8s pod k8 8s

labels k8s k8 8s