参考：

网站、视频

  1. 官网https://www.cncf.io/certification/cka/
  3. 大纲https://training.linuxfoundation.cn/certificates/1
  5. k8s官网
  6. 命令查询https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands
  8. 学习指南
  9. https://github.com/David-VTUK/CKA-StudyGuide 
  11. 网络策略专项
  12. https://github.com/ahmetb/kubernetes-network-policy-recipes 
  14. 模拟考试
  15. https://killer.sh 
  17. 视频：
  18. 极客时间：《深入剖析Kubernetes》
  19. 阿里：《云原生技术公开课》
  20. B站：培训视频


网友笔记、指南

  1. 《Kubernetes CKA 证书备考笔记》
  2. https://mp.weixin.qq.com/s/09L3OhW6vO9DpCUOk3zaGg
  3. https://github.com/kabary/kubernetes-cka/wiki/CKA-Killer-20-Questions 
  5. 《CKA备考》
  6. https://www.yuque.com/enjoy-ayk9k/tag9bz/lazqbg
  8. 《CKA考试题目》
  9. https://www.yuque.com/zunlong/yty1dh/oruzdy
  11. 高阶：
  13. 《云原生学习笔记》
  14. https://www.yuque.com/baxiaoshi/tyado3

考试情况简介

报名费：2498。黑色星期五有活动。
17道题，上机。有一次补考机会

大纲：

  1. CKA认证考试包括这些一般领域及其在考试中的权重：
  3. 集群架构，安装和配置：25%    
  4. 工作负载和调度：15%    
  5. 服务和网络：20%
  6. 存储：10%
  7. 故障排除：30%    
  10. 详细内容：
  13. 集群架构，安装和配置：25%
  15. • 管理基于角色的访问控制（RBAC）
  17. • 使用Kubeadm安装基本集群
  19. • 管理高可用性的Kubernetes集群
  21. • 设置基础架构以部署Kubernetes集群
  23. • 使用Kubeadm在Kubernetes集群上执行版本升级
  25. • 实施etcd备份和还原
  29. 工作负载和调度：15%
  31. • 了解部署以及如何执行滚动更新和回滚
  33. • 使用ConfigMaps和Secrets配置应用程序
  35. • 了解如何扩展应用程序
  37. • 了解用于创建健壮的、自修复的应用程序部署的原语
  39. • 了解资源限制如何影响Pod调度
  41. • 了解清单管理和通用模板工具
  45. 服务和网络：20%
  47. • 了解集群节点上的主机网络配置
  49. • 理解Pods之间的连通性
  51. • 了解ClusterIP、NodePort、LoadBalancer服务类型和端点
  53. • 了解如何使用入口控制器和入口资源
  55. • 了解如何配置和使用CoreDNS
  57. • 选择适当的容器网络接口插件
  61. 存储：10%
  63. • 了解存储类、持久卷
  65. • 了解卷模式、访问模式和卷回收策略
  67. • 理解持久容量声明原语
  69. • 了解如何配置具有持久性存储的应用程序
  73. 故障排除：30%
  75. • 评估集群和节点日志
  77. • 了解如何监视应用程序
  79. • 管理容器标准输出和标准错误日志
  81. • 解决应用程序故障
  83. • 对群集组件故障进行故障排除
  85. • 排除网络故障

技巧和效率

  1. 与考点相关的官方文档可以提前加入收藏夹。
  2. 考试时直接根据考点快速查看，相当于建了个索引，能极大提高检索效率。
  4. 尽量从官网复制yaml文件,或用--dry-run=client,
  5. 而不是手打，能大大提高效率，也避免敲错浪费时间。
  7. 善用 --dry-run=client -o yaml 避免手动敲太多
  8. #kubectl create deployment --image=xxx --dry-run=client -o yaml
  10. 灵活利用-h
  12. kubectl 自动补全 
  13. https://kubernetes.io/zh/docs/reference/kubectl/cheatsheet/#kubectl-%E8%87%AA%E5%8A%A8%E8%A1%A5%E5%85%A8
  14. echo "source <(kubectl completion bash)" >> ~/.bashrc; source ~/.bashrc
  16. 每道题开始前要切换 context 和 namespace；
  18. 必要的 alias
  20. 考试系统的 Ctrl+C 、Ctrl+V的替代键为Ctrl+Insert、Shift+Insert。实际考试时可灵活利用

