1. 概述

1.1 基本介绍

  1. k8s是Google在2014年开业的容器化集群管理系统。
  2. 使用k8s进行容器化应用部署
  3. 使用k8s利于应用扩展

  4. k8s目标实施让部署容器化应用更加简单和高效

    1.2 k8s集群架构组件

    Master 主控节点

  5. apiserver

集群统一入口，以restful方式，交个etcd存储

  1. scheduler

节点调度，选择node节点应用部署

  1. controller-manager

处理集群中常规后台任务，一个资源对应一个控制器

  1. etcd

存储系统，用于保存集群相关的数据
node 组件

  1. kube let

master排到node节点代表，管理本机容器

  1. kube-proxy

提供网络代理，负载均衡等操作

1.3 k8s核心概念

Pod

  1. 最小部署单元
  2. 一组容器（如Docker容器）的集合
  3. 共享网络，一个pod中的网络共享
  4. 声明周期是短暂的
  5. 一个Pod有一个特殊的被称为“根容器”的Pause容器

Controller

  1. 定期检查系统中存活的Pod，确保预期的pod数量和Replication Controller（RC）提交的一致
  2. 支持无状态应用部署
  3. 支持有状态应用部署
  4. 确保所有的node运行同一个pod
  5. 定义一次性任务和定时任务

Service

  1. 定义一组pod的访问规则

    2. 部署硬件要求

    Master 节点
    2核 4G 20G
    Node节点
    4核 8G 40G

    3. 使用

    3.1 kubernetes 集群命令行工具kubectl

  2. kubectl 语法格式

kubectl [common] [TYPE] [NAME] [flags]

  1. [root@master1 ~]# kubectl get nodes node2

  1. 帮助命令

    1. kubectl --help
    2. 具体查看某个操作
    3. kubectl get --help

  2. 目前使用到的命令

    1. #部署一个服务
    2. kubectl create deployment nginx --image=nginx
  1. #开放服务端口
  2. kubectl expose deployment nginx --port=80 --type=NodePort
  1. #查看已经部署服务
  2. kubectl get pod,svc
  1. #通过yaml文件部署服务
  2. kubectl apply -f
  1. #查看controller服务
  2. kubectl get cs
  1. #查看node节点
  2. kubectl get nodes

3.2 如何快速编写yaml文件

  1. # 第一种：使用kubectl create 命令生成yaml文件,新建一条yaml文件
  2. kubectl create deployment web1 --image=nginx --dry-run -o yaml > deployment.yaml
  1. 第二种：使用kubectl get 命令导出yaml文件,用已经创建好的pod来生成yaml文件
  2. kubectl get deploy
  3. kubectl get deploy nginx -o=yaml --export > de.yaml

4. POD 最小单元

4.1 Pod节本概念

  1. 最小部署的单元
  2. 包含多个容器（一组容器（如Docker容器）的集合）
  3. 一个pod中容器共享网络命名空间

  4. pod是短暂的

    4.2 Pod存在的意义

  5. 创建容器使用docker，一个docker对应一个容器，一个容器有进程，一个容器运行一个应用程序

  6. Pod是多进程设计，运行多个应用程序（一个Pod 有多个容器，一个容器里面运行一个应用程序）
  7. Pod存在为了亲密性应用
  • 两个应用之间进行交互
  • 网络之间调用
  • 两个应用需要频繁调用

    4.3 共享网络

    共享网络
    通过Pause容器（每个pod默认都包含有一个Pause容器），把其他容器加入到Pause容器里面，让所有业务容器在同一个名称空间中，可以实现网络共享
    共享存储
    引入数据卷概念Volumn，使用数据卷进行持久化存储

    4.4 Pod镜像拉取策略

    pod提供三种镜像拉取策略
    IfNotPresent： 默认值，镜像在宿主机上不存在时才拉取
    Always：每次创建Pod 都会重新拉取一次镜像
    Never： Pod 永远不会主动拉取这个镜像

    4.5 Pod资源限制

    pod提供对节点主机资源的上限和下限限制
    1. resources:
    2. requests:
    3.   memory: "64Mi"  #对内存最小调度限制
    4.   cpu: "250m"     #对cpu最小调度限制
    5. limits:
    6.   memory: "128Mi" #对内存最大调度限制
    7.   cpu: "500m"     #对cpu最大调度限制

    4.6 Pod重启策略

    yaml文件中用restartPolicy：Never 表示重启机制，提供三种重启机制
    Always：当容器终止退出后，总是重启容器，默认策略
    OnFailure：当容器异常退出（退出状态码非0）时，才重启容器
    Never：当容器终止退出，从不重启容器

    4.7 Pod健康检查

    ```yaml

    livenessProbe (存活检查)

    如果检查失败，将杀死容器，根据Pod的restartPolicy来操作

readinessProbe (就绪检查)

如果检查失败，Kubernetes会把Pod从service endpoints中剔除

  2. ```yaml
  3. # Probe 支持以下三种检查方式
  4. ## httpGet
  5. ### 发送HTTP请求，返回200-400范围状态码为成功
  7. ## exec
  8. ### 执行Shell命令返回状态码是0为成功
  10. ## tcpSocket
  11. ### 发起TCP Socket建立成功

