Allow minikube to function with misconfigured NO_PROXY value

cmd/minikube/cmd/dashboard.go

@@ -32,9 +32,11 @@ import (
 	configcmd "k8s.io/minikube/cmd/minikube/cmd/config"
 	"k8s.io/minikube/pkg/minikube/cluster"
 	"k8s.io/minikube/pkg/minikube/config"
+	pkg_config "k8s.io/minikube/pkg/minikube/config"
 	"k8s.io/minikube/pkg/minikube/console"
 	"k8s.io/minikube/pkg/minikube/exit"
 	"k8s.io/minikube/pkg/minikube/machine"
+	"k8s.io/minikube/pkg/minikube/proxy"
 	"k8s.io/minikube/pkg/minikube/service"
 	"k8s.io/minikube/pkg/util"
 )
@@ -52,11 +54,13 @@ var dashboardCmd = &cobra.Command{
 	Short: "Access the kubernetes dashboard running within the minikube cluster",
 	Long:  `Access the kubernetes dashboard running within the minikube cluster`,
 	Run: func(cmd *cobra.Command, args []string) {
+		cc, err := pkg_config.Load()
+		proxy.UpdateNoProxy(cc.KubernetesConfig.NodeIP)
+
 		kubectl, err := exec.LookPath("kubectl")
 		if err != nil {
 			exit.WithCode(exit.NoInput, "kubectl not found in PATH, but is required for the dashboard. Installation guide: https://kubernetes.io/docs/tasks/tools/install-kubectl/")
 		}
-
 		api, err := machine.NewAPIClient()
 		defer func() {
 			err := api.Close()
@@ -117,7 +121,9 @@ var dashboardCmd = &cobra.Command{
 func kubectlProxy(path string) (*exec.Cmd, string, error) {
 	// port=0 picks a random system port
 	// config.GetMachineName() respects the -p (profile) flag
+
 	cmd := exec.Command(path, "--context", config.GetMachineName(), "proxy", "--port=0")
+
 	stdoutPipe, err := cmd.StdoutPipe()
 	if err != nil {
 		return nil, "", errors.Wrap(err, "cmd stdout")

cmd/minikube/cmd/start.go

@@ -51,6 +51,7 @@ import (
 	"k8s.io/minikube/pkg/minikube/exit"
 	"k8s.io/minikube/pkg/minikube/logs"
 	"k8s.io/minikube/pkg/minikube/machine"
+	"k8s.io/minikube/pkg/minikube/proxy"
 	pkgutil "k8s.io/minikube/pkg/util"
 	"k8s.io/minikube/pkg/version"
 )
@@ -102,9 +103,6 @@ var (
 	apiServerNames   []string
 	apiServerIPs     []net.IP
 	extraOptions     pkgutil.ExtraOptionSlice
-
-	// proxyVars are variables we plumb through to the underlying container runtime
-	proxyVars = []string{"HTTP_PROXY", "HTTPS_PROXY", "NO_PROXY"}
 )
 
 func init() {
@@ -222,6 +220,8 @@ func runStart(cmd *cobra.Command, args []string) {
 	host, preexisting := startHost(m, config.MachineConfig)
 
 	ip := validateNetwork(host)
+	// Makes minikube node ip to bypass http(s) proxy. since it is local traffic.
+	proxy.UpdateNoProxy(ip)
 	// Save IP to configuration file for subsequent use
 	config.KubernetesConfig.NodeIP = ip
 	if err := saveConfig(config); err != nil {
@@ -383,7 +383,7 @@ func generateConfig(cmd *cobra.Command, k8sVersion string) (cfg.Config, error) {
 	// Feed Docker our host proxy environment by default, so that it can pull images
 	if _, ok := r.(*cruntime.Docker); ok {
 		if !cmd.Flags().Changed("docker-env") {
-			for _, k := range proxyVars {
+			for _, k := range proxy.EnvVars {
 				if v := os.Getenv(k); v != "" {
 					dockerEnv = append(dockerEnv, fmt.Sprintf("%s=%s", k, v))
 				}
@@ -522,13 +522,17 @@ func validateNetwork(h *host.Host) string {
 	}
 
 	optSeen := false
-	for _, k := range proxyVars {
+	for _, k := range proxy.EnvVars {
 		if v := os.Getenv(k); v != "" {
 			if !optSeen {
 				console.OutStyle("internet", "Found network options:")
 				optSeen = true
 			}
 			console.OutStyle("option", "%s=%s", k, v)
+			isNp, _ := proxy.IsInNoProxyEnv(ip) // Skip warning if minikube ip is already in NO_PROXY
+			if (k == "HTTP_PROXY" || k == "HTTPS_PROXY") && !isNp {
+				console.Warning("You are using a proxy, You need to add minikube IP to the NO_PROXY. Use `export NO_PROXY=$NO_PROXY,%s`", ip)
+			}
 		}
 	}
 

pkg/minikube/bootstrapper/kubeadm/kubeadm.go

@@ -123,6 +123,7 @@ func (k *Bootstrapper) GetAPIServerStatus(ip net.IP, apiserverPort int) (string,
 	url := fmt.Sprintf("https://%s:%d/healthz", ip, apiserverPort)
 	// To avoid: x509: certificate signed by unknown authority
 	tr := &http.Transport{
+		Proxy:           nil, // To avoid connectiv issue if http(s)_proxy is set.
 		TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
 	}
 	client := &http.Client{Transport: tr}

pkg/minikube/proxy/cidir.go

@@ -0,0 +1,32 @@
+/*
+Copyright 2019 The Kubernetes Authors All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package proxy
+
+import "net"
+
+// isInBlock checks if ip is a CIDIR block
+func isInBlock(ip string, block string) (bool, error) {
+	_, b, err := net.ParseCIDR(block)
+	if err != nil {
+		return false, err
+	}
+	i := net.ParseIP(ip)
+	if b.Contains(i) {
+		return true, nil
+	}
+	return false, nil
+}

pkg/minikube/proxy/cidir_test.go

@@ -0,0 +1,48 @@
+/*
+Copyright 2019 The Kubernetes Authors All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package proxy
+
+import (
+	"testing"
+)
+
+var bTests = []struct {
+	ip             string
+	block          string
+	expectedResult bool
+	expectedErr    error
+}{
+	{"", "192.168.0.1/32", false, nil},
+	{"192.168.0.1", "192.168.0.1/32", true, nil},
+	{"192.168.0.2", "192.168.0.1/32", false, nil},
+	{"192.168.0.1", "192.168.0.1/18", true, nil},
+	{"abcd", "192.168.0.1/18", false, nil},
+}
+
+func TestIsInBlock(t *testing.T) {
+
+	for _, tt := range bTests {
+		actualR, actualErr := isInBlock(tt.ip, tt.block)
+		if actualR != tt.expectedResult {
+			t.Errorf("isInBlock(%s,%s): expected %t, actual %t", tt.ip, tt.block, tt.expectedResult, actualR)
+		}
+		if actualErr != tt.expectedErr {
+			t.Errorf("isInBlock(%s,%s): expected error %s, err %s", tt.ip, tt.block, tt.expectedErr, actualErr)
+		}
+	}
+
+}

pkg/minikube/proxy/env.go

@@ -0,0 +1,20 @@
+/*
+Copyright 2019 The Kubernetes Authors All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package proxy
+
+// EnvVars are variables we plumb through to the underlying container runtime
+var EnvVars = []string{"HTTP_PROXY", "HTTPS_PROXY", "NO_PROXY"}

pkg/minikube/proxy/noproxy.go

@@ -0,0 +1,58 @@
+/*
+Copyright 2019 The Kubernetes Authors All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package proxy
+
+import (
+	"fmt"
+	"os"
+	"strings"
+)
+
+// UpdateNoProxy is used to whitelist minikube's VM ip from going through proxy
+// It updates NO_PROXY environment variable, for the current run.
+func UpdateNoProxy(ip string) error {
+	yes, v := IsInNoProxyEnv(ip)
+	if yes { // skip if already whitelisted
+		return nil
+	}
+	return os.Setenv("NO_PROXY", fmt.Sprintf("%s,%s", v, ip))
+}
+
+// IsInNoProxyEnv checks if ip is set in NO_PROXY env variable
+// Checks for both IP and IP ranges
+func IsInNoProxyEnv(ip string) (bool, string) {
+	v := os.Getenv("NO_PROXY")
+
+	if v == "" {
+		return false, ""
+	}
+
+	//  Checking for IP explicitly, i.e., 192.168.39.224
+	if strings.Contains(v, ip) {
+		return true, v
+	}
+
+	// Checks if ip included in IP ranges, i.e., 192.168.39.13/24
+	noProxyBlocks := strings.Split(v, ",")
+	for _, b := range noProxyBlocks {
+		if yes, _ := isInBlock(ip, b); yes {
+			return true, v
+		}
+	}
+
+	return false, v
+}