kubenetes入门学习-十四-存储卷3-Secret和configMap

柔光的暖阳◎ 2022-03-06 06:12 430阅读 0赞

[最近学习k8s遇到很多问题，建了一个qq群：153144292，交流devops、k8s、docker等][k8s_qq_153144292_devops_k8s_docker]

配置容器应用：Secret和configMap

configMap：k8s配置中心  
Secret：通过另外一种编码方式加密

配置容器化应用的方式  
    1、自定义命令行参数  
         command  
         args \[\]  
    2、把配置文件直接copy进镜像  
    3、环境变量  
         a、Cloud Native的应用程序一般可以直接通过环境变量加载配置  
         b、通过entrypoint脚本来预处理变量为配置文件的配置信息  
    4、存储卷  
      
    而在Kubernetes系统之中也存在这样的组件，就是特殊的存储卷类型。其并不是提供pod存储空间，  
而是给管理员或用户提供从集群外部向Pod内部的应用注入配置信息的方式。这两种特殊类型的存储卷  
分别是：configMap和secret

Secret：用于向Pod传递敏感信息，比如密码，私钥，证书文件等，这些信息如果在容器中定义容易泄露，Secret资源可以让用户将这些信息存储在急群众，然后通过Pod进行挂载，实现敏感数据和系统解耦的效果。  
ConfigMap：主要用于向Pod注入非敏感数据，使用时，用户将数据直接存储在ConfigMap对象当中，然后Pod通过使用ConfigMap卷进行引用，实现容器的配置文件集中定义和管理。

解耦目的  
两种方式注入：直接使用configmap存储卷、env脚本注入  
============================  
configMap  
    跟分布式中心Diamond（阿里）、Apollo（携程）、Qconf（360）、disconf（百度）类是的配置  
中心。  
    作为分布式系统的k8s也提供了一套配置管理方案--CconfigMap。  
    configmap是让配置文件从镜像中解耦，让镜像的可移植性和可复制性。许多应用程序会从配置  
文件、命令行参数或环境变量中读取配置信息。这些配置信息需要与docker image解耦，你总不能每  
修改一个配置就重做一个image吧？ConfigMap API给我们提供了向容器中注入配置信息的机制，ConfigMap  
可以被用来保存单个属性，也可以用来保存整个配置文件或者JSON二进制大对象

ConfigMap API资源用来保存key-value pair配置数据，这个数据可以在pods里使用，或者被用来  
为像controller一样的系统组件存储配置数据。虽然ConfigMap跟Secrets类似，但是ConfigMap更方便  
的处理不含敏感信息的字符串。   
    注意：ConfigMaps不是属性配置文件的替代品。ConfigMaps只是作为多个properties文件的引用。  
可以把它理解为Linux系统中的/etc目录，专门用来存储配置文件的目录。

下面举个例子，使用ConfigMap配置来创建Kuberntes Volumes，ConfigMap中的每个data项都会成  
为一个新文件。  
\[root@master volumes\]\# kubectl explain cm  
KIND:     ConfigMap  
VERSION:  v1  
FIELDS:  
   apiVersion   <string>  
   binaryData   <map\[string\]string>  
   data <map\[string\]string>  
   kind <string>  
   metadata <Object>

ConfigMap创建方式  
ConfigMap和Secret一样 也支持四种创建方式：

1、利用直接值创建  
通过--from-literal：每个--from-literal对应一个信息条目。  
\[root@master wolf3\]\# kubectl create configmap nginx-config --from-literal=nginx\_port=80 --from-literal=server\_name=myapp.magedu.com  
configmap/nginx-config created  
\[root@master wolf3\]\# kubectl get cm  
NAME           DATA   AGE  
nginx-config   2      8s  
\[root@master wolf3\]\# kubectl describe cm nginx-config  
Name:         nginx-config  
Namespace:    default  
Labels:       <none>  
Annotations:  <none>

Data  
====  
nginx\_port:  
\----  
80  
server\_name:  
\----  
myapp.magedu.com  
Events:  <none>

