apiVersion: V1
kind: pod
metadata:
  name: pod1
spec:
  containers:
    # 容器需要的是列表参数，所以这里用的是连接符 - 
    - name: nginx-pod
      image: nginx:latest
      imagePullPolicy: IfNotPresent
      ports:
        - name: nginx-port
          containerPort: 80
      resources:
        requests:
          memery: 100Mi
          cpu: 100m # 0.1 核
        limits:
          memery: 150Gi
          cpu: 0.2m
      readinessProbe:  # 这个是用来检测服务是否准备就绪，可以挂到负载均衡上去了
        tcpSocket:
          port: 8080
        initialDelaySeconds: 10   # 容器启动后，过多久执行命令
        periodSeconds: 10    # 每隔多久执行一次命令
        failureThreshold: 1  # 连续执行几次失败重启pod
        successThreshold: 1  # 连续成功几次，认定为一切正常
        timeoutSeconds: 5    # 执行命令的超时时间
      livenessProbe: # 这是用来探活，用来决定是否需要重启pod的
        tcpSocket:
          port: 8080
        initialDelaySeconds: 10   # 容器启动后，过多久执行命令
        periodSeconds: 10    # 每隔多久执行一次命令
        failureThreshold: 1  # 连续执行几次失败重启pod
        successThreshold: 1  # 连续成功几次，认定为一切正常
        timeoutSeconds: 5    # 执行命令的超时时间


---
apiVersion: V1
kind: pod
metadata:
  name: test
spec:
  # 注意在这里直接定义的东西都是pod级别的
  # 是否使用数组基的网络
  hostNetwork: true
  # 是否使用数组基的PID
  hostPID: true
  # 由于container的hosts文件是由pod统一创建的，因此，要修改容器内的host文件，需要在构建pod的时候就
  # 修改，如下，添加主机别名，就可以添加主机别名
  hostAliases:
  - ip: "10.121.20.111"
    hostnames:
    - "test111"
    - "test222"
  containers:
  - name: tet
    image: ss
    imagePullPolicy: IfNotPresent
    ports:
    - name: ye
      containerport: 80
    volumeMounts:
    - name: shared-volume
      mountPath: /shared-volume
  - name: test2
    image: aa
    imagePullPolicy: always
    ports:
    - name: absd
      containerPort: 52
    # 卷挂载，这里是说将名字为shared-volume的卷，挂载到容器内的/shared-volume目录
    volumeMounts:
    - name: shared-volume
      mountPath: /shared-volume
  # 注意这个volume卷,是和container齐平的，也就是说，这里的卷，pod里的容器共享的
  volumes:
    # 这里定义卷的名称，因为卷可能有很多，因此，定义名称，以名称为区分，与容器的volumeMounts里的
    # name遥相呼应
    - name: shared-volume
      hostPath:
        path: /shared-volume-data
    - name: default-token
      # 这里直接选择了一个kind为secret的对象作为挂载
      secret:
        defaultMode: 420
        secretName: default-token



---


# 由于存在有些服务只用1M内存，但是却故意写需要10G的情况，所以，k8s会有一种限制机制，就是 LimitRange
# 它可以限制pod的大小，容器的大小
# 这个yml一旦生效，它作用的将是pod对应的yml文件，而不是deployment（控制器）的yml文件

apiVersion: V1
kind: LimitRange
metadata:
  name: test-limit
spec:
  limits:
    - type: Pod   # pod 本身是个逻辑性的概念，所以无需设定默认值
      max:
        cpu: 4000m  # 4核
        memory: 2Gi
      min:
        cpu: 100m
        memory: 100Mi
      maxLimitRequestRatio: # 最大限制和请求的比率
        cpu: 3  # cpu 这一项limit的值不能超过request的值的3倍
        memory: 2  # memory 这一项limit的值不能超过request的值的2倍
    - type: Container
      default:  # 不多写就指 defaultLimit
        cpu: 300m
        memory: 200Mi
      defaultRequest:  # 在创建pod里spec，container这一项里如果没有指定resource，那就默认安这里的设定走
        cpu: 200m
        memory: 100Mi
      max:
        cpu: 2000m
        memory: 1Gi
      min:
        cpu: 100m
        memory: 100Mi
      maxLimitRequestRatio:
        cpu: 5
        memory: 4

