Merge pull request #794 from kakkoyun/ksonnet_no_more_16

Remove ksonnet from prometheus/prometheus.libsonnet

jsonnet/kube-prometheus/prometheus/prometheus.libsonnet

@@ -1,21 +1,12 @@
-local k3 = import 'github.com/ksonnet/ksonnet-lib/ksonnet.beta.3/k.libsonnet';
-local k = import 'github.com/ksonnet/ksonnet-lib/ksonnet.beta.4/k.libsonnet';
+local relabelings = import 'kube-prometheus/dropping-deprecated-metrics-relabelings.libsonnet';
 
 {
   _config+:: {
     namespace: 'default',
 
-    versions+:: {
-      prometheus: 'v2.22.1',
-    },
-
-    imageRepos+:: {
-      prometheus: 'quay.io/prometheus/prometheus',
-    },
-
-    alertmanager+:: {
-      name: 'main',
-    },
+    versions+:: { prometheus: 'v2.22.1' },
+    imageRepos+:: { prometheus: 'quay.io/prometheus/prometheus' },
+    alertmanager+:: { name: 'main' },
 
     prometheus+:: {
       name: 'k8s',
@@ -35,24 +26,33 @@ local k = import 'github.com/ksonnet/ksonnet-lib/ksonnet.beta.4/k.libsonnet';
     prometheusRules:: $._config.prometheus.rules,
     alertmanagerName:: $.alertmanager.service.metadata.name,
 
-    serviceAccount:
-      local serviceAccount = k.core.v1.serviceAccount;
+    serviceAccount: {
+      apiVersion: 'v1',
+      kind: 'ServiceAccount',
+      metadata: {
+        name: 'prometheus-' + p.name,
+        namespace: p.namespace,
+      },
+    },
 
-      serviceAccount.new('prometheus-' + p.name) +
-      serviceAccount.mixin.metadata.withNamespace(p.namespace),
-    service:
-      local service = k.core.v1.service;
-      local servicePort = k.core.v1.service.mixin.spec.portsType;
+    service: {
+      apiVersion: 'v1',
+      kind: 'Service',
+      metadata: {
+        name: 'prometheus-' + p.name,
+        namespace: p.namespace,
+        labels: { prometheus: p.name },
+      },
+      spec: {
+        ports: [
+          { name: 'web', targetPort: 'web', port: 9090 },
+        ],
+        selector: { app: 'prometheus', prometheus: p.name },
+        sessionAffinity: 'ClientIP',
+      },
+    },
 
-      local prometheusPort = servicePort.newNamed('web', 9090, 'web');
-
-      service.new('prometheus-' + p.name, { app: 'prometheus', prometheus: p.name }, prometheusPort) +
-      service.mixin.spec.withSessionAffinity('ClientIP') +
-      service.mixin.metadata.withNamespace(p.namespace) +
-      service.mixin.metadata.withLabels({ prometheus: p.name }),
-
-    rules:
-      {
+    rules: {
       apiVersion: 'monitoring.coreos.com/v1',
       kind: 'PrometheusRule',
       metadata: {
@@ -69,117 +69,130 @@ local k = import 'github.com/ksonnet/ksonnet-lib/ksonnet.beta.4/k.libsonnet';
     },
 
     roleBindingSpecificNamespaces:
-      local roleBinding = k.rbac.v1.roleBinding;
-
-      local newSpecificRoleBinding(namespace) =
-        roleBinding.new() +
-        roleBinding.mixin.metadata.withName('prometheus-' + p.name) +
-        roleBinding.mixin.metadata.withNamespace(namespace) +
-        roleBinding.mixin.roleRef.withApiGroup('rbac.authorization.k8s.io') +
-        roleBinding.mixin.roleRef.withName('prometheus-' + p.name) +
-        roleBinding.mixin.roleRef.mixinInstance({ kind: 'Role' }) +
-        roleBinding.withSubjects([{ kind: 'ServiceAccount', name: 'prometheus-' + p.name, namespace: p.namespace }]);
-
-      local roleBindingList = k3.rbac.v1.roleBindingList;
-      roleBindingList.new([newSpecificRoleBinding(x) for x in p.roleBindingNamespaces]),
-    clusterRole:
-      local clusterRole = k.rbac.v1.clusterRole;
-      local policyRule = clusterRole.rulesType;
-
-      local nodeMetricsRule = policyRule.new() +
-                              policyRule.withApiGroups(['']) +
-                              policyRule.withResources(['nodes/metrics']) +
-                              policyRule.withVerbs(['get']);
-
-      local metricsRule = policyRule.new() +
-                          policyRule.withNonResourceUrls('/metrics') +
-                          policyRule.withVerbs(['get']);
-
-      local rules = [nodeMetricsRule, metricsRule];
-
-      clusterRole.new() +
-      clusterRole.mixin.metadata.withName('prometheus-' + p.name) +
-      clusterRole.withRules(rules),
-    roleConfig:
-      local role = k.rbac.v1.role;
-      local policyRule = role.rulesType;
-
-      local configmapRule = policyRule.new() +
-                            policyRule.withApiGroups(['']) +
-                            policyRule.withResources([
-                              'configmaps',
-                            ]) +
-                            policyRule.withVerbs(['get']);
-
-      role.new() +
-      role.mixin.metadata.withName('prometheus-' + p.name + '-config') +
-      role.mixin.metadata.withNamespace(p.namespace) +
-      role.withRules(configmapRule),
-    roleBindingConfig:
-      local roleBinding = k.rbac.v1.roleBinding;
-
-      roleBinding.new() +
-      roleBinding.mixin.metadata.withName('prometheus-' + p.name + '-config') +
-      roleBinding.mixin.metadata.withNamespace(p.namespace) +
-      roleBinding.mixin.roleRef.withApiGroup('rbac.authorization.k8s.io') +
-      roleBinding.mixin.roleRef.withName('prometheus-' + p.name + '-config') +
-      roleBinding.mixin.roleRef.mixinInstance({ kind: 'Role' }) +
-      roleBinding.withSubjects([{ kind: 'ServiceAccount', name: 'prometheus-' + p.name, namespace: p.namespace }]),
-    clusterRoleBinding:
-      local clusterRoleBinding = k.rbac.v1.clusterRoleBinding;
-
-      clusterRoleBinding.new() +
-      clusterRoleBinding.mixin.metadata.withName('prometheus-' + p.name) +
-      clusterRoleBinding.mixin.roleRef.withApiGroup('rbac.authorization.k8s.io') +
-      clusterRoleBinding.mixin.roleRef.withName('prometheus-' + p.name) +
-      clusterRoleBinding.mixin.roleRef.mixinInstance({ kind: 'ClusterRole' }) +
-      clusterRoleBinding.withSubjects([{ kind: 'ServiceAccount', name: 'prometheus-' + p.name, namespace: p.namespace }]),
-    roleSpecificNamespaces:
-      local role = k.rbac.v1.role;
-      local policyRule = role.rulesType;
-      local coreRule = policyRule.new() +
-                       policyRule.withApiGroups(['']) +
-                       policyRule.withResources([
-                         'services',
-                         'endpoints',
-                         'pods',
-                       ]) +
-                       policyRule.withVerbs(['get', 'list', 'watch']);
-      local ingressRule = policyRule.new() +
-                          policyRule.withApiGroups(['extensions']) +
-                          policyRule.withResources([
-                            'ingresses',
-                          ]) +
-                          policyRule.withVerbs(['get', 'list', 'watch']);
-
-      local newSpecificRole(namespace) =
-        role.new() +
-        role.mixin.metadata.withName('prometheus-' + p.name) +
-        role.mixin.metadata.withNamespace(namespace) +
-        role.withRules([coreRule, ingressRule]);
-
-      local roleList = k3.rbac.v1.roleList;
-      roleList.new([newSpecificRole(x) for x in p.roleBindingNamespaces]),
-    prometheus:
-      local statefulSet = k.apps.v1.statefulSet;
-      local container = statefulSet.mixin.spec.template.spec.containersType;
-      local resourceRequirements = container.mixin.resourcesType;
-      local selector = statefulSet.mixin.spec.selectorType;
-
-
-      local resources =
-        resourceRequirements.new() +
-        resourceRequirements.withRequests({ memory: '400Mi' });
-
+      local newSpecificRoleBinding(namespace) = {
+        apiVersion: 'rbac.authorization.k8s.io/v1',
+        kind: 'RoleBinding',
+        metadata: {
+          name: 'prometheus-' + p.name,
+          namespace: namespace,
+        },
+        roleRef: {
+          apiGroup: 'rbac.authorization.k8s.io',
+          kind: 'Role',
+          name: 'prometheus-' + p.name,
+        },
+        subjects: [{
+          kind: 'ServiceAccount',
+          name: 'prometheus-' + p.name,
+          namespace: p.namespace,
+        }],
+      };
       {
+        apiVersion: 'rbac.authorization.k8s.io/v1',
+        kind: 'RoleBindingList',
+        items: [newSpecificRoleBinding(x) for x in p.roleBindingNamespaces],
+      },
+
+    clusterRole: {
+      apiVersion: 'rbac.authorization.k8s.io/v1',
+      kind: 'ClusterRole',
+      metadata: { name: 'prometheus-' + p.name },
+      rules: [
+        {
+          apiGroups: [''],
+          resources: ['nodes/metrics'],
+          verbs: ['get'],
+        },
+        {
+          nonResourceURLs: ['/metrics'],
+          verbs: ['get'],
+        },
+      ],
+    },
+
+    roleConfig: {
+      apiVersion: 'rbac.authorization.k8s.io/v1',
+      kind: 'Role',
+      metadata: {
+        name: 'prometheus-' + p.name + '-config',
+        namespace: p.namespace,
+      },
+      rules: [{
+        apiGroups: [''],
+        resources: ['configmaps'],
+        verbs: ['get'],
+      }],
+    },
+
+    roleBindingConfig: {
+      apiVersion: 'rbac.authorization.k8s.io/v1',
+      kind: 'RoleBinding',
+      metadata: {
+        name: 'prometheus-' + p.name + '-config',
+        namespace: p.namespace,
+      },
+      roleRef: {
+        apiGroup: 'rbac.authorization.k8s.io',
+        kind: 'Role',
+        name: 'prometheus-' + p.name + '-config',
+      },
+      subjects: [{
+        kind: 'ServiceAccount',
+        name: 'prometheus-' + p.name,
+        namespace: p.namespace,
+      }],
+    },
+
+    clusterRoleBinding: {
+      apiVersion: 'rbac.authorization.k8s.io/v1',
+      kind: 'ClusterRoleBinding',
+      metadata: { name: 'prometheus-' + p.name },
+      roleRef: {
+        apiGroup: 'rbac.authorization.k8s.io',
+        kind: 'ClusterRole',
+        name: 'prometheus-' + p.name,
+      },
+      subjects: [{
+        kind: 'ServiceAccount',
+        name: 'prometheus-' + p.name,
+        namespace: p.namespace,
+      }],
+    },
+
+    roleSpecificNamespaces:
+      local newSpecificRole(namespace) = {
+        apiVersion: 'rbac.authorization.k8s.io/v1',
+        kind: 'Role',
+        metadata: {
+          name: 'prometheus-' + p.name,
+          namespace: namespace,
+        },
+        rules: [
+          {
+            apiGroups: [''],
+            resources: ['services', 'endpoints', 'pods'],
+            verbs: ['get', 'list', 'watch'],
+          },
+          {
+            apiGroups: ['extensions'],
+            resources: ['ingresses'],
+            verbs: ['get', 'list', 'watch'],
+          },
+        ],
+      };
+      {
+        apiVersion: 'rbac.authorization.k8s.io/v1',
+        kind: 'RoleList',
+        items: [newSpecificRole(x) for x in p.roleBindingNamespaces],
+      },
+
+    prometheus: {
       apiVersion: 'monitoring.coreos.com/v1',
       kind: 'Prometheus',
       metadata: {
         name: p.name,
         namespace: p.namespace,
-          labels: {
-            prometheus: p.name,
-          },
+        labels: { prometheus: p.name },
       },
       spec: {
         replicas: p.replicas,
@@ -193,19 +206,21 @@ local k = import 'github.com/ksonnet/ksonnet-lib/ksonnet.beta.4/k.libsonnet';
         podMonitorNamespaceSelector: {},
         probeNamespaceSelector: {},
         nodeSelector: { 'kubernetes.io/os': 'linux' },
-          ruleSelector: selector.withMatchLabels({
+        ruleSelector: {
+          matchLabels: {
             role: 'alert-rules',
             prometheus: p.name,
-          }),
-          resources: resources,
+          },
+        },
+        resources: {
+          requests: { memory: '400Mi' },
+        },
         alerting: {
-            alertmanagers: [
-              {
+          alertmanagers: [{
             namespace: p.namespace,
             name: p.alertmanagerName,
             port: 'web',
-              },
-            ],
+          }],
         },
         securityContext: {
           runAsUser: 1000,
@@ -214,77 +229,59 @@ local k = import 'github.com/ksonnet/ksonnet-lib/ksonnet.beta.4/k.libsonnet';
         },
       },
     },
-    serviceMonitor:
-      {
+
+    serviceMonitor: {
       apiVersion: 'monitoring.coreos.com/v1',
       kind: 'ServiceMonitor',
       metadata: {
         name: 'prometheus',
         namespace: p.namespace,
-          labels: {
-            'k8s-app': 'prometheus',
-          },
+        labels: { 'k8s-app': 'prometheus' },
       },
       spec: {
         selector: {
-            matchLabels: {
-              prometheus: p.name,
+          matchLabels: { prometheus: p.name },
         },
-          },
-          endpoints: [
-            {
+        endpoints: [{
           port: 'web',
           interval: '30s',
-            },
-          ],
+        }],
       },
     },
-    serviceMonitorKubeScheduler:
-      {
+
+    serviceMonitorKubeScheduler: {
       apiVersion: 'monitoring.coreos.com/v1',
       kind: 'ServiceMonitor',
       metadata: {
         name: 'kube-scheduler',
         namespace: p.namespace,
-          labels: {
-            'k8s-app': 'kube-scheduler',
-          },
+        labels: { 'k8s-app': 'kube-scheduler' },
       },
       spec: {
         jobLabel: 'k8s-app',
-          endpoints: [
-            {
+        endpoints: [{
           port: 'https-metrics',
           interval: '30s',
           scheme: 'https',
           bearerTokenFile: '/var/run/secrets/kubernetes.io/serviceaccount/token',
-              tlsConfig: {
-                insecureSkipVerify: true,
-              },
-            },
-          ],
+          tlsConfig: { insecureSkipVerify: true },
+        }],
         selector: {
-            matchLabels: {
-              'k8s-app': 'kube-scheduler',
-            },
+          matchLabels: { 'k8s-app': 'kube-scheduler' },
         },
         namespaceSelector: {
-            matchNames: [
-              'kube-system',
-            ],
+          matchNames: ['kube-system'],
         },
       },
     },
-    serviceMonitorKubelet:
-      {
+
+    serviceMonitorKubelet: {
       apiVersion: 'monitoring.coreos.com/v1',
       kind: 'ServiceMonitor',
       metadata: {
         name: 'kubelet',
         namespace: p.namespace,
-          labels: {
-            'k8s-app': 'kubelet',
-          },
+        labels: { 'k8s-app': 'kubelet' },
       },
       spec: {
         jobLabel: 'k8s-app',
@@ -294,17 +291,13 @@ local k = import 'github.com/ksonnet/ksonnet-lib/ksonnet.beta.4/k.libsonnet';
             scheme: 'https',
             interval: '30s',
             honorLabels: true,
-              tlsConfig: {
-                insecureSkipVerify: true,
-              },
+            tlsConfig: { insecureSkipVerify: true },
             bearerTokenFile: '/var/run/secrets/kubernetes.io/serviceaccount/token',
-              metricRelabelings: (import 'kube-prometheus/dropping-deprecated-metrics-relabelings.libsonnet'),
-              relabelings: [
-                {
+            metricRelabelings: relabelings,
+            relabelings: [{
               sourceLabels: ['__metrics_path__'],
               targetLabel: 'metrics_path',
-                },
-              ],
+            }],
           },
           {
             port: 'https-metrics',
@@ -317,12 +310,10 @@ local k = import 'github.com/ksonnet/ksonnet-lib/ksonnet.beta.4/k.libsonnet';
               insecureSkipVerify: true,
             },
             bearerTokenFile: '/var/run/secrets/kubernetes.io/serviceaccount/token',
-              relabelings: [
-                {
+            relabelings: [{
               sourceLabels: ['__metrics_path__'],
               targetLabel: 'metrics_path',
-                },
-              ],
+            }],
             metricRelabelings: [
               // Drop a bunch of metrics which are disabled but still sent, see
               // https://github.com/google/cadvisor/issues/1925.
@@ -339,45 +330,34 @@ local k = import 'github.com/ksonnet/ksonnet-lib/ksonnet.beta.4/k.libsonnet';
             path: '/metrics/probes',
             interval: '30s',
             honorLabels: true,
-              tlsConfig: {
-                insecureSkipVerify: true,
-              },
+            tlsConfig: { insecureSkipVerify: true },
             bearerTokenFile: '/var/run/secrets/kubernetes.io/serviceaccount/token',
-              relabelings: [
-                {
+            relabelings: [{
               sourceLabels: ['__metrics_path__'],
               targetLabel: 'metrics_path',
-                },
-              ],
+            }],
           },
         ],
         selector: {
-            matchLabels: {
-              'k8s-app': 'kubelet',
-            },
+          matchLabels: { 'k8s-app': 'kubelet' },
         },
         namespaceSelector: {
-            matchNames: [
-              'kube-system',
-            ],
+          matchNames: ['kube-system'],
         },
       },
     },
-    serviceMonitorKubeControllerManager:
-      {
+
+    serviceMonitorKubeControllerManager: {
       apiVersion: 'monitoring.coreos.com/v1',
       kind: 'ServiceMonitor',
       metadata: {
         name: 'kube-controller-manager',
         namespace: p.namespace,
-          labels: {
-            'k8s-app': 'kube-controller-manager',
-          },
+        labels: { 'k8s-app': 'kube-controller-manager' },
       },
       spec: {
         jobLabel: 'k8s-app',
-          endpoints: [
-            {
+        endpoints: [{
           port: 'https-metrics',
           interval: '30s',
           scheme: 'https',
@@ -385,37 +365,30 @@ local k = import 'github.com/ksonnet/ksonnet-lib/ksonnet.beta.4/k.libsonnet';
           tlsConfig: {
             insecureSkipVerify: true,
           },
-              metricRelabelings: (import 'kube-prometheus/dropping-deprecated-metrics-relabelings.libsonnet') + [
+          metricRelabelings: relabelings + [
             {
               sourceLabels: ['__name__'],
               regex: 'etcd_(debugging|disk|request|server).*',
               action: 'drop',
             },
           ],
-            },
-          ],
+        }],
         selector: {
-            matchLabels: {
-              'k8s-app': 'kube-controller-manager',
-            },
+          matchLabels: { 'k8s-app': 'kube-controller-manager' },
         },
         namespaceSelector: {
-            matchNames: [
-              'kube-system',
-            ],
+          matchNames: ['kube-system'],
         },
       },
     },
-    serviceMonitorApiserver:
-      {
+
+    serviceMonitorApiserver: {
       apiVersion: 'monitoring.coreos.com/v1',
       kind: 'ServiceMonitor',
       metadata: {
         name: 'kube-apiserver',
         namespace: p.namespace,
-          labels: {
-            'k8s-app': 'apiserver',
-          },
+        labels: { 'k8s-app': 'apiserver' },
       },
       spec: {
         jobLabel: 'component',
@@ -426,12 +399,9 @@ local k = import 'github.com/ksonnet/ksonnet-lib/ksonnet.beta.4/k.libsonnet';
           },
         },
         namespaceSelector: {
-            matchNames: [
-              'default',
-            ],
+          matchNames: ['default'],
         },
-          endpoints: [
-            {
+        endpoints: [{
           port: 'https',
           interval: '30s',
           scheme: 'https',
@@ -440,7 +410,7 @@ local k = import 'github.com/ksonnet/ksonnet-lib/ksonnet.beta.4/k.libsonnet';
             serverName: 'kubernetes',
           },
           bearerTokenFile: '/var/run/secrets/kubernetes.io/serviceaccount/token',
-              metricRelabelings: (import 'kube-prometheus/dropping-deprecated-metrics-relabelings.libsonnet') + [
+          metricRelabelings: relabelings + [
             {
               sourceLabels: ['__name__'],
               regex: 'etcd_(debugging|disk|server).*',
@@ -462,40 +432,31 @@ local k = import 'github.com/ksonnet/ksonnet-lib/ksonnet.beta.4/k.libsonnet';
               action: 'drop',
             },
           ],
-            },
-          ],
+        }],
       },
     },
-    serviceMonitorCoreDNS:
-      {
+
+    serviceMonitorCoreDNS: {
       apiVersion: 'monitoring.coreos.com/v1',
       kind: 'ServiceMonitor',
       metadata: {
         name: 'coredns',
         namespace: p.namespace,
-          labels: {
-            'k8s-app': 'coredns',
-          },
+        labels: { 'k8s-app': 'coredns' },
       },
       spec: {
         jobLabel: 'k8s-app',
         selector: {
-            matchLabels: {
-              'k8s-app': 'kube-dns',
-            },
+          matchLabels: { 'k8s-app': 'kube-dns' },
         },
         namespaceSelector: {
-            matchNames: [
-              'kube-system',
-            ],
+          matchNames: ['kube-system'],
         },
-          endpoints: [
-            {
+        endpoints: [{
           port: 'metrics',
           interval: '15s',
           bearerTokenFile: '/var/run/secrets/kubernetes.io/serviceaccount/token',
-            },
-          ],
+        }],
       },
     },
   },