jsonnet 和 Kubernetes

Posted k8s技术圈

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了jsonnet 和 Kubernetes相关的知识，希望对你有一定的参考价值。

Jsonnet 是 Google 开源的一门配置语言，用于增强 JSON 暴露出来的短板，它与 JSON 完全兼容并加入了一些新特性，包括注释、引用、算术运算、条件操作符、数组和对象深入、引入函数、局部变量、继承等，Jsonnet 程序被编译为兼容 JSON 的数据格式，简单来说 Jsonnet 就是 JSON 的增强版。

核心的思想就是某些 JSON 字段会被作为在编译时计算的变量或者表达式保留下来，比如，JSON 对象 {"size":10}可以表示为 {size:5+5}，除此之外，我们还可以使用在编译期间引用的 ::来声明隐藏的字段，比如 {x::5,y::5,size:$.x+$.y}也会被计算成 {"size":10}。

Jsonnet 对象还可以通过将对象连接在一起来覆盖字段值来进行子类化，例如，我们定义下面的内容：

 
   
   
 
    
  
    
    
  
  1. local base = {
    2. 
  
    
    
  
  2.     x:: error "必须定义'x'的值",
    3. 
  
    
    
  
  3.     y:: 2,  // 属性y有默认值2
    4. 
  
    
    
  
  4.     size: $.x + $.y
    5. 
  
    
    
  
  5. };
    6.

然后 Jsonnet 表达式 (base+{x::8})就将会被编译成 {"size":10}，我们需要提供属性 x的值，否则会引发错误，这样，我们就可以把 base看成在 Jsonnet 中定义抽象基类了。

当然除此之外，Jsonnet 还有一些其他的用法，更多关于 Jsonnet 的使用方法，我们可以前往官方网站 https://jsonnet.org/ 查看说明。

Jsonnet 和 Kubernetes

Kubernetes 作为一个强大的容器化编排系统，可以通过 JSON 和 YAML 文件来管理各种资源对象，自然 Jsonnet 也是支持的。

如果我们只在 Jsonnet 中只配置一个 Kubernetes 对象的话，那么我们就会错过了在具有共性的对象集合之间删除重复数据的能力。幸运的是，我们有几种方法可以来配置 Kubernetes 对象集合：使用 YAML 流输出、多文件输出或者单个 kubectl 列对象，熟悉 Kubernetes 的都知道，后面一种是 Kubernetes 支持的，无需 Jsonnet 提供任何支持，它允许我们将几个 Kubernetes 对象组合成一个对象，这是一个非常重要的能力，因为它不需要任何的中间文件。

Kubernetes 社区对 Jsonnet 非常活跃，下面的一些资源对你了解 Jsonnet 可能有所帮助：

  • Jsonnet repo 的一个简单例子：https://github.com/google/jsonnet/tree/master/case_studies/kubernetes

  • Kubecfg（https://github.com/ksonnet/kubecfg）是一个使用 Jsonnet 来管理 Kubernetes 资源的工具，另外还附带一个模板库（https://github.com/bitnami-labs/kube-libsonnet），可以通过这篇文章了解更多信息（https://engineering.bitnami.com/articles/an-example-of-real-kubernetes-bitnami.html）。

  • Heptio（https://heptio.com）是 Ksonnet（https://ksonnet.io） 的 Kubecfg 的一个分支，它使用一个 Jsonnet 库，该库是从 Kubernetes API 规范中自动生成的，现在这个库已经形成了一个框架，可以使用更高级的方式来描述 Kubernetes 对象。

  • Kapitan（https://github.com/deepmind/kapitan）是 Deepmind（https://deepmind.com/）与 Jsonnet和文本模板驱动 Kubernetes 的另外一个工具。

  • Box（https://www.box.com/）在博客（https://blog.box.com/blog/kubernetes-box-microservices-maximum-velocity/）和 Youtube（https://youtu.be/QIDrdZlEQdw?t=10m35s）上谈到了其内部Kubernetes为主的基础设施如何使用 Jsonnet 的。

  • Databricks（https://databricks.com/）写了一篇关于如何使用 Jsonnet 来管理 Kubernetes 基础设施的（https://databricks.com/blog/2017/06/26/declarative-infrastructure-jsonnet-templating-language.html），除此之外，他们还写了一个关于 Jsonnet 的风格指南（https://github.com/databricks/jsonnet-style-guide）。