4.8 Pod创建流程

Kubernetes基础 - 图1说明：
master节点

  1. createpod — apiserver — etcd
  2. scheduler — apiserver — etcd — 调度算法，把pod调度某个node节点上

node节点

  1. kubelet — apiserver — 读取etcd拿到分配给当前节点pod — docker 创建容器

    4.9 Pod调度节点亲和性

    硬亲和性： 约束条件必须满足
    1. spec:
    2. affinity:
    3.    nodeAffinity: 
    4.    requiredDuringSchedulingIgnoredDuringExecution:
    5.      - nodeSelectorTerms:
    6.        - key: env role
    7.          operator: In
    8.          values:
    9.          - dev
    10.          - test

软亲和性： 尝试满足，不保证一定满足

  1. spec:
  2.   affinity:
  3.     nodeAffinity: 
  4.       requiredDuringSchedulingIgnoredDuringExecution:
  5.         - weight: 1
  6.           preference:
  7.            matchExpressions:
  8.             -key: group
  9.               operator: In
  10.               values:
  11.               - otherprod

4.10 Pod调度节点选择器

  1. Pod资源限制对Pod调用产生影响

    1. resources:
    2. requests:
    3.  memory: "64Mi"
    4.  cpu: "250m"

  2. 节点选择器标签影响Pod调度

    1. spec:
    2. nodeSelector:
    3.  env_role: dev

4.11 Pod调度污点和污点容忍

  1. 基本介绍

nodeSelector和nodeAffinity：Pod调度到某些节点上，Pod属性调度时候实现
Taint污点：节点不做普通分配调度，是节点属性

  1. 使用场景
  • 专用节点
  • 配置特点硬件节点
  • 基于Taint驱逐
  1. 查看节点污点情况 
    1. #kubectl describe node [节点名称] | grep Taint 
    2. kubectl describe node k8smaster | grep Taint

污点有三个值
NoSchedule：一定不被调用
PreferNoSchdule： 尽量不被调度
NoExecute：不会调度，并且还会驱逐Node已有Pod

  1. 为节点添加污点

    1. #kubectl taint node [节点名称] key=value:[污点的三个值]
    2. kubectl taint node master1 key=value:NoSchedule

  2. 删除污点

    1. kubectl taint node master1 env_role:NoSchedule-node/master1 untainted

  3. 污点容忍

    1. spec:
    2. tolerations:
    3. - key: "key"
    4.  operator: "Equal"
    5.  value: "value"
    6.  effect: "NoSchedule"

4.12 常用命令

  1. 查看已经部署的pod

    1. kubectl get deployment

  2. 删除pod

    1. kubectl delete deployment nginx-dep

  3. 查看pvc

    1. kubectl get pvc -A

  4. 删除pvc

    1. #删除pvc
    2. kubectl delete pvc XXX
    3. #强制删除
    4. kubectl delete pvc XXX --force --grace-period=0

5. Controller控制器

5.1 什么是Controller

Controller是一个在集群上管理和运行容器的对象，通俗的说就是用来管理Pod的

5.2 Pod和Controller的关系

  1. Pod是通过Controller 实现应用的运维，比如伸缩，滚动升级等等
  2. Pod和Controller 之间通过label标签建立关系 
    1. spec:
    2. selector:
    3. matchLabels:
    4.   app: filebeat  #和labels app保持一致
    5. template:
    6. metadata:
    7.   labels:
    8.     app: filebeat #和selector app保持一致