---

# 资源配额。这是为了限制一个团队能使用的资源，总不能一个团队就把所有资源完全占据，那别的团队咋整
# 资源配额的使用，通常需要配合命名空间来使用，也就是说，它将限制这个命名空间可以分配到多少资源

apiVersion: v1
kind: ResourceQuota
metadata:
  name: resource-quota
spec:
  hard:
    pods: 4
    requests.cpu: 2000m
    requests.memory: 4Gi
    limits.cpu: 4000m
    limits.memory: 8Gi

---
apiVersion: v1
kind: RsourceQuota
metadata:
  name: object-count
spec:
  hard:
    configmaps: 10
    persistentvolumeclaims: 4
    replicationcontrollers: 20
    secrets: 10
    service: 10


---

apiVersion: apps/V1
# 这次是构建控制器类型的对象，控制器的作用：用于对应用运行的资源对象的监控，当pod出现问题时，
# 会把pod重新拉起，以达到用户期望的状态
kind: Deployment
metadata:
  name: nginx-app2
  # 这个地方的label可以给，也可以不给，不是很影响
  labels:
    app: nginx
spec:
  # 副本数
  replicas: 1
  # 这是一个选择器，上面我们指定了kind是控制器，那么控制器要控制什么pod，就是由选择器决定了。
  # 选择器会去下面的template去找匹配到的pod模板，然后生产pod，最后交给控制器控制
  selector:
    matchLabels:
      app: nginx
  templates:
    # 这里给出的信息是构建的pod的信息，比如pod的label，name
    metadata:
      name: pod1
      labels:
        app: nginx
    spec:
      containers:
        - name: nginxapp2-container
          image: nginx:latest
          imagePullPolicy: IfNotPresent
          ports:
            - containerPort: 80
          livenessProbe:  # 这是用来探活，用来决定是否需要重启pod的
            httpGet:
              path: /examples/index.html
              port: 80   # 容器启动端口
              scheme: HTTP         # 注意，只有返回200才算成功，重定向都不行
            initialDelaySeconds: 10   # 容器启动后，过多久执行命令
            periodSeconds: 10    # 每隔多久执行一次命令
            failureThreshold: 1  # 连续执行几次失败重启pod
            successThreshold: 1  # 连续成功几次，认定为一切正常
            timeoutSeconds: 5    # 执行命令的超时时间


---

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-app3
  labels:
    app: nginx
spec:
  replicas: 2
  selectors:
    # 这里matchLabels 和 matchExpressions，2个条件要同时满足，才可以被选择上
    matchLabels:
      app: nginx
    matchExpressions:
      - {key: grop, values: [nap, wap], operator: In}  # key为grop，value为nap或wap
  templates:
    metadata:
      labels:
        grop: nap   # 这里必须和上面的选择器匹配，否则无法造pod
        app: nginx
    spec:
      containers:
      - name: nginx-app3
        images: nginx:latest
        imagePullPolicy: IfNotPresent
        ports:
        - containerPort: 80
        livenessProbe:   # 容器服务探活指针
          exec:
            command:
              - /bin/bash
              - -c
              - ps -ef|grep java|grep -v grep
          initialDelaySeconds: 10   # 容器启动后，过多久执行命令
          periodSeconds: 10    # 每隔多久执行一次命令
          failureThreshold: 2  # 连续执行几次失败重启pod
          successThreshold: 1  # 连续成功几次，认定为一切正常
          timeoutSeconds: 5    # 执行命令的超时时间

      # 这里注意，此处的nodeSelector是与container是同一级，是说该pod要求被部署的node上
      # 有标签 disktype: ssd
      nodeSelector:   # 节点选择器
        disktype: ssd    # 这是一个key: value的标签


---

apiVersion: V1
kind: Service
metadata:
  name: nginx-service
spec:
  type: ClusterIP
  ports:
  - port: 80
    targetPort: 80
    protocol: TCP
  selector:
    app: nginx


---
# nodeport 模式，会打开所有节点的nodeport分到的那个端口号对应的端口，所以，在任意节点上，根据端
# 口号访问pod，都是可以访问的到的

apiVersion: V1
kind: service
metadata:
  name: test
