YAML技术

    根据YAML规范，有两种类型的集合，以及许多标量类型。

    这两种类型的集合是map和sequences：

    标量值是单个值（与集合相对）

    YAML中的标量类型

    在Helm的YAML方言中，值的标量数据类型由一组复杂的规则确定，包括用于资源定义的Kubernetes模式。 但是，在推断类型时，以下规则往往成立。

    如果一个整数或浮点数是不加引号的单词，它通常被视为一个数字类型：

    2. size: 2.34

    但如果他们被引用，他们被视为字符串：

    1. count: "1" # <-- string, not int
    2. size: '2.34' # <-- string, not float

    布尔值也是如此：

    1. isGood: true   # bool
    2. answer: "true" # string

    如果值为空value,那么它是null（不是Nil）。

    请注意，端口：“80”是有效的YAML，并且将通过模板引擎和YAML分析器，但如果Kubernetes预期端口为整数，则会失败。

    在某些情况下，您可以使用YAML节点标签强制进行特定的类型推断：

    1. coffee: "yes, please"
    2. age: !!str 21
    3. port: !!int "80"

    在上面，!! str告诉解析器年龄是一个字符串，即使它看起来像一个int。 并且端口被视为int，尽管它被引用。

    YAML中的字符串

    我们放在YAML文档中的大部分数据都是字符串。 YAML有多种表示字符串的方式。 本节将介绍这些方法并演示如何使用其中的一些方法。

    有三种“内联”的方式来声明一个字符串：

    1. way1: bare words
    2. way2: "double-quoted strings"
    3. way3: 'single-quoted strings'

    所有内联样式必须位于同一行上。

    • bare words没有被引用，并且没有逃脱。 出于这个原因，你必须小心你使用什么字符。
    • 双引号字符串可以使用\转义特定字符。 例如“\”hello\“，she said”。 您可以使用\ n来换行。
    • 单引号字符串是“literal(字面)”字符串，并且不使用\来转义字符。 唯一的转义序列是’’，它被解码为一个’。

    除了单行字符串外，还可以声明多行字符串：

    1. coffee: |
    2.   Latte
    3.   Cappuccino
    4.   Espresso

    请注意，|后的第一行 必须正确缩进。 所以我们可以通过这样做来打破上面的例子：

    由于Latte被错误地缩进，我们会得到这样的错误：

      在模板中，为了防止出现上述错误，在多行文档中放置伪造的“第一行”内容有时更安全：

      1. coffee: |
      2.   # Commented first line
      3.          Latte
      4.   Cappuccino
      5.   Espresso

      在上面的例子中，我们使用了| 表示一个多行字符串。 但请注意，我们的字符串的内容后跟着\ n。 如果我们希望YAML处理器去掉尾随的换行符，我们可以在|后面添加 -

      1. coffee: |-
      2.   Latte
      4.   Espresso

      现在，caffee的价值将是：Latte\nCappuccino\nEspresso（没有拖尾\ n）。

      其他时候，我们可能希望保留所有尾随空格。 我们可以用| +符号来做到这一点：

      1. coffee: |+
      2.   Latte
      3.   Cappuccino
      4.   Espresso
      7. another: value

      现在caffee的价值将是Latte\nCappuccino\nEspresso\n\n\n。

      文本块内部的缩进被保留，并导致保留换行符：

      1. coffee: |-
      2.   Latte
      3.     12 oz
      4.     16 oz
      5.   Cappuccino
      6.   Espresso

      在上述情况下，咖啡将是拿铁\n 12 oz\n 16 oz\nCappuccino\nEspresso。

      缩进和模板

      在编写模板时，您可能会发现自己希望将文件内容注入模板。 正如我们在前面的章节中看到的，有两种方法可以做到这一点：

      • 使用{{.Files.Get“ FILENAME”}}获取chart中文件的内容。
      • 使用{{include “tempalet” . }}渲染模板，然后将其内容放入chart中。

      将文件插入YAML时，最好理解上面的多行规则。 通常情况下，插入静态文件的最简单方法是做这样的：

      1. myfile: |
      2. {{ .Files.Get "myfile.txt" | indent 2 }}

      请注意我们如何执行上面的缩进：indent 2告诉模板引擎使用两个空格缩进“myfile.txt”中的每一行。 请注意，我们不缩进该模板行。 那是因为如果我们做了，第一行的文件内容会缩进两次

      折叠多行字符串

      有时候你想在你的YAML中用多行代表一个字符串，但是当它被解释时，要把它当作一个长行。 这被称为“折叠”。 要声明折叠块，请使用>代替|：

      以上coffee的value将是Latte Cappuccino Espresso\n。 请注意，除最后一个换行符之外的所有内容都将转换为空格。 您可以将空格控件与折叠的文本标记组合起来，因此> - 将替换或修剪所有换行符。

      1. coffee: >-
      2.   Latte
      3.     16 oz
      4.   Cappuccino
      5.   Espresso

      可以将多个YAML文档放入单个文件中。 这是通过在一个新的文档前添加开始标识符—和结束标识符…

      1. ---
      3. ...
      4. ---
      5. document: 2
      6. ...

      在许多情况下，—-或…可能被省略。

      Helm中的某些文件不能包含多个文档。 例如，如果在values.yaml文件内部提供了多个文档，则只会使用第一个文档。

      但是，模板文件可能有多个文档。 发生这种情况时，文件（及其所有文档）在模板呈现过程中被视为一个对象。 但是，最终的YAML在被送到Kubernetes之前被分成多个文件。

      我们建议每个文件只在绝对必要时使用多个文档。 在一个文件中有多个文件可能很难调试。

      YAML是JSON的一个超集

      因为YAML是JSON的超集，所以任何有效的JSON文档都应该是有效的YAML。

      1. {
      2.   "coffee": "yes, please",
      3.   "coffees": [
      4.     "Latte", "Cappuccino", "Espresso"
      5.   ]
      6. }

      另一种表达方式：

      1. coffee: yes, please
      2. coffees:
      3. - Latte
      4. - Cappuccino
      5. - Espresso

      这两者可以混合使用（小心）：

      1. coffee: "yes, please"
      2. coffees: [ "Latte", "Cappuccino", "Espresso"]

      以上这三个都应该解析为相同的内部表示。

      虽然这意味着像values.yaml这样的文件可能包含JSON数据，但Helm不会将文件扩展名.json视为有效的后缀。

      YAML锚点

      YAML规范提供了一种方法来存储对某个值的引用，并稍后通过引用来引用该值。 YAML将此称为“锚点(anchoring)”：

      1. coffee: "yes, please"
      2. favorite: &favoriteCoffee "Cappucino"
      3. coffees:
      4.   - Latte
      5.   - *favoriteCoffee
      6.   - Espresso

      在上面，＆favoriteCoffee设置了对Cappuccino的引用。 之后，该引用被用作*favoriteCoffee。 所以coffees变成Latte，Cappucino，浓Espresso。

      虽然在少数情况下锚点是有用的，但它们的一个方面可能导致细微的错误：第一次使用YAML时，引用被扩展，然后被丢弃。

      所以如果我们要解码然后重新编码上面的例子，那么产生的YAML将是：

      因为Helm和Kubernetes经常读取，修改并重写YAML文件，锚将会丢失。