Formatted files with jsonnet_fmt

2024-11-20 19:07:17 +01:00 · 2019-03-13 18:44:01 -03:00 · 2019-03-13 18:44:01 -03:00 · 362478a928
commit 362478a928
parent 408e21d044
9 changed files with 292 additions and 285 deletions
--- a/base_operator_stack.jsonnet
+++ b/base_operator_stack.jsonnet
@ -1,7 +1,7 @@
 local k = import 'ksonnet/ksonnet.beta.3/k.libsonnet';
 {
-	_config+:: {
-    namespace: "monitoring",
+  _config+:: {
+    namespace: 'monitoring',

    urls+:: {
      prom_ingress: 'prometheus.internal.carlosedp.com',
@ -13,7 +13,7 @@ local k = import 'ksonnet/ksonnet.beta.3/k.libsonnet';
    prometheus+:: {
      names: 'k8s',
      replicas: 1,
-      namespaces: ["default", "kube-system", "monitoring", "logging", "metallb-system"],
+      namespaces: ['default', 'kube-system', 'monitoring', 'logging', 'metallb-system'],
    },

    alertmanager+:: {
@ -31,16 +31,16 @@ local k = import 'ksonnet/ksonnet.beta.3/k.libsonnet';
      memoryPerNode: '30Mi',
    },

-      // Add custom Grafana dashboards
-      grafanaDashboards+:: {
-        'kubernetes-cluster-dashboard.json': (import 'grafana-dashboards/kubernetes-cluster-dashboard.json'),
-        'prometheus-dashboard.json': (import 'grafana-dashboards/prometheus-dashboard.json'),
-        'coredns-dashboard.json': (import 'grafana-dashboards/coredns-dashboard.json'),
-      },
+    // Add custom Grafana dashboards
+    grafanaDashboards+:: {
+      'kubernetes-cluster-dashboard.json': (import 'grafana-dashboards/kubernetes-cluster-dashboard.json'),
+      'prometheus-dashboard.json': (import 'grafana-dashboards/prometheus-dashboard.json'),
+      'coredns-dashboard.json': (import 'grafana-dashboards/coredns-dashboard.json'),
+    },

-      grafana+:: {
-        config: {
-          sections: {
+    grafana+:: {
+      config: {
+        sections: {
          //   database: { path: '/data/grafana.db' },
          //   paths: {
          //     data: '/var/lib/grafana',
@ -48,149 +48,151 @@ local k = import 'ksonnet/ksonnet.beta.3/k.libsonnet';
          //     plugins: '/var/lib/grafana/plugins',
          //     provisioning: '/etc/grafana/provisioning',
          //   },
-            session: { provider: 'memory' },
-            'auth.basic': {enabled: false},
-            'auth.anonymous': {enabled: false},
-            smtp: {
-              enabled: true,
-              host: 'smtp-server.monitoring.svc:25',
-              user: '',
-              password: '',
-              from_address:'carlosedp@gmail.com',
-              from_name: 'Grafana Alert',
-              skip_verify: true
-            },
+          session: { provider: 'memory' },
+          'auth.basic': { enabled: false },
+          'auth.anonymous': { enabled: false },
+          smtp: {
+            enabled: true,
+            host: 'smtp-server.monitoring.svc:25',
+            user: '',
+            password: '',
+            from_address: 'carlosedp@gmail.com',
+            from_name: 'Grafana Alert',
+            skip_verify: true,
          },
        },
      },
    },
-    //---------------------------------------
-    // End of _config
-    //---------------------------------------
+  },
+  //---------------------------------------
+  // End of _config
+  //---------------------------------------

-    prometheus+:: {
-      local pvc = k.core.v1.persistentVolumeClaim,
-      prometheus+: {
-        spec+: {
-          retention: '15d',
-          externalUrl: 'http://' + $._config.urls.prom_ingress,
-          storage: {
+  prometheus+:: {
+    local pvc = k.core.v1.persistentVolumeClaim,
+    prometheus+: {
+      spec+: {
+        retention: '15d',
+        externalUrl: 'http://' + $._config.urls.prom_ingress,
+        storage: {
          volumeClaimTemplate:
            pvc.new() +
            pvc.mixin.spec.withAccessModes('ReadWriteOnce') +
-            pvc.mixin.spec.resources.withRequests({ storage: '20Gi' })
-            # Uncomment below to define a StorageClass name
-            #+ pvc.mixin.spec.withStorageClassName('nfs-master-ssd'),
-          },
+            pvc.mixin.spec.resources.withRequests({ storage: '20Gi' }),
+          // Uncomment below to define a StorageClass name
+          //+ pvc.mixin.spec.withStorageClassName('nfs-master-ssd'),
        },
      },
    },
+  },

-  # Override deployment for Grafana data persistence
-    grafana+:: {
-      deployment+: {
-        spec+: {
-          template+: {
-            spec+: {
+  // Override deployment for Grafana data persistence
+  grafana+:: {
+    deployment+: {
+      spec+: {
+        template+: {
+          spec+: {
            volumes:
              std.map(
                function(v)
                  if v.name == 'grafana-storage' then
-                    {'name':'grafana-storage',
-                     'persistentVolumeClaim': {
-                       'claimName': 'grafana-storage'}
+                    {
+                      name: 'grafana-storage',
+                      persistentVolumeClaim: {
+                        claimName: 'grafana-storage',
+                      },
                    }
                  else v,
                super.volumes
              ),
-            },
          },
        },
      },
-      storage:
-        local pvc = k.core.v1.persistentVolumeClaim;
-        pvc.new() +
-        pvc.mixin.metadata.withNamespace($._config.namespace) +
-        pvc.mixin.metadata.withName("grafana-storage") +
-        pvc.mixin.spec.withAccessModes('ReadWriteMany') +
-        pvc.mixin.spec.resources.withRequests({ storage: '2Gi' }),
    },
+    storage:
+      local pvc = k.core.v1.persistentVolumeClaim;
+      pvc.new() +
+      pvc.mixin.metadata.withNamespace($._config.namespace) +
+      pvc.mixin.metadata.withName('grafana-storage') +
+      pvc.mixin.spec.withAccessModes('ReadWriteMany') +
+      pvc.mixin.spec.resources.withRequests({ storage: '2Gi' }),
+  },

-    grafanaDashboards+:: $._config.grafanaDashboards,
+  grafanaDashboards+:: $._config.grafanaDashboards,

  // Create ingress objects per application
-    ingress+: {
-      local secret = k.core.v1.secret,
-      local ingress = k.extensions.v1beta1.ingress,
-      local ingressTls = ingress.mixin.spec.tlsType,
-      local ingressRule = ingress.mixin.spec.rulesType,
-      local httpIngressPath = ingressRule.mixin.http.pathsType,
+  ingress+: {
+    local secret = k.core.v1.secret,
+    local ingress = k.extensions.v1beta1.ingress,
+    local ingressTls = ingress.mixin.spec.tlsType,
+    local ingressRule = ingress.mixin.spec.rulesType,
+    local httpIngressPath = ingressRule.mixin.http.pathsType,

-      'alertmanager-main':
-        ingress.new() +
-        ingress.mixin.metadata.withName('alertmanager-main') +
-        ingress.mixin.metadata.withNamespace($._config.namespace) +
-        ingress.mixin.spec.withRules(
-          ingressRule.new() +
-          ingressRule.withHost($._config.urls.alert_ingress) +
-          ingressRule.mixin.http.withPaths(
-            httpIngressPath.new() +
-            httpIngressPath.withPath('/') +
-            httpIngressPath.mixin.backend.withServiceName('alertmanager-main') +
-            httpIngressPath.mixin.backend.withServicePort('web')
-          ),
+    'alertmanager-main':
+      ingress.new() +
+      ingress.mixin.metadata.withName('alertmanager-main') +
+      ingress.mixin.metadata.withNamespace($._config.namespace) +
+      ingress.mixin.spec.withRules(
+        ingressRule.new() +
+        ingressRule.withHost($._config.urls.alert_ingress) +
+        ingressRule.mixin.http.withPaths(
+          httpIngressPath.new() +
+          httpIngressPath.withPath('/') +
+          httpIngressPath.mixin.backend.withServiceName('alertmanager-main') +
+          httpIngressPath.mixin.backend.withServicePort('web')
        ),
-      'grafana':
-        ingress.new() +
-        ingress.mixin.metadata.withName('grafana') +
-        ingress.mixin.metadata.withNamespace($._config.namespace) +
-        ingress.mixin.spec.withRules(
-          ingressRule.new() +
-          ingressRule.withHost($._config.urls.grafana_ingress) +
-          ingressRule.mixin.http.withPaths(
-            httpIngressPath.new() +
-            httpIngressPath.withPath('/') +
-            httpIngressPath.mixin.backend.withServiceName('grafana') +
-            httpIngressPath.mixin.backend.withServicePort('http')
-          ),
+      ),
+    grafana:
+      ingress.new() +
+      ingress.mixin.metadata.withName('grafana') +
+      ingress.mixin.metadata.withNamespace($._config.namespace) +
+      ingress.mixin.spec.withRules(
+        ingressRule.new() +
+        ingressRule.withHost($._config.urls.grafana_ingress) +
+        ingressRule.mixin.http.withPaths(
+          httpIngressPath.new() +
+          httpIngressPath.withPath('/') +
+          httpIngressPath.mixin.backend.withServiceName('grafana') +
+          httpIngressPath.mixin.backend.withServicePort('http')
        ),
-        'prometheus-k8s':
-          ingress.new() +
-          ingress.mixin.metadata.withName('prometheus-k8s') +
-          ingress.mixin.metadata.withNamespace($._config.namespace) +
-          ingress.mixin.spec.withRules(
-            ingressRule.new() +
-            ingressRule.withHost($._config.urls.prom_ingress) +
-            ingressRule.mixin.http.withPaths(
-              httpIngressPath.new() +
-              httpIngressPath.withPath('/') +
-              httpIngressPath.mixin.backend.withServiceName('prometheus-k8s') +
-              httpIngressPath.mixin.backend.withServicePort('web')
-            ),
-          ),
-        // // Example external ingress with authentication
-        // 'grafana-external':
-        //     ingress.new() +
-        //     ingress.mixin.metadata.withName('grafana-external') +
-        //     ingress.mixin.metadata.withNamespace($._config.namespace) +
-        //     ingress.mixin.metadata.withLabels({'traffic-type': 'external'}) +
-        //     ingress.mixin.metadata.withAnnotations({
-        //       'ingress.kubernetes.io/auth-type': 'basic',
-        //       'ingress.kubernetes.io/auth-secret': 'basic-auth',
-        //     }) +
-        //     ingress.mixin.spec.withRules(
-        //         ingressRule.new() +
-        //         ingressRule.withHost($._config.urls.grafana_ingress_external) +
-        //         ingressRule.mixin.http.withPaths(
-        //             httpIngressPath.new() +
-        //             httpIngressPath.withPath('/') +
-        //             httpIngressPath.mixin.backend.withServiceName('grafana') +
-        //             httpIngressPath.mixin.backend.withServicePort('http')
-        //         ),
-        //     ),
-        // 'basic-auth-secret':
-        //     // First generate the auth secret with gen_auth.sh script
-        //     secret.new('basic-auth', { auth: std.base64(importstr 'auth') }) +
-        //     secret.mixin.metadata.withNamespace($._config.namespace),
-        },
-    }
+      ),
+    'prometheus-k8s':
+      ingress.new() +
+      ingress.mixin.metadata.withName('prometheus-k8s') +
+      ingress.mixin.metadata.withNamespace($._config.namespace) +
+      ingress.mixin.spec.withRules(
+        ingressRule.new() +
+        ingressRule.withHost($._config.urls.prom_ingress) +
+        ingressRule.mixin.http.withPaths(
+          httpIngressPath.new() +
+          httpIngressPath.withPath('/') +
+          httpIngressPath.mixin.backend.withServiceName('prometheus-k8s') +
+          httpIngressPath.mixin.backend.withServicePort('web')
+        ),
+      ),
+    // // Example external ingress with authentication
+    // 'grafana-external':
+    //     ingress.new() +
+    //     ingress.mixin.metadata.withName('grafana-external') +
+    //     ingress.mixin.metadata.withNamespace($._config.namespace) +
+    //     ingress.mixin.metadata.withLabels({'traffic-type': 'external'}) +
+    //     ingress.mixin.metadata.withAnnotations({
+    //       'ingress.kubernetes.io/auth-type': 'basic',
+    //       'ingress.kubernetes.io/auth-secret': 'basic-auth',
+    //     }) +
+    //     ingress.mixin.spec.withRules(
+    //         ingressRule.new() +
+    //         ingressRule.withHost($._config.urls.grafana_ingress_external) +
+    //         ingressRule.mixin.http.withPaths(
+    //             httpIngressPath.new() +
+    //             httpIngressPath.withPath('/') +
+    //             httpIngressPath.mixin.backend.withServiceName('grafana') +
+    //             httpIngressPath.mixin.backend.withServicePort('http')
+    //         ),
+    //     ),
+    // 'basic-auth-secret':
+    //     // First generate the auth secret with gen_auth.sh script
+    //     secret.new('basic-auth', { auth: std.base64(importstr 'auth') }) +
+    //     secret.mixin.metadata.withNamespace($._config.namespace),
+  },
+}
--- a/elasticsearch_exporter.jsonnet
+++ b/elasticsearch_exporter.jsonnet
@ -21,18 +21,20 @@ local k = import 'ksonnet/ksonnet.beta.3/k.libsonnet';
      local podLabels = { 'k8s-app': 'elasticsearch-exporter' };
      local elasticExporter =
        container.new('elasticsearch-exporter',
-                    $._config.imageRepos.elasticExporter + ':' + $._config.versions.elasticExporter) +
-        container.withCommand(['/bin/elasticsearch_exporter',
-                                '-es.uri=http://elasticsearch.logging.svc:9200',
-                                '-es.timeout=60s',
-                                '-es.all=true']) +
+                      $._config.imageRepos.elasticExporter + ':' + $._config.versions.elasticExporter) +
+        container.withCommand([
+          '/bin/elasticsearch_exporter',
+          '-es.uri=http://elasticsearch.logging.svc:9200',
+          '-es.timeout=60s',
+          '-es.all=true',
+        ]) +
        container.withPorts(containerPort.newNamed('es-metrics', 9108)) +
-        container.mixin.securityContext.capabilities.withDrop(['SETPCAP' , 'MKNOD' , 'AUDIT_WRITE' , 'CHOWN' , 'NET_RAW' , 'DAC_OVERRIDE' , 'FOWNER' , 'FSETID' , 'KILL' , 'SETGID' , 'SETUID' , 'NET_BIND_SERVICE' , 'SYS_CHROOT' , 'SETFCAP']) +
+        container.mixin.securityContext.capabilities.withDrop(['SETPCAP', 'MKNOD', 'AUDIT_WRITE', 'CHOWN', 'NET_RAW', 'DAC_OVERRIDE', 'FOWNER', 'FSETID', 'KILL', 'SETGID', 'SETUID', 'NET_BIND_SERVICE', 'SYS_CHROOT', 'SETFCAP']) +
        container.mixin.securityContext.withRunAsNonRoot(true) +
        container.mixin.securityContext.withRunAsUser(1000) +
        container.mixin.securityContext.withReadOnlyRootFilesystem(true) +
-        container.mixin.resources.withRequests({memory: "64Mi", cpu: "25m"}) +
-        container.mixin.resources.withLimits({memory: "128Mi", cpu: "100m"}) +
+        container.mixin.resources.withRequests({ memory: '64Mi', cpu: '25m' }) +
+        container.mixin.resources.withLimits({ memory: '128Mi', cpu: '100m' }) +
        container.mixin.livenessProbe.httpGet.withPath('/health') +
        container.mixin.livenessProbe.httpGet.withPort(9108) +
        container.mixin.livenessProbe.withInitialDelaySeconds(30) +
@ -43,16 +45,16 @@ local k = import 'ksonnet/ksonnet.beta.3/k.libsonnet';
        container.mixin.readinessProbe.withInitialDelaySeconds(30) +
        container.mixin.readinessProbe.withTimeoutSeconds(10);

-        local c = [elasticExporter];
+      local c = [elasticExporter];

-        deployment.new('elasticsearch-exporter', $._config.replicas, c, podLabels) +
-        deployment.mixin.metadata.withNamespace($._config.namespace) +
-        deployment.mixin.metadata.withLabels(podLabels) +
-        deployment.mixin.spec.selector.withMatchLabels(podLabels) +
-        deployment.mixin.spec.strategy.withType('RollingUpdate') +
-        deployment.mixin.spec.strategy.rollingUpdate.withMaxSurge(1) +
-        deployment.mixin.spec.strategy.rollingUpdate.withMaxUnavailable(0) +
-        deployment.mixin.spec.template.spec.withRestartPolicy('Always'),
+      deployment.new('elasticsearch-exporter', $._config.replicas, c, podLabels) +
+      deployment.mixin.metadata.withNamespace($._config.namespace) +
+      deployment.mixin.metadata.withLabels(podLabels) +
+      deployment.mixin.spec.selector.withMatchLabels(podLabels) +
+      deployment.mixin.spec.strategy.withType('RollingUpdate') +
+      deployment.mixin.spec.strategy.rollingUpdate.withMaxSurge(1) +
+      deployment.mixin.spec.strategy.rollingUpdate.withMaxUnavailable(0) +
+      deployment.mixin.spec.template.spec.withRestartPolicy('Always'),

    service:
      local service = k.core.v1.service;
@ -64,68 +66,68 @@ local k = import 'ksonnet/ksonnet.beta.3/k.libsonnet';
      service.mixin.metadata.withLabels({ 'k8s-app': 'elasticsearch-exporter' }),

    serviceMonitorElastic:
-    {
-      apiVersion: 'monitoring.coreos.com/v1',
-      kind: 'ServiceMonitor',
-      metadata: {
-        name: 'elasticsearch-exporter',
-        namespace: $._config.namespace,
-        labels: {
-          'k8s-app': 'elasticsearch-exporter',
-        },
-      },
-      spec: {
-        jobLabel: 'k8s-app',
-        selector: {
-          matchLabels: {
-          'k8s-app': 'elasticsearch-exporter',
+      {
+        apiVersion: 'monitoring.coreos.com/v1',
+        kind: 'ServiceMonitor',
+        metadata: {
+          name: 'elasticsearch-exporter',
+          namespace: $._config.namespace,
+          labels: {
+            'k8s-app': 'elasticsearch-exporter',
          },
        },
-        endpoints: [
-          {
-          port: 'es-metrics',
-          scheme: 'http',
-          interval: '30s',
+        spec: {
+          jobLabel: 'k8s-app',
+          selector: {
+            matchLabels: {
+              'k8s-app': 'elasticsearch-exporter',
+            },
+          },
+          endpoints: [
+            {
+              port: 'es-metrics',
+              scheme: 'http',
+              interval: '30s',
+            },
+          ],
+          namespaceSelector: {
+            matchNames: [
+              'monitoring',
+            ],
          },
-        ],
-        namespaceSelector: {
-          matchNames: [
-            'monitoring',
-          ]
        },
      },
-    },
    serviceMonitorFluentd:
-    {
-      apiVersion: 'monitoring.coreos.com/v1',
-      kind: 'ServiceMonitor',
-      metadata: {
-        name: 'fluentd-es',
-        namespace: $._config.namespace,
-        labels: {
+      {
+        apiVersion: 'monitoring.coreos.com/v1',
+        kind: 'ServiceMonitor',
+        metadata: {
+          name: 'fluentd-es',
+          namespace: $._config.namespace,
+          labels: {
            'k8s-app': 'fluentd-es',
-        },
-      },
-      spec: {
-        jobLabel: 'k8s-app',
-        selector: {
-          matchLabels: {
-          'k8s-app': 'fluentd-es',
          },
        },
-        endpoints: [
-          {
-          port: 'metrics',
-          scheme: 'http',
-          interval: '30s',
+        spec: {
+          jobLabel: 'k8s-app',
+          selector: {
+            matchLabels: {
+              'k8s-app': 'fluentd-es',
+            },
          },
-        ],
-        namespaceSelector: {
-          matchNames: [
+          endpoints: [
+            {
+              port: 'metrics',
+              scheme: 'http',
+              interval: '30s',
+            },
+          ],
+          namespaceSelector: {
+            matchNames: [
              'logging',
-          ]
+            ],
+          },
        },
      },
-    },
  },
 } + (import 'elasticsearch_rules.jsonnet')
--- a/image_sources_versions.jsonnet
+++ b/image_sources_versions.jsonnet
@ -1,37 +1,37 @@
 {
-	_config+:: {
+  _config+:: {
    versions+:: {
-      prometheus: "v2.7.0",
-      alertmanager: "v0.16.0",
-      kubeStateMetrics: "v1.5.0",
-      kubeRbacProxy: "v0.4.1",
-      addonResizer: "2.1",
-      nodeExporter: "v0.17.0",
-      prometheusOperator: "v0.28.0",
-      prometheusAdapter: "v0.4.1",
-      grafana: "5.4.3",
-      configmapReloader: "v0.2.2",
-      prometheusConfigReloader: "v0.28.0",
+      prometheus: 'v2.7.0',
+      alertmanager: 'v0.16.0',
+      kubeStateMetrics: 'v1.5.0',
+      kubeRbacProxy: 'v0.4.1',
+      addonResizer: '2.1',
+      nodeExporter: 'v0.17.0',
+      prometheusOperator: 'v0.28.0',
+      prometheusAdapter: 'v0.4.1',
+      grafana: '5.4.3',
+      configmapReloader: 'v0.2.2',
+      prometheusConfigReloader: 'v0.28.0',
      armExporter: 'latest',
      smtpServer: 'v1.0.1',
-      elasticExporter: '1.0.4rc1'
+      elasticExporter: '1.0.4rc1',
    },

    imageRepos+:: {
-      prometheus: "carlosedp/prometheus",
-      alertmanager: "carlosedp/alertmanager",
-      kubeStateMetrics: "carlosedp/kube-state-metrics",
-      kubeRbacProxy: "carlosedp/kube-rbac-proxy",
-      addonResizer: "carlosedp/addon-resizer",
-      nodeExporter: "carlosedp/node_exporter",
-      prometheusOperator: "carlosedp/prometheus-operator",
-      prometheusAdapter: "carlosedp/k8s-prometheus-adapter",
-      grafana: "grafana/grafana",
-      configmapReloader: "carlosedp/configmap-reload",
-      prometheusConfigReloader: "carlosedp/prometheus-config-reloader",
+      prometheus: 'carlosedp/prometheus',
+      alertmanager: 'carlosedp/alertmanager',
+      kubeStateMetrics: 'carlosedp/kube-state-metrics',
+      kubeRbacProxy: 'carlosedp/kube-rbac-proxy',
+      addonResizer: 'carlosedp/addon-resizer',
+      nodeExporter: 'carlosedp/node_exporter',
+      prometheusOperator: 'carlosedp/prometheus-operator',
+      prometheusAdapter: 'carlosedp/k8s-prometheus-adapter',
+      grafana: 'grafana/grafana',
+      configmapReloader: 'carlosedp/configmap-reload',
+      prometheusConfigReloader: 'carlosedp/prometheus-config-reloader',
      armExporter: 'carlosedp/arm_exporter',
      smtpServer: 'carlosedp/docker-smtp',
-      elasticExporter: 'carlosedp/elasticsearch-exporter'
+      elasticExporter: 'carlosedp/elasticsearch-exporter',
    },
  },
 }
--- a/main.jsonnet
+++ b/main.jsonnet
@ -1,26 +1,27 @@
 local k = import 'ksonnet/ksonnet.beta.3/k.libsonnet';

 // Enable or disable additional modules
-local installModules = { 'arm-exporter': true,
-                         'metallb': true,
-                         'traefik': true,
-                         'ups-exporter': true,
-                         'elastic-exporter': true,
-                       };
+local installModules = {
+  'arm-exporter': true,
+  metallb: true,
+  traefik: true,
+  'ups-exporter': true,
+  'elastic-exporter': true,
+};

-local kp =  (import 'kube-prometheus/kube-prometheus.libsonnet')
-          + (import 'kube-prometheus/kube-prometheus-anti-affinity.libsonnet')
-          + (import 'kube-prometheus/kube-prometheus-kops-coredns.libsonnet')
-          + (import 'kube-prometheus/kube-prometheus-kubeadm.libsonnet')
-          + (import 'image_sources_versions.jsonnet')
-          + (import 'base_operator_stack.jsonnet')
-          + (import 'smtp_server.jsonnet')
-          // Additional Modules
-          + (if installModules['arm-exporter'] then (import 'arm_exporter.jsonnet') else {})
-          + (if installModules['metallb'] then (import 'metallb.jsonnet') else {})
-          + (if installModules['traefik'] then (import 'traefik.jsonnet') else {})
-          + (if installModules['ups-exporter'] then (import 'ups_exporter.jsonnet') else {})
-          + (if installModules['elastic-exporter'] then (import 'elasticsearch_exporter.jsonnet') else {});
+local kp = (import 'kube-prometheus/kube-prometheus.libsonnet')
+           + (import 'kube-prometheus/kube-prometheus-anti-affinity.libsonnet')
+           + (import 'kube-prometheus/kube-prometheus-kops-coredns.libsonnet')
+           + (import 'kube-prometheus/kube-prometheus-kubeadm.libsonnet')
+           + (import 'image_sources_versions.jsonnet')
+           + (import 'base_operator_stack.jsonnet')
+           + (import 'smtp_server.jsonnet')
+           // Additional Modules
+           + (if installModules['arm-exporter'] then (import 'arm_exporter.jsonnet') else {})
+           + (if installModules.metallb then (import 'metallb.jsonnet') else {})
+           + (if installModules.traefik then (import 'traefik.jsonnet') else {})
+           + (if installModules['ups-exporter'] then (import 'ups_exporter.jsonnet') else {})
+           + (if installModules['elastic-exporter'] then (import 'elasticsearch_exporter.jsonnet') else {});

 { ['00namespace-' + name]: kp.kubePrometheus[name] for name in std.objectFields(kp.kubePrometheus) }
 { ['0prometheus-operator-' + name]: kp.prometheusOperator[name] for name in std.objectFields(kp.prometheusOperator) } +
@ -34,12 +35,12 @@ local kp =  (import 'kube-prometheus/kube-prometheus.libsonnet')
 { ['smtp-server-' + name]: kp.smtpServer[name] for name in std.objectFields(kp.smtpServer) } +
 // Additional Modules
 (if installModules['arm-exporter'] then
-    { ['arm-exporter-' + name]: kp.armExporter[name] for name in std.objectFields(kp.armExporter) }  else {}) +
-(if installModules['metallb'] then
-    { ['metallb-' + name]: kp.metallb[name] for name in std.objectFields(kp.metallb) } else {}) +
-(if installModules['traefik'] then
-    { ['traefik-' + name]: kp.traefik[name] for name in std.objectFields(kp.traefik) } else {}) +
+   { ['arm-exporter-' + name]: kp.armExporter[name] for name in std.objectFields(kp.armExporter) } else {}) +
+(if installModules.metallb then
+   { ['metallb-' + name]: kp.metallb[name] for name in std.objectFields(kp.metallb) } else {}) +
+(if installModules.traefik then
+   { ['traefik-' + name]: kp.traefik[name] for name in std.objectFields(kp.traefik) } else {}) +
 (if installModules['ups-exporter'] then
-    { ['ups-exporter-' + name]: kp.upsExporter[name] for name in std.objectFields(kp.upsExporter) } else {}) +
+   { ['ups-exporter-' + name]: kp.upsExporter[name] for name in std.objectFields(kp.upsExporter) } else {}) +
 (if installModules['elastic-exporter'] then
-    { ['elasticexporter-' + name]: kp.elasticExporter[name] for name in std.objectFields(kp.elasticExporter)} else {})
+   { ['elasticexporter-' + name]: kp.elasticExporter[name] for name in std.objectFields(kp.elasticExporter) } else {})
--- a/metallb.jsonnet
+++ b/metallb.jsonnet
@ -32,10 +32,10 @@ local k = import 'ksonnet/ksonnet.beta.3/k.libsonnet';
            },
          ],
          namespaceSelector: {
-              matchNames: [
-                'metallb-system',
-              ]
-            },
+            matchNames: [
+              'metallb-system',
+            ],
+          },

        },
      },
@ -45,7 +45,7 @@ local k = import 'ksonnet/ksonnet.beta.3/k.libsonnet';
      local servicePort = k.core.v1.service.mixin.spec.portsType;
      local metallbPort = servicePort.newNamed('http', 7472, 7472);

-      service.new('metallb-controller', {"app": "metallb", "component": "controller"}, metallbPort) +
+      service.new('metallb-controller', { app: 'metallb', component: 'controller' }, metallbPort) +
      service.mixin.metadata.withNamespace('metallb-system') +
      service.mixin.metadata.withLabels({ 'k8s-app': 'metallb-controller' }) +
      service.mixin.spec.withClusterIp('None'),
--- a/smtp_server.jsonnet
+++ b/smtp_server.jsonnet
@ -29,25 +29,27 @@ local k = import 'ksonnet/ksonnet.beta.3/k.libsonnet';
              secretKeyRef: { name: 'smtp-account', key: 'password' },
            },
          },
-          {name: 'DISABLE_IPV6',
-          value: 'True'},
-          {name: 'RELAY_DOMAINS', value: ':192.168.0.0/24:10.0.0.0/16'},
+          {
+            name: 'DISABLE_IPV6',
+            value: 'True',
+          },
+          { name: 'RELAY_DOMAINS', value: ':192.168.0.0/24:10.0.0.0/16' },
        ]);

-        local c = [smtpServer];
+      local c = [smtpServer];

-        deployment.new('smtp-server', 1, c, podLabels) +
-        deployment.mixin.metadata.withNamespace($._config.namespace) +
-        deployment.mixin.metadata.withLabels(podLabels) +
-        deployment.mixin.spec.selector.withMatchLabels(podLabels),
+      deployment.new('smtp-server', 1, c, podLabels) +
+      deployment.mixin.metadata.withNamespace($._config.namespace) +
+      deployment.mixin.metadata.withLabels(podLabels) +
+      deployment.mixin.spec.selector.withMatchLabels(podLabels),

    service:
-        local service = k.core.v1.service;
-        local servicePort = k.core.v1.service.mixin.spec.portsType;
-        local smtpServerPorts = servicePort.newNamed('smtp', 25, 'smtp');
+      local service = k.core.v1.service;
+      local servicePort = k.core.v1.service.mixin.spec.portsType;
+      local smtpServerPorts = servicePort.newNamed('smtp', 25, 'smtp');

-        service.new('smtp-server', $.smtpServer.deployment.spec.selector.matchLabels, smtpServerPorts) +
-        service.mixin.metadata.withNamespace($._config.namespace) +
-        service.mixin.metadata.withLabels({ 'run': 'smtp-server' })
+      service.new('smtp-server', $.smtpServer.deployment.spec.selector.matchLabels, smtpServerPorts) +
+      service.mixin.metadata.withNamespace($._config.namespace) +
+      service.mixin.metadata.withLabels({ run: 'smtp-server' }),
  },
 }
--- a/traefik.jsonnet
+++ b/traefik.jsonnet
@ -5,7 +5,7 @@ local k = import 'ksonnet/ksonnet.beta.3/k.libsonnet';
    namespace: 'monitoring',
    // Add custom dashboards
    grafanaDashboards+:: {
-            'traefik-dashboard.json': (import 'grafana-dashboards/traefik-dashboard.json'),
+      'traefik-dashboard.json': (import 'grafana-dashboards/traefik-dashboard.json'),
    },
  },

@ -38,7 +38,7 @@ local k = import 'ksonnet/ksonnet.beta.3/k.libsonnet';
          namespaceSelector: {
            matchNames: [
              'kube-system',
-            ]
+            ],
          },
        },
      },
--- a/ups_exporter.jsonnet
+++ b/ups_exporter.jsonnet
@ -14,8 +14,8 @@ local k = import 'ksonnet/ksonnet.beta.3/k.libsonnet';
    },
  },

-    upsExporter+:: {
-      serviceMonitor:
+  upsExporter+:: {
+    serviceMonitor:
      {
        apiVersion: 'monitoring.coreos.com/v1',
        kind: 'ServiceMonitor',
@ -30,14 +30,14 @@ local k = import 'ksonnet/ksonnet.beta.3/k.libsonnet';
          jobLabel: 'k8s-app',
          selector: {
            matchLabels: {
-            'k8s-app': 'ups-exporter',
+              'k8s-app': 'ups-exporter',
            },
          },
          endpoints: [
            {
-            port: 'metrics',
-            scheme: 'http',
-            interval: '30s',
+              port: 'metrics',
+              scheme: 'http',
+              interval: '30s',
            },
          ],
        },
@ -65,11 +65,11 @@ local k = import 'ksonnet/ksonnet.beta.3/k.libsonnet';
                      endpointPort.withProtocol('TCP');

      local subset = endpointSubset.new() +
-                      endpointSubset.withAddresses([
-                          { ip: IP }
-                          for IP in $._config.ups.ips
-                          ]) +
-                      endpointSubset.withPorts(upsPort);
+                     endpointSubset.withAddresses([
+                       { ip: IP }
+                       for IP in $._config.ups.ips
+                     ]) +
+                     endpointSubset.withPorts(upsPort);

      endpoints.new() +
      endpoints.mixin.metadata.withName('ups-exporter') +