5.3 deployment 应用场景

  1. 部署无状态应用
  2. 管理Pod和ReplicaSet
  3. 部署，滚动升级等功能
  4. 应用场景：web服务，微服务

5.4 使用deployment部署应用

  1. 导出yaml文件

  • 通过镜像拉去创建yaml文件

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

  • 通过已经创建的pod生成yaml文件

    1. [root@master1 kubernetes]# kubectl get deploy
    2. NAME    READY   UP-TO-DATE   AVAILABLE   AGE
    3. nginx   1/1     1            1           5h4m
    4. [root@master1 kubernetes]# kubectl get deploy nginx -o=yaml --export > web1.yaml

  1. 使用yaml部署应用

    1. kubectl apply -f web.yaml

  2. 对外暴露发布端口

    1. 生成yaml文件
    2. kubectl expose deployment web --port=80 --type=NodePort --target-port=80 --name=web -o yaml > web.yaml
    3. 部署应用
    4. kubectl apply -f web.yaml
    5. 查看访问端口
    6. kubectl get svc
    7. NAME         TYPE        CLUSTER-IP     EXTERNAL-IP   PORT(S)        AGE
    8. kubernetes   ClusterIP   10.1.0.1       <none>        443/TCP        5h31m
    9. nginx        NodePort    10.1.8.108     <none>        80:30499/TCP   5h9m
    10. web          NodePort    10.1.181.210   <none>        80:30942/TCP   103s

5.5 应用升级回滚和弹性伸缩

  1. 应用升级
    1. kubectl set image deployment web nginx=nginx:1.15
  1. kubectl rollout status deployment web

  1. 查看升级版本

    1. [root@master1 kubernetes]# kubectl rollout history deployment web
    2. deployment.apps/web 
    3. REVISION  CHANGE-CAUSE
    4. 1         <none>
    5. 2         <none>
    6. 3         <none>

  2. 回滚到上一个版本

    1. kubectl rollout undo deployment web

  3. 回滚到指定的版本

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

  4. 查看升级状态

    1. kubectl rollout status deployment web
    2. Waiting for deployment "web" rollout to finish: 1 old replicas are pending termination...
    3. Waiting for deployment "web" rollout to finish: 1 old replicas are pending termination...
    4. deployment "web" successfully rolled out

  5. 弹性伸缩

    1. kubectl scale deployment web --replicas=10

6. Service

6.1 Service 存在的意义

  1. 防止Pod 失联（起到服务发现的作用）

  2. 定义一组Pod访问策略（负债均衡）

    6.2 Pod和Service关系

    通过selector.app.nginx 和 labels.app.nginx关联

    6.3 常用Service 类型

  3. ClusterIP： 集群内部使用

  4. NodePort：对外访问应用使用
  5. LoadBalancer：对外访问应用使用，公有云

说明：node 内网部署应用时，外网是不可以访问的。可以通过一台可以访问外网的服务器，部署nginx做反向代理。手动把可以访问的节点添加到nginx里面

7. 配置管理

8. 集群安全机制

8.1 概述

  1. 访问k8s集群的时候，需要经过三个步骤完成具体操作
  • 第一步 认证
  • 第二步 鉴权（授权）
  • 第三部 准入控制
  1. 进行访问的时候，过程中都需要经过apiserver，apiserver 做统一协调，比如门卫。
  • 访问过程中需要证书、token、或者用户名+密码，如果访问pod，需要serviceAccount

    8.2 认证

  1. 传输安全

对外不暴露8080端口，只能内部访问，对外使用端口6443

  1. 认证

客户端身份证方式：

  • https 证书认证，基于ca证书
  • http token 认证，通过token识别用户
  • http基本认证，用户名+密码认证

    8.3 鉴权(授权)

  1. 基于RBAC进行鉴权操作

  2. 基于角色访问控制

    8.4 准入控制

  3. 就是准入控制器的列表，如果列表有请求内容，通过，没有拒绝

    8.5 RBAC基于角色的访问控制

  4. 角色

role：特定命名空间访问权限
ClusterRole：所有命名空间访问权限

  1. 角色绑定

roleBinding：角色绑定到主体
ClusterRoleBinding：集群角色绑定到主体

  1. 主体

user：用户
group：用户组
serviceAccount：服务账号