简单

  1. #切换环境？
  2. $ kubectl config use-context k8s
  4. #查看 具有指定标签的Pod 的资源情况
  5. $ kubectl  top po -A -l name=cpu-user
  7. #将ek8s-node-1节点设置为不可用，然后重新调度该节点上的所有Pod
  8. $ kubectl cordon $node-name
  9. $ kubectl drain $node-name --delete-emptydir-data --ignore-daemonsets --force
  10. # --ignore-daemonsets：无视DaemonSet管理下的Pod
  11. # -force：强制执行
  14. 统计这个集群中没有污染的就绪节点，并输出到文件 /root/cka/readyNode.txt
  15. # Ready 状态的数量
  16. $ kubectl get node | grep -w Ready | wc -l
  17. # 查看含有 Taint 的数量，需要排除掉这些
  18. $ kubectl describe node | grep Taints | grep -i NoSchedule | wc -l

练习题

工作负载和调度

Pod内多容器、空目录

创建一个pod名称日志，容器名称 log-pro 使用image busybox，在 /log/data/output.log 输出重要信息。然后另一个容器名称 log-cus 使用 image busybox，在 /log/data/output.log 加载 output.log 并打印它。 请注意，此日志文件只能在 pod 内共享

  1. $ kubectl run busybox-log --image=busybox --dry-run=client -o yaml > busybox-log.yaml
  2. $ cat busybox-log.yaml
  4. #自动生成的yaml文件
  5. apiVersion: v1
  6. kind: Pod
  7. metadata:
  8.   creationTimestamp: null
  9.   labels:
  10.     run: busybox-log
  11.   name: busybox-log
  12. spec:
  13.   containers:
  14.   - image: busybox
  15.     name: busybox-log
  16.     resources: {}
  17.   dnsPolicy: ClusterFirst
  18.   restartPolicy: Always
  19. status: {}
  1. #修改yaml文件
  2. $ vi busybox-log.yaml
  3. spec:
  4.   containers:
  5.   - command:
  6.     - sh
  7.     - -c
  8.     - echo important information > /log/data/output.log; sleep 1d
  9.     image: busybox
  10.     name: log-pro
  11.     resources: {}
  12.     imagePullPolicy: IfNotPresent
  13.     volumeMounts:
  14.     - mountPath: /log/data
  15.       name: log
  16. #增加一个容器
  17.   - command:
  18.     - sh
  19.     - -c
  20.     - tail -f /log/data/output.log
  21.     image: busybox
  22.     name: log-cus
  23.     imagePullPolicy: IfNotPresent
  24.     volumeMounts:
  25.     - mountPath: /log/data
  26.       name: log
  27.   dnsPolicy: ClusterFirst
  28.   restartPolicy: Always
  29.   volumes:
  30.   - name: log
  31.     emptyDir: {}
  32. status: {}

kubectl -n cka apply -f busybox-log.yaml

打印

  1. [root@zm001 cka]# kubectl -n cka exec -it busybox-log -- cat /log/data/output.log
  2. Defaulted container "busybox-pro" out of: busybox-pro, log-cus
  3. information
  5. [root@zm001 cka]# kubectl -n cka exec -it busybox-log -c log-cus -- cat /log/data/output.log
  6. information

Taints和Toleration


  1. #因为master节点一般存在Taints ：node-role.kubernetes.io/master=NoSchedule
  3. tolerations:
  4.   - key: node-role.kubernetes.io/master
  5.     effect: NoSchedule

