k8s学习笔记

K8S

Helm ： Kubernetes包管理器，类似dockerhub

K8S节点图

应用关系

集群部署

kubectl语法

• kubectl [command] [type] [name] [flags]
• command：指定对资源的操作如create，delete
• type：资源类型，如deplyment pod
• name：资源名称，大小写敏感
• flags：额外的可选参数

命令分类

命令分类	命令	作用
基本命令	create	创建一个资源
	edit	编辑一个资源
	get	获取一个资源
	patch	更新一个资源
	delete	删除一个资源
	explain	展示一个资源
运行和调试	run	在集群中运行一个指定的镜像
	expose	暴露资源为service
	describe	显示资源内部信息
	logs	输出容器在pod中的日志
	attach	进入运行的容器
	exec	执行容器中的一个命令
	cp	在pod内外复制文件
	rollout	管理资源等等发布
	scale	扩缩容pod数量
	autoscale	自动调整pod数量
高级命令	apply	通过文件对资源进行配置
	label	更新资源上的标签
其他命令	cluster-info	显示集群信息
	version	显示当前server和client的版本

kubectl中创建资源，直接用下面的命令，xxx.yml就是资源的配置文件

kubectl apply -f xxx.yml 

# 查看kubectl版本
kubectl version
kubectl get all

名称空间(Namespace)

• 名称空间用来隔离资源，不隔离网络

命令行形式创建和删除名称空间

kubectl create ns aaa
kubectl delete ns aaa

配置文件形式创建和删除名称空间

apiVersion: v1 # 版本号
kind: Namespace #资源类型
metadata: # 元数据
  name: aaa # 名称空间名字

kubectl apply -f xxx.yml 

kubectl create/get -f xxx.yml
kubectl delete -f xxx.yml 

Pod

• 运行中的一组容器，是k8s中的最小单位
• 每一个pod，k8s都会分配一个ip，私有ip
• 同一个pod内共享网络空间，共享存储，所以同一个pod的容器，想要访问pod内其他容器直接localhost
• 每一个pod都会有一个根容器，可以根据它评估pod的健康状态。

# 创建一个pod，名字为（mypod）
kubectl run mypod --image=nginx

# 每隔1秒运行，查看pod
watch -n 1 kubectl get pod
# 查看所有pod
kubectl get pod -A
# 查看所有pod，状态变化过程
kubectl get pod -w
# 查看pod，默认查看的是default名称空间下的pod
kubectl get pod
# 查看pod详细的信息，出力的内容里有(Events:事件)
kubectl describe pod mypod
# 删除pod，删除的是默认的名称空间default里面的pod
kubectl delete pod mypod
# 删除aaa名称空间里面的 pod
kubectl delete pod mypod -n aaa
# 查看pod更完善的信息
kubectl get pod -owide
# 进入pod里面
kubectl exec -it mypod -n aaa -- /bin/bash
# 如果pod里面有多个容器，进入具体的容器-c nginx
kubectl exec -it mypod -n aaa -c nginx -- /bin/bash

# 查看pod的标签
kubectl get pod --show labels

# 查看每种资源的可配置项
# kubectl explain 资源
# kubectl explain 资源.属性
kubectl explain pod
kubectl explain pod.medtadata

# 查看版本，由k8s内部定义
kubectl api-versions
# 查看资源，由k8s内部定义
kubectl api-resources

# 每隔1秒运行，查看pod
watch -n 1 kubectl get pod

配置文件创建一个pod，里面包含一个容器

apiVersion: v1 # 版本号
kind: Pod #资源类型
metadata: # 元数据
  labels: #标签
    run: mypod
  name: mypod # Pod名字
