Kubernetes configMap 应用配置-摩杜云开发者社区

应用配置配置管理

confimap

这个和上节课的PV和PVC持久卷是有关联关系的

confimap 和secret 还一个downward API 这三个是一种特殊的持久卷

不管什么应用都有配置文件 nginx redis 各种各样的服务都有配置文件的,通过一个一个的配置文件去更改我们想要的配置的,未来在k8s里面运行的,各种各样pod,他也一样里面各种各样的应用,里面也有各种各样的配置文件,配置在k8s里面多数情况下就用configmap配置映射还一个secrest 基于安全的角度出发的配置选项

configmap和secret是两种单独的资源对象,就相当于把我们的配置从pod分离出来 ,解耦出来,未来专门通过configmap 这种资源对象去管理我们的配置,未来对应的配置,就比如nginx 我们大量的nginx配置文件,就可以直接通过confimap资源对象,来对他进行修改,未来去修改配置文件的时候就不需要从新去构建pod了,就直接去修改类似的configmap资源对象就能实现配置文件的修改,这样就实现了个解耦的关系,从之前讲docker开始容器化的应用配置

容器化应用配置的常见方式

容器镜像一般由多个只读层叠加组成，构建完成后无法进行修改，另一方面，"黑盒化"运行的容器

使用隔离的专用文件系统，那么，如何为容器化应用提供配置信息呢?传统实践中，通常有这么几种途

径。

启动容器时直接向应用程序传递参数。

将定义好的配置文件硬编码（嵌入）于镜像文件中。

通过环境变量传递配置数据。

基于存储卷传送配置文件。

命令行参数

Dockerfile 中的 ENTRYPOINT 和 CMD 指令用于指定容器启动时要运行的程序及其相关的参数。其中，CMD 指令以列表形式指定要运行的程序及其相关的参数，若同时存在 ENTRYPOINT 指令，则CMD指令中的列表所有元素均被视作由 ENTRYPOINT指定程序的命令行参数。另外，在基于某镜像创建容器时，可以通过向 ENTRYPOINT中的程序传递额外的自定义参数，甚至还可以修改要运行的应用程序本向。例如，使用 docker run 命令创建并启动容器的格式为∶

docker run [OPTIONS] IMAGE [COMMAND] [ARG...]

其中的【COMMAND】即为自定义运行的程序，【ARG】则是传递给程序的参数。若定义相关的镜像文件时使用了ENTRYPOINT指令，则【COMMAND】和【ARG】都会被当作命令行参数传递给ENTRYPOINT指令中指定的程序，除非为 docker run 命令额外使用- entrypoint 选项覆盖 ENTRYPOINT指令而指定运行其他程序。使用详情请参考 Docker 的相关教程。

在 Kubernetes 系统上创建 Pod 资源时，也能够向容器化应用传递命令行参数，甚至指定运行其他应用程序，相关的字段分别为 pods.spec.containers[].command和pods.spec. containers[].args，该话题在 Pod 资源的相关话题中已有过介绍。

之前容器的时候容器命令行参数 docker run -e 的方式传环境变量再就是打docker file 的时候用env参数也可以把环境变量传到docker file 里面

还有种将配置文件嵌入镜像文件

将配置文件嵌入镜像文件

这种就是打docker file 的时候把文件通过ADD COPY 的方式

传到镜像里面去所谓将配置文件嵌入镜像文件，是指用户在 Dockerfile 中使用 COPY 指令把定义好的配置文件复制到镜像文件系统上的目标位置，或者使用RUN 指令调用sed或echo一类的命令修改配置文件，从而达到为容器化应用提供自定义配置文件之目的。这种方式的优势在于简单易用，用户无须任何额外的设定就能启动符合需求的容器。但配置文件相关的任何额外的修改需求都不得不通过重新构建镜像文件来实现，路径长且效率低。

通过环境变量向容器注入配置信息

通过环境变量的方式注入

docker run -e

今天讲的是通过存储卷向容器注入配置信息

configmap和secret都是一种特殊的存储卷

容器的环境变量之前docker的时候通过docker run -e 参数传环境变量 docker-compose 用env 传环境变量

k8s pod级别有个containers 里面有env 字段可以往我们的容器里面传变量 env里面的子字段


[root@k8s-master1 pvc]# kubectl explain pod.spec.containers.env
KIND:     Pod
VERSION:  v1

RESOURCE: env <[]Object>

DESCRIPTION:
     List of environment variables to set in the container. Cannot be updated.

     EnvVar represents an environment variable present in a Container.

FIELDS:
   name <string> -required-
   #名称 必选字段  变量的名称  key
     Name of the environment variable. Must be a C_IDENTIFIER.

   value        <string>
   #变量的值  value
      #在定义变量的时候.value和valueFrom同时只能出现一个,如过出现value就不能出现valueFrom 

     Variable references $(VAR_NAME) are expanded using the previously defined
     environment variables in the container and any service environment
     variables. If a variable cannot be resolved, the reference in the input
     string will be unchanged. Double $$ are reduced to a single $, which allows
     for escaping the $(VAR_NAME) syntax: i.e. "$$(VAR_NAME)" will produce the
     string literal "$(VAR_NAME)". Escaped references will never be expanded,
     regardless of whether the variable exists or not. Defaults to "".

   valueFrom    <Object>
   #基于一个其他已经存在的变量 
   #列入 pod资源的名称  名称空间 标签等 
   #还有congimap secret这些都可以作为 valueFrom的源 
   
   #在定义变量的时候.value和valueFrom同时只能出现一个,如过出现value就不能出现valueFrom 
     Source for the environment variable's value. Cannot be used if value is not
     empty.