排序

  1.   kubectl get pod -A --sort-by '.metadata.creationTimestamp'

手动调度Pod

暂时停止 kube-scheduler，这意味着可以在之后再次启动它；
创建一个pod，手动调度该 Pod；
再次启动 kube-scheduler，确保自动调度。

  1. #kube-scheduler属于static pod，因此需要用到kubelet
  3. #查询kube-scheduler相关文件所在的位置
  4. $ cat /var/lib/kubelet/config.yaml | grep -i staticpod
  5. staticPodPath: /etc/kubernetes/manifests
  6. $ ls /etc/kubernetes/manifests
  7. etcd.yaml  kube-apiserver.yaml    kube-controller-manager.yaml  kube-scheduler.yaml
  9. #暂时将文件挪走，并重启kubelet
  10. $ mv /etc/kubernetes/manifests/kube-scheduler.yaml /etc/kubernetes
  11. $ systemctl restart kubelet
  1. #创建pod
  2. $ kubectl run manual-schedule --image httpd:2.4-alpine
  3. $ kubectl get pod | grep manual-schedule
  4. manual-schedule          0/1     Pending   0          16s
  6. #编辑
  7. $ kubectl edit pod manual-schedule
  9. #添加字段nodeName，指定节点名，从而手动调度
  10. nodeName: cka
  12. #检查是否变为running
  1. #恢复scheduler
  2. $ mv /etc/kubernetes/kube-scheduler.yaml /etc/kubernetes/manifests
  3. $ systemctl restart kubelet
  5. #检查是否运行
  6. $ kubectl get pod -A | grep kube-scheduler
  8. #创建
  9. $ kubectl run manual-schedule2 --image httpd:2.4-alpine

其他：

查看指定日志 并输出
kubectl logs foobar | grep unable-access-website >> /opt/KUTR00101/foobar

nodeSelector：调度到指定节点
按如下要求调度一个 pod:
● 名称：nginx-kusc00401
● Image: nginx
● Node slector: disk=ssd

  1. kubectl run --image=nginx nginx-kusc00401 -o yaml --dry-run=client > 9.yml
  3. $ vim 9.yml
  4. //修改为如下，并添加红色字体部分
  5. apiVersion: v1
  6. kind: Pod
  7. metadata:
  8.   name: nginx-kusc00401
  9. spec:
  10.   containers:
  11.   - image: nginx
  12.     name: nginx-kusc00401
  13.   nodeSelector:
  14.     disk: ssd
  16. $ kubectl apply -f 9.yml

集群架构，安装和配置

集群master节点升级

image.png
现有的Kubernetes集权正在运行的版本是1.18.8，仅将主节点上的所有kubernetes控制面板和组件升级到版本1.19.0。另外，在主节点上升级kubelet和kubectl，确定在升级前drain主节点，升级后uncordon主节点，请不要升级工作节点。

  1. 查看master节点所在机器
  2. $ kubectl get nodes
  3. 切换到master节点
  4. $ ssh k8s-master
  5. 将节点标记为不可调度状态
  6. $ kubectl cordon k8s-master
  7. 驱逐节点上面的pod
  8. $ kubectl drain k8s-master --delete-local-data --ignore-daemonsets --force
  9. 升级组件
  10. $ apt-get install kubeadm=1.19.0-00 kubelet=1.19.0-00 kubectl=1.19.0-00
  11. 重启kubelet服务
  12. $ systemctl restart kubelet
  13. 升级集群
  14. $ kubeadm upgrade apply 1.19.0 --etcd-upgrade=false
  15. 将节点标记为可调度状态
  16. $ kubectl uncordon k8s-master