spec: #对各种资源配置的详细描述
  containers:
  - image: nginx # 镜像
    # Always 总是用远程仓库的
    # IfNotPresent 如果本地有，就使用本地的，本地没有就用远程仓库的
    # Never 总是使用本地的
    # 如果镜像tag是版本号，默认是IfNotPresent，如果镜像tag是latest默认是Always
    imagePullPolicy: Always # 镜像拉取策略
    name: nginx # 镜像别名
    command: # <[]string> #容器启动的命令
    - /bin/sh
    args: # <[]string> #容器启动命令需要的参数
    - aa
    env: # <[]object> #容器环境变量配置
    - name: "name" 
      value: "value"
    ports: # <[]object> #容器需要暴露的端口号列表
    - name: "ngnix-port" #端口名称
      containerPort: 80 #容器要监听的端口
      protocol: TCP #端口协议 TCP,UDP,SCTP
    resources: # <object> #资源限制和资源请求的设置
      limits: # 限制资源(上限) 当资源超过了就会重启
        cpu: "2m" #可以为整数或小数
        memory: "20Mi" # Gi，Mi，G，M
      requests:# 请求资源(下限) 如果资源不够则无法启动
        cpu: "1m"
        memory: "5Mi"
    lifecycle: # 初始化容器，执行顺序从上到下，先mysql，再redis。
      postStart: #容器启动后钩子
        #tcpSocket: 在当前容器访问指定的socket
        #httpGet: 在当前容器发起http请求
        exec: #在当前容器内执行命令
          command:
          - ll
      preStop: #容器终止前钩子
        exec: #在当前容器内执行命令
          command:
          - pwd
    livenessProbe: # 存活性探针，检查当前实例是否是正常运行状态，如果不是，k8s会重启
      exec: #在当前容器内执行命令
        command:
        - ll
      tcpSocket: #在当前容器访问指定的socket
        port: 8080 #尝试访问8080端口
      httpGet: #在当前容器发起http请求
        scheme: HTTP #请求的协议http，https
        prot: 80 #端口号
        path: /hello #URI地址
      initialDelaySeconds: #容器启动后等待多少秒执行第一次探测
      timeoutSeconds: #探测超时时间
      periodSeconds: #执行探测的频率
      failureThreshold: #连续探测失败多少次才认定失败
      successThreshold: #连续探测成功多少次认定成功
    readnessProbe: # 就绪性探针，检查当前实例是否可以接收请求，如果不是，k8s不会将请求转进来
  - image: tomcat # 镜像
    name: tomcat # 镜像别名
  initContainers: # 初始化容器，执行顺序从上到下，先mysql，再redis。
  - image: mysql # 镜像
    name: mysql
  - image: redis # 镜像
    name: redis
  restartPolicy: Never #容器重启策略，Always容器失效时自动重启，默认值。OnFailure容器终止运行且退出码不为0时重启。Never不重启容器
  nodeName: node1 # 定向调度，根据节点名字
  nodeSelector:
    nodeabc: deve #定向调度，根据节点的标签，将pod调度到具有nodeabc=deve标签的节点上
  affinity: # 亲和性设置
    #nodeAffinity: node亲和性
    #podAffinity: pod亲和性
    #podAntiAffinity: pod反亲和性
  tolerations: # 容忍调度
  - key: "youname" #容忍污点的key
    operator: "Equal" #操作符 =
    value: "abcd" #容忍污点的value
    effect: "PreferNoSchedule" #容忍污点的effect，容忍规则
    

pod的生命周期

• pod创建
• 运行初始化容器 init container
• 运行主容器 main container
• 容器启动后钩子post start ，容器终止前钩子pre stop
• 容器的存活性探针 liveness probe 容器的就绪性探针 readliness probe
• pod终止

pod调度

• 自动调度
• 定向调度[pod角度]：NodeName（根据节点名字）， NodeSelector（根据节点的标签）
• 亲和性调度[pod角度]：NodeAffinity（node亲和性），PodAffinity（pod亲和性），PodAntiAffinity（pod反亲和性）
• 污点调度[node角度]： Taints(污点)，node设置污点之后就和pod产生一种相斥关系。
  • 污点格式key=value:effect (key=value)是污点的标签，(effect)是描述的污点作用。master节点默认有污点。
  • PreferNoSchedule：尽量不调度过来
  • NoSchedule：新的不要调度过来，已经存在的就保持
  • NoExecute：新的不要调度过来，已经存在的也赶走