sepc:
  type: NodePort
  posts:
    - port: 80
      # 这个参数可以不给，如果不给k8s会自动分配
      nodeport: 30001
      targetPort: 80
      protocol: TCP
  selector:
    app: nginx

---
# ingress-nginx
# 做高可用的时候，用于搞服务的发现的，这块的东西，在k8s的官网上可以找到，过程很简单，就是将yml文件先下载下来，然后，修改yaml文件
# 只需要在最后的deploy的部分的template部分的spec部分添加2行代码即可，hostNetwork: true 和 nodeSelector: xxx(给个标签)，
# 就可以了。基本上就是为了将ingress的服务固定到一个node上，省的执行yml文件以后，找不到ingress服务部署到哪去了，或者来说，
# 我们更希望，它部署到我们指定的node上
apiVersion: v1
kind: Ingress
metadata:
  name: web
spec:
  rules:
    - host: web.server.com   # 定义浏览器访问的域名
      http:
        paths:
          - path: /
            backend:
              serviceName: nginx-service  # 这里给service的名称，比如在122行那个service的名称
              servicePort: 80 # 这里给service自己的port


---

apiVersion: apps/V1
kind: Deployment
metadata:
  name: nginx-app2
  labels:
    app: nginx
spec:
  replicas: 1
  selector:
    matchLabels:
      app: nginx
  templates:
    metadata:
      name: pod1
      labels:
        app: nginx
    spec:
      containers:
        - name: nginxapp2-container
          image: nginx:latest
          imagePullPolicy: IfNotPresent
          ports:
            - containerPort: 80
      affinity:   # 亲和性
        nodeAffinity:  # 节点亲和性
          requiredDuringSchedulingIgnoredDuringExecution:  # 必须满足的亲和条件(可以有多个，每个之间是或的关系)
            nodeSelectorTerms:  # 节点选择策略，下面给的nodeSelectorTerms也是列表，就是说可以给多个nodeSelectorTerms，它们之间是或的关系，最少满足一个就行
              - matchExpressions: # matchExpressions下面给的是列表，也就说可以给多个值，这里给的多个值之间是且的关系，就是必须全部满足
                - key: beta.sss/arc   # node的标签名称
                  operator: In
                  values:
                    - amd64          # 标签 beta.sss/arc 对应的值
          preferredDuringSchedulingIgnoredDuringExecution: # 最好满足的亲和条件(可以有多个，每个之间是或的关系)
            - weight: 1
              preference:
                - matchExpressions:
                    - key: disktype
                      operator: NotIn
                      values:
                        - asd

---


apiVersion: apps/V1
kind: Deployment
metadata:
  name: nginx-app2
  labels:
    app: nginx
spec:
  replicas: 1
  selector:
    matchLabels:
      app: nginx
  templates:
    metadata:
      name: pod1
      labels:
        app: nginx
    spec:
      containers:
        - name: nginxapp2-container
          image: nginx:latest
          imagePullPolicy: IfNotPresent
          ports:
            - containerPort: 80
      affinity:   # 亲和性
        podAffinity:  # pod亲和性, 主要是在进行Scheduler调度的时候选择node，该pod更愿意跟哪个pod在一起运行
          requiredDuringSchedulingIgnoredDuringExecution:  # 必须满足的亲和条件(可以有多个，每个之间是或的关系)
            - labelSelector:
                matchExpressions:
                  - key: app
                    operator: In
                    values:
                      - web-demo
              topologyKey: kubernetes.io/hostname   # 节点的选择范围（具有这样标签的节点）
          preferredDuringSchedulingIgnoredDuringExecution: # 最好满足的亲和条件(可以有多个，每个之间是或的关系)
            - weight: 100
              podAffinityTerm:  # 节点亲和策略
                labelSelector:
                  - matchExpressions:
                      - key: disktype
                        operator: NotIn
                        values:
                          - asd
                topologyKey: kubernetes.io/hostname   # 节点的选择范围（具有这样标签的节点）


---

apiVersion: apps/V1
kind: Deployment
metadata:
  name: nginx-app2
  labels:
    app: nginx