查看集群信息

  1. #显示多个集群
  2. $ kubectl config get-contexts -o name
  4. #将当前集群名，输出到可执行脚本/opt/course/1/context_default_kubectl.sh中
  5. $ cat > /opt/course/1/context_default_kubectl.sh <<EOF
  6. kubectl config current-context
  7. EOF
  8. $ chmod +x /opt/course/1/context_default_kubectl.sh
  10. #得到当前集群名。不使用kubectl命令。
  11. $ cat ~/.kube/config | grep current-context | awk '{print $2}'

检查 master 组件 kubelet、kube-apiserver、kube-scheduler、kube-controller-manager 和 etcd 如何在 master 节点上启动/安装。还要找出 DNS 应用的名称以及它是如何在主节点上启动/安装的。

思路：当前比较的组件都是以static pod的形式运行的，而 static pod 都是由 Kubelet 管理的，所以从 kubelet 处入手。

  1. [root@zm cka]# ps -ef | grep -w kubelet
  3. root     17281     1  1 Apr15 ?        
  4. 01:00:00 /usr/bin/kubelet 
  5. --bootstrap-kubeconfig=/etc/kubernetes/bootstrap-kubelet.conf 
  6. --kubeconfig=/etc/kubernetes/kubelet.conf 
  7. --config=/var/lib/kubelet/config.yaml 
  8. --network-plugin=cni 
  9. --pod-infra-container-image=registry.aliyuncs.com/google_containers/pause:3.6

定位到—kubeconfig=/etc/kubernetes/kubelet.conf 

  1. [root@zm cka]# cat /var/lib/kubelet/config.yaml
  2. apiVersion: kubelet.config.k8s.io/v1beta1
  3. authentication:
  4.   anonymous:
  5.     enabled: false
  6.   webhook:
  7.     cacheTTL: 0s
  8.     enabled: true
  9.   x509:
  10.     clientCAFile: /etc/kubernetes/pki/ca.crt
  11. authorization:
  12.   mode: Webhook
  13.   webhook:
  14.     cacheAuthorizedTTL: 0s
  15.     cacheUnauthorizedTTL: 0s
  16. cgroupDriver: systemd
  17. clusterDNS:
  18. - 10.96.0.10
  19. clusterDomain: cluster.local
  20. cpuManagerReconcilePeriod: 0s
  21. evictionPressureTransitionPeriod: 0s
  22. fileCheckFrequency: 0s
  23. healthzBindAddress: 127.0.0.1
  24. healthzPort: 10248
  25. httpCheckFrequency: 0s
  26. imageMinimumGCAge: 0s
  27. kind: KubeletConfiguration
  28. logging:
  29.   flushFrequency: 0
  30.   options:
  31.     json:
  32.       infoBufferSize: "0"
  33.   verbosity: 0
  34. memorySwap: {}
  35. nodeStatusReportFrequency: 0s
  36. nodeStatusUpdateFrequency: 0s
  37. rotateCertificates: true
  38. runtimeRequestTimeout: 0s
  39. shutdownGracePeriod: 0s
  40. shutdownGracePeriodCriticalPods: 0s
  41. staticPodPath: /etc/kubernetes/manifests
  42. streamingConnectionIdleTimeout: 0s
  43. syncFrequency: 0s
  44. volumeStatsAggPeriod: 0s

查找staticpod线索

  1. cgroupDriver: systemd
  2. clusterDNS:
  3. - 10.96.0.10
  4. staticPodPath: /etc/kubernetes/manifests
  6. #查找staticpod相关信息
  7. [root@zm manifests]# cat /var/lib/kubelet/config.yaml | grep -i staticpod
  8. staticPodPath: /etc/kubernetes/manifests

进入staticPodPath: /etc/kubernetes/manifests

  1. [root@zm manifests]# ls /etc/kubernetes/manifests
  2. etcd.yaml  kube-apiserver.yaml  kube-controller-manager.yaml  kube-scheduler.yaml
  1. [root@zm manifests]# kubectl get pod -A | grep dns
  2. kube-system   coredns-6d8c4cb4d-gdttk      1/1     Running            0                2d6h
  3. kube-system   coredns-6d8c4cb4d-wr27t      1/1     Running            0                2d6h