下面是一个我们平时经常使用的 YAML 文件来声明的对象资源：(kube.yaml)

 
   
   
 
    
  
    
    
  
  1. kind: ReplicationController
    2. 
  
    
    
  
  2. apiVersion: v1
    3. 
  
    
    
  
  3. metadata:
    4. 
  
    
    
  
  4.   name: spark-master-controller
    5. 
  
    
    
  
  5. spec:
    6. 
  
    
    
  
  6.   replicas: 1
    7. 
  
    
    
  
  7.   selector:
    8. 
  
    
    
  
  8.     component: spark-master
    9. 
  
    
    
  
  9.   template:
    10. 
  
    
    
  
  10.     metadata:
    11. 
  
    
    
  
  11.       labels:
    12. 
  
    
    
  
  12.         component: spark-master
    13. 
  
    
    
  
  13.     spec:
    14. 
  
    
    
  
  14.       containers:
    15. 
  
    
    
  
  15.         - name: spark-master
    16. 
  
    
    
  
  16.           image: k8s.gcr.io/spark:1.5.2_v1
    17. 
  
    
    
  
  17.           command: ["/start-master"]
    18. 
  
    
    
  
  18.           ports:
    19. 
  
    
    
  
  19.             - containerPort: 7077
    20. 
  
    
    
  
  20.             - containerPort: 8080
    21. 
  
    
    
  
  21.           resources:
    22. 
  
    
    
  
  22.             requests:
    23. 
  
    
    
  
  23.               cpu: 100m
    24.

如果将上述 YAML 文件转换成对应的 Jsonnet 文件的：(output.jsonnet)

 
   
   
 
    
  
    
    
  
  1. {
    2. 
  
    
    
  
  2.   kind: 'ReplicationController',
    3. 
  
    
    
  
  3.   apiVersion: 'v1',
    4. 
  
    
    
  
  4.   metadata: {
    5. 
  
    
    
  
  5.     name: 'spark-master-controller',
    6. 
  
    
    
  
  6.   },
    7. 
  
    
    
  
  7.   spec: {
    8. 
  
    
    
  
  8.     replicas: 1,
    9. 
  
    
    
  
  9.     selector: {
    10. 
  
    
    
  
  10.       component: 'spark-master',
    11. 
  
    
    
  
  11.     },
    12. 
  
    
    
  
  12.     template: {
    13. 
  
    
    
  
  13.       metadata: {
    14. 
  
    
    
  
  14.         labels: {
    15. 
  
    
    
  
  15.           component: 'spark-master',
    16. 
  
    
    
  
  16.         },
    17. 
  
    
    
  
  17.       },
    18. 
  
    
    
  
  18.       spec: {
    19. 
  
    
    
  
  19.         containers: [
    20. 
  
    
    
  
  20.           {
    21. 
  
    
    
  
  21.             name: 'spark-master',
    22. 
  
    
    
  
  22.             image: 'k8s.gcr.io/spark:1.5.2_v1',
    23. 
  
    
    
  
  23.             command: [
    24. 
  
    
    
  
  24.               '/start-master',
    25. 
  
    
    
  
  25.             ],
    26. 
  
    
    
  
  26.             ports: [
    27. 
  
    
    
  
  27.               {
    28. 
  
    
    
  
  28.                 containerPort: 7077,
    29. 
  
    
    
  
  29.               },
    30. 
  
    
    
  
  30.               {
    31. 
  
    
    
  
  31.                 containerPort: 8080,
    32. 
  
    
    
  
  32.               },
    33. 
  
    
    
  
  33.             ],
    34. 
  
    
    
  
  34.             resources: {
    35. 
  
    
    
  
  35.               requests: {
    36. 
  
    
    
  
  36.                 cpu: '100m',
    37. 
  
    
    
  
  37.               },
    38. 
  
    
    
  
  38.             },
    39. 
  
    
    
  
  39.           },
    40. 
  
    
    
  
  40.         ],
    41. 
  
    
    
  
  41.       },
    42. 
  
    
    
  
  42.     },
    43. 
  
    
    
  
  43.   },
    44. 
  
    
    
  
  44. }
    45.

