Support non-default docker endpoints

cmd/minikube/cmd/docker-env.go

@@ -30,6 +30,7 @@ import (
 
 	"github.com/spf13/cobra"
 	"k8s.io/klog/v2"
+
 	"k8s.io/minikube/pkg/drivers/kic/oci"
 	"k8s.io/minikube/pkg/minikube/command"
 	"k8s.io/minikube/pkg/minikube/constants"
@@ -43,7 +44,31 @@ import (
 	"k8s.io/minikube/pkg/minikube/sysinit"
 )
 
-var dockerEnvTmpl = fmt.Sprintf("{{ .Prefix }}%s{{ .Delimiter }}{{ .DockerTLSVerify }}{{ .Suffix }}{{ .Prefix }}%s{{ .Delimiter }}{{ .DockerHost }}{{ .Suffix }}{{ .Prefix }}%s{{ .Delimiter }}{{ .DockerCertPath }}{{ .Suffix }}{{ .Prefix }}%s{{ .Delimiter }}{{ .MinikubeDockerdProfile }}{{ .Suffix }}{{ if .NoProxyVar }}{{ .Prefix }}{{ .NoProxyVar }}{{ .Delimiter }}{{ .NoProxyValue }}{{ .Suffix }}{{end}}{{ .UsageHint }}", constants.DockerTLSVerifyEnv, constants.DockerHostEnv, constants.DockerCertPathEnv, constants.MinikubeActiveDockerdEnv)
+var dockerSetEnvTmpl = fmt.Sprintf(
+	"{{ .Prefix }}%s{{ .Delimiter }}{{ .DockerTLSVerify }}{{ .Suffix }}"+
+		"{{ .Prefix }}%s{{ .Delimiter }}{{ .DockerHost }}{{ .Suffix }}"+
+		"{{ .Prefix }}%s{{ .Delimiter }}{{ .DockerCertPath }}{{ .Suffix }}"+
+		"{{ if .ExistingDockerTLSVerify }}"+
+		"{{ .Prefix }}%s{{ .Delimiter }}{{ .ExistingDockerTLSVerify }}{{ .Suffix }}"+
+		"{{ end }}"+
+		"{{ if .ExistingDockerHost }}"+
+		"{{ .Prefix }}%s{{ .Delimiter }}{{ .ExistingDockerHost }}{{ .Suffix }}"+
+		"{{ end }}"+
+		"{{ if .ExistingDockerCertPath }}"+
+		"{{ .Prefix }}%s{{ .Delimiter }}{{ .ExistingDockerCertPath }}{{ .Suffix }}"+
+		"{{ end }}"+
+		"{{ .Prefix }}%s{{ .Delimiter }}{{ .MinikubeDockerdProfile }}{{ .Suffix }}"+
+		"{{ if .NoProxyVar }}"+
+		"{{ .Prefix }}{{ .NoProxyVar }}{{ .Delimiter }}{{ .NoProxyValue }}{{ .Suffix }}"+
+		"{{ end }}"+
+		"{{ .UsageHint }}",
+	constants.DockerTLSVerifyEnv,
+	constants.DockerHostEnv,
+	constants.DockerCertPathEnv,
+	constants.ExistingDockerTLSVerifyEnv,
+	constants.ExistingDockerHostEnv,
+	constants.ExistingDockerCertPathEnv,
+	constants.MinikubeActiveDockerdEnv)
 
 // DockerShellConfig represents the shell config for Docker
 type DockerShellConfig struct {
@@ -54,6 +79,10 @@ type DockerShellConfig struct {
 	MinikubeDockerdProfile string
 	NoProxyVar             string
 	NoProxyValue           string
+
+	ExistingDockerCertPath  string
+	ExistingDockerHost      string
+	ExistingDockerTLSVerify string
 }
 
 var (
@@ -81,6 +110,11 @@ func dockerShellCfgSet(ec DockerEnvConfig, envMap map[string]string) *DockerShel
 	s.DockerCertPath = envMap[constants.DockerCertPathEnv]
 	s.DockerHost = envMap[constants.DockerHostEnv]
 	s.DockerTLSVerify = envMap[constants.DockerTLSVerifyEnv]
+
+	s.ExistingDockerCertPath = envMap[constants.ExistingDockerCertPathEnv]
+	s.ExistingDockerHost = envMap[constants.ExistingDockerHostEnv]
+	s.ExistingDockerTLSVerify = envMap[constants.ExistingDockerTLSVerifyEnv]
+
 	s.MinikubeDockerdProfile = envMap[constants.MinikubeActiveDockerdEnv]
 
 	if ec.noProxy {
@@ -228,7 +262,7 @@ type DockerEnvConfig struct {
 // dockerSetScript writes out a shell-compatible 'docker-env' script
 func dockerSetScript(ec DockerEnvConfig, w io.Writer) error {
 	envVars := dockerEnvVars(ec)
-	return shell.SetScript(ec.EnvConfig, w, dockerEnvTmpl, dockerShellCfgSet(ec, envVars))
+	return shell.SetScript(ec.EnvConfig, w, dockerSetEnvTmpl, dockerShellCfgSet(ec, envVars))
 }
 
 // dockerSetScript writes out a shell-compatible 'docker-env unset' script
@@ -246,7 +280,6 @@ func dockerUnsetScript(ec DockerEnvConfig, w io.Writer) error {
 			vars = append(vars, k)
 		}
 	}
-
 	return shell.UnsetScript(ec.EnvConfig, w, vars)
 }
 
@@ -257,14 +290,21 @@ func dockerURL(ip string, port int) string {
 
 // dockerEnvVars gets the necessary docker env variables to allow the use of minikube's docker daemon
 func dockerEnvVars(ec DockerEnvConfig) map[string]string {
-	env := map[string]string{
+	rt := map[string]string{
 		constants.DockerTLSVerifyEnv:       "1",
 		constants.DockerHostEnv:            dockerURL(ec.hostIP, ec.port),
 		constants.DockerCertPathEnv:        ec.certsDir,
 		constants.MinikubeActiveDockerdEnv: ec.profile,
 	}
-
-	return env
+	if os.Getenv(constants.MinikubeActiveDockerdEnv) == "" {
+		for _, env := range constants.DockerDaemonEnvs {
+			if v := oci.InitialEnv(env); v != "" {
+				key := constants.MinikubeExistingPrefix + env
+				rt[key] = v
+			}
+		}
+	}
+	return rt
 }
 
 // dockerEnvVarsList gets the necessary docker env variables to allow the use of minikube's docker daemon to be used in a exec.Command

pkg/drivers/kic/kic.go

@@ -30,6 +30,7 @@ import (
 	"github.com/docker/machine/libmachine/state"
 	"github.com/pkg/errors"
 	"k8s.io/klog/v2"
+
 	pkgdrivers "k8s.io/minikube/pkg/drivers"
 	"k8s.io/minikube/pkg/drivers/kic/oci"
 	"k8s.io/minikube/pkg/minikube/assets"
@@ -93,22 +94,29 @@ func (d *Driver) Create() error {
 		klog.Infof("calculated static IP %q for the %q container", ip.String(), d.NodeConfig.MachineName)
 		params.IP = ip.String()
 	}
+	drv := d.DriverName()
+	listAddr := oci.DefaultBindIPV4
+	if oci.IsExternalRuntimeHost(drv) {
+		klog.Infof("Listening 0.0.0.0 on external docker host %v", oci.RuntimeHost(drv))
+		listAddr = "0.0.0.0"
+	}
 
 	// control plane specific options
-	params.PortMappings = append(params.PortMappings, oci.PortMapping{
-		ListenAddress: oci.DefaultBindIPV4,
-		ContainerPort: int32(params.APIServerPort),
-	},
+	params.PortMappings = append(params.PortMappings,
+		oci.PortMapping{
+			ListenAddress: listAddr,
+			ContainerPort: int32(params.APIServerPort),
+		},
 		oci.PortMapping{
-			ListenAddress: oci.DefaultBindIPV4,
+			ListenAddress: listAddr,
 			ContainerPort: constants.SSHPort,
 		},
 		oci.PortMapping{
-			ListenAddress: oci.DefaultBindIPV4,
+			ListenAddress: listAddr,
 			ContainerPort: constants.DockerDaemonPort,
 		},
 		oci.PortMapping{
-			ListenAddress: oci.DefaultBindIPV4,
+			ListenAddress: listAddr,
 			ContainerPort: constants.RegistryAddonPort,
 		},
 	)
@@ -224,12 +232,12 @@ func (d *Driver) GetIP() (string, error) {
 
 // GetExternalIP returns an IP which is accessible from outside
 func (d *Driver) GetExternalIP() (string, error) {
-	return oci.DefaultBindIPV4, nil
+	return oci.RuntimeHost(d.DriverName()), nil
 }
 
 // GetSSHHostname returns hostname for use with ssh
 func (d *Driver) GetSSHHostname() (string, error) {
-	return oci.DefaultBindIPV4, nil
+	return oci.RuntimeHost(d.DriverName()), nil
 }
 
 // GetSSHPort returns port for use with ssh

pkg/drivers/kic/oci/cli_runner.go

@@ -27,6 +27,7 @@ import (
 	"time"
 
 	"k8s.io/klog/v2"
+
 	"k8s.io/minikube/pkg/minikube/out"
 	"k8s.io/minikube/pkg/minikube/style"
 )
@@ -128,6 +129,7 @@ func runCmd(cmd *exec.Cmd, warnSlow ...bool) (*RunResult, error) {
 	cmd.Stderr = errb
 
 	start := time.Now()
+	klog.Infof("Running %v", cmd.Args)
 	err := cmd.Run()
 	elapsed := time.Since(start)
 	if warn {

pkg/drivers/kic/oci/env.go

@@ -0,0 +1,47 @@
+/*
+Copyright 2020 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 oci
+
+import (
+	"os"
+
+	"k8s.io/minikube/pkg/minikube/constants"
+)
+
+var initialEnvs = make(map[string]string)
+
+func init() {
+	for _, env := range constants.DockerDaemonEnvs {
+		if v, set := os.LookupEnv(env); set {
+			initialEnvs[env] = v
+		}
+		exEnv := constants.MinikubeExistingPrefix + env
+		if v, set := os.LookupEnv(exEnv); set {
+			initialEnvs[exEnv] = v
+		}
+	}
+}
+
+// InitialEnv returns the value of the environment variable env before any environment changes made by minikube
+func InitialEnv(env string) string {
+	return initialEnvs[env]
+}
+
+// LookupInitialEnv returns the value of the environment variable env before any environment changes made by minikube
+func LookupInitialEnv(env string) (string, bool) {
+	v, set := initialEnvs[env]
+	return v, set
+}

pkg/drivers/kic/oci/network.go

@@ -164,6 +164,5 @@ func dockerContainerIP(name string) (string, string, error) {
 	if len(ips) != 2 {
 		return "", "", errors.Errorf("container addresses should have 2 values, got %d values: %+v", len(ips), ips)
 	}
-
 	return ips[0], ips[1], nil
 }

pkg/drivers/kic/oci/oci.go

@@ -17,26 +17,26 @@ limitations under the License.
 package oci
 
 import (
+	"bufio"
+	"bytes"
 	"context"
+	"fmt"
+	"net/url"
 	"os"
+	"os/exec"
+	"runtime"
+	"strconv"
+	"strings"
 	"time"
 
-	"bufio"
-	"bytes"
-
 	"github.com/docker/machine/libmachine/state"
 	"github.com/pkg/errors"
 
 	"k8s.io/klog/v2"
+
 	"k8s.io/minikube/pkg/minikube/constants"
 	"k8s.io/minikube/pkg/minikube/out"
 	"k8s.io/minikube/pkg/util/retry"
-
-	"fmt"
-	"os/exec"
-	"runtime"
-	"strconv"
-	"strings"
 )
 
 // DeleteContainersByLabel deletes all containers that have a specific label
@@ -521,18 +521,29 @@ func ListContainersByLabel(ociBin string, label string, warnSlow ...bool) ([]str
 // PointToHostDockerDaemon will unset env variables that point to docker inside minikube
 // to make sure it points to the docker daemon installed by user.
 func PointToHostDockerDaemon() error {
-	p := os.Getenv(constants.MinikubeActiveDockerdEnv)
-	if p != "" {
+
+	if p := os.Getenv(constants.MinikubeActiveDockerdEnv); p != "" {
 		klog.Infof("shell is pointing to dockerd inside minikube. will unset to use host")
+		for _, e := range constants.DockerDaemonEnvs {
+			if err := resetEnv(e); err != nil {
+				return err
+			}
+		}
 	}
 
-	for i := range constants.DockerDaemonEnvs {
-		e := constants.DockerDaemonEnvs[i]
-		err := os.Setenv(e, "")
-		if err != nil {
-			return errors.Wrapf(err, "resetting %s env", e)
-		}
+	return nil
+}
 
+func resetEnv(key string) error {
+	v := os.Getenv(constants.MinikubeExistingPrefix + key)
+	if v == "" {
+		if err := os.Unsetenv(key); err != nil {
+			return errors.Wrapf(err, "resetting %s env", key)
+		}
+		return nil
+	}
+	if err := os.Setenv(key, v); err != nil {
+		return errors.Wrapf(err, "resetting %s env", key)
 	}
 	return nil
 }
@@ -628,3 +639,36 @@ func iptablesFileExists(ociBin string, nameOrID string) bool {
 	}
 	return true
 }
+
+// RuntimeHost returns the ip/hostname where OCI daemon service for driver is running
+// For Podman it's always DefaultBindIPV4
+// For Docker return the host part of DOCKER_HOST environment variable if set
+// or DefaultBindIPV4 otherwise
+func RuntimeHost(driver string) string {
+	if driver != Docker {
+		return DefaultBindIPV4
+	}
+	if dh := os.Getenv(constants.DockerHostEnv); dh != "" {
+		if u, err := url.Parse(dh); err == nil {
+			if u.Host != "" {
+				return u.Hostname()
+			}
+		}
+	}
+	return DefaultBindIPV4
+}
+
+// IsExternalRuntimeHost returns whether or not the OCI runtime is running on an external/virtual host
+// For Podman driver it's always false for now
+// For Docker driver return true if DOCKER_HOST is set to a URI, and the URI contains a host item
+func IsExternalRuntimeHost(driver string) bool {
+	if driver != Docker {
+		return false
+	}
+	if dh := os.Getenv(constants.DockerHostEnv); dh != "" {
+		if u, err := url.Parse(dh); err == nil {
+			return u.Host != ""
+		}
+	}
+	return false
+}