commit 55fa98dd76658309d0f9045f4a901637e5e7bf5d · pyrox.dev/nixpkgs

+62 -61
nixos/modules/services/cluster/kubernetes/dns.nix
···

       3
       3
        
       with lib;

     

       4
       4
        
       

     

       5
       5
        
       let

     

       6
       6
       -
         version = "1.14.4";

     

       6
       6
       +
         version = "1.14.10";

     

       7
       7
        
       

     

       8
       8
        
         k8s-dns-kube-dns = pkgs.dockerTools.pullImage {

     

       9
       9
       -
           imageName = "gcr.io/google_containers/k8s-dns-kube-dns-amd64";

     

       9
       9
       +
           imageName = "k8s.gcr.io/k8s-dns-kube-dns-amd64";

     

       10
       10
       +
           imageDigest = "sha256:b99fc3eee2a9f052f7eb4cc00f15eb12fc405fa41019baa2d6b79847ae7284a8";

     

       10
       11
        
           finalImageTag = version;

     

       11
       11
       -
           sha256 = "0q97xfqrigrfjl2a9cxl5in619py0zv44gch09jm8gqjkxl80imp";

     

       12
       12
       -
           imageDigest = "sha256:40790881bbe9ef4ae4ff7fe8b892498eecb7fe6dcc22661402f271e03f7de344";

     

       12
       12
       +
           sha256 = "0x583znk9smqn0fix7ld8sm5jgaxhqhx3fq97b1wkqm7iwhvl3pj";

     

       13
       13
        
         };

     

       14
       14
        
       

     

       15
       15
        
         k8s-dns-dnsmasq-nanny = pkgs.dockerTools.pullImage {

     

       16
       16
       -
           imageName = "gcr.io/google_containers/k8s-dns-dnsmasq-nanny-amd64";

     

       16
       16
       +
           imageName = "k8s.gcr.io/k8s-dns-dnsmasq-nanny-amd64";

     

       17
       17
       +
           imageDigest = "sha256:bbb2a290a568125b3b996028958eb773f33b5b87a6b37bf38a28f8b62dddb3c8";

     

       17
       18
        
           finalImageTag = version;

     

       18
       18
       -
           sha256 = "051w5ca4qb88mwva4hbnh9xzlsvv7k1mbk3wz50lmig2mqrqqx6c";

     

       19
       19
       -
           imageDigest = "sha256:aeeb994acbc505eabc7415187cd9edb38cbb5364dc1c2fc748154576464b3dc2";

     

       19
       19
       +
           sha256 = "1fihml7s2mfwgac51cbqpylkwbivc8nyhgi4vb820s83zvl8a6y1";

     

       20
       20
        
         };

     

       21
       21
        
       

     

       22
       22
        
         k8s-dns-sidecar = pkgs.dockerTools.pullImage {

     

       23
       23
       -
           imageName = "gcr.io/google_containers/k8s-dns-sidecar-amd64";

     

       23
       23
       +
           imageName = "k8s.gcr.io/k8s-dns-sidecar-amd64";

     

       24
       24
       +
           imageDigest = "sha256:4f1ab957f87b94a5ec1edc26fae50da2175461f00afecf68940c4aa079bd08a4";

     

       24
       25
        
           finalImageTag = version;

     

       25
       25
       -
           sha256 = "1z0d129bcm8i2cqq36x5jhnrv9hirj8c6kjrmdav8vgf7py78vsm";

     

       26
       26
       -
           imageDigest = "sha256:97074c951046e37d3cbb98b82ae85ed15704a290cce66a8314e7f846404edde9";

     

       26
       26
       +
           sha256 = "08l1bv5jgrhvjzpqpbinrkgvv52snc4fzyd8ya9v18ns2klyz7m0";

     

       27
       27
        
         };

     

       28
       28
        
       

     

       29
       29
        
         cfg = config.services.kubernetes.addons.dns;

     