看下valueFrom包含那些字段

[root@k8s-master1 pvc]# kubectl explain pod.spec.containers.env.valueFrom
KIND:     Pod
VERSION:  v1

RESOURCE: valueFrom <Object>

DESCRIPTION:
     Source for the environment variable's value. Cannot be used if value is not
     empty.

     EnvVarSource represents a source for the value of an EnvVar.

FIELDS:
   configMapKeyRef      <Object>
   #他可以是configmap
     Selects a key of a ConfigMap.

   fieldRef     <Object>
   #fieldRef是整个资源对象以及存在的 比如pod的名称 你所存在的名称空间  标签值 
   #这个不需要人为来定义,我可以引用现有的 资源对象已经存在的东西  
   #如下
metadata.name: 当前资源的名称。
metadata.namespace: 当前资源所在的命名空间。
metadata.labels['label-key']: 当前资源的指定标签的值。
metadata.annotations['annotation-key']: 当前资源的指定注释的值。
spec.nodeName: 当前 Pod 所在的节点的名称。
status.podIP: 当前 Pod 的IP地址。
status.hostIP: 当前 Pod 所在节点的IP地址。
status.podIPs: 当前 Pod 所有IP地址的列表。
status.qosClass: 当前 Pod 的QoS类别。
#######################################################
     Selects a field of the pod: supports metadata.name, metadata.namespace,
     `metadata.labels['<KEY>']`, `metadata.annotations['<KEY>']`, spec.nodeName,
     spec.serviceAccountName, status.hostIP, status.podIP, status.podIPs.

   resourceFieldRef     <Object>
   #基于资源的限制 内存大小 可以有最大内存  最大cpu 的值 
     Selects a resource of the container: only resources limits and requests
     (limits.cpu, limits.memory, limits.ephemeral-storage, requests.cpu,
     requests.memory and requests.ephemeral-storage) are currently supported.

   secretKeyRef <Object>
   #可以是secret 
     Selects a key of a secret in the pod's namespace

这是通过创建pod的时候在配置清单里通过那些值来传递环境变量的方式

写一个


[root@k8s-master1 pod]# cat env-nginx-1.yml
apiVersion: v1
kind: Pod
metadata:
  name: env-nginx
  namespace: default
spec:
  containers:
  - name: nginx
    env:
    - name: NAME
      value: FengQichen
    - name: NODE
      valueFrom:  #基于已存在的变量
        fieldRef: #fieldRef是整个资源对象以及存在的
          fieldPath: spec.nodeName  #这个是node的名字
    - name: NAMESPACE
      valueFrom:
        fieldRef:
          fieldPath: metadata.namespace  #这个是namespace的名字
    image: images.guoguo.com/apps/nginx:1.22.1
    ports:
    - containerPort: 80

进入到容器里面看一下

root@env-nginx:/# cat env.sh
#!/bin.bash
echo NAME=              ${NAME}
echo NODE=              ${NODE}
echo NAMESPACE=         ${NAMESPACE}
root@env-nginx:/# sh env.sh
NAME= FengQichen
NODE= k8s-node2.guoguo.com
NAMESPACE= default

这就是我通过在pod里面定义env这个字段,通过环境变量的方式把值传给我们对应的pod里面让他能够运行,这个就是容器里面使用环境变量的方式

今天讲的configmap和secret和环境变量有着很紧密的关系的

因为创建的配置后这种configmap和secret 资源对象来引用的时候就是通过env的方式通过一种变量的方式把我们创建出来的配置传给我们的容器来使用

应用程序配置管理与ConfigMap资源

ConfigMap资源用于在运行时将配置文件命令行参数环境变量端口号以及其他配置工件绑定至Pod的容器和系统组件 kubernetes借助于ConfigMap对象实现了将配置文件从容器镜像种解耦,

ConfigMap其实最主要的就是存配置文件

配置文件修改频繁的NGINX 加新的虚拟主机之类的配置会频繁的去修改配置文件如果按照以前的方式我们在对应的容器里面修改配置文件了只能去重新生成 dockerfile 用dockerfiel 从新打个镜像然后对应更新pod 这种方式过程太复杂所有的东西都得从新来做我用configmap的方式就可以修改configmap的一种资源对象就可以了配置文件频繁修改的方式就不需要操纵原有的pod资源了

创建资源对象

两种方式: 命令行资源配置清单创建

命令行

kubectl create configmap 名字 数据源

1基于字面量值数据源

通过命令行直接传给他的,--from-literal 他就可以定义key value key value 这种方式

比如

kubectl create configmap configmap_name --from-literal=key-1=value-1

创建一个

[root@k8s-master1 pod]# kubectl create configmap demoapp-config --from-literal=demoapp.host='0.0.0.0' --from-literal=demo.port='8080'
configmap/demoapp-config created
#创建了一个 名为 demoapp-config 的 configmap
#然后指定的变量有两个
#第一个变量名是 dempapp.host 的值是0.0.0.0
#第二个变量名是 demo.port 的值是 8080
#如果不指定名称空间那默认就是在default里面创建

查询一下

[root@k8s-master1 pod]# kubectl get configmaps
NAME               DATA   AGE
demoapp-config     2      4s

详细看下

[root@k8s-master1 pod]# kubectl get configmaps demoapp-config -o yaml
apiVersion: v1
data:
  demo.port: "8080"
  dempapp.host: 0.0.0.0