2、利用文件创建  
通过 --from-file：每个文件内容对应一个信息条目。  
\[root@master manifests\]\# mkdir configmap && cd configmap  
\[root@master configmap\]\# vim www.conf  
server \{  
    server\_name myapp.magedu.com;  
    listen 80;  
    root /data/web/html;  
\}  
\[root@master configmap\]\# ll  
total 4  
\-rw-r--r--. 1 root root 85 Mar 17 10:14 www.conf  
\[root@master configmap\]\# kubectl create configmap nginx-www --from-file=./www.conf  
configmap/nginx-www created  
\[root@master configmap\]\# kubectl get cm  
NAME           DATA   AGE  
nginx-config   2      3m16s  
nginx-www      1      20s  
\[root@master configmap\]\# kubectl get cm nginx-www -o yaml  
apiVersion: v1  
data:  
  www.conf: |  
    server \{  
        server\_name myapp.magedu.com;  
        listen 80;  
        root /data/web/html;  
    \}  
kind: ConfigMap  
metadata:  
  creationTimestamp: "2019-03-17T14:14:36Z"  
  name: nginx-www  
  namespace: default  
  resourceVersion: "2143132"  
  selfLink: /api/v1/namespaces/default/configmaps/nginx-www  
  uid: fe84fb3c-48be-11e9-bca0-a0369f95b76e

3、利用目录创建  
下面可以有多个键值  
\[root@master configmap\]\# kubectl create configmap nginx-config-files --from-file=./  
configmap/nginx-config-files created  
\[root@master configmap\]\# kubectl get cm nginx-config-files -o yaml  
apiVersion: v1  
data:  
  pod-configmap.yaml: "apiVersion: v1\\nkind: Pod\\nmatedata:\\n  name: pod-cm-1\\n  namespace:  
    default\\n  labels: \\n    app: myapp\\n    tier: frontend\\n  annotations:\\n    magedu.com/created-by:  
    \\"cluster admin\\"\\nspec:\\n  containers:\\n  - name: myapp\\n    image: nginx\\n    ports:\\n  
    \\   - name: http\\n      containerPort: 80 \\n    env:\\n    - name: NGINX\_SERVER\_PORT\\n  
    \\     valueFrom:\\n        configMapKeyRef:\\n          name: nginx-config\\n          key:  
    nginx\_port\\n    - name: NGINX\_SERVER\_NAME\\n      valueFrom:\\n        configMapKeyRef:\\n  
    \\         name: nginx-config\\n          key: server\_name\\n"  
  www.conf: |  
    server \{  
        server\_name myapp.magedu.com;  
        listen 80;  
        root /data/web/html;  
    \}  
kind: ConfigMap  
metadata:  
  creationTimestamp: "2019-03-17T14:36:46Z"  
  name: nginx-config-files  
  namespace: default  
  resourceVersion: "2145188"  
  selfLink: /api/v1/namespaces/default/configmaps/nginx-config-files  
  uid: 1776a6ee-48c2-11e9-bca0-a0369f95b76e  
4、利用清单创建  
apiVersion: v1  
kind: configmap  
metadata:  
  name: configmap-demo  
  namespace: default  
data:  
  log\_level: INFO  
  log\_file: /var/log/test.log  
\[root@master configmap\]\# kubectl apply -f configmap-demo.yaml   
configmap/configmap-demo created  
\[root@master configmap\]\# kubectl get cm configmap-demo -o yaml  
apiVersion: v1  
data:  
  log\_file: /var/log/test.log  
  log\_level: INFO  
kind: ConfigMap  
metadata:  
  annotations:  
    kubectl.kubernetes.io/last-applied-configuration: |  
      \{"apiVersion":"v1","data":\{"log\_file":"/var/log/test.log","log\_level":"INFO"\},"kind":"ConfigMap","metadata":\{"annotations":\{\},"name":"configmap-demo","namespace":"default"\}\}  
  creationTimestamp: "2019-03-17T14:40:26Z"  
  name: configmap-demo  
  namespace: default  
  resourceVersion: "2145528"  
  selfLink: /api/v1/namespaces/default/configmaps/configmap-demo  
  uid: 9a523e62-48c2-11e9-bca0-a0369f95b76e  
    