···

       59
       59
        
       

     

       60
       60
        
           services.kubernetes.addonManager.addons = {

     

       61
       61
        
             kubedns-deployment = {

     

       62
       62
       -
               apiVersion = "apps/v1beta1";

     

       62
       62
       +
               apiVersion = "extensions/v1beta1";

     

       63
       63
        
               kind = "Deployment";

     

       64
       64
        
               metadata = {

     

       65
       65
        
                 labels = {

     
···

       84
       84
        
                     labels.k8s-app = "kube-dns";

     

       85
       85
        
                   };

     

       86
       86
        
                   spec = {

     

       87
       87
       +
                     priorityClassName = "system-cluster-critical";

     

       87
       88
        
                     containers = [

     

       88
       89
        
                       {

     

       89
       90
        
                         name = "kubedns";

     

       91
       91
       +
                         image = "k8s.gcr.io/k8s-dns-kube-dns-amd64:${version}";

     

       92
       92
       +
                         resources = {

     

       93
       93
       +
                           limits.memory = "170Mi";

     

       94
       94
       +
                           requests = {

     

       95
       95
       +
                             cpu = "100m";

     

       96
       96
       +
                             memory = "70Mi";

     

       97
       97
       +
                           };

     

       98
       98
       +
                         };

     

       99
       99
       +
                         livenessProbe = {

     

       100
       100
       +
                           failureThreshold = 5;

     

       101
       101
       +
                           httpGet = {

     

       102
       102
       +
                             path = "/healthcheck/kubedns";

     

       103
       103
       +
                             port = 10054;

     

       104
       104
       +
                             scheme = "HTTP";

     

       105
       105
       +
                           };

     

       106
       106
       +
                           initialDelaySeconds = 60;

     

       107
       107
       +
                           successThreshold = 1;

     

       108
       108
       +
                           timeoutSeconds = 5;

     

       109
       109
       +
                         };

     

       110
       110
       +
                         readinessProbe = {

     

       111
       111
       +
                           httpGet = {

     

       112
       112
       +
                             path = "/readiness";

     

       113
       113
       +
                             port = 8081;

     

       114
       114
       +
                             scheme = "HTTP";

     

       115
       115
       +
                           };

     

       116
       116
       +
                           initialDelaySeconds = 3;

     

       117
       117
       +
                           timeoutSeconds = 5;

     

       118
       118
       +
                         };

     

       90
       119
        
                         args = [

     

       91
       120
        
                           "--domain=${cfg.clusterDomain}"

     

       92
       121
        
                           "--dns-port=10053"

     
···

       99
       128
        
                             value = "10055";

     

       100
       129
        
                           }

     

       101
       130
        
                         ];

     

       102
       102
       -
                         image = "gcr.io/google_containers/k8s-dns-kube-dns-amd64:${version}";

     

       103
       103
       -
                         livenessProbe = {

     

       104
       104
       -
                           failureThreshold = 5;

     

       105
       105
       -
                           httpGet = {

     

       106
       106
       -
                             path = "/healthcheck/kubedns";

     

       107
       107
       -
                             port = 10054;

     

       108
       108
       -
                             scheme = "HTTP";

     

       109
       109
       -
                           };

     

       110
       110
       -
                           initialDelaySeconds = 60;

     

       111
       111
       -
                           successThreshold = 1;

     

       112
       112
       -
                           timeoutSeconds = 5;

     

       113
       113
       -
                         };

     

       114
       131
        
                         ports = [

     

       115
       132
        
                           {

     

       116
       133
        
                             containerPort = 10053;

     
···

       128
       145
        
                             protocol = "TCP";

     

       129
       146
        
                           }

     

       130
       147
        
                         ];

     

       131
       131
       -
                         readinessProbe = {

     

       132
       132
       -
                           httpGet = {

     

       133
       133
       -
                             path = "/readiness";

     

       134
       134
       -
                             port = 8081;

     

       135
       135
       -
                             scheme = "HTTP";

     

       136
       136
       -
                           };

     

       137
       137
       -
                           initialDelaySeconds = 3;

     

       138
       138
       -
                           timeoutSeconds = 5;

     

       139
       139
       -
                         };

     

       140
       140
       -
                         resources = {

     

       141
       141
       -
                           limits.memory = "170Mi";

     

       142
       142
       -
                           requests = {

     

       143
       143
       -
                             cpu = "100m";

     

       144
       144
       -
                             memory = "70Mi";

     

       145
       145
       -
                           };

     

       146
       146
       -
                         };

     

       147
       148
        
                         volumeMounts = [

     

       148
       149
        
                           {

     

       149
       150
        
                             mountPath = "/kube-dns-config";

     
···

       152
       153
        
                         ];

     

       153
       154
        
                       }

     

       154
       155
        
                       {

     

       156
       156
       +
                         name = "dnsmasq";

     

       157
       157
       +
                         image = "k8s.gcr.io/k8s-dns-dnsmasq-nanny-amd64:${version}";

     

       158
       158
       +
                         livenessProbe = {

     

       159
       159
       +
                           httpGet = {

     

       160
       160
       +
                             path = "/healthcheck/dnsmasq";

     

       161
       161
       +
                             port = 10054;

     

       162
       162
       +
                             scheme = "HTTP";

     

       163
       163
       +
                           };

     

       164
       164
       +
                           initialDelaySeconds = 60;

     

       165
       165
       +
                           timeoutSeconds = 5;

     

       166
       166
       +
                           successThreshold = 1;

     

       167
       167
       +
                           failureThreshold = 5;

     

       168
       168
       +
                         };

     

       155
       169
        
                         args = [

     

       156
       170
        
                           "-v=2"

     

       157
       171
        
                           "-logtostderr"

     
···

       165
       179
        
                           "--server=/in-addr.arpa/127.0.0.1#10053"

     

       166
       180
        
                           "--server=/ip6.arpa/127.0.0.1#10053"

     

       167
       181
        
                         ];

     

       168
       168
       -
                         image = "gcr.io/google_containers/k8s-dns-dnsmasq-nanny-amd64:${version}";

     

       169
       169
       -
                         livenessProbe = {

     

       170
       170
       -
                           failureThreshold = 5;

     

       171
       171
       -
                           httpGet = {

     

       172
       172
       -
                             path = "/healthcheck/dnsmasq";

     

       173
       173
       -
                             port = 10054;

     

       174
       174
       -
                             scheme = "HTTP";

     

       175
       175
       -
                           };

     

       176
       176
       -
                           initialDelaySeconds = 60;

     

       177
       177
       -
                           successThreshold = 1;

     

       178
       178
       -
                           timeoutSeconds = 5;

     

       179
       179
       -
                         };

     

       180
       180
       -
                         name = "dnsmasq";

     

       181
       182
        
                         ports = [

     

       182
       183
        
                           {

     

       183
       184
        
                             containerPort = 53;

     
···

       205
       206
        
                       }

     

       206
       207
        
                       {

     

       207
       208
        
                         name = "sidecar";

     

       208
       208
       -
                         image = "gcr.io/google_containers/k8s-dns-sidecar-amd64:${version}";

     

       209
       209
       -
                         args = [

     

       210
       210
       -
                           "--v=2"

     

       211
       211
       -
                           "--logtostderr"

     

       212
       212
       -
                           "--probe=kubedns,127.0.0.1:10053,kubernetes.default.svc.${cfg.clusterDomain},5,A"

     

       213
       213
       -
                           "--probe=dnsmasq,127.0.0.1:53,kubernetes.default.svc.${cfg.clusterDomain},5,A"

     

       214
       214
       -
                         ];

     

       209
       209
       +
                         image = "k8s.gcr.io/k8s-dns-sidecar-amd64:${version}";

     

       215
       210
        
                         livenessProbe = {

     

       216
       216
       -
                           failureThreshold = 5;

     

       217
       211
        
                           httpGet = {

     

       218
       212
        
                             path = "/metrics";

     

       219
       213
        
                             port = 10054;

     

       220
       214
        
                             scheme = "HTTP";

     

       221
       215
        
                           };

     

       222
       216
        
                           initialDelaySeconds = 60;

     

       217
       217
       +
                           timeoutSeconds = 5;

     

       223
       218
        
                           successThreshold = 1;

     

       224
       224
       -
                           timeoutSeconds = 5;

     

       219
       219
       +
                           failureThreshold = 5;

     

       225
       220
        
                         };

     

       221
       221
       +
                         args = [

     

       222
       222
       +
                           "--v=2"

     

       223
       223
       +
                           "--logtostderr"

     

       224
       224
       +
                           "--probe=kubedns,127.0.0.1:10053,kubernetes.default.svc.${cfg.clusterDomain},5,A"

     

       225
       225
       +
                           "--probe=dnsmasq,127.0.0.1:53,kubernetes.default.svc.${cfg.clusterDomain},5,A"

     

       226
       226
       +
                         ];

     

       226
       227
        
                         ports = [

     

       227
       228
        
                           {

     

       228
       229
        
                             containerPort = 10054;