spec:
  replicas: 1
  selector:
    matchLabels:
      app: nginx
  templates:
    metadata:
      name: pod1
      labels:
        app: nginx
    spec:
      containers:
        - name: nginxapp2-container
          image: nginx:latest
          imagePullPolicy: IfNotPresent
          ports:
            - containerPort: 80
      affinity:   # 亲和性
        podAntiAffinity:  # pod的反亲和性(不跟满足下面条件的节点在一起)
          requiredDuringSchedulingIgnoredDuringExecution:  # 必须满足的亲和条件(可以有多个，每个直接是或的关系)
            - labelSelector:
                matchExpressions:
                  - key: app
                    operator: In
                    values:
                      - web-demo
              topologyKey: kubernetes.io/hostname   # 节点的选择范围（具有这样标签的节点）
          preferredDuringSchedulingIgnoredDuringExecution: # 最好满足的亲和条件(可以有多个，每个直接是或的关系)
            - weight: 100
              podAffinityTerm:  # 节点亲和策略
                labelSelector:
                  - matchExpressions:
                      - key: disktype
                        operator: NotIn
                        values:
                          - asd
                topologyKey: kubernetes.io/hostname   # 节点的选择范围（具有这样标签的节点）

---
# 污点的标签组成：key=value:effect
# 每个污点有一个 key 和 value 作为污点的标签，其中 value 可以为空，effect 描述污点的作用。
# 打污点：kubectl taint nodes k8s-node2 check=yuanzhang:NoExecute
# 查看污点：kubectl describe nodes k8s-node2
# 去除污点：kubectl taint nodes k8s-node2 check:NoExecute-
# 有污点就需要，有pod去容忍污点


apiVersion: apps/V1
kind: Deployment
metadata:
  name: nginx-app2
  labels:
    app: nginx
spec:
  replicas: 1
  selector:
    matchLabels:
      app: nginx
  templates:
    metadata:
      name: pod1
      labels:
        app: nginx
    spec:
      containers:
        - name: nginxapp2-container
          image: nginx:latest
          imagePullPolicy: IfNotPresent
          ports:
            - containerPort: 80
      tolerations:  # 污点容忍
        - key: "key"
          operator: "Equal"
          value: "value"
          effect: "NoSchedule"  # 效果(必须跟打污点时给定的效果一致)


---

apiVersion: apps/V1
kind: Deployment
metadata:
  name: nginx-app2
  labels:
    app: nginx
spec:
  strategy:  # 部署策略
    type: Recreate  # 部署的时候，先停止原先的容器，然后重新启动容器
  replicas: 1
  selector:
    matchLabels:
      app: nginx
  templates:
    metadata:
      name: pod1
      labels:
        app: nginx
    spec:
      containers:
        - name: nginxapp2-container
          image: nginx:latest
          imagePullPolicy: IfNotPresent
          ports:
            - containerPort: 80
      tolerations:  # 污点容忍(吐了睿身)
        - key: "key"
          operator: "Equal"
          value: "value"
          effect: "NoSchedule"  # 效果(必须跟打污点时给定的效果一致)


---

apiVersion: apps/V1
kind: Deployment
metadata:
  name: nginx-app2
  labels:
    app: nginx
spec:
  strategy:  # 部署策略(升级策略这一项如果不配置，那么默认就是滚动升级，然后，参数就是2个25%)
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 25%   # 滚动升级时，最多同时启动的实例比例
      maxUnavailable: 25%  # 滚动升级时，最多不可用的实例比例
  replicas: 1
  selector:
    matchLabels:
      app: nginx
  templates:
    metadata:
      name: pod1
      labels:
        app: nginx
    spec:
      containers:
        - name: nginxapp2-container
          image: nginx:latest
          imagePullPolicy: IfNotPresent
          ports:
            - containerPort: 80
      tolerations:  # 污点容忍
        - key: "key"
          operator: "Equal"
          value: "value"
          effect: "NoSchedule"  # 效果(必须跟打污点时给定的效果一致)

# 升级的回滚命令: kubectl rollout undo deploy xxx.yaml -n xx_namespace


---
# ============================  蓝绿部署  green ========================

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-app3
  labels:
    app: nginx
spec:
  replicas: 2
  selectors:
    matchLabels:
      app: nginx
  templates:
    metadata:
      labels:
        app: nginx
        version: green
    spec:
      containers:
      - name: nginx-app3
        images: nginx:latest
        imagePullPolicy: IfNotPresent
        ports:
        - containerPort: 80