• 容忍调度[node角度]：Toleration（容忍），即使node有污点，也可以容忍调度。

# 设置污点
#kubectl taint nodes node1 key=value:effect
kubectl taint nodes node1 youname=abcd:PreferNoSchedule
# 去除污点
#kubectl taint nodes node1 key=effect-
kubectl taint nodes node1 youname=PreferNoSchedule-
# 去除所有污点
#kubectl taint nodes node1 key-
kubectl taint nodes node1 youname-

标签(Label)

# 为pod资源打标签
kubectl label pod mpod version=1.0 -n aaa
#  更新pod资源标签
kubectl label pod mpod version=2.0 -n aaa --overwrite
# 查看标签
kubectl get pod mpod -n aaa --show-labels
# 筛选标签
kubectl get pod mpod -n aaa version=2.0 --show-labels
kubectl get pod mpod -n aaa version!=2.0 --show-labels
# 删除标签
kubectl label pod mpod -n aaa version-

# 为node资源打标签
kubectl label nodes mpod version=1.0

ReplicaSet(RS)

• 保证一定数量的pod正常运行，会持续监听pod状态，一旦pod故障就会重启pod

kubectl get rs
# 修改rs，然后是以yml形式打开部署，之后更改配置
kubectl edit rs rs-a -n dev

apiVersion: apps/v1 # 版本号
kind: ReplicaSet #资源类型
metadata: # 元数据 包含了 Pod 的元数据,例如名称、标签、命名空间
  labels: #标签
    app: mydev
  name: mydev # 部署名字
spec: # 定义了 部署的行为和构建
  replicas: 3
  selector: 
    matchLabels:
      app: mydev
  template: # 模板
    metadata:
      labels: #标签
        app: mydev
    spec:
      containers:
      - image: nginx # 容器镜像地址
        name: mypod # 容器名称

部署(Deployment)

• 通过控制ReplicaSet来控制pod，使pod拥有多副本，自愈，故障转移，扩缩容，滚动更新等等
• Deployment进行滚动更新时，会新建ReplicaSet，然后在新建ReplicaSet里面新建pod，然后删除旧ReplicaSet里面pod。最终旧ReplicaSet下pod变成0，但是k8s不会删除旧的ReplicaSet，主要是用来做版本回退。

# 创建一个部署，名字为（mydev） 并启动3个pod副本【多副本】
# pod副本的名字为 mydev-xxx 其中xxx是自动生成的序列号随机的。--record会记录每次更新的过程
kubectl create deployment mydev --image=nginx --replicas=3 --record
# 删除pod，但由于该pod是部署mydev启动的pod副本，所有删除后，部署（mydev）又会重新启动一个新的pod【自愈】。
kubectl delete pod mydev-xxx

# 查看部署，默认是defalult名称空间
kubectl get deployment

# 查看部署，以yml形式输出
kubectl get deployment -o yaml

# 查看部署，以json形式输出
kubectl get deployment -o json

# 删除部署，部署的pod副本都会被删除
kubectl delete deployment mydev

apiVersion: apps/v1 # 版本号
kind: Deployment #资源类型
metadata: # 元数据 包含了 Pod 的元数据,例如名称、标签、命名空间
  labels: #标签
    app: mydev
  name: mydev # 部署名字
spec: # 定义了 部署的行为和构建
  replicas: 3 #副本数量
  revisionHistoryLimit: 3 #保留历史版本，默认10
  paused: false #暂停部署，默认false
  progressDeadlineSeconds: 600 #部署时间超过(s)
  strategy: #策略
    #type: Recreate 在创建新pod之前，会关掉所有老版本的pod
    type: RollingUpdate #滚动更新策略，先启动一个新的，然后关闭一个旧的。
    rollingUpdate: #滚动更新
      maxSurge: 30% #最大额外可以存在的副本数
      maxUnavailable: 30% #最大不可用状态的pod最大值
  selector: 
    matchLabels:
      app: mydev
  template:
    metadata:
      labels: #标签
        app: mydev
    spec:
      containers:
      - image: nginx # 容器镜像地址
        name: mypod # 容器名称