8.6 rbac实现鉴权

  1. 创建命名空间

    1. kubectl create ns roledemo

  2. 在新建的命名空间创建pod

    1. kubectl run nginx --image=nginx -n roledemo

  3. 创建角色

新建rbac-role.yaml文件，文件名可以随意

  1. kind: Role
  2. apiVersion: rbac.authorization.k8s.io/v1
  3. metadata:
  4.   namespace: ctnrs
  5.   name: pod-reader
  6. rules:
  7. - apiGroups: [""] # "" indicates the core API group
  8.   resources: ["pods"]
  9.   verbs: ["get", "watch", "list"]

执行yaml文件

  1. kubectl apply -f rbac-role.yaml

查看角色

  1. kubectl get role -n roledemo
  1. 创建角色绑定

新建rbac-rolebinding.yaml文件

  1. kind: RoleBinding
  2. apiVersion: rbac.authorization.k8s.io/v1
  3. metadata:
  4.   name: read-pods
  5.   namespace: roletest
  6. subjects:
  7. - kind: User
  8.   name: lucy # Name is case sensitive
  9.   apiGroup: rbac.authorization.k8s.io
  10. roleRef:
  11.   kind: Role #this must be Role or ClusterRole
  12.   name: pod-reader # this must match the name of the Role or ClusterRole you wish to bind to
  13.   apiGroup: rbac.authorization.k8s.io

执行yaml文件

  1. kubectl apply -f rbac-rolebinding.yaml

查看角色和角色绑定

  1. kubectl get role,rolebinding -n roledemo

9. Ingress

9.1 为什么引入Ingress

  1. 把端口号对外暴露，通过ip+端口号进行访问

使用Service里面的NodePort实现

  1. NodePort缺陷
  • 在每个节点上都会起到端口，在访问时候通过任何节点，通过节点ip+暴露端口实现访问
  • 这意味着每个端口只能使用一次，一个端口号对应着一个应用
  • 实际访问中都是用域名，根据不同域名跳转到不同端口对应的服务中

    9.2 Ingress和Pod关系

  1. pod和ingress通过service关联的

  2. ingress作为统一入口，由service关联一组pod

    9.3 使用Ingress对外暴露应用

    部署ingress Controller
    这里选择官方维护的nginx控制器实现部署

  3. 创建nginx应用

    1. kubectl create deployment web2 --image=nginx

  4. 对外暴露端口使用NodePort

    1. kubectl expose deployment web2 --port=80 --target-port=80 --type=NodePort

  5. 部署Ingress controller

