配置服务和 pod

ENTERPRISE

配置服务和 pod 以使用密钥

您的服务定义可将密钥引用环境变量或文件。

基于文件的密钥

您可以以文件指向将密钥，为提高其他进程安全性，或者您的服务需要从容器中安装的文件中读取密钥。指向基于文件的密钥对以下内容特别有用：

  • Kerberos keytab 或其他凭据文件。
  • SSL 证书。
  • 包含敏感数据的配置文件。

任务沙盒 ($MESOS_SANDBOX/<configured-path>) 中提供基于文件的密钥。

先决条件

  • 现有密钥。以下示例使用了存储在 developer 路径名为 my-secret 的密钥。如果您完成[创建密钥]中的步骤(/cn/1.12/security/ent/secrets/create-secrets/)，则您将满足此先决条件。

  • 已安装 DC/OS CLI 以及 已安装 DC/OS Enterprise CLI。

  • 您必须 获取根证书，才能发布此部分的 curl 命令。

  • 您的[安全模式]的适当权限(/cn/1.12/security/ent/#security-modes)。

    权限执行模式
    dcos:adminrouter:service:marathon full所有安全模式
    dcos:service:marathon:marathon:services:/[service-group full严格和宽容安全模式

    在 strict 模式，用户也可能需要以下内容。

    • dcos:adminrouter:ops:mesos full：查看 任务 面板信息。
    • dcos:adminrouter:ops:slave full：查看任务的详细信息，包括日志。

    只要密钥的路径和组的路径匹配正确，服务将能够访问密钥值。

    该步骤根据您是否要将密钥提供给 pod 或单个服务而有所不同。

    配置服务以使用密钥

    程序因接口而异。请参阅与您所需界面相对应的部分。

  1. ## 配置服务以通过 Web 界面使用密钥
  3. 1.  作为具有必要权限的用户登录 Web 界面，如 [权限管理]($000eeac177fea75f.md) 和 [授予访问密钥选项卡]($41f293bbed5c76a7.md) 中所述。
  5. 2.  单击 **Services** 选项卡。
  7. 3.  单击右上方的 **+** 图标。
  9.     ![添加服务](/projects/mesosphere-1.12-zh/31fc4e33607f4df5a9495535a1783241.png)
  11.     图 1. 运行服务
  13. 4.  单击 **JSON Editor** 切换按钮。
  15. 5.  选择默认 JSON 架构的内容并删除它们，以便黑框中不显示任何文本。
  17. 6.  复制以下简单应用定义之一，并将其粘贴到黑框中。此应用定义在开发人员组内创建新服务，并引用了存储在开发人员路径内的密钥。
  19.     基于环境变量的密钥：
  21.     ```
  22.     {  
  23.         "id":"/developer/service",
  24.         "cmd":"sleep 100",
  25.         "env":{  
  26.           "MY_SECRET":{  
  27.               "secret":"secret0"
  28.           }
  29.         },
  30.         "secrets":{  
  31.           "secret0":{  
  32.               "source":"developer/my-secret"
  33.           }
  34.         }
  35.     }
  36.     ```
  38.     在上述示例中，DC/OS 存储环境变量 `"MY_SECRET"` 下的密钥。观察 `"env"` 和 `"secrets"` 对象如何用于定义基于环境变量的密钥。
  40.     基于文件的密钥：
  42.     ```
  43.     {
  44.       "id": "developer/service",
  45.       "cmd": "sleep 100",
  46.       "container": {
  47.           "type": "MESOS",
  48.           "volumes": [
  49.           {
  50.             "containerPath": "path",
  51.             "secret": "secretpassword"
  52.           }
  53.         ]
  54.       },
  55.       "secrets": {
  56.         "secretpassword": {
  57.           "source": "developer/databasepassword"
  58.         }
  59.       }
  60.     }
  61.     ```
  63.     在上述示例中，密钥将具有文件名 `path`，并且将在任务的沙盒中可用 (`$MESOS_SANDBOX/path`) 。
  65.     由于服务和密钥路径匹配，服务将能够访问该密钥。有关路径的更多详细信息，请参阅[空间]($3ecd320bdee07940.md#spaces)。
  67. 7.  单击 **审查并运行**。
  69. 8.  单击 **运行服务**。
  71. 9.  单击服务组名称，即**开发人员**。
  73. 10.  单击服务名称。
  75. 11.  单击其任务名称。
  77. 12.  滚动浏览**详细信息**选项卡，找到基于环境变量的密钥 `DCOS_SECRETS_DIRECTIVE`。
  79.     如果要测试基于文件的密钥是否成功，可以将 `cat path` 添加到应用程序 `cmd`，以将密钥打印到 `stdout` 日志。
  81.     例如：
  83.     ```
  84.     {
  85.       "id": "developer/service",
  86.       "cmd": "cat path && sleep 100",
  87.       "container": {
  88.         "type": "MESOS",
  89.         "volumes": [
  90.       {
  91.         "containerPath": "path",
  92.         "secret": "secretpassword"
  93.       }
  94.       ]
  95.       },
  96.         "secrets": {
  97.           "secretpassword": {
  98.             "source": "developer/databasepassword"
  99.         }
  100.       }
  101.     }
  102.     ```
  105. # 通过 Marathon 应用定义配置服务以使用基于环境变量的密钥
  107. 1.  通过 `dcos auth login` 以具有必要权限的用户身份登录 CLI。请参阅 [关于配置服务和 pod 以使用密钥](#service) 来发现所需的权限。
  109. 2.  在文本编辑器内，为 Marathon 服务创建应用定义。以下应用程序定义在开发人员组内创建新服务，并引用了存储在开发人员路径内的密钥。
  111.     基于环境变量的密钥：
  113.     ```
  114.     {  
  115.         "id":"/developer/service",
  116.         "cmd":"sleep 100",
  117.         "env":{  
  118.           "MY_SECRET":{  
  119.               "secret":"secret0"
  120.           }
  121.         },
  122.         "secrets":{  
  123.           "secret0":{  
  124.               "source":"developer/my-secret"
  125.           }
  126.         }
  127.     }
  128.     ```
  130.     在上述示例中，DC/OS 存储环境变量 `"MY_SECRET"` 下的密钥。观察 `"env"` 和 `"secrets"` 对象如何用于定义基于环境变量的密钥。
  132.     基于文件的密钥：
  134.     ```
  135.     {
  136.       "id": "developer/service",
  137.       "cmd": "sleep 100",
  138.       "container": {
  139.          "type": "MESOS",
  140.          "volumes": [
  141.           {
  142.             "containerPath": "path",
  143.             "secret": "secretpassword"
  144.           }
  145.         ]
  146.       },
  147.       "secrets": {
  148.         "secretpassword": {
  149.           "source": "developer/databasepassword"
  150.         }
  151.       }
  152.     }
  153.     ```
  155.     由于服务组和密钥路径匹配，服务将能够访问密钥。有关路径的更多详细信息，请参阅[空间]($3ecd320bdee07940.md#spaces)。
  157. 3.  使用描述性名称保存文件，如 `myservice.json`。
  159. 4.  通过 DC/OS CLI 将服务添加到 DC/OS。
  161.     ```
  162.     dcos marathon app add myservice.json
  163.     ```
  165.     或者，使用 Marathon API 部署应用程序，如下所示。
  167.     ```
  168.     curl -X POST --cacert dcos-ca.crt $(dcos config show core.dcos_url)/service/marathon/v2/apps -d @myservice.json -H "Content-type: application/json" -H "Authorization: token=$(dcos config show core.dcos_acs_token)"
  169.     ```
  171. 5.  打开 DC/OS Web 界面。
  173. 6.  单击服务组名称，即**开发人员**。
  175. 7.  单击服务名称。
  177. 8.  单击其任务名称。
  179. 9.  滚动浏览**详细信息**标签，找到基于环境变量的密钥 `DCOS_SECRETS_DIRECTIVE`。
  181.     如果要测试基于文件的密钥是否成功，可以将 `cat path` 添加到应用程序 `cmd`，以将密钥打印到 `stdout` 日志。
  183.     例如：
  185.     ```
  186.     {
  187.       "id": "developer/service",
  188.       "cmd": "cat path && sleep 100",
  189.       "container": {
  190.         "type": "MESOS",
  191.         "volumes": [
  192.         {
  193.         "containerPath": "path",
  194.         "secret": "secretpassword"
  195.         }
  196.       ]
  197.       },
  198.         "secrets": {
  199.           "secretpassword": {
  200.             "source": "developer/databasepassword"
  201.         }
  202.       }
  203.     }
  204.     ```
  207. # 配置 pod 以使用密钥
  209. 1.  通过 `dcos auth login` 以具有必要权限的用户身份登录 CLI。有关权限的更多信息，请参阅 [关于配置服务和 pod 以使用密钥](#service)。
  211. 2.  在文本编辑器内，为 pod 创建应用定义。您可以使用 `"environment"` 和 `"secrets"` 对象添加密钥，如下所示。以下简单应用程序在开发人员组内定义新服务，并引用了存储在开发人员路径内的密钥。它将密钥存储在环境变量 `"MY_SECRET"` 下。
  213.     基于环境变量的密钥：
  215.     ```
  216.     {
  217.       "id": "/developer/pod-secret",
  218.       "environment": {
  219.         "MY_SECRET": {
  220.           "secret": "secret0"
  221.         }
  222.       },
  223.       "secrets": {
  224.         "secret0": { "source": "developer/my-secret"}
  225.       },
  226.       "containers": [
  227.         {
  228.           "name": "container-1",
  229.           "resources": {
  230.             "cpus": 0.1,
  231.             "mem": 128
  232.           },
  233.           "exec": {
  234.             "command": {
  235.               "shell": "sleep 3600"
  236.             }
  237.           }
  238.         }
  239.       ],
  240.       "scaling": {
  241.         "kind": "fixed",
  242.         "instances": 1
  243.       },
  244.       "networks": [
  245.         {
  246.           "mode": "host"
  247.         }
  248.       ]
  249.     }
  250.     ```
  252.     基于文件的密钥：
  254.     ```
  255.     {
  256.       "id": "developer/pod-with-secrets",
  257.       "containers": [
  258.          {
  259.            "type": "MESOS",
  260.            "name": "container-1",
  261.            "exec": {
  262.              "command": {
  263.                "shell": "sleep 1"
  264.              }
  265.          },
  266.          "volumeMounts": [
  267.            {
  268.              "name": "secretvolume",
  269.              "mountPath": "path/to/db/password"
  270.            }
  271.          ]
  272.        }
  273.      ],
  274.      "volumes": [
  275.        {
  276.          "name": "secretvolume",
  277.          "secret": "secretpassword"
  278.        }
  279.      ],
  280.      "secrets": {
  281.        "secretpassword": {
  282.          "source": "developer/databasepassword"
  283.        }
  284.      }
  285.     }
  286.     ```
  288.     **注意：**由于服务组和密钥路径匹配，pod 将能够访问密钥。有关路径的更多详细信息，请参阅[命名空间](https://docs.d2iq.com/mesosphere/dcos/1.12/security/ent/#spaces)。
  290. 3.  使用描述性名称保存文件，如 `mypod.json`。
  292. 4.  使用 DC/OS CLI 部署 Pod，如下所示。
  294.     ```
  295.     dcos marathon pod add mypod.json
  296.     ```
  298. 5.  打开 DC/OS Web 界面。
  300. 6.  单击服务组名称，即**开发人员**。
  302. 7.  单击 Pod 的名称。
  304. 8.  单击以打开 **Configuration** 选项卡。
  306. 9.  滚动到 **环境变量** 区域，找到您的密钥 `MY_SECRET`。
  309. ### 限制
  311. 基于文件的密钥仅与 UCR 配合使用。