集群备份和恢复

对在 cluster3-master1 上运行的 etcd 进行备份，并将其保存在主节点上的 /tmp/etcd-backup.db。

  1. #操作 etcd 需要 endpoints、cacert、cert、key。Kubernetes 
  2. 的所有组件与 etcd 的数据交互都是通过 api-server 完成的，
  3. 我只需要找到 api-server 的运行命令就行
  5. #查找apiserver启动参数 中的相关路径    
  6. $ ps -ef | grep kube-apiserver
  7. $ kubectl get pod -n kube-system kube-apiserver-cka -o jsonpath='{.spec.containers[].command}'
  10. [root@zm ~]# kubectl get pod -n kube-system kube-apiserver-zm -o jsonpath='{.spec.containers[].command}'
  11. ["kube-apiserver","--advertise-address=172.23.178.70","--allow-privileged=true","--authorization-mode=Node,RBAC","--client-ca-file=/etc/kubernetes/pki/ca.crt","--enable-admission-plugins=NodeRestriction","--enable-bootstrap-token-auth=true","--etcd-cafile=/etc/kubernetes/pki/etcd/ca.crt","--etcd-certfile=/etc/kubernetes/pki/apiserver-etcd-client.crt","--etcd-keyfile=/etc/kubernetes/pki/apiserver-etcd-client.key","--etcd-servers=https://127.0.0.1:2379","--kubelet-client-certificate=/etc/kubernetes/pki/apiserver-kubelet-client.crt","--kubelet-client-key=/etc/kubernetes/pki/apiserver-kubelet-client.key","--kubelet-preferred-address-types=InternalIP,ExternalIP,Hostname","--proxy-client-cert-file=/etc/kubernetes/pki/front-proxy-client.crt","--proxy-client-key-file=/etc/kubernetes/pki/front-proxy-client.key","--requestheader-allowed-names=front-proxy-client","--requestheader-client-ca-file=/etc/kubernetes/pki/front-proxy-ca.crt","--requestheader-extra-headers-prefix=X-Remote-Extra-","--requestheader-group-headers=X-Remote-Group","--requestheader-username-headers=X-Remote-User","--secure-port=6443","--service-account-issuer=https://kubernetes.default.svc.cluster.local","--service-account-key-file=/etc/kubernetes/pki/sa.pub","--service-account-signing-key-file=/etc/kubernetes/pki/sa.key","--service-cluster-ip-range=10.96.0.0/12","--tls-cert-file=/etc/kubernetes/pki/apiserver.crt","--tls-private-key-file=/etc/kubernetes/pki/apiserver.key"]

https://kubernetes.io/zh/docs/tasks/administer-cluster/configure-upgrade-etcd/#%E5%A4%87%E4%BB%BD-etcd-%E9%9B%86%E7%BE%A4

  1. #备份到/tmp/etcd-backup.db
  2. #替换-cacert，-cert=<> --key=<>
  3. $ETCDCTL_API=3 etcdctl --endpoints=https://127.0.0.1:2379 \
  4.   --cacert=<> --cert=<> --key=<> \
  5.   snapshot save /tmp/etcd-backup.db
  8.   #恢复到/var/lib/etcd-backup
  9.   #替换-cacert，-cert=<> --key=<>
  10.   $ ETCDCTL_API=3 etcdctl --endpoints=https://127.0.0.1:2379 \
  11.   --cacert=<> \
  12.   --cert=<>\
  13.   --key=<> snapshot restore /tmp/etcd-backup.db \
  14.   --data-dir /var/lib/etcd-backup