Kubernetes 集合

在某些地方，Kubernetes API 对象使用命名对象或者键值对的列表，而不是使用对象将名称映射到值，这使得这些对象很难在 Jsonnet 中引用和扩展，例如，Pod 的容器声明部分如下所示：

 
   
   
 
    
  
    
    
  
  1. local PodSpec = {
    2. 
  
    
    
  
  2.     containers: [
    3. 
  
    
    
  
  3.         {
    4. 
  
    
    
  
  4.             name: "foo",
    5. 
  
    
    
  
  5.             env: [
    6. 
  
    
    
  
  6.                 {name: 'var1', value: 'somevalue'},
    7. 
  
    
    
  
  7.                 {name: 'var2', value: 'somevalue'}
    8. 
  
    
    
  
  8.             ]
    9. 
  
    
    
  
  9.         },
    10. 
  
    
    
  
  10.         {
    11. 
  
    
    
  
  11.             name: 'bar',
    12. 
  
    
    
  
  12.             env: [
    13. 
  
    
    
  
  13.                 {name: 'var2', value: 'somevalue'},
    14. 
  
    
    
  
  14.                 {name: 'var3': value: 'somevalue'}
    15. 
  
    
    
  
  15.             ]
    16. 
  
    
    
  
  16.         }
    17. 
  
    
    
  
  17.     ]
    18. 
  
    
    
  
  18. };
    19.

如果我们想要覆盖它来修改环境变量 var3 的值，那么我们可以使用数组索引来引用特定的容器和环境变量：

 
   
   
 
    
  
    
    
  
  1. PodSpec { 
    2. 
  
    
    
  
  2.   containers：[ 
    3. 
  
    
    
  
  3.     super.containers [0]，
    4. 
  
    
    
  
  4.     super.containers [1] { 
    5. 
  
    
    
  
  5.       env：[ 
    6. 
  
    
    
  
  6.         super.env [0]，
    7. 
  
    
    
  
  7.         super.env [1] {value：'othervalue'}，
    8. 
  
    
    
  
  8.       ]，
    9. 
  
    
    
  
  9.     }，
    10. 
  
    
    
  
  10.   ]，
    11. 
  
    
    
  
  11. }
    12.

但是很明显上面的代码是比较乱的，更好的解决方案是使用对象来表示映射，然后转换为 Kubernetes 对象。首先定义一个工具类：（utils.libsonnet）

 
   
   
 
    
  
    
    
  
  1. // utils.libsonnet
    2. 
  
    
    
  
  2. {
    3. 
  
    
    
  
  3.   pairList(tab, kfield='name', vfield='value'):: [
    4. 
  
    
    
  
  4.     { [kfield]: k, [vfield]: tab[k] }
    5. 
  
    
    
  
  5.     for k in std.objectFields(tab)
    6. 
  
    
    
  
  6.   ],
    7. 
  
    
    
  

    8. 
  
    
    
  
  8.   namedObjectList(tab, name_field='name'):: [
    9. 
  
    
    
  
  9.     tab[name] + { [name_field]: name }
    10. 
  
    
    
  
  10.     for name in std.objectFields(tab)
    11. 
  
    
    
  
  11.   ],
    12. 
  
    
    
  
  12. }
    13.