---

apiVersion: V1
kind: Service
metadata:
  name: nginx-service
spec:
  type: ClusterIP
  ports:
  - port: 80
    targetPort: 80
    protocol: TCP
  selector:
    app: nginx
    version: green


---
# ============================  蓝绿部署 blue ========================

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-app3
  labels:
    app: nginx
spec:
  replicas: 2
  selectors:
    matchLabels:
      app: nginx
  templates:
    metadata:
      labels:
        app: nginx
        version: blue
    spec:
      containers:
      - name: nginx-app3
        images: nginx:latest
        imagePullPolicy: IfNotPresent
        ports:
        - containerPort: 80

---

apiVersion: V1
kind: Service
metadata:
  name: nginx-service
spec:
  type: ClusterIP
  ports:
  - port: 80
    targetPort: 80
    protocol: TCP
  selector:
    app: nginx
    version: blue


---
# ============================ 金丝雀部署 ========================

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-app3
  labels:
    app: nginx
spec:
  replicas: 2
  selectors:
    matchLabels:
      app: nginx
  templates:
    metadata:
      labels:
        app: nginx
        version: blue
    spec:
      containers:
      - name: nginx-app3
        images: nginx:latest
        imagePullPolicy: IfNotPresent
        ports:
        - containerPort: 80

---

apiVersion: V1
kind: Service
metadata:
  name: nginx-service
spec:
  type: ClusterIP
  ports:
  - port: 80
    targetPort: 80
    protocol: TCP
  selector: # 不给version标签，就行
    app: nginx


---

# 浅谈pod：
# pod本身是个逻辑性的概念，在k8s中，并不存在一个叫pod的组件。pod的本质上来讲，就是一个容器，这个
# 容器大概100~200K，很小，而且平常也都处于暂停状态，所以并不会对node的性能造成任何影响。k8s是基于
# 这个容器，引入pod的概念，并通过pod(也就是这个容器)来管理其他的容器的。这个容器，本身是可以看到
# 其他容器的。因为pod本身就是容器，所以，它本身就具备许多容器的特性，比如卷...所以，在pod这块，是
# 可以创建卷的，然后，由于容器于容器之间网络互通，资源共享，所以，pod中可以定义卷，然后，在pod中的
# 容器就可以通过挂载卷来访问卷中的内容，同样，基于这样的特点，被同一个pod所管理的容器之间，就可以
# 以这种方式，进行进行文件的传递。比如，有的容器负责记录日志，那就使劲的写文件。有的容器负责采集
# 日志信息，那就使劲的读文件。有了这个共享卷，就可以很方便的去做这样的事情.

apiVersion: v1
kind: Pod
metadata:
  name: pod-volume
spec:
  containers:
    - name: web
      image: hub/k8s/web:v1
      ports:
        - containerPort: 8080
      volumeMounts:   # 挂载卷
        - name: share-volume   # 要挂载哪个卷，这里给卷的名字
          mountPath: /shared-web  # 挂载到容器内的啥地方，这里给路径
    - name: dubbo  # 第二个容器
      image: hub/k8s/dubbo:v1
      ports:
        - containerPort: 8081
          hostPort: 8081
          protocol: TCP
      env:
        - name: DUBBO_PORT
          value: "8081"
      volumeMounts:
        - name: share-volume   # 要挂载哪个卷，这里给卷的名字
          mountPath: /share-dubbo
  volumes:  # 构建pod的卷，以供容器挂载
    - name: share-volume
      hostPath:
        path: /shared-volume-data

---
# 同理，由于pod是要管理在它里面的容器的，所以，有需要公共性质的东西，是不能直接在容器内部直接改的
# 需要在pod的层面去修改，比如：/etc/hostname,如果要给这文件添加新的hostname信息，是不可以直接
# 加到具体的容器内部的。需要在pod这里加。

apiVersion: v1
kind: Pod
metadata:
  name: pod-volume