新建ingress-con.yaml文件，文件名可以随意

  1. apiVersion: v1
  2. kind: Namespace
  3. metadata:
  4.   name: ingress-nginx
  5.   labels:
  6.     app.kubernetes.io/name: ingress-nginx
  7.     app.kubernetes.io/part-of: ingress-nginx
  9. ---
  11. kind: ConfigMap
  12. apiVersion: v1
  13. metadata:
  14.   name: nginx-configuration
  15.   namespace: ingress-nginx
  16.   labels:
  17.     app.kubernetes.io/name: ingress-nginx
  18.     app.kubernetes.io/part-of: ingress-nginx
  20. ---
  21. kind: ConfigMap
  22. apiVersion: v1
  23. metadata:
  24.   name: tcp-services
  25.   namespace: ingress-nginx
  26.   labels:
  27.     app.kubernetes.io/name: ingress-nginx
  28.     app.kubernetes.io/part-of: ingress-nginx
  30. ---
  31. kind: ConfigMap
  32. apiVersion: v1
  33. metadata:
  34.   name: udp-services
  35.   namespace: ingress-nginx
  36.   labels:
  37.     app.kubernetes.io/name: ingress-nginx
  38.     app.kubernetes.io/part-of: ingress-nginx
  40. ---
  41. apiVersion: v1
  42. kind: ServiceAccount
  43. metadata:
  44.   name: nginx-ingress-serviceaccount
  45.   namespace: ingress-nginx
  46.   labels:
  47.     app.kubernetes.io/name: ingress-nginx
  48.     app.kubernetes.io/part-of: ingress-nginx
  50. ---
  51. apiVersion: rbac.authorization.k8s.io/v1beta1
  52. kind: ClusterRole
  53. metadata:
  54.   name: nginx-ingress-clusterrole
  55.   labels:
  56.     app.kubernetes.io/name: ingress-nginx
  57.     app.kubernetes.io/part-of: ingress-nginx
  58. rules:
  59.   - apiGroups:
  60.       - ""
  61.     resources:
  62.       - configmaps
  63.       - endpoints
  64.       - nodes
  65.       - pods
  66.       - secrets
  67.     verbs:
  68.       - list
  69.       - watch
  70.   - apiGroups:
  71.       - ""
  72.     resources:
  73.       - nodes
  74.     verbs:
  75.       - get
  76.   - apiGroups:
  77.       - ""
  78.     resources:
  79.       - services
  80.     verbs:
  81.       - get
  82.       - list
  83.       - watch
  84.   - apiGroups:
  85.       - ""
  86.     resources:
  87.       - events
  88.     verbs:
  89.       - create
  90.       - patch
  91.   - apiGroups:
  92.       - "extensions"
  93.       - "networking.k8s.io"
  94.     resources:
  95.       - ingresses
  96.     verbs:
  97.       - get
  98.       - list
  99.       - watch
  100.   - apiGroups:
  101.       - "extensions"
  102.       - "networking.k8s.io"
  103.     resources:
  104.       - ingresses/status
  105.     verbs:
  106.       - update
  108. ---
  109. apiVersion: rbac.authorization.k8s.io/v1beta1
  110. kind: Role
  111. metadata:
  112.   name: nginx-ingress-role
  113.   namespace: ingress-nginx
  114.   labels:
  115.     app.kubernetes.io/name: ingress-nginx
  116.     app.kubernetes.io/part-of: ingress-nginx
  117. rules:
  118.   - apiGroups:
  119.       - ""
  120.     resources:
  121.       - configmaps
  122.       - pods
  123.       - secrets
  124.       - namespaces
  125.     verbs:
  126.       - get
  127.   - apiGroups:
  128.       - ""
  129.     resources:
  130.       - configmaps
  131.     resourceNames:
  132.       # Defaults to "<election-id>-<ingress-class>"
  133.       # Here: "<ingress-controller-leader>-<nginx>"
  134.       # This has to be adapted if you change either parameter
  135.       # when launching the nginx-ingress-controller.
  136.       - "ingress-controller-leader-nginx"
  137.     verbs:
  138.       - get
  139.       - update
  140.   - apiGroups:
  141.       - ""
  142.     resources:
  143.       - configmaps
  144.     verbs:
  145.       - create
  146.   - apiGroups:
  147.       - ""
  148.     resources:
  149.       - endpoints
  150.     verbs:
  151.       - get
  153. ---
  154. apiVersion: rbac.authorization.k8s.io/v1beta1
  155. kind: RoleBinding
  156. metadata:
  157.   name: nginx-ingress-role-nisa-binding
  158.   namespace: ingress-nginx
  159.   labels:
  160.     app.kubernetes.io/name: ingress-nginx
  161.     app.kubernetes.io/part-of: ingress-nginx
  162. roleRef:
  163.   apiGroup: rbac.authorization.k8s.io
  164.   kind: Role
  165.   name: nginx-ingress-role
  166. subjects:
  167.   - kind: ServiceAccount
  168.     name: nginx-ingress-serviceaccount
  169.     namespace: ingress-nginx
  171. ---
  172. apiVersion: rbac.authorization.k8s.io/v1beta1
  173. kind: ClusterRoleBinding
  174. metadata:
  175.   name: nginx-ingress-clusterrole-nisa-binding
  176.   labels:
  177.     app.kubernetes.io/name: ingress-nginx
  178.     app.kubernetes.io/part-of: ingress-nginx
  179. roleRef:
  180.   apiGroup: rbac.authorization.k8s.io
  181.   kind: ClusterRole
  182.   name: nginx-ingress-clusterrole
  183. subjects:
  184.   - kind: ServiceAccount
  185.     name: nginx-ingress-serviceaccount
  186.     namespace: ingress-nginx
  188. ---
  190. apiVersion: apps/v1
  191. kind: Deployment
  192. metadata:
  193.   name: nginx-ingress-controller
  194.   namespace: ingress-nginx
  195.   labels:
  196.     app.kubernetes.io/name: ingress-nginx
  197.     app.kubernetes.io/part-of: ingress-nginx
  198. spec:
  199.   replicas: 1
  200.   selector:
  201.     matchLabels:
  202.       app.kubernetes.io/name: ingress-nginx
  203.       app.kubernetes.io/part-of: ingress-nginx
  204.   template:
  205.     metadata:
  206.       labels:
  207.         app.kubernetes.io/name: ingress-nginx
  208.         app.kubernetes.io/part-of: ingress-nginx
  209.       annotations:
  210.         prometheus.io/port: "10254"
  211.         prometheus.io/scrape: "true"
  212.     spec:
  213.       hostNetwork: true
  214.       # wait up to five minutes for the drain of connections
  215.       terminationGracePeriodSeconds: 300
  216.       serviceAccountName: nginx-ingress-serviceaccount
  217.       nodeSelector:
  218.         kubernetes.io/os: linux
  219.       containers:
  220.         - name: nginx-ingress-controller
  221.           image: lizhenliang/nginx-ingress-controller:0.30.0
  222.           args:
  223.             - /nginx-ingress-controller
  224.             - --configmap=$(POD_NAMESPACE)/nginx-configuration
  225.             - --tcp-services-configmap=$(POD_NAMESPACE)/tcp-services
  226.             - --udp-services-configmap=$(POD_NAMESPACE)/udp-services
  227.             - --publish-service=$(POD_NAMESPACE)/ingress-nginx
  228.             - --annotations-prefix=nginx.ingress.kubernetes.io
  229.           securityContext:
  230.             allowPrivilegeEscalation: true
  231.             capabilities:
  232.               drop:
  233.                 - ALL
  234.               add:
  235.                 - NET_BIND_SERVICE
  236.             # www-data -> 101
  237.             runAsUser: 101
  238.           env:
  239.             - name: POD_NAME
  240.               valueFrom:
  241.                 fieldRef:
  242.                   fieldPath: metadata.name
  243.             - name: POD_NAMESPACE
  244.               valueFrom:
  245.                 fieldRef:
  246.                   fieldPath: metadata.namespace
  247.           ports:
  248.             - name: http
  249.               containerPort: 80
  250.               protocol: TCP
  251.             - name: https
  252.               containerPort: 443
  253.               protocol: TCP
  254.           livenessProbe:
  255.             failureThreshold: 3
  256.             httpGet:
  257.               path: /healthz
  258.               port: 10254
  259.               scheme: HTTP
  260.             initialDelaySeconds: 10
  261.             periodSeconds: 10
  262.             successThreshold: 1
  263.             timeoutSeconds: 10
  264.           readinessProbe:
  265.             failureThreshold: 3
  266.             httpGet:
  267.               path: /healthz
  268.               port: 10254
  269.               scheme: HTTP
  270.             periodSeconds: 10
  271.             successThreshold: 1
  272.             timeoutSeconds: 10
  273.           lifecycle:
  274.             preStop:
  275.               exec:
  276.                 command:
  277.                   - /wait-shutdown
  279. ---
  281. apiVersion: v1
  282. kind: LimitRange
  283. metadata:
  284.   name: ingress-nginx
  285.   namespace: ingress-nginx
  286.   labels:
  287.     app.kubernetes.io/name: ingress-nginx
  288.     app.kubernetes.io/part-of: ingress-nginx
  289. spec:
  290.   limits:
  291.   - min:
  292.       memory: 90Mi
  293.       cpu: 100m
  294.     type: Container