查看证书有效期

  1. $ ps -ef | grep kube-apiserver
  2. #查看文件路径和文件名
  3. --tls-cert-file=/etc/kubernetes/pki/apiserver.crt
  5. #替换
  6. $ openssl x509 -noout -text -in /etc/kubernetes/pki/apiserver.crt | grep -i valid -A2
  8. [root@zm ~]# openssl x509 -noout -text -in /etc/kubernetes/pki/apiserver.crt | grep -i valid -A2
  9.         Validity
  10.             Not Before: Apr 15 02:56:59 2022 GMT
  11.             Not After : Apr 15 02:56:59 2023 GMT

RBAC

https://kubernetes.io/zh/docs/reference/access-authn-authz/rbac/#role-and-clusterole

  1. kubectl create serviceaccout xxx -n <name_space>
  3. kubectl create clusterrole xxx --resource="deployment,statefulSet,daemonSet" --verb="create"
  5. kubectl create rolebinding xxx --clusterrole=xxx
  6. --serviceaccount="<name_space>:xxx" -n <name_space>

存储

创建PV，PVC并挂载

https://kubernetes.io/zh/docs/tasks/configure-pod-container/configure-persistent-volume-storage/

  1. 创建一个名为 safari-pv 的新 PersistentVolume。它应该具有 2Gi 的容量、
  2. accessMode ReadWriteOnce、hostPath /Volumes/Data 并且没有定义 storageClassName
  4. apiVersion: v1
  5. kind: PersistentVolume
  6. metadata:
  7.   name: safari-pv
  8.   labels:
  9.     type: local
  10. spec:
  11.   capacity:
  12.     storage: 2Gi
  13.   accessModes:
  14.     - ReadWriteOnce
  15.   hostPath:
  16.     path: "/Volumes/Data"
  18. 接下来在命名空间 project-tiger 中创建一个
  19. 名为 safari-pvc 的新 PersistentVolumeClaim。 它应该请求 2Gi 存储，
  20. accessMode ReadWriteOnce 并且不应定义 storageClassName。 PVC 应该正确绑定到 PV。
  22. apiVersion: v1
  23. kind: PersistentVolumeClaim
  24. metadata:
  25.   name: safari-pvc
  26. spec:
  27.   accessModes:
  28.     - ReadWriteOnce
  29.   resources:
  30.     requests:
  31.       storage: 2Gi
  33. 最后在命名空间 project-tiger 中创建一个新的 Deployment safari，
  34. 它将该卷挂载到 /tmp/safari-data。该 Deployment 的 Pod 应该是镜像 httpd:2.4.41-alpine。
  36. $ kubectl create deployment safari --image httpd:2.4.41-alpine --dry-run=client -o yaml
  38. 编辑：
  39. 。。。前面部分省略
  40.  template:
  41.     metadata:
  42.       creationTimestamp: null
  43.       labels:
  44.         app: safari
  45.     spec:
  46.       containers:
  47.       - image: httpd:2.4.41-alpine
  48.         name: httpd
  49.         resources: {}
  50.         volumeMounts:
  51.         - mountPath: /tmp/safari-data
  52.           name: data
  53.       volumes:
  54.       - name: data
  55.         persistentVolumeClaim:
  56.           claimName: safari-pvc

故障排除

服务和网络

网络策略 NetworkPolicy

https://kubernetes.io/zh/docs/concepts/services-networking/network-policies/
在现有的 namspace fubar 中创建一个名为 allow-port-from-namespace 的新 NetworkPolicy
确保新的 NetworkPolicy 允许 namespace internal 中的 Pods 连接到 namespace fubar 中的 Pods 端口 9200

  1. kubectl label ns internal ns=internal
  3. [student@node-1]$ vim 5.yaml
  4. apiVersion: networking.k8s.io/v1
  5. kind: NetworkPolicy
  6. metadata:
  7.   name: allow-port-from-namespace
  8.   namespace: fubar
  9. spec:
  10.   podSelector: {}
  11.   policyTypes:
  12.   - Ingress
  13.   ingress:
  14.   - from:
  15.     - namespaceSelector:
  16.       matchLabels:
  17.         ns: internal
  18.     ports:
  19.     - protocol: TCP
  20.       port: 9200