spec:
  hostNetwork: true # 是否使用数组基的网络
  hostPID: true # 是否使用数组基的PID
  hostAliases: # 在这里定义需要添加到容器的新的 hostname,然后被该pod所管理的所有容器里就都有这个host的信息了
    - ip: "10.55.12.11"
      hostnames:
        - "web.aa.com"
  containers:
    - name: web
      image: hub/k8s/web:v1
      ports:
        - containerPort: 8080
      volumeMounts:   # 挂载卷
        - name: share-volume   # 要挂载哪个卷，这里给卷的名字
          mountPath: /shared-web  # 挂载到容器内的啥地方，这里给路径
    - name: dubbo  # 第二个容器
      image: hub/k8s/dubbo:v1
      ports:
        - containerPort: 8081
          hostPort: 8081
          protocol: TCP
      env:
        - name: DUBBO_PORT
          value: "8081"
      volumeMounts:
        - name: share-volume   # 要挂载哪个卷，这里给卷的名字
          mountPath: /share-dubbo
  volumes:  # 构建pod的卷，以供容器挂载
    - name: share-volume
      hostPath:
        path: /shared-volume-data


---
# 容器的生命周期，是可以做一些管理的


apiVersion: v1
kind: Pod
metadata:
  name: pod-volume
spec:
  hostNetwork: true # 是否使用数组基的网络
  hostPID: true # 是否使用数组基的PID
  hostAliases: # 在这里定义需要添加到容器的新的 hostname,然后被该pod所管理的所有容器里就都有这个host的信息了
    - ip: "10.55.12.11"
      hostnames:
        - "web.aa.com"
  containers:
    - name: web
      image: hub/k8s/web:v1
      ports:
        - containerPort: 8080
      volumeMounts:   # 挂载卷
        - name: share-volume   # 要挂载哪个卷，这里给卷的名字
          mountPath: /shared-web  # 挂载到容器内的啥地方，这里给路径
    - name: dubbo  # 第二个容器
      image: hub/k8s/dubbo:v1
      ports:
        - containerPort: 8081
          hostPort: 8081
          protocol: TCP
      env:
        - name: DUBBO_PORT
          value: "8081"
      volumeMounts:
        - name: share-volume   # 要挂载哪个卷，这里给卷的名字
          mountPath: /share-dubbo
      lifecycle:
        postStart: # 这里的启动执行，是在启动容器时就会执行的，是同步执行，所以这里不要执行那些需要容器彻底启动之后才可以执行的命令
          exec:
            command: ["/bin/sh", "-c", "echo dubbo staring ... >> /var/log/messages"]
        preStop: # 这里是容器停止之前要执行的命令，是顺序执行。在发出停止容器的指令之后，这个命令会立刻执行，它执行结束，
                 # 才会停止容器。但是，这里容器的停止，并不会无限的等待，也是存在一个超时时间的，如果执行这条命令耗时很长，容器最后也会直接停止的。
          exec:
            command: ["/bin/sh", "-c", "echo dubbo stopping ... >> /var/log/messages && sleep 3"]
  volumes:  # 构建pod的卷，以供容器挂载
    - name: share-volume
      hostPath:
        path: /shared-volume-data


---

apiVersion: v1
kind: Secret
metadata:
  name: dbpass
type: Opaque # 混乱类型，不让别人看明文
data:
  username: eW1r  # 这里给 base64 码就行
  passwd: aW1vb2M=

---
# 将 secret 投射到pod，通常有些pod在执行的时候需要用到一些特定文件，比如用户名，密码这种东西，这样往往apiServer往往在一开始，就会
# 将相应的文件投射到pod上，然后，容器通过挂载的方式，去获取这些文件的内容
# 还有，这样将kind为secret的资源映射到pod的时候，资源中的data的每一个key都会成为一个文件的文件
# 名，在pod管理的docker里的具体位置，是需要cat -n 文件，才能看到具体内容的，-n的意思是不要换行符

apiVersion: v1
kind: Pod
metadata:
  name: pod-volume
spec:
  containers:
    - name: web
      image: hub/k8s/web:v1
      ports:
        - containerPort: 8080
      volumeMounts:   # 挂载卷
        - name: db-secret   # 要挂载哪个卷，这里给卷的名字，注意，这里挂载上去后，会出现两个文件，一个username， passwd，只要 cat xx,就能看见具体内容了
          mountPath: /db-secret  # 挂载到容器内的啥地方，这里给路径
          readOnly: true   # 设定文件权限

  volumes:  # 构建pod的卷，以供容器挂载
    - name: db-secret
      projected: # 投射
        sources:
          - secret:
              name: dbpass  # 这里选择上面 kind为 secret 的 yml 中的那个matadata的name就行