执行yaml文件

  1. kubectl apply -f ingress-con.yaml

查看ingress controller状态

  1. kubectl get pods -n ingress-nginx
  1. 创建ingress规则

新建ingressy.yaml规则文件

  1. apiVersion: networking.k8s.io/v1beta1
  2. kind: Ingress
  3. metadata:
  4.   name: example-ingress
  5. spec:
  6.   rules:
  7.   - host: example.ingredemo.com
  8.     http:
  9.       paths:
  10.       - path: /
  11.         backend:
  12.           serviceName: web
  13.           servicePort: 80

执行yaml文件

  1. kubectl apply -f ingress.yaml

  1. 查看部署应用在哪个节点上

    1. kubectl get pods -n ingress-nginx -o wide

  2. 查看域名映射端口

    1. kubectl get ing

10. Helm

10.1 Helm介绍

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

10.2 使用helm 可以解决哪些问题？

  1. 使用helm可以把这些yaml作为一个整体管理
  2. 实现yaml高效复用

  3. 使用helm应用级别的版本管理

    10.3 Helm三个重要概念

  4. helm 是一个命令行客户端工具

  5. Chart 把yaml打包，是yaml集合
  6. Release 基于chart部署实体，应用级别的版本管理

10.4 Helm常用命令

  1. 创建一个chart并制定名字

    1. helm create mchart

  2. 管理chart依赖

    1. helm dependency

  3. 下载一个 release。 可用子命令： all、 hooks、 manifest、 notes、 values

  4. 获取 release 历史

  5. 安装一个 chart

    1. #helm install 安装之后名称 应用名称或创建的chart名称
    2. helm install ui stable/weave-scope

  6. 列出 release

    1. helm list

  7. 将 chart 目录打包到 chart 存档文件中

  8. 从远程仓库中下载 chart 并解压到本地

    1. helm pull stable/mysql -- untar

  9. 添加， 列出， 移除， 更新和索引 chart 仓库。 可用子命令： add、 index、 list、 remove、 update

    1. #添加仓库 helm repo add [仓库名称] [仓库地址]
    2. helm repo add stable http://mirror.azure.cn/kubernetes/charts
    3. #仓库列表
    4. helm repo list
    5. #更新仓库
    6. helm repo update
    7. #索引
    8. helm repo index
    9. #移除 helm repo remove [仓库名称]
    10. helm repo remove aliyun

  10. 从之前版本回滚

    1. helm rollback

  11. 根据关键字搜索 chart。 可用子命令： hub、 repo ```shell helm search repo mysql

helm search hub mysql

  2. 11. 查看 chart 详细信息。 可用子命令： all、 chart、 readme、 values
  3. ```shell
  4. show

  1. 显示已命名版本的状态

    1. #helm status [应用名称]
    2. helm status web3

  2. 本地呈现模板

    1. template

  3. 卸载一个release

    1. helm release web3

  4. 更新一个release

    1. helm upgrade web3

  5. 查看helm客户端版本

    1. helm version