扩缩容

# 扩容量，缩容量 【deployment/mydev】是扩容或者缩容，哪个部署。默认是default名称空间
kubectl scale deployment/mydev --replicas=5 
kubectl scale deployment mydev --replicas=5 

# 修改部署，然后是以yml形式打开部署，之后更改配置
kubectl edit deployment mydev

滚动更新

• 不停机更新应用

# 更新镜像 nginx=是原来部署中的镜像名字,nginx:1.15.1镜像的版本 --record代表记录更新
kubectl set image deployment mydev nginx=nginx:1.15.1 --record

版本回退

• kubectl rollout 版本升级选项
  • status 显示当前升级状态
  • history 显示升级历史记录
  • pause 暂停版本升级过程
  • resume 继续已经暂停的版本升级过程
  • restart 重启版本升级过程
  • undo 回滚到上一个版本

# 显示当前升级状态
kubectl rollout status deployment mydev
# 历史记录
kubectl rollout history deployment/mydev
# 查看某个历史详情 2是历史记录中的版本号
kubectl rollout history deployment/mydev --revision=2
# 回滚到上次
kubectl rollout undo deployment/mydev
# 回滚到指定版本
kubectl rollout undo deployment/mydev --to-revision=2

工作负载

• Deployment：如果pod宕机了，在其他node中重启了pod，那么pod之前数据就没有了。
• StateFulSet：如果pod宕机了，在其他node中重启了pod，那么pod之前数据，还可以挂载访问。提供稳定的存储功能

Horizontal Pod Autoscaler(HPA)

• 获取pod的利用率，然后动态的扩缩容
  

kubectl get hpa -n dev

apiVersion: autlscaling/v1 # 版本号
kind: HorizontalPodAutoscaler #资源类型
metadata: # 元数据
  name: myhpa # HPA名字
spec:
  minReplicas: 1 #最小pod数
  maxReplicas: 3 #最大pod数
  targetCPUUtilizationPercentage: 3 #cpu使用率指标
  scaleTargetRef: #要控制的信息
    apiVersion: apps/v1
    kind: Deployment
    name: mydev #要控制的部署的名字

DaemonSet(DS)

• 保证集群中，每一台（或指定）节点上都运行一个副本，一般用于日志收集
• 每当向集群中添加一个节点时，就会向DaemonSet中添加一个pod的副本
• 当节点从集群中移除，pod也就被垃圾回收了。
  

apiVersion: apps/v1 # 版本号
kind: DaemonSet #资源类型
metadata: # 元数据
  name: myds # DS名字
spec: # 定义了 部署的行为和构建
  revisionHistoryLimit: 3 #保留历史版本，默认10
  strategy: #策略
    type: RollingUpdate #滚动更新策略，先启动一个新的，然后关闭一个旧的。
    rollingUpdate: #滚动更新
      maxSurge: 30% #最大额外可以存在的副本数
      maxUnavailable: 30% #最大不可用状态的pod最大值
  selector: 
    matchLabels:
      app: myds
  template:
    metadata:
      labels: #标签
        app: myds
    spec:
      containers:
      - image: nginx # 容器镜像地址
        name: mypod # 容器名称

Job

• 负责处理批量，一次性任务。
• 当jod创建的pod执行成功后，会记录pod的数量
• 当成功执行的pod达到指定数量时，job将完成执行

apiVersion: batch/v1 # 版本号
kind: Job #资源类型
metadata: # 元数据
  name: myjob # Job名字
spec: # 定义了 部署的行为和构建
  completions: 1 #指定jod需要成功运行pods的次数
  parallelism: 1 #指定pod并发数量
  activeDeadLineSeconds: 30 #指定pod可运行的时间期限
  backoffLimit: 6 #指定job失败后重试的次数
  manualSelector: true #是否可以使用selector选择器选择pod，默认是false
  selector: 
    matchLabels:
      app: myjob
  template:
    metadata:
      labels: #标签
        app: myjob
    spec:
      restartPolicy: Never #重启策略只能设置为Never或OnFailure
      containers:
      - image: nginx # 容器镜像地址
        name: mypod # 容器名称