---
# k8s中除了可以搞secret类型的数据存储，然后投射到pod以外，还可以搞configmap类型的内容，做类似的操作
# kebectl create configmap web-game(创建一个configmap类型的对象，名字为web-game) --from-file game.properties
# 这是直接以命令去创建，当然，也可以通过yml去创

apiVersion: v1
kind: ConfigMap
metadata:
  name: web-game
data:
  game.properties:  |    # 注意这里有个 | ，这代表，下面的内容都属于这个文件，或者叫变量，都可以。
    enemies=aliens
    lives=3
    secret.code.allowed=true

---

apiVersion: v1
kind: Pod
metadata:
  name: pod-volume
spec:
  containers:
    - name: web
      image: hub/k8s/web:v1
      ports:
        - containerPort: 8080
      volumeMounts:   # 挂载卷
        - name: game  # 这里会在挂载文件目录下看到一个文件 game.properties, cat game.properties 就可看到具体内容
          mountPath: /etc/config/game  # 挂载到容器内的啥地方，这里给路径
          readOnly: true   # 设定文件权限

  volumes:  # 构建pod的卷，以供容器挂载
    - name: game
      configMap:
        name: web-game

---
# 除了挂载的方式去取configMap的值以外，还可以以环境变量的方式直接在容器中取值

apiVersion: v1
kind: ConfigMap
metadata:
  name: configs
data:
  PATHONPATH: /home/abc/build/
  LOG_LEVEL: DEBUG

---

apiVersion: v1
kind: Pod
metadata:
  name: pod-env
spec:
  containers:
    - name: web
      image: hub/k8s/web:v1
      ports:
        - containerPort: 8080
      env:
        - name: LOG_LEVEL_CONFIG # 定义环境变量 LOG_LEVEL_CONFIG
          valueFrom:
            configMapKeyRef:
              name: configs   # configMap的名称，用于选择具体的configMap对象
              key: LOG_LEVEL  # 这个key就是名为configs的configmap类型的对象中的，key: LOG_LEVEL,这里将取到LOG_LEVEL对应的值，
                              # 并将其赋值给 LOG_LEVEL_CONFIG

---
# 这里搞出的环境变量，也可以直接应用到容器的命令里去

apiVersion: v1
kind: Pod
metadata:
  name: pod-env
spec:
  containers:
    - name: web
      image: hub/k8s/web:v1
      ports:
        - containerPort: 8080
      command: ["/bin/sh", "-c", "python xxx.py --python-path=$(PATHONPATH)"]  # 这里直接引用了下面定义的环境变量
      env:
        - name: PATHONPATH # 定义环境变量 PATHON_PATH
          valueFrom:
            configMapKeyRef:
              name: configs   # configMap的名称，用于选择具体的configMap对象
              key: PATHONPATH

---
# downwardAPI，这种类型的作用是，可以直接得到pod本身的一些东西，同样是用过挂载的方式，可以让容器访问到

apiVersion: v1
kind: Pod
metadata:
  name: pod-downwardapi
  labels:
    app: downwardapi
    type: webapp
spec:
  containers:
    - name: web
      image: hub/k8s/web:v1
      ports:
        - containerPort: 8080
      volumeMountes:
        - name: podinfo
          mountPath: /etc/podinfo
  volumes:
    - name: podinfo
      projected:
        sources:
          - downwardAPI:
              items:
                - path: "labels"  # 这里注意下，在这定义的变量，会以文件的方式显示到挂载目录，
                                  # cat labels,就可以看到metadata.labels中的labels信息，有啥就显示啥，有几个就显示几个
                  fieldRef:
                    fieldPath: metadata.labels
                - path: "name"
                  fieldRef:
                    fieldPath: metadata.name
                - path: "namespace"   # 没有定义，就是 default，所以，cat namespace,看到的就是default
                  fieldRef:
                    fieldPath: metadata.namespace
                - path: "mem-request"  # 没定义，拿到的就是整个机子的磁盘大小
                  resourceFieldRef:
                    containerName: web
                    resource: limits.memory