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

Logo

K8S/Kubernetes社区为您提供最前沿的新闻资讯和知识内容

更多推荐