kind: ConfigMap
metadata:
  creationTimestamp: "2023-08-20T01:12:23Z"
  name: demoapp-config
  namespace: default
  resourceVersion: "353250"
  uid: 90519ec3-48b3-42b4-a09a-2dc9cdeb4cd8

configmap和secret是一种特殊的资源对象,这里面本身没有spec status 字段

他的字段除了apiVersion 和 kind metadata以外还有个data 叫数据源因为这里面不包含期望值 ,就是我们confimap和secret 两种资源对象没有期望值因为这一个都是一个文件传值的,所以里面不包含期望值所以不包含status 状态值

除了apiVersion kind metadata 以外只有data 数据源

这就是创建出来的 configmap

第一种创建configmap的方式基于自变量,第二种方式通常基于一个文件

基于一个已经存在的文件

类似于我们把nginx配置文件做成一个configmap的方式

指定文件直接文件里面内容,类似于变量的值文件名称类似于变量的名称

通过文件的方式创建

我们写几个文件

[root@k8s-master1 nginx]# cat index.html
test.guoguo.com
[root@k8s-master1 nginx]# cat test.guoguo.com.conf
server {
        liseten: 80;
        server_name test.guoguo.com;
          location / {
              root /data/web/dir2;
              index index.html index.htm;
                         }
        }

两个文件一个虚拟主机一个测试页

基于文件的方式创建configmap

[root@k8s-master1 nginx]# kubectl create configmap nginx-vhost --from-file=./test.guoguo.com.conf --from-file=./index.html
configmap/nginx-vhost created

一次性可以跟多个路径可以是绝对路径和全局路径

[root@k8s-master1 nginx]# kubectl get configmaps nginx-vhost
NAME          DATA   AGE
nginx-vhost   2      74s

[root@k8s-master1 nginx]# kubectl get configmaps nginx-vhost -o yaml
apiVersion: v1
data:
  index.html: |   #文件名称 类似变量的名
    test.guoguo.com  #文件内容 类似变量的值
  test.guoguo.com.conf #文件名称 类似变量的名: "server {\n\tliseten: 80;\n\tserver_name test.guoguo.com;\n\t   #文件内容 类似变量的值
    \ location / {\n\t      root /data/web/dir2;\n\t      index index.html index.htm;\n\t\t
    \ \t }\t\t\t\n\t}\t\n"
kind: ConfigMap
metadata:
  creationTimestamp: "2023-08-23T08:41:19Z"
  name: nginx-vhost
  namespace: default
  resourceVersion: "86811"
  uid: 1dfe885a-d40d-40ca-962f-e5998726ad89

上面是因为文件里面用了tab键我把tab键换成了空格看下

[root@k8s-master1 nginx]# cat nginx-vhost-configmap.yml
apiVersion: v1
data:
  index.html: | #文件名称 类似变量的名
    test.guoguo.com #文件内容 类似变量的值
    test_vhosts
  test.guoguo.com.conf: | #文件名称 类似变量的名
    server {
            listen 80;            #文件内容 类似变量的值
            server_name test.guoguo.com;
                location / {
                root /data/web/dir2;
                index index.html index.htm;
                               }
            }
kind: ConfigMap
metadata:
  creationTimestamp: "2023-08-24T05:49:27Z" 
  name: nginx-vhost
  namespace: default
  resourceVersion: "365612"
  uid: 6c7e4371-94ff-4d0b-9698-cb2960ac50a0

这个就是通过文件的方式创建configmap

这种文件的方式比较繁琐,因为如果文件很多指定的文件很多得写很长很长的 from-file

有基于目录的数据源只要指定目录就不需要一个个指定文件了,

[root@k8s-master1 nginx]# kubectl create configmap nginx-conf --from-file=./
configmap/nginx-conf created

[root@k8s-master1 nginx]# kubectl get configmaps nginx-conf -o yaml
[root@k8s-master1 nginx]# cat nginx-vhost-configmap.yml
apiVersion: v1
data:
  index.html: |
    test.guoguo.com
    test_vhosts
  test.guoguo.com.conf: |
    server {
            listen 80;
            server_name test.guoguo.com;
                location /dir2 {
                root /data/web/;
                index index.html index.htm;
                               }
            }
kind: ConfigMap
metadata:
  creationTimestamp: "2023-08-24T05:49:27Z" 
  name: nginx-vhost
  namespace: default
  resourceVersion: "365612"
  uid: 6c7e4371-94ff-4d0b-9698-cb2960ac50a0

指定为某个文件和指定某个目录内容一样

以上是通过命令行的方式创建configmap

还有通过资源配置清单的方式创建

我们可以将上面创建的重定向变成yml文件

[root@k8s-master1 nginx]# kubectl get configmaps nginx-conf -o yaml > nginx-conf-configmap.yml

打开看下

[root@k8s-master1 nginx]# cat nginx-vhost-configmap.yml
apiVersion: v1
data:
  index.html: |
    test.guoguo.com
    test_vhosts
  test.guoguo.com.conf: |
    server {
            listen 80;
            server_name test.guoguo.com;
                location / {
                root /data/web/dir2;
                index index.html index.htm;
                               }
            }
kind: ConfigMap
metadata:
  creationTimestamp: "2023-08-24T05:49:27Z"  #删掉
  name: nginx-vhost
  namespace: default
  resourceVersion: "365612"  #删掉
  uid: 6c7e4371-94ff-4d0b-9698-cb2960ac50a0  #删掉

这种方式创建比较常见

先用命令行的方式.创建出来,创建出来完成以后,再用查询的时候加 -o yaml 然后重定向一个文件然后稍作修改就可以直接用了

这样就直接可以创建

如果我现在直接执行这个文件