\[root@master configmap\]\# kubectl get cm  
NAME                 DATA   AGE  
configmap-demo       2      69s     清单创建  
nginx-config         2      29m     利用直接值创建  
nginx-config-files   2      4m49s   利用目录创建  
nginx-www            1      26m     利用文件创建  
\----------------------------  
如何使用configMap？？ 我理解的就是先创建cm，创建完成之后在清单里引用即可。  
1、环境变量方式注入到pod  
\[root@master configmap\]\# cat pod-configmap.yaml   
apiVersion: v1  
kind: Pod  
metadata:  
  name: pod-cm-1  
  namespace: default  
  labels:   
    app: wolf  
    tier: frontend  
  annotations:  
    magedu.com/created-by: "cluster admin"  
spec:  
  containers:  
  - name: wolf  
    image: nginx  
    ports:  
    - name: http  
      containerPort: 80   
    env:  
    - name: NGINX\_SERVER\_PORT  
      valueFrom:  
        configMapKeyRef:                     这里引用  
          name: nginx-config  
          key: nginx\_port  
    - name: NGINX\_SERVER\_NAME  
      valueFrom:  
        configMapKeyRef:  
          name: nginx-config  
          key: server\_name  
\[root@master configmap\]\# kubectl apply -f pod-configmap.yaml   
pod/pod-cm-1 created  
\[root@master configmap\]\# kubectl get pods  
NAME                                 READY   STATUS    RESTARTS   AGE  
pod-cm-1                             1/1     Running   0          38s

\[root@master configmap\]\# kubectl exec -it pod-cm-1 -- /bin/sh  
\# echo $NGINX\_SERVER\_PORT  
80  
\# echo $NGINX\_SERVER\_NAME  
myapp.magedu.com

\# env  
MYAPP\_SERVICE\_PORT\_HTTP=80  
KUBERNETES\_SERVICE\_PORT=443  
KUBERNETES\_PORT=tcp://10.96.0.1:443  
TOMCAT\_PORT\_8080\_TCP=tcp://10.106.171.107:8080  
HOSTNAME=pod-cm-1  
HOME=/root  
MYAPP\_SERVICE\_HOST=10.104.235.133  
NGINX\_SERVER\_PORT=80  
NGINX\_SERVER\_NAME=myapp.magedu.com  
MYAPP\_SERVICE\_PORT=80  
MYAPP\_PORT=tcp://10.104.235.133:80  
TERM=xterm  
KUBERNETES\_PORT\_443\_TCP\_ADDR=10.96.0.1  
NGINX\_VERSION=1.15.9-1~stretch  
PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin  
MYAPP\_PORT\_80\_TCP\_ADDR=10.104.235.133  
TOMCAT\_SERVICE\_PORT\_HTTP=8080  
KUBERNETES\_PORT\_443\_TCP\_PORT=443  
NJS\_VERSION=1.15.9.0.2.8-1~stretch  
KUBERNETES\_PORT\_443\_TCP\_PROTO=tcp  
MYAPP\_PORT\_80\_TCP\_PORT=80  
MYAPP\_PORT\_80\_TCP\_PROTO=tcp  
TOMCAT\_PORT\_8080\_TCP\_ADDR=10.106.171.107  
TOMCAT\_SERVICE\_HOST=10.106.171.107  
KUBERNETES\_PORT\_443\_TCP=tcp://10.96.0.1:443  
KUBERNETES\_SERVICE\_PORT\_HTTPS=443  
TOMCAT\_PORT\_8080\_TCP\_PORT=8080  
TOMCAT\_PORT\_8080\_TCP\_PROTO=tcp  
MYAPP\_PORT\_80\_TCP=tcp://10.104.235.133:80  
KUBERNETES\_SERVICE\_HOST=10.96.0.1  
PWD=/  
TOMCAT\_SERVICE\_PORT=8080  
TOMCAT\_PORT=tcp://10.106.171.107:8080

修改端口，可以发现使用环境变化注入pod中的端口不会根据配置的更改而变化  
\[root@master configmap\]\# kubectl edit cm nginx-config  
configmap/nginx-config edited   修改为8080  
\[root@master configmap\]\# kubectl exec -it pod-cm-1 -- /bin/sh  
\# env  
NGINX\_SERVER\_PORT=80  
NGINX\_SERVER\_NAME=myapp.magedu.com