Ingress

https://kubernetes.io/zh/docs/concepts/services-networking/ingress/

如下创建一个新的 nginx Ingress 资源：
● 名称：pong
● Namespace: ing-internal
● 使用服务端口 5678 在路径/hello 上公开 service hello

  1. [student@node-1]$ kubectl get ingressclass
  2. //检查是否有 ingressclass，如果有，记录名字
  4. [student@node-1]$ kubectl create ingress pong -n ing-internal --rule='/hello=hello:5678' --class=nginx
  5. //检查如果有 ingressclass，则指定，否则忽略--class=nginx

附：

灵雀云CKA线上培训课程大纲
30课时

  1. 一、kubernetes框架
  3. 了解kubernetes的框架
  5. 了解kubernetes各个组件的含义
  7. 二、kubernetes安装
  9. etcd管理
  11. etcd快照管理
  13. kubeadmin安装
  15. 多集群之间切换
  17. 了解什么是命名空间
  19. 命名空间管理
  21. 三、pod及节点管理
  23. 创建查询及删除pod
  25. 了解pod重启策略
  27. 在pod中运行指定命令
  29. pod中变量的设置
  31. 在pod中执行命令
  33. pod的调度策略
  35. 通过label手动指定pod运行的节点
  37. 初始化容器 （init container）
  39. 静态pod （static pod）
  41. 节点cordon及uncordon管理
  43. 四、密码管理
  45. 使用secret管理密码
  47. 以卷的方式引用密码
  49. 以变量的方式引用密码
  51. 使用configmap管理密码
  53. 五、deployment
  55. 理解deployment的作用
  57. 通过命令行的方式快速deployment
  59. 通过YAML方式创建deployment
  61. 使用deployment对镜像版本进行升级及回滚
  63. 使用deployment管理pod副本数
  65.     弹性伸缩
  67.     滚动升级
  69.     自动弹性伸缩
  71. 六、健康性检查
  73. pod的默认检查策略
  75. 通过liveness对pod健康性检查
  77. 使用readiness对pod健康性检查
  79. 健康性检查在各种环境中的应用
  81. 七、daemonset
  83. 八、服务发现
  85. 理解service的工作原理
  87. 服务的类型: clusterIP, NodePort, LoadBalancer，ingress
  89. 服务的发现
  91.     环境变量
  93.     DNS
  95. 九、存储管理
  97. 本地卷
  99.    emptyDir
  101.    hostPath
  103. 网络数据卷
  105.    NFS
  107.    iscsi
  109. 持久性存储
  111.    persistent volume
  113.    persistent volumeclaim
  115. 十、job
  117. 创建job
  119. 了解job中pod的重启策略
  121. 计划任务job
  123. 十一、网络模型
  125. kubernetes跨机器通信原理
  127. flannel网络
  129. calico网络
  131. cancl网络
  133. 网络策略
  135. 十二、kubernetes日志管理
  137. Kubernetes日志收集方法介绍
  139. ELK概述及部署
  141. ELK日志管理
  143. 十三kubernetes监控
  145. 监控方案
  147. 使用prometheus监控
  149. 十四、Kubernetes应用部署HelmChart
  151. Helm工具的架构和安装使用
  153. Charts的概念和使用
  155. 十五、安全及配额管理
  157. 安全管理
  159.    API服务器认证及授权
  161.    Authorization（ABAC，RBAC）
  163.    Service Account
  165. 资源限制
  167.    LimitRange
  169.    ResourceQuota
  171.    Security Contexts
  173. 十六、DevOps
  175. 了解devops
  177. gitlab配置
  179. 安装及配置Jenkins
  181. 使用gitlab+Jenkins+kubernetes建立CI/CD解决方案