[root@k8s-master1 nginx]# kubectl apply -f nginx-vhost-configmap.yml
Warning: resource configmaps/nginx-vhost is missing the kubectl.kubernetes.io/last-applied-configuration annotation which is required by kubectl apply. kubectl apply should only be used on resources created declaratively by either kubectl create --save-config or kubectl apply. The missing annotation will be patched automatically.
configmap/nginx-vhost configured

他提示你已经存在了而且没有变更

我们做点修改更新一下他

replace 基于文件或者标准输入变更

apiVersion: v1
data:
  index.html: |
    test.guoguo.com
    test_vhosts
    test_guoguo  #做个修改
  test.guoguo.com.conf: |
    server {
            listen 80;
            server_name test.guoguo.com;
                location /dir2 {
                root /data/web/;
                index index.html index.htm;
                               }
            }
kind: ConfigMap
metadata:
  name: nginx-vhost
  namespace: default

bash[root@k8s-master1 nginx]# kubectl replace -f nginx-vhost-configmap.yml
configmap/nginx-vhost replaced

查询一下有没有变更

[root@k8s-master1 nginx]# kubectl get configmaps nginx-vhost -o yaml
apiVersion: v1
data:
  index.html: |  #这个configmap有两个值 | 后面是第一个值   下一个| 后面是第二个值
    test.guoguo.com
    test_vhosts
    test_guoguo  #我们更新的
  test.guoguo.com.conf: |
    server {
            listen 80;
            server_name test.guoguo.com;
                location /dir2 {
                root /data/web/;
                index index.html index.htm;
                               }
            }
kind: ConfigMap
metadata:
  creationTimestamp: "2023-08-24T05:49:27Z"
  name: nginx-vhost
  namespace: default
  resourceVersion: "368696"
  uid: 6c7e4371-94ff-4d0b-9698-cb2960ac50a0

未来i想修改configmap的时候首先重定向为一个文件，然后对文件进行修改

这是通过资源配置清单的方式创建configmap

通过四种方式去创建configmap

最终pod去引用

pod有两种方式来引用

一种是通过变量的方式来引用，

变量

[root@k8s-master1 nginx]# kubectl explain pod.spec.containers.env.valueFrom.configMapKeyRef
KIND:     Pod
VERSION:  v1

RESOURCE: configMapKeyRef <Object>

DESCRIPTION:
     Selects a key of a ConfigMap.

     Selects a key from a ConfigMap.

FIELDS:
   key  <string> -required-
   #key 的名称 键的名称   这个key的意思是 configmap里面有很多key 引用那个key
     The key to select.

   name <string>
   #这个name是configmap的名称
     Name of the referent. More info:
     https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names

   optional     <boolean>
   #configmap 可能有多个值  是否引用其中某一项  而不是引用全部值
#optional 字段表示这个 ConfigMap 和 key 是否必须存在,如果为 true,则允许它们不存在。
   
# optional 是一个布尔类型的值,默认为 false。

#它控制的是如果引用的 ConfigMap 或 ConfigMap 中的 key 不存在,是否允许错误。

#如果 optional 为 false (默认),那么 ConfigMap 和 key 必须存在,否则会产生错误。
#如果 optional 为 true,则允许 ConfigMap 或 key 不存在,在这种情况下,会以空字符串填充该环境变量的值。
#它的作用是控制容错性。在生产环境中,我们通常希望设置为 false,以确保注入的配置正确无误。

#但在某些情况下,可以将 optional 设置为 true,这样不是关键的配置可以省略,Pod 启动也不会失败。

#总结一下:

#optional=false : ConfigMap 和 key 必须存在,否则报错。
#optional=true : 允许 ConfigMap 或 key 不存在,使用空字符串作为值。
     Specify whether the ConfigMap or its key must be defined

我们去引用

创建configmap 然后引用

apiVersion: v1
kind: ConfigMap	#类型ConfigMap
metadata:
  name: conf-nginx-1
data:
  nginx-port: "8080"   #在一个configmap里面可以定义多个key value
  nginx-host: "127.0.0.1"    #他没有spec 因为他没有期待值
---
apiVersion: v1
kind: Pod
metadata:
  name: nginx-config-nginx-1
spec:
  containers:
  - name: nginx
    image: images.guoguo.com/apps/nginx:1.22.1
    ports:
    - containerPort: 80
    env:  #env  使用变量的方式引用configmap
    - name: PORT   #这里定义一个变量明 在pod里面使用
      valueFrom:
        configMapKeyRef:
          key: nginx-port  #引用上面 date里面定义的 key  在容器里面使用的是他的value  也就是“8080”
          name: conf-nginx-1   #这个key属于conf-nginx-1的configmap 
          optional: true  #如果为true  表示这个环境变量是可选的,如果指定的ConfigMap或者key不存在,Pod也可以正常启动,不会出现错误。
    - name: HOST
      valueFrom:
        configMapKeyRef:
          key: nginx-host
          name: conf-nginx-1
          optional: true  #如果为false 表示变量必选 如果 指定的configmap 或者key不存在  会报错

执行

[root@k8s-master1 configmap]# kubectl get configmaps conf-nginx-1  -o yaml
apiVersion: v1
data:
  nginx-host: 127.0.0.1
  nginx-port: "8080"
kind: ConfigMap
metadata:
  annotations:
    kubectl.kubernetes.io/last-applied-configuration: |
      {"apiVersion":"v1","data":{"nginx-host":"127.0.0.1","nginx-port":"8080"},"kind":"ConfigMap","metadata":{"annotations":{},"name":"conf-nginx-1","namespace":"default"}}
  creationTimestamp: "2023-08-26T02:28:15Z"
  name: conf-nginx-1
  namespace: default
  resourceVersion: "186488"
  uid: a21a5886-1fb5-4ff3-8929-b0362470d693