然后定义 Pod ：（pod-spec.jsonnet）

 
   
   
 
    
  
    
    
  
  1. local utils = import 'utils.libsonnet';
    2. 
  
    
    
  

    3. 
  
    
    
  
  3. local PodSpec = {
    4. 
  
    
    
  
  4.   containersObj:: {
    5. 
  
    
    
  
  5.     foo: {
    6. 
  
    
    
  
  6.       envObj:: {
    7. 
  
    
    
  
  7.         var1: 'somevalue',
    8. 
  
    
    
  
  8.         var2: 'somevalue',
    9. 
  
    
    
  
  9.       },
    10. 
  
    
    
  
  10.       env: utils.pairList(self.envObj),
    11. 
  
    
    
  
  11.     },
    12. 
  
    
    
  
  12.     bar: {
    13. 
  
    
    
  
  13.       envObj:: {
    14. 
  
    
    
  
  14.         var2: 'somevalue',
    15. 
  
    
    
  
  15.         var3: 'somevalue',
    16. 
  
    
    
  
  16.       },
    17. 
  
    
    
  
  17.       env: utils.pairList(self.envObj),
    18. 
  
    
    
  
  18.     },
    19. 
  
    
    
  
  19.   },
    20. 
  
    
    
  
  20.   containers:
    21. 
  
    
    
  
  21.     utils.namedObjectList(self.containersObj),
    22. 
  
    
    
  
  22. };
    23. 
  
    
    
  

    24. 
  
    
    
  
  24. PodSpec {
    25. 
  
    
    
  
  25.   containersObj+: {
    26. 
  
    
    
  
  26.     bar+: { envObj+: { var3: 'othervalue' } }
    27. 
  
    
    
  
  27.   }
    28. 
  
    
    
  
  28. }
    29.

然后编译后就可以得到环境变量被替换后的结果：(output.json)

 
   
   
 
    
  
    
    
  
  1. {
    2. 
  
    
    
  
  2.   "containers": [
    3. 
  
    
    
  
  3.     {
    4. 
  
    
    
  
  4.       "env": [
    5. 
  
    
    
  
  5.         {
    6. 
  
    
    
  
  6.           "name": "var2",
    7. 
  
    
    
  
  7.           "value": "somevalue"
    8. 
  
    
    
  
  8.         },
    9. 
  
    
    
  
  9.         {
    10. 
  
    
    
  
  10.           "name": "var3",
    11. 
  
    
    
  
  11.           "value": "othervalue"
    12. 
  
    
    
  
  12.         }
    13. 
  
    
    
  
  13.       ],
    14. 
  
    
    
  
  14.       "name": "bar"
    15. 
  
    
    
  
  15.     },
    16. 
  
    
    
  
  16.     {
    17. 
  
    
    
  
  17.       "env": [
    18. 
  
    
    
  
  18.         {
    19. 
  
    
    
  
  19.           "name": "var1",
    20. 
  
    
    
  
  20.           "value": "somevalue"
    21. 
  
    
    
  
  21.         },
    22. 
  
    
    
  
  22.         {
    23. 
  
    
    
  
  23.           "name": "var2",
    24. 
  
    
    
  
  24.           "value": "somevalue"
    25. 
  
    
    
  
  25.         }
    26. 
  
    
    
  
  26.       ],
    27. 
  
    
    
  
  27.       "name": "foo"
    28. 
  
    
    
  
  28.     }
    29. 
  
    
    
  
  29.   ]
    30. 
  
    
    
  
  30. }
    31.

这种模式也使得引用的时候更加容易，现在，我们就可以使用以下代码访问相同的环境变量：

 
   
   
 
    
  
    
    
  
  1. PodSpec.containersObj.bar.envObj.var3
    2.

原文链接：https://jsonnet.org/articles/kubernetes.html

以上是关于jsonnet 和 Kubernetes的主要内容，如果未能解决你的问题，请参考以下文章

如何在 Jsonnet 中为 Grafana 仪表板模板填充变量

ksonnet 一个简化编写以及部署kubernetes的工具

Using-JSONNET-for-dynamic-JSON-parsing

jsonnet锛屽氨杩欎箞绁炲

使用 Gitlab 仪表板 - 如何将 grafonnet 与 jsonnet 一起使用以生成我可以与 Grafana 一起使用的 json 文件

kubernetes1.4简介和安装部署