• YAML技术
    • 标志和集合
    • YAML中的标量类型
    • YAML中的字符串
    • 控制多行字符串中的空格
    • 缩进和模板
    • 折叠多行字符串
    • 在一个文件中嵌入多个文档
    • YAML是JSON的一个超集
    • YAML锚点

    YAML技术

    本指南的大部分内容都集中在编写模板语言。 在这里，我们将看看YAML格式。 YAML具有一些有用的功能，我们作为模板作者可以使我们的模板更少出错并更易于阅读。

    标志和集合

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

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

    1. map:
    2.   one: 1
    3.   two: 2
    4.   three: 3
    6. sequence:
    7.   - one
    8.   - two
    9.   - three

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

    YAML中的标量类型

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

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

    1. count: 1
    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

    以上将把coffee的value视为一个相当于Latte\ nCappuccino\ nEspresso\ n的字符串。

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

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

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

    1. Error parsing file: error converting YAML to JSON: yaml: line 7: did not find expected key

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

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

    请注意，无论第一行是什么，它都将保留在字符串的输出中。 因此，如果您使用这种技术将文件内容注入到ConfigMap中，那么该注释应该是任何正在读取该条目的预期类型。

    控制多行字符串中的空格

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

    1. coffee: |-
    2.   Latte
    3.   Cappuccino
    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中用多行代表一个字符串，但是当它被解释时，要把它当作一个长行。 这被称为“折叠”。 要声明折叠块，请使用>代替|：

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

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

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

    以上将产生Latte\n 12 oz\n 16 oz\nCappuccino Espresso。 请注意，间距和换行符都在那里。

    在一个文件中嵌入多个文档

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

    1. ---
    2. document: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将是：

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

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