进去看下

[root@k8s-master1 configmap]# kubectl exec nginx-config-nginx-1 -it /bin/bash
root@nginx-config-nginx-1:/# echo $HOST
127.0.0.1
root@nginx-config-nginx-1:/# echo $PORT
8080

这是第一种引用configmap的方式，使用环境变量的方式

env在k8s里面还有另外一种变量 envFrom

直接将configMap资源一次性导入

[root@k8s-master1 configmap]# kubectl explain pod.spec.containers.envFrom
KIND:     Pod
VERSION:  v1

RESOURCE: envFrom <[]Object>

DESCRIPTION:
     List of sources to populate environment variables in the container. The
     keys defined within a source must be a C_IDENTIFIER. All invalid keys will
     be reported as an event when the container is starting. When a key exists
     in multiple sources, the value associated with the last source will take
     precedence. Values defined by an Env with a duplicate key will take
     precedence. Cannot be updated.

     EnvFromSource represents the source of a set of ConfigMaps

FIELDS:
   configMapRef	<Object>
   #configMap对象值
     The ConfigMap to select from

   prefix	<string>
   #前置的一个字段 前缀 被你引用的configMap变量添加一个前缀名，为了怕有些变量名一样 造成冲突
     An optional identifier to prepend to each key in the ConfigMap. Must be a
     C_IDENTIFIER.

   secretRef	<Object>
     The Secret to select from

[root@k8s-master1 configmap]# kubectl explain pod.spec.containers.envFrom.configMapRef
KIND:     Pod
VERSION:  v1

RESOURCE: configMapRef <Object>

DESCRIPTION:
     The ConfigMap to select from

     ConfigMapEnvSource selects a ConfigMap to populate the environment
     variables with.

     The contents of the target ConfigMap's Data field will represent the
     key-value pairs as environment variables.

FIELDS:
   name	<string>
   #引用configmap的名字
     Name of the referent. More info:
     https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names

   optional	<boolean>
   #为true 就key和value存不存在都没事，  如果为false key 和value 必须存在 否则报错
     Specify whether the ConfigMap must be defined

写一个

apiVersion: v1
kind: ConfigMap
metadata:
  name: conf-nginx-2
data:
  conf-name: "fengqichen"   #定义的第一个变量和值
  conf-age: "22"    #第二个
---
apiVersion: v1
kind: Pod
metadata:
  name: conf-nginx-2
spec:
  containers:
  - name: nginx
    image: images.guoguo.com/apps/nginx:1.22.1
    envFrom:   #使用envFrom  他是直接可以引用confmap全部的值的
    - configMapRef:
        name: conf-nginx-2       #configMap的名字
        optional: false         #为true 就key和value存不存在都没事，  如果为false key 和value 必须存在 否则报错

进去看下

[root@k8s-master1 configmap]# kubectl exec conf-nginx-2 -- env
PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
HOSTNAME=conf-nginx-2
conf-name=fengqichen  #这里
conf-age=22  #这里
KUBERNETES_SERVICE_PORT=443
NGINX_1_SERVICE_HOST=10.111.231.202
NGINX_1_PORT_80_TCP_ADDR=10.111.231.202
NGINX_1_PORT_80_TCP_PORT=80
KUBERNETES_SERVICE_PORT_HTTPS=443
KUBERNETES_PORT_443_TCP_PROTO=tcp
KUBERNETES_PORT_443_TCP_PORT=443
NGINX_1_PORT_80_TCP_PROTO=tcp
NGINX_1_SERVICE_PORT=80
NGINX_1_PORT_80_TCP=tcp://10.111.231.202:80
KUBERNETES_SERVICE_HOST=10.96.0.1
KUBERNETES_PORT=tcp://10.96.0.1:443
KUBERNETES_PORT_443_TCP=tcp://10.96.0.1:443
KUBERNETES_PORT_443_TCP_ADDR=10.96.0.1
NGINX_1_PORT=tcp://10.111.231.202:80
HOME=/root

这俩的不同是

pod.spec.containers.env.valueFrom 是单独引用configmap里面某一个ket value

pod.spec.containers.envFrom.configMapRef 是直接全部引用configMap里面的key value

只是引用方式不同而已

还一种方式，引用存储卷的方式挂在到pod里面引用

挂载存储卷，首先定义好configMap以后，他会把你configMap名称当成一个数据卷直接进行对某个目录进行挂载

就是volues 和voluesMount

[root@k8s-master1 configmap]# kubectl explain pod.spec.volumes.configMap
KIND:     Pod
VERSION:  v1

RESOURCE: configMap <Object>

DESCRIPTION:
     configMap represents a configMap that should populate this volume

     Adapts a ConfigMap into a volume.
     The contents of the target ConfigMap's Data field will be presented in a
     volume as files using the keys in the Data field as the file names, unless
     the items element is populated with specific mappings of keys to paths.
     ConfigMap volumes support ownership management and SELinux relabeling.