10.5 Helm安装（v3版本）

  1. 下载离线压缩文件

  2. 解压helm压缩文件

    1. tar -zxvf helm-v3.0.0-linux-amd64.tar.gz

  3. 把解压缩之后的helm目录复制(移动)到Linux服务器的/usr/bin目录下

    1. mv help /usr/bin

10.6 helm仓库管理

  1. 添加仓库

    1. #helm repo add 仓库名称 仓库地址
    2. helm repo add stable http://mirror.azure.cn/kubernetes/charts

  2. 查看仓库地址

    1. helm repo list

  3. 更新仓库地址

    1. helm repo update

  4. 删除仓库地址

    1. helm repo remove aliyun

10.7 使用helm快速部署应用

  1. 根据helm命令搜索应用

    1. #helm search repo [应用名称]
    2. [root@master1 bin]# helm search repo weave
    3. NAME                  CHART VERSION    APP VERSION    DESCRIPTION                                       
    4. stable/weave-cloud    0.3.9            1.4.0          DEPRECATED - Weave Cloud is a add-on to Kuberne...
    5. stable/weave-scope    1.1.12           1.12.0         DEPRECATED - A Helm chart for the Weave Scope c...

  2. 根据helm搜索内容选择安装

    1. #helm install 安装之后名称 搜索之后应用名称
    2. helm install ui stable/weave-scope

  3. 查看通过helm安装的应用列表

    1. helm list

  4. 查看通过helm安装的应用状态

    1. #helm status [应用名称]
    2. helm status ui

10.8 如何使用Chart

  1. 使用命令创建chart
    1. # 创建mchart
    2. helm create mchart
    3. # 进入mchart文件夹
    4. [root@master1 mchart]# ls
    5. charts  Chart.yaml  templates  values.yaml

文件说明
Chart yaml：当前Chart属性配置信息
templates：编写yaml文件放到这个目录中
values.yaml：yaml文件可以使用全局变量

  1. 在templates文件夹下创建两个yaml文件
    可以通过 导出yaml的方式导出文件 

    1. 生成deployment.yaml文件
    2. kubectl create deployment web3 --image=nginx --dry-run -o yaml > deployment.yaml
    3. 生成service.yaml文件
    4. kubectl expose deployment web3 --port=80 --target-port=80 --type=NodePort --dry-run -o yaml > service.yaml

  2. 安装chart（要回到mchart的上级目录下）

  1. helm install web3 mchart/