2、存储卷方式挂载configmap：  
Volume 形式的 ConfigMap 也支持动态更新  
\[root@master configmap\]\# vim pod-configmap-2.yaml  
apiVersion: v1  
kind: Pod  
metadata:  
  name: pod-cm-2  
  namespace: default  
  labels:   
    app: myapp  
    tier: frontend  
  annotations:  
    magedu.com/created-by: "cluster admin"  
spec:  
  containers:  
  - name: myapp  
    image: nginx  
    ports:  
    - name: http  
      containerPort: 80   
    volumeMounts:  
    - name: nginxconf  
      mountPath: /etc/nginx/config.d/  
      readOnly: true  
  volumes:  
  - name: nginxconf  
    configMap:  
      name: nginx-config

\[root@master configmap\]\# kubectl apply -f pod-configmap-2.yaml  
pod/pod-cm-2 created  
\[root@master configmap\]\# kubectl get pods  
NAME                                 READY   STATUS    RESTARTS   AGE  
pod-cm-1                             1/1     Running   0          11m  
pod-cm-2                             1/1     Running   0          9s

\[root@master configmap\]\# kubectl exec -it pod-cm-2 -- /bin/sh  
\# cd /etc/nginx/config.d  
\# cat nginx\_port  
8080  
\# cat server\_name  
myapp.magedu.com

\[root@master ~\]\# kubectl edit cm nginx-config  \#修改端口，再在容器中查看端口是否变化  
configmap/nginx-config edited  
\[root@master configmap\]\# kubectl exec -it pod-cm-2 -- /bin/sh  
\# cd /etc/nginx/config.d  
\# cat nginx\_port  
8089\#

3、以nginx-www配置nginx  
\[root@master configmap\]\# vim pod-configmap-3.yaml  
apiVersion: v1  
kind: Pod  
metadata:  
  name: pod-cm-3  
  namespace: default  
  labels:   
    app: laolang  
    tier: frontend  
  annotations:  
    magedu.com/created-by: "cluster admin"  
spec:  
  containers:  
  - name: laolang  
    image: nginx  
    ports:  
    - name: http  
      containerPort: 80   
    volumeMounts:  
    - name: nginxconf  
      mountPath: /etc/nginx/conf.d/  
      readOnly: true  
  volumes:  
  - name: nginxconf  
    configMap:  
      name: nginx-www  
\[root@master configmap\]\# kubectl apply -f pod-configmap-3.yaml  
pod/pod-cm-3 created  
\[root@master configmap\]\# kubectl get pods  
NAME                                 READY   STATUS    RESTARTS   AGE  
pod-cm-1                             1/1     Running   0          17m  
pod-cm-2                             1/1     Running   0          5m30s  
pod-cm-3                             1/1     Running   0          7s

\[root@master configmap\]\# kubectl exec -it pod-cm-3 -- /bin/sh  
\# cd /etc/nginx/conf.d/  
\# ls  
www.conf  
\# cat www.conf  
server \{  
    server\_name myapp.magedu.com;  
    listen 80;  
    root /data/web/html;  
\}  
\#   
=============================  
Secret  
    Secret对象存储数据的方式是以键值方式存储数据，在Pod资源进行调用Secret的方式是通过环境  
变量或者存储卷的方式进行访问数据，解决了密码、token、密钥等敏感数据的配置问题，而不需要把  
这些敏感数据暴露到镜像或者Pod Spec中。另外，Secret对象的数据存储和打印格式为Base64编码的字  
符串，因此用户在创建Secret对象时，也需要提供该类型的编码格式的数据。在容器中以环境变量或存  
储卷的方式访问时，会自动解码为明文格式。需要注意的是，如果是在Master节点上，Secret对象以非  
加密的格式存储在etcd中，所以需要对etcd的管理和权限进行严格控制。

Secret有4种类型：  
    Service Account ：用来访问Kubernetes API，由Kubernetes自动创建，并且会自动挂载到Pod的/run/secrets/kubernetes.io/serviceaccount目录中；  
    Opaque ：base64编码格式的Secret，用来存储密码、密钥、信息、证书等，类型标识符为generic；  
    kubernetes.io/dockerconfigjson ：用来存储私有docker registry的认证信息，类型标识为docker-registry。  
    kubernetes.io/tls：用于为SSL通信模式存储证书和私钥文件，命令式创建类型标识为tls。