FIELDS:
   defaultMode	<integer>
     defaultMode is optional: mode bits used to set permissions on created files
     by default. Must be an octal value between 0000 and 0777 or a decimal value
     between 0 and 511. YAML accepts both octal and decimal values, JSON
     requires decimal values for mode bits. Defaults to 0644. Directories within
     the path are not affected by this setting. This might be in conflict with
     other options that affect the file mode, like fsGroup, and the result can
     be other mode bits set.

   items	<[]Object>
     items if unspecified, each key-value pair in the Data field of the
     referenced ConfigMap will be projected into the volume as a file whose name
     is the key and content is the value. If specified, the listed keys will be
     projected into the specified paths, and unlisted keys will not be present.
     If a key is specified which is not present in the ConfigMap, the volume
     setup will error unless it is marked optional. Paths must be relative and
     may not contain the '..' path or start with '..'.

   name	<string>
     Name of the referent. More info:
     https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names

   optional	<boolean>
     optional specify whether the ConfigMap or its keys must be defined

开干

[root@k8s-master1 conf.d]# cat myserver.conf
server {
    listen 80;
    server_name test.guoguo.com;

    include /apps/nginx/conf/vhost/*.cfg;

    location / {
        root /data/web/dir1/;
        index index.html index.htm;
    }
}

[root@k8s-master1 conf.d]# cat myserver-gzip.cfg
gzip  on;
gzip_comp_level 5;
gzip_min_length 1k;
gzip_http_version 1.0;
gzip_buffers 32 8k;
gzip_types text/plain application/javascript application/x-javascript text/css application/xml text/javascript application/x-httpd-php image/jpeg image/gif image/png image/jpg;
gzip_vary on;

[root@k8s-master1 conf.d]# cat myserver-status.cfg
location /nginx_status {
    stub_status;
}

[root@k8s-master1 test]# kubectl create configmap testconf --from-file=./
configmap/nginx-vhost-1 created

查看一下

[root@k8s-master1 conf.d]# kubectl get configmaps testconf -o yaml
apiVersion: v1
data:
  myserver-gzip.cfg: |+
    gzip  on;
    gzip_comp_level 5;
    gzip_min_length 1k;
    gzip_http_version 1.0;
    gzip_buffers 32 8k;
    gzip_types text/plain application/javascript application/x-javascript text/css application/xml text/javascript application/x-httpd-php image/jpeg image/gif image/png image/jpg;
    gzip_vary on;

  myserver-status.cfg: |+
    location /nginx_status {
        stub_status;
    }

  myserver.conf: |+
    server {
        listen 80;
        server_name test.guoguo.com;

        include /apps/nginx/conf/vhost/*.cfg;

        location / {
            root /data/web/dir1/;
            index index.html index.htm;
        }
    }

kind: ConfigMap
metadata:
  creationTimestamp: "2023-08-28T02:33:23Z"
  name: testconf
  namespace: default
  resourceVersion: "260807"
  uid: c27eaaff-f715-4843-bc11-fa493243397e

然后引用到pod里面

apiVersion: v1
kind: Pod
metadata:
  name: test-nginx-1
spec:
  volumes:
  - name: test  #定义一个名字 下面containers.volumeMounts要引用
    configMap:
      name: testconf  #这个是congimap的名字
      optional: true  #true 表示 key 和valume存在不存在无所谓 如果为false 那么key或balume不存在就报错
  containers:
  - name: nginx
    image: images.guoguo.com/apps/nginx:1.22.1
    volumeMounts:
    - name: test
      mountPath: /apps/nginx/conf/vhost/
      readOnly: false   #是否为只读  true为只读  默认或者写false为读写
    ports:
    - containerPort: 80

创建然后查看

[root@k8s-master1 pod]# kubectl get pods -owide
NAME           READY   STATUS    RESTARTS   AGE   IP              NODE                   NOMINATED NODE   READINESS GATES
test-nginx-1   1/1     Running   0          6s    192.17.65.243   k8s-node3.guoguo.com   <none>           <none>
[root@k8s-master1 pod]# curl -H "Host:test.guoguo.com" http://192.17.65.243
VERSION:NGINX:1.22.1-www.guoguo.com:dir_/data/web/dir1/index.html
[root@k8s-master1 pod]# curl -H "Host:test.guoguo.com" http://192.17.65.243/nginx_status
Active connections: 1
server accepts handled requests
 2 2 2
Reading: 0 Writing: 1 Waiting: 0

欧克了

nginx还有个命令nginx -T 可以看到给配置文件加了那些内容

#下面是nginx -T  的尾部
# configuration file /apps/nginx/conf/vhost/myserver.conf:
server {
    listen 80;
    server_name test.guoguo.com;

    include /apps/nginx/conf/vhost/*.cfg;

    location / {
        root /data/web/dir1/;
        index index.html index.htm;
    }
}


# configuration file /apps/nginx/conf/vhost/myserver-gzip.cfg:
gzip  on;
gzip_comp_level 5;
gzip_min_length 1k;
gzip_http_version 1.0;
gzip_buffers 32 8k;
gzip_types text/plain application/javascript application/x-javascript text/css application/xml text/javascript application/x-httpd-php image/jpeg image/gif image/png image/jpg;
gzip_vary on;


# configuration file /apps/nginx/conf/vhost/myserver-status.cfg:
location /nginx_status {
    stub_status;
}

#里面有我们挂载的configMap

上面是用数据卷的方式去引用configmap 这是引用了configmap里面所有的值

也可以通过上面环境变量的方式，只引用某些值。其中一个或者两个，configmap本身有个items

[root@k8s-master1 pod]# kubectl explain pod.spec.volumes.configMap
KIND:     Pod
VERSION:  v1

RESOURCE: configMap <Object>

DESCRIPTION:
     configMap represents a configMap that should populate this volume

     Adapts a ConfigMap into a volume.
     The contents of the target ConfigMap's Data field will be presented in a
     volume as files using the keys in the Data field as the file names, unless
     the items element is populated with specific mappings of keys to paths.
     ConfigMap volumes support ownership management and SELinux relabeling.

FIELDS:
   defaultMode  <integer>
     defaultMode is optional: mode bits used to set permissions on created files
     by default. Must be an octal value between 0000 and 0777 or a decimal value
     between 0 and 511. YAML accepts both octal and decimal values, JSON
     requires decimal values for mode bits. Defaults to 0644. Directories within
     the path are not affected by this setting. This might be in conflict with
     other options that affect the file mode, like fsGroup, and the result can
     be other mode bits set.

   items        <[]Object>
   #可以只引用某些项，就是你configmap里面某些data  某些数据源 数据源里面某些值
     items if unspecified, each key-value pair in the Data field of the
     referenced ConfigMap will be projected into the volume as a file whose name
     is the key and content is the value. If specified, the listed keys will be
     projected into the specified paths, and unlisted keys will not be present.
     If a key is specified which is not present in the ConfigMap, the volume
     setup will error unless it is marked optional. Paths must be relative and
     may not contain the '..' path or start with '..'.

   name <string>
     Name of the referent. More info:
     https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names

   optional     <boolean>
     optional specify whether the ConfigMap or its keys must be defined

[root@k8s-master1 pod]# kubectl explain pod.spec.volumes.configMap.items
KIND:     Pod
VERSION:  v1

RESOURCE: items <[]Object>

DESCRIPTION:
     items if unspecified, each key-value pair in the Data field of the
     referenced ConfigMap will be projected into the volume as a file whose name
     is the key and content is the value. If specified, the listed keys will be
     projected into the specified paths, and unlisted keys will not be present.
     If a key is specified which is not present in the ConfigMap, the volume
     setup will error unless it is marked optional. Paths must be relative and
     may not contain the '..' path or start with '..'.

     Maps a string key to a path within a volume.

FIELDS:
   key  <string> -required-
   #引用的键的名称
     key is the key to project.

   mode <integer>
   #权限
     mode is Optional: mode bits used to set permissions on this file. Must be
     an octal value between 0000 and 0777 or a decimal value between 0 and 511.
     YAML accepts both octal and decimal values, JSON requires decimal values
     for mode bits. If not specified, the volume defaultMode will be used. This
     might be in conflict with other options that affect the file mode, like
     fsGroup, and the result can be other mode bits set.

   path <string> -required-
   #路径
   #映射出来上面key叫啥名，可以跟键名不相同
     path is the relative path of the file to map the key to. May not be an
     absolute path. May not contain the path element '..'. May not start with
     the string '..'.

下面这个configmap和上面的一样只是名字改了下，内容一样的

[root@k8s-master1 conf.d]# cat myserver.conf
server {
    listen 80;
    server_name test.guoguo.com;

    include /apps/nginx/conf/vhost/*.cfg;

    location / {
        root /data/web/dir1/;
        index index.html index.htm;
    }
}

[root@k8s-master1 conf.d]# cat myserver-gzip.cfg
gzip  on;
gzip_comp_level 5;
gzip_min_length 1k;
gzip_http_version 1.0;
gzip_buffers 32 8k;
gzip_types text/plain application/javascript application/x-javascript text/css application/xml text/javascript application/x-httpd-php image/jpeg image/gif image/png image/jpg;
gzip_vary on;

[root@k8s-master1 conf.d]# cat myserver-status.cfg
location /nginx_status {
    stub_status;
}

[root@k8s-master1 conf.d]# kubectl create configmap dir1-test --from-file=./

[root@k8s-master1 pod]# cat dir1-test-1.yaml

apiVersion: v1
kind: Pod
metadata:
  name: dir1-pod-1
spec:
  volumes:
  - name: dir1  #起个名字  容器挂载的时候用
    configMap:
      name: dir1-test  #configmap的名字
      items: #可以单独引用configmap里面的某一些项
      - key: myserver-status.cfg  #configmap里面的key  也就是文件名
        path: myserver-status.cfg  #在容器里面 的名字  也就是在容器里面叫啥文件名
      - key: myserver.conf
        path: myserver.conf
      optional: true
  containers:
  - name: nginx
    image: images.guoguo.com/apps/nginx:1.22.1
    ports:
    - containerPort: 80
    volumeMounts:
    - name: dir1  #引用上面起的名字
      mountPath: /apps/nginx/conf/vhost/   #挂载的目录

上面configmap里面有三个文件但是只引用了两个文件

我们看下

[root@k8s-master1 conf.d]# kubectl exec -it dir1-pod-1 -- nginx -T

#.....省略前面这些
# configuration file /apps/nginx/conf/vhost/myserver.conf:
server {
    listen 80;
    server_name test.guoguo.com;

    include /apps/nginx/conf/vhost/*.cfg;

    location / {
        root /data/web/dir1/;
        index index.html index.htm;
    }
}


# configuration file /apps/nginx/conf/vhost/myserver-status.cfg:
location /nginx_status {
    stub_status;
}

没有挂载gzip 所以上面配置文件里面没有

进入容器里面详细看下

root@dir1-pod-1:/apps/nginx/conf/vhost# pwd
/apps/nginx/conf/vhost
#这是挂载的目录
root@dir1-pod-1:/apps/nginx/conf/vhost# ll
total 0
drwxrwxrwx 3 root root 108 Aug 28 06:45 ./
drwxr-xr-x 1 root root  19 Aug 23 06:40 ../
drwxr-xr-x 2 root root  54 Aug 28 06:45 ..2023_08_28_06_45_11.1536850526/
lrwxrwxrwx 1 root root  32 Aug 28 06:45 ..data -> ..2023_08_28_06_45_11.1536850526/
lrwxrwxrwx 1 root root  26 Aug 28 06:45 myserver-status.cfg -> ..data/myserver-status.cfg
lrwxrwxrwx 1 root root  20 Aug 28 06:45 myserver.conf -> ..data/myserver.conf
#看上面 myserver-status.cfg 和 myserver.conf  是链接文件 链接到..data/myserver-status.cfg 目录
#..data/myserver-status.cfg目录也是链接指向 ..2023_08_28_06_45_11.1536850526/ 目录
root@dir1-pod-1:/apps/nginx/conf/vhost# cd ..2023_08_28_06_45_11.1536850526/
root@dir1-pod-1:/apps/nginx/conf/vhost/..2023_08_28_06_45_11.1536850526# ll
total 8
drwxr-xr-x 2 root root  54 Aug 28 06:45 ./
drwxrwxrwx 3 root root 108 Aug 28 06:45 ../
-rw-r--r-- 1 root root  45 Aug 28 06:45 myserver-status.cfg
-rw-r--r-- 1 root root 193 Aug 28 06:45 myserver.conf
#进入..2023_08_28_06_45_11.1536850526/ 目录 我们源文件在这里呢
#

他是通过两层挂载目录的方式给你挂载的，未来更新的话就会去修改源文件，我们现在针对configmap坐下修改

[root@k8s-master1 conf.d]# kubectl get configmaps dir1-test -o yaml > dir1-test.yaml
#重定向一个文件去修改

apiVersion: v1
data:
  index.html: |
    dir2-test
  myserver-gzip.cfg: |+
    gzip  on;
    gzip_comp_level 5;
    gzip_min_length 1k;
    gzip_http_version 1.0;
    gzip_buffers 32 8k;
    gzip_types text/plain application/javascript application/x-javascript text/css application/xml text/javascript application/x-httpd-php image/jpeg image/gif image/png image/jpg;
    gzip_vary on;

  myserver-status.cfg: |+
    location /status { #状态页从nginx_status 改为status
        stub_status;
    }

  myserver.conf: |+
    server {
        listen 8080;  #端口号从80改为8080
        server_name test.guoguo.com;

        include /apps/nginx/conf/vhost/*.cfg;

        location / {
            root /data/web/dir1/;
            index index.html index.htm;
        }
    }

kind: ConfigMap
metadata:
  name: dir1-test
  namespace: default

[root@k8s-master1 conf.d]# kubectl replace -f dir1-test.yaml
configmap/dir1-test replaced

进入到容器里面

root@dir1-pod-1:/apps/nginx/conf/vhost# ll
total 0
drwxrwxrwx 3 root root 108 Aug 28 06:45 ./
drwxr-xr-x 1 root root  19 Aug 23 06:40 ../
drwxr-xr-x 2 root root  54 Aug 28 06:45 ..2023_08_28_06_45_11.1536850526/
lrwxrwxrwx 1 root root  32 Aug 28 06:45 ..data -> ..2023_08_28_06_45_11.1536850526/
																	#现在尾号是26
lrwxrwxrwx 1 root root  26 Aug 28 06:45 myserver-status.cfg -> ..data/myserver-status.cfg
lrwxrwxrwx 1 root root  20 Aug 28 06:45 myserver.conf -> ..data/myserver.conf
root@dir1-pod-1:/apps/nginx/conf/vhost# ll
total 0
drwxrwxrwx 3 root root 107 Aug 28 07:40 ./
drwxr-xr-x 1 root root  19 Aug 23 06:40 ../
drwxr-xr-x 2 root root  54 Aug 28 07:40 ..2023_08_28_07_40_21.298468154/
lrwxrwxrwx 1 root root  31 Aug 28 07:40 ..data -> ..2023_08_28_07_40_21.298468154/
																#已经改为54了 已经修改了
lrwxrwxrwx 1 root root  26 Aug 28 06:45 myserver-status.cfg -> ..data/myserver-status.cfg
lrwxrwxrwx 1 root root  20 Aug 28 06:45 myserver.conf -> ..data/myserver.conf
#验证一下
root@dir1-pod-1:/apps/nginx/conf/vhost# nginx -s reload
#这里需要nginx -s reload 一下这是虚拟机时代遗留问题
root@dir1-pod-1:/apps/nginx/conf/vhost# curl -H "Host:test.guoguo.com" 127.0.0.1:8080/status
Active connections: 1
server accepts handled requests
 16 16 16
Reading: 0 Writing: 1 Waiting: 0

#已经成功了

nginx有个点他修改配置文件后必须需要nginx -s reload 一下

tomcat 有个自动部署的功能

当软件运行的时候，他是将磁盘里面的东西运行到内存里面去，当你修改了文件后，只是修改的磁盘文件，这时候需要将修改好的文件加载到内存里面去

现在修改了只是修改了硬盘里面的文件，没有让更新好的文件加载到内存里面去，所以说没有生效，但是这种方式可以修改的，通过类似于服务发现的机制

这种方式可以修改的，服务发现机制，比如当我们etcd一修改，后面就知道他变化了，他有个服务发现机制，有个监控的机制

可以把nginx 修改完直接生效有个两秒钟三秒钟不需要reload 可以把这些配置存在类似etcd 服务发现存储里面让后让服务实时etcd的变化

这个挺难实现的，一般公司没有实现，但是不建议这样做，因为不小心把nginx改错了，直接生效了，直接起不来了，保证每次修改都素hi对的才可以

应用配置 配置管理