CronJob(CJ)

• 可以在特定的时间，周期性的重复去执行job
  

apiVersion: batch/v1beta1 # 版本号
kind: CronJob #资源类型
metadata: # 元数据
  name: mycronjob # Job名字
spec: # 定义了 部署的行为和构建
  #cron格式
  #1      *    *   *   *
  #<分钟><小时><日><月><星期>
  schedule: #cron格式的调度运行时间
  concurrencyPolicy: # 并发策略
  failedJobHisotryLimit: #为成功的任务执行保留历史记录
  successfulJobHistoryLimit: #为失败的任务执行保留历史记录
  startingDeadlineSeconds: #启动作业错误的超时时长
  jobTemplate: #job控制器模板
    metadata:
    spec: # 定义了 部署的行为和构建
      completions: 1 #指定jod需要成功运行pods的次数
      parallelism: 1 #指定pod并发数量
      activeDeadLineSeconds: 30 #指定pod可运行的时间期限
      backoffLimit: 6 #指定job失败后重试的次数
      manualSelector: true #是否可以使用selector选择器选择pod，默认是false
      selector: 
        matchLabels:
          app: myjob
      template:
        metadata:
          labels: #标签
            app: myjob
        spec:
          restartPolicy: Never #重启策略只能设置为Never或OnFailure
          containers:
          - image: nginx # 容器镜像地址
            name: mypod # 容器名称

服务(Service)

• 将一组pod公开为网络服务
• service只是一个概念，真正起作用的是kube-proxy
• service下会生成Endpoints。
• Endpoints是k8s的一种资源，存储在etcd中。作用是建立service和pod的关联，用来记录一个service对应的所有pod的访问地址

# 对外暴露服务 port是外部可以访问的服务端口，--target-port是pod的容器端口
# 集群内任意访问
kubectl expose deployment mydev --port=8000 --target-port=80
# ClusterIP是集群ip，即只能在集群内部访问，和上面的命令同样的作用
kubectl expose deployment mydev --port=8000 --target-port=80 --type=ClusterIP
# NodePort是，在集群内部或 集群外部都 能访问
# 此时该service的端口变为例如（8000:30948/TCP）其中前面8080是集群内部访问的端口，30948是集群外部访问的端口
# NodePort 默认范围是30000-32767之间
kubectl expose deployment mydev --port=8000 --target-port=80 --type=NodePort
#删除部署的服务
kubectl delete service mydev

# 服务的域名为（服务名.所在的名称空间.svc）
# 上记域名只能在其他pod内访问，直接在pod外机器上访问是不行的。
curl mydev.aaa.svc

kubectl describe service mydev

kubectl get service

kubectl get endpoints

#进入容器后
cat /etc/resolv.conf

apiVersion: v1 # 版本号
kind: Service #资源类型
metadata: # 元数据
  labels: #标签
    app: myservice
  name: myservice # service名字
spec:
  selector: 
    app: mypod # 根据pod的标签选择pod
  type: clusterIP #service类型 默认值，只能在集群内访问
  clusterIP: 10.100.11.1#集群ip，不写默认会生成一个
  #clusterIP: None #将clusterIP设置为None，即可创建headliness Service ，不会生成clusterIP只能通过域名访问
  #type: NodePort #将暴露端口给外部，集群外部也能访问，通过端口号31100
  #type: LoadBalancer #将暴露端口给外部，使用外部负载均衡器完成到服务器的负载分发
  #type: ExternalName #把集群外部的服务，引入集群内部
  #externalName: www.baidu.com
  serssionAffinity: #serssion亲和性
  ports:
  - port: 8000
    protocol: TCP
    targetPort: 80
    # nodePort: 31100 #NodePort 不指定默认会在30000-32767之间分配一个