创建 Secret的2种方式  
命令式创建（下面3中命令方式）  
1、通过 --from-literal：每个 --from-literal 对应一个信息条目。  
\[root@master configmap\]\# kubectl create secret -h  
Create a secret using specified subcommand.

Available Commands:  
  docker-registry Create a secret for use with a Docker registry  
  generic         Create a secret from a local file, directory or literal value  
  tls             Create a TLS secret

Usage:  
  kubectl create secret \[flags\] \[options\]

Use "kubectl <command> --help" for more information about a given command.  
Use "kubectl options" for a list of global command-line options (applies to all commands).  
\[root@master configmap\]\#  kubectl create secret generic mysecret-1 --from-literal=username=admin --from-literal=password=123456  
secret/mysecret-1 created  
\[root@master configmap\]\# kubectl get secret  
NAME                    TYPE                                  DATA   AGE  
default-token-6q28w     kubernetes.io/service-account-token   3      17d  
mysecret                Opaque                                2      74s  
mysecret-1              Opaque                                2      8s  
tomcat-ingress-secret   kubernetes.io/tls                     2      3d23h

2、通过 --from-file：每个文件内容对应一个信息条目  
\[root@master configmap\]\# echo -n admin > ./username  
\[root@master configmap\]\# echo -n 123456 > ./password  
\[root@master configmap\]\# kubectl create secret generic mysecret --from-file=./username --from-file=./password   
secret/mysecret created  
\[root@master configmap\]\# kubectl get secret  
NAME                    TYPE                                  DATA   AGE  
default-token-6q28w     kubernetes.io/service-account-token   3      17d  
mysecret                Opaque                                2      8s  
tomcat-ingress-secret   kubernetes.io/tls                     2      3d23h

3、通过 --from-env-file：文件 env.txt 中每行 Key=Value 对应一个信息条目。  
\[root@master configmap\]\# cat << EOF > env.txt  
> username=admin  
> password=123456  
> EOF  
\[root@master configmap\]\# kubectl create secret generic mysecret2 --from-env-file=env.txt   
secret/mysecret2 created  
\[root@master configmap\]\# kubectl get secret                                              
NAME                    TYPE                                  DATA   AGE  
default-token-6q28w     kubernetes.io/service-account-token   3      17d  
mysecret                Opaque                                2      2m23s  
mysecret-1              Opaque                                2      77s  
mysecret2               Opaque                                2      3s  
tomcat-ingress-secret   kubernetes.io/tls                     2      3d23h

清单式创建  
通过 YAML 配置文件：  
\#事先完成敏感数据的Base64编码  
\#事先完成敏感数据的Base64编码  
\[root@master configmap\]\# echo -n admin |base64  
YWRtaW4=  
\[root@master configmap\]\# echo -n 123456 |base64  
MTIzNDU2  
\[root@master configmap\]\# vim secret.yaml  
apiVersion: v1  
kind: Secret  
metadata:  
  name: mysecret  
data:  
  username: YWRtaW4=  
  password: MTIzNDU2

\[root@master configmap\]\# kubectl apply -f secret.yaml   
secret/mysecret configured  
\[root@master configmap\]\# kubectl get secret  
NAME                    TYPE                                  DATA   AGE  
default-token-6q28w     kubernetes.io/service-account-token   3      17d  
mysecret                Opaque                                2      6m31s  
mysecret-1              Opaque                                2      5m25s  
mysecret2               Opaque                                2      4m11s  
tomcat-ingress-secret   kubernetes.io/tls                     2      3d23h

\[root@master configmap\]\# kubectl describe secret mysecret  
Name:         mysecret  
Namespace:    default  
Labels:       <none>  
Annotations:    
Type:         Opaque

Data  
====  
password:  6 bytes  
username:  5 bytes  
\[root@master configmap\]\#  kubectl edit secret mysecret

\[root@master configmap\]\# kubectl edit secret mysecret  
Edit cancelled, no changes made.  
\[root@master configmap\]\# echo -n MTIzNDU2 |base64 --decode  反编码  不安全啊  
123456  
\[root@master configmap\]\# echo -n YWRtaW4= |base64 --decode  
admin  
\[root@master configmap\]\#