10.9 复用yaml文件

待完善

11. 持久存储

数据卷emptydir 是本地存储，当pod重启后数据就不存在了，需要对数据持久化存储
NFS是一个网络存储，当pod重启后，数据还是存在的

11.1 NFS安装

  1. 安装NFS
    找一台nfs存储服务器 

    1. yum install -y nfs-utils

  2. 设置挂载路径

    1. vi /etc/exports
  1. /data/nfs *(rw,no_root_squash)

注意：挂载路径需要手动创建出来

11.2 在k8s集群node节点中安装nfs

  1. yum install -y nfs-utils

11.3 在nfs服务器中启动nfs服务

  1. #启动nfs服务
  2. systemctl start nfs
  3. #查看nfs服务是否启动
  4. ps -ef | grep nfs

11.4 在k8s集群部署应用使用nfs持久网络存储

  1. apiVersion: apps/v1
  2. kind: Deployment
  3. metadata:
  4.   name: nginx-dep1
  5. spec:
  6.   replicas: 1
  7.   selector:
  8.     matchLabels:
  9.       app: nginx
  10.   template:
  11.     metadata:
  12.       labels:
  13.         app: nginx
  14.     spec:
  15.       containers:
  16.       - name: nginx
  17.         image: nginx
  18.         volumeMounts:
  19.         - name: wwwroot
  20.           mountPath: /usr/share/nginx/html  # k8s集群中目录，nfs目录中的文件会同步到这个文件夹
  21.         ports:
  22.         - containerPort: 80
  23.       volumes:
  24.         - name: wwwroot
  25.           nfs:
  26.             server: 192.168.44.134  # nfs服务器ip
  27.             path: /data/nfs         # nfs 挂载目录

这样nfs服务器中/data/nfs目录中的文件就可以同步到/usr/share/nginx/html文件夹中了

11.5 PV和PVC

nfs存储，需要制定nfs服务器的ip，这在实际生产项目中有诸多的不变为了解决这个问题引入pv和pvc，在yaml文件中指定nfs的别名，根据容量来匹配nfs服务器

  1. PV：持久化存储，对存储资源进行抽象，对外提供可以调用的地方（生产者）
  2. PVC：用于调用，不需要关心内部实现细节（消费者）

11.6 PV和PVC的使用

  1. 在master节点中安装服务

新建pvc.yaml文件，在文件中指定nfs别名

  1. apiVersion: apps/v1
  2. kind: Deployment
  3. metadata:
  4.   name: nginx-dep1
  5. spec:
  6.   replicas: 3
  7.   selector:
  8.     matchLabels:
  9.       app: nginx
  10.   template:
  11.     metadata:
  12.       labels:
  13.         app: nginx
  14.     spec:
  15.       containers:
  16.       - name: nginx
  17.         image: nginx
  18.         volumeMounts:
  19.         - name: wwwroot
  20.           mountPath: /usr/share/nginx/html
  21.         ports:
  22.         - containerPort: 80
  23.       volumes:
  24.       - name: wwwroot
  25.         persistentVolumeClaim:
  26.           claimName: my-pvc #通过别名的方式指定nfs服务器
  28. ---
  30. # 声明nfs服务器别名
  31. apiVersion: v1
  32. kind: PersistentVolumeClaim
  33. metadata:
  34.   name: my-pvc
  35. spec:
  36.   accessModes:
  37.     - ReadWriteMany #匹配模式，pv和pvc是根据容量来匹配的
  38.   resources:
  39.     requests:
  40.       storage: 5Gi

安装pvc服务

  1. kubectl apply -f pvc.yaml

查看pvc服务

  1. kubectl get pvc
  1. 安装pv服务

新建pv.yaml文件

  1. apiVersion: v1
  2. kind: PersistentVolume
  3. metadata:
  4.   name: my-pv
  5. spec:
  6.   capacity:
  7.     storage: 5Gi
  8.   accessModes:
  9.     - ReadWriteMany
  10.   nfs:
  11.     path: /k8s/nfs
  12.     server: 192.168.242.150 # 这个是nfs服务的ip

安装pv服务

  1. kubectl get pv