入口(Ingress)

• service的统一网关入口
• 不是k8s自带的资源，要下载。
• 和nginx类似的功能

• 访问order.atguigu.com就会访问service a
• 访问user.atguigu.com就会访问service b

# 查看入口
kubectl get ingress

apiVersion: networking.k8s.io/v1 # 版本号
kind: Ingress #资源类型
metadata: # 元数据
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /$2 # 路径重写
    nginx.ingress.kubernetes.io/limit-rps: "1" # 流量限制
  name: my-ingress 
spec:
  ingressClassName: nginx
  #tls: 此方式是https的请求
  #- hosts:
  #  - order.atguigu.com
  #  - user.atguigu.com
  #  secretName: tls-secret #指定密钥
  rules:
 - host: "order.atguigu.com" # 匹配域名
    http:
      paths:
      - type: Prefix # 前缀模式
        path: "/" #以/开始的所有服务
        backend:
          service:
            name: a # service的名字
            port:
             number: 8000 # serivce的端口号
 - host: "user.atguigu.com" # 匹配域名
    http:
      paths:
      - type: Prefix　　#Exact精确模式
        path: "/user(/|$)(.*)" # 路径重写 即访问 user.atguigu.com/user/name --> user.atguigu.com/name
        backend:
          service:
            name: b
            port:
             number: 8000

存储抽象

挂载目录

• 原始方式挂载
• 输出存储 : emptyDir，hostPath，nfs

apiVersion: apps/v1 # 版本号
kind: Deployment #资源类型
metadata: # 元数据 包含了 Pod 的元数据,例如名称、标签、命名空间
  labels: #标签
    app: mydev
  name: mydev # 部署名字
spec: # 定义了 部署的行为和构建
  replicas: 2
  selector: 
    matchLabels:
      app: mydev
  template:
    metadata:
      labels: #标签
        app: mydev
    spec:
      containers:
      - image: nginx # 镜像
        name: nginx # 镜像别名
        volumeMounts: # 卷挂载
        - name: html1 #挂载到外部，名字叫做html1
          mountPath: /usr/shard/nginx/html # 镜像内部的路径
      volumes:
        - name: html1 # 挂载方式，就是上面的html1
        nfs: #nfs形式挂载
          server: 10.11.101.1 # 挂载到外部的服务器
          path: /usr/shard/mydev1 #挂载到的地址

• pv: 持久卷，将应用需要持久化的数据保存到指定位置
• pvc：持久卷申明，申明需要使用的持久卷规格
  

# 查看资源 持久化卷
kubectl get persistentvolume
kubectl get pv

• 创建PV

apiVersion: v1 
kind: PersistentVolume # 持久化卷
metadata:
  name: pv01
spec:
  capacity:  # 容量
    storage: 10M
  accessModes:
  - ReadWriteMany # 读写模式，可读可写多节点
  storageClassName: nfss
  nfs:
    path: /nfs/data/01 # 外部电脑中的路径，需要提前创建好目录
    server: 10.11.101.1
---
apiVersion: v1 
kind: PersistentVolume # 持久化卷
metadata:
  name: pv02
spec:
  capacity:  # 容量
    storage: 1gi
  accessModes:
  - ReadWriteMany # 读写模式，可读可写多节点
  storageClassName: nfss
  nfs: #网络文件存储系统
    path: /nfs/data/02　# 外部电脑中的路径，需要提前创建好目录
    server: 10.11.101.1

# 查看资源 持久化卷申请书
kubectl get persistentvolumeclaim
kubectl get pvc

• 创建PVC

apiVersion: v1 
kind: PersistentVolumeClaim # 持久化卷
metadata:
  name: ng-pv
spec:
  accessModes:
 - ReadWriteMany # 读写模式，可读可写多节点
  resources:
    request:
      storage: 200Mi # 需要200M
  storageClassName: nfss #此处nfss是上面创建的pv里面的nfss

• pod 绑定pvc