\-----------------------------  
如何使用Secret？？  
Pod 可以通过 Volume 或者环境变量的方式使用 Secret  
apiVersion: v1  
kind: Pod  
metadata:  
  name: pod-secret  
spec:  
  containers:  
  - name: pod-secret  
    image: busybox  
    args:  
      - /bin/sh  
      - -c  
      - sleep 10;touch /tmp/healthy;sleep 30000  
    volumeMounts:  
    - name: foo  
      mountPath: /etc/foo  
      readOnly: true  
  volumes:  
  - name: foo  
    secret:  
      secretName: mysecret  
\[root@master configmap\]\# kubectl apply -f pod-secret-demo.yaml   
pod/pod-secret created  
\[root@master configmap\]\# kubectl get pods  
NAME                                 READY   STATUS    RESTARTS   AGE  
pod-cm-1                             1/1     Running   0          35m  
pod-cm-2                             1/1     Running   0          23m  
pod-cm-3                             1/1     Running   0          18m  
pod-secret                           1/1     Running   0          8s  
\[root@master configmap\]\# kubectl exec -it pod-secret -- /bin/sh  
/ \# ls /etc/foo  
password  username  
/ \# cat /etc/foo/username  
admin/ \# cat /etc/foo/password  
123456/ \#

可以看到，Kubernetes 会在指定的路径 /etc/foo 下为每条敏感数据创建一个文件，文  
件名就是数据条目的 Key，这里是 /etc/foo/username 和 /etc/foo/password，Value 则以  
明文存放在文件中。也可以自定义存放数据的文件名，比如将配置文件改为：  
\[root@master ~\]\# kubectl explain Pod.spec.volumes.secret.items  
\[root@master configmap\]\# kubectl delete -f pod-secret-demo.yaml   
pod "pod-secret" deleted  
\[root@master configmap\]\# cat pod-secret-demo.yaml   
apiVersion: v1  
kind: Pod  
metadata:  
  name: pod-secret  
spec:  
  containers:  
  - name: pod-secret  
    image: busybox  
    args:  
      - /bin/sh  
      - -c  
      - sleep 10;touch /tmp/healthy;sleep 30000  
    volumeMounts:  
    - name: foo  
      mountPath: /etc/foo  
      readOnly: true  
  volumes:  
  - name: foo  
    secret:  
      secretName: mysecret  
      items:  
      - key: username  
        path: my-secret/my-username  
      - key: password  
        path: my-secret/my-password

\[root@master configmap\]\# kubectl get pods  
NAME                                 READY   STATUS    RESTARTS   AGE  
pod-cm-1                             1/1     Running   0          44m  
pod-cm-2                             1/1     Running   0          33m  
pod-cm-3                             1/1     Running   0          27m  
pod-secret                           1/1     Running   0          5s  
\[root@master configmap\]\# kubectl exec -it pod-secret -- /bin/sh  
/ \# cat /etc/foo/my-secret/my  
cat: can't open '/etc/foo/my-secret/my': No such file or directory  
/ \# cd /etc/foo  
/etc/foo \# ls  
my-secret  
/etc/foo   
\# cd my-secret  
/etc/foo/..2019\_03\_17\_15\_34\_42.337036428/my-secret   
\# ls  
my-password  my-username  
/etc/foo/..2019\_03\_17\_15\_34\_42.337036428/my-secret   
\# cat my-password  
123456/etc/foo/..2019\_03\_17\_15\_34\_42.337036428/my-secret   
\# cat my-username  
admin/etc/foo/..2019\_03\_17\_15\_34\_42.337036428/my-secret  
 \#

这时数据将分别存放在 /etc/foo/my-secret/my-username 和 /etc/foo/my-secret/my-password 中。  
以 Volume 方式使用的 Secret 支持动态更新：Secret 更新后，容器中的数据也会更新。  
将 password 更新为 abcdef，base64 编码为 YWJjZGVm  
\[root@master configmap\]\# cat secret.yaml   
apiVersion: v1  
kind: Secret  
metadata:  
  name: mysecret  
data:  
  username: YWRtaW4=  
  password: YWJjZGVm  修改这里

\[root@master configmap\]\# kubectl apply -f secret.yaml   
secret/mysecret configured  
\[root@master configmap\]\# kubectl exec -it pod-secret -- /bin/sh  
/ \# cd /etc/foo  
/etc/foo \# ls  
my-secret  
/etc/foo \# cd my-secret  
/etc/foo/..2019\_03\_17\_15\_39\_24.948486602/my-secret \# ls  
my-password  my-username  
/etc/foo/..2019\_03\_17\_15\_39\_24.948486602/my-secret \# cat my-password  
abcdef     已更新  
/etc/foo/..2019\_03\_17\_15\_39\_24.948486602/my-secret \#    
通过 Volume 使用 Secret，容器必须从文件读取数据，会稍显麻烦，Kubernetes 还支持通过环境变量使用 Secret。   
\[root@master configmap\]\# cat pod-secret-env-demo.yaml   
apiVersion: v1  
kind: Pod  
metadata:  
  name: pod-secret-env  
spec:  
  containers:  
  - name: pod-secret-env  
    image: busybox  
    args:  
      - /bin/sh  
      - -c  
      - sleep 10;touch /tmp/healthy;sleep 30000  
    env:  
      - name: SECRET\_USERNAME  
        valueFrom:  
          secretKeyRef:  
            name: mysecret  
            key: username  
      - name: SECRET\_PASSWORD  
        valueFrom:  
          secretKeyRef:  
            name: mysecret  
            key: password  
\[root@master configmap\]\# kubectl apply -f pod-secret-env-demo.yaml  
pod/pod-secret-env created  
\[root@master configmap\]\# kubectl get pods  
NAME                                 READY   STATUS    RESTARTS   AGE  
pod-cm-1                             1/1     Running   0          58m  
pod-cm-2                             1/1     Running   0          47m  
pod-cm-3                             1/1     Running   0          41m  
pod-secret                           1/1     Running   0          14m  
pod-secret-env                       1/1     Running   0          8s

\[root@master configmap\]\# kubectl exec -it pod-secret-env sh  
/ \# echo $SECRET\_USERNAME  
admin  
/ \# echo $SECRET\_PASSWORD  
abcdef  
=============================  
\[root@master wolf3\]\# kubectl explain pods.spec.volumes  
......  
   configMap    <Object>  
     ConfigMap represents a configMap that should populate this volume

secret   <Object>  
     Secret represents a secret that should populate this volume. More info:  
     https://kubernetes.io/docs/concepts/storage/volumes\#secret

\[root@master wolf3\]\# kubectl explain cm  
KIND:     ConfigMap  
VERSION:  v1

DESCRIPTION:  
     ConfigMap holds configuration data for pods to consume.

FIELDS:  
   apiVersion    <string>  
     APIVersion defines the versioned schema of this representation of an  
     object. Servers should convert recognized schemas to the latest internal  
     value, and may reject unrecognized values. More info:  
     https://git.k8s.io/community/contributors/devel/api-conventions.md\#resources

binaryData    <map\[string\]string>  
     BinaryData contains the binary data. Each key must consist of alphanumeric  
     characters, '-', '\_' or '.'. BinaryData can contain byte sequences that are  
     not in the UTF-8 range. The keys stored in BinaryData must not overlap with  
     the ones in the Data field, this is enforced during validation process.  
     Using this field will require 1.10+ apiserver and kubelet.

data    <map\[string\]string>  
     Data contains the configuration data. Each key must consist of alphanumeric  
     characters, '-', '\_' or '.'. Values with non-UTF-8 byte sequences must use  
     the BinaryData field. The keys stored in Data must not overlap with the  
     keys in the BinaryData field, this is enforced during validation process.

kind    <string>  
     Kind is a string value representing the REST resource this object  
     represents. Servers may infer this from the endpoint the client submits  
     requests to. Cannot be updated. In CamelCase. More info:  
     https://git.k8s.io/community/contributors/devel/api-conventions.md\#types-kinds

metadata    <Object>  
     Standard object's metadata. More info:  
     https://git.k8s.io/community/contributors/devel/api-conventions.md\#metadata

[k8s_qq_153144292_devops_k8s_docker]: https://blog.csdn.net/yujin2010good/article/details/88621259