apiVersion: apps/v1 # 版本号
kind: Deployment #资源类型
metadata: # 元数据 包含了 Pod 的元数据,例如名称、标签、命名空间
  labels: #标签
    app: mydev
  name: mydev # 部署名字
spec: # 定义了 部署的行为和构建
  replicas: 2
  selector: 
    matchLabels:
      app: mydev
  template:
    metadata:
      labels: #标签
        app: mydev
    spec:
      containers:
      - image: nginx # 镜像
        name: nginx # 镜像别名
        volumeMounts: # 卷挂载
        - name: html1 #挂载到外部，名字叫做html1
          mountPath: /usr/shard/nginx/html # 镜像内部的路径
      volumes:
      - name: html1 # 挂载方式，就是上面的html1
        PersistentVolumeClaim: 
          claimName: ng-pv # 与申请书绑定

配置集(configMap)

• 抽取应用配置，并且可以自动更新

# 创建配置，redis保存到k8s的etcd中。redis.conf是redis的配置文件
kubectl create configMap redis-conf --from-file=redis.conf

# 查看配置集，配置集存储在etcd中
kubectl get configMap
kubectl get cm

apiVersion: v1 
kind: ConfigMap # 配置集
metadata:
  name: redis-c # 配置集名字
data:　#所有真正的数据
  # redisco1(key) 会变成文件名，| 表示接下来是大文本，appendonly yes启用持久化存储(value)  会变成文件中的内容
  redisco1: |
    appendonly yes //启用持久化存储
    requirepass 123

# pod使用configmap
apiVersion: v1 # 版本号
kind: Pod #资源类型
metadata:
  labels: #标签
    app: mydev
  name: mydev
spec:
  containers:
  - image: redis # 镜像
    name: nginx # 镜像别名
    command: 
    - redis-server
    - "/redis-master/redis.conf" #容器内的路径
    ports:
    - port
      containerPort: 6379
    volumeMounts: # 卷挂载
    - name: data1 #挂载到外部，名字叫做data
      mountPath: /data # 镜像内部的路径
    - name: config #挂载到外部，名字叫做data
      mountPath: /redis-master # 镜像内部的路径
  volumes: # 生命存储卷
  - name: data1 # 挂载方式，就是上面的data1
    emptyDir: {} # 在pod分配到node上时，随机分配的目录，是宿主机上的一个空目录，当pod销毁时，数据也会销毁
  - name: data1 # 挂载方式，就是上面的data1
    hostPath:
      path: /root/log
      type: DirectoryOrCreate # 目录存在就使用，不存在就创建
  - name: data1 # 挂载方式，就是上面的data1
    nfs: #网络文件存储系统
      path: /nfs/data/02　# 外部电脑中的路径，需要提前创建好目录
      server: 10.11.101.1
  - name: config
    configMap:
      name: redis-c # 从配置集为【redis-c】中取配置
      items:
        key: redisco1 # 上面配置集data下面一行的redisco1
        path: redis.conf # 

Secret

• Secret用来保存敏感信息

# 创建Secret secret-a01
kubectl create secret docker-registry secret-a01 \
--docker-uername=nihao
--docker-password=123456

kubectl create secret docker-registry regcred \
--docker-server=<镜像服务>
--docker-uername=nihao
--docker-password=123456

#  查看当前的secret
kubectl get secret

# base64加密
echo -n 'admin' | base64
# base64解密
echo YWRtaW4= | base64 -d

• 创建Secret

apiVersion: v1 
kind: Secret # 密钥
metadata:
  name: secret-a01 # 密钥名字
type: Opaque
data:
  username: xxx #xxx 非明文格式的内容 ,base64格式

• 引用Secret

apiVersion: v1 
kind: Pod # 配置集
metadata:
  name: my-nginx
spec:
  containers:
 - name: nginx
    image: nginx
  imagePullSecrets:
 - name: secret-a01

安全认证

• HTTP Base认证：用户名+密码
• HTTP Token认证：Token
• HTTPS 证书认证：基于CA根证书的双向数字证书认证