kubernetes
/
minikube
mirror of https://github.com/kubernetes/minikube.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Merge branch 'master' of github.com:kubernetes/minikube into node-delete-vol

pull/8224/head
Sharif Elgamal 2020-05-20 14:59:31 -07:00
parent bbf4d66b48 07c7b7ca97
commit 01145c3c99
11 changed files with 126 additions and 71 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
cmd/minikube/cmd/delete.go
View File

@ -271,7 +271,10 @@ func deleteProfile(profile *config.Profile) error {
// if driver is oci driver, delete containers and volumes
if driver.IsKIC(profile.Config.Driver) {
out.T(out.DeletingHost, `Deleting "{{.profile_name}}" in {{.driver_name}} ...`, out.V{"profile_name": profile.Name, "driver_name": profile.Config.Driver})
deletePossibleKicLeftOver(profile.Name, profile.Config.Driver)
for _, n := range profile.Config.Nodes {
machineName := driver.MachineName(*profile.Config, n)
deletePossibleKicLeftOver(machineName, profile.Config.Driver)
}
}
} else {
glog.Infof("%s has no configuration, will try to make it work anyways", profile.Name)

22
cmd/minikube/cmd/start.go
View File

@ -56,7 +56,6 @@ import (
"k8s.io/minikube/pkg/minikube/node"
"k8s.io/minikube/pkg/minikube/notify"
"k8s.io/minikube/pkg/minikube/out"
"k8s.io/minikube/pkg/minikube/proxy"
"k8s.io/minikube/pkg/minikube/registry"
"k8s.io/minikube/pkg/minikube/translate"
"k8s.io/minikube/pkg/util"
@ -317,7 +316,8 @@ func startWithDriver(starter node.Starter, existing *config.ClusterConfig) (*kub
}
func warnAboutMultiNode() {
out.WarningT("Multi-node clusters are currently experimental and might exhibit unintended behavior.\nTo track progress on multi-node clusters, see https://github.com/kubernetes/minikube/issues/7538.")
out.WarningT("Multi-node clusters are currently experimental and might exhibit unintended behavior.")
out.T(out.Documentation, "To track progress on multi-node clusters, see https://github.com/kubernetes/minikube/issues/7538.")
}
func updateDriver(driverName string) {
@ -909,24 +909,6 @@ func createNode(cc config.ClusterConfig, kubeNodeName string, existing *config.C
return cc, cp, nil
}
// setDockerProxy sets the proxy environment variables in the docker environment.
func setDockerProxy() {
for _, k := range proxy.EnvVars {
if v := os.Getenv(k); v != "" {
// convert https_proxy to HTTPS_PROXY for linux
// TODO (@medyagh): if user has both http_proxy & HTTPS_PROXY set merge them.
k = strings.ToUpper(k)
if k == "HTTP_PROXY" || k == "HTTPS_PROXY" {
if strings.HasPrefix(v, "localhost") || strings.HasPrefix(v, "127.0") {
out.WarningT("Not passing {{.name}}={{.value}} to docker env.", out.V{"name": k, "value": v})
continue
}
}
config.DockerEnv = append(config.DockerEnv, fmt.Sprintf("%s=%s", k, v))
}
}
}
// autoSetDriverOptions sets the options needed for specific driver automatically.
func autoSetDriverOptions(cmd *cobra.Command, drvName string) (err error) {
err = nil

5
cmd/minikube/cmd/start_flags.go
View File

@ -36,6 +36,7 @@ import (
"k8s.io/minikube/pkg/minikube/driver"
"k8s.io/minikube/pkg/minikube/exit"
"k8s.io/minikube/pkg/minikube/out"
"k8s.io/minikube/pkg/minikube/proxy"
pkgutil "k8s.io/minikube/pkg/util"
"k8s.io/minikube/pkg/version"
)
@ -340,8 +341,8 @@ func generateClusterConfig(cmd *cobra.Command, existing *config.ClusterConfig, k
// Feed Docker our host proxy environment by default, so that it can pull images
// doing this for both new config and existing, in case proxy changed since previous start
if _, ok := r.(*cruntime.Docker); ok && !cmd.Flags().Changed("docker-env") {
setDockerProxy()
if _, ok := r.(*cruntime.Docker); ok {
proxy.SetDockerEnv()
}
var kubeNodeName string

34
pkg/minikube/machine/cluster_test.go
View File

@ -81,7 +81,7 @@ func TestCreateHost(t *testing.T) {
t.Fatal("Machine already exists.")
}
_, err := createHost(api, defaultClusterConfig, config.Node{Name: "minikube"})
_, err := createHost(api, &defaultClusterConfig, &config.Node{Name: "minikube"})
if err != nil {
t.Fatalf("Error creating host: %v", err)
}
@ -122,7 +122,7 @@ func TestStartHostExists(t *testing.T) {
api := tests.NewMockAPI(t)
// Create an initial host.
ih, err := createHost(api, defaultClusterConfig, config.Node{Name: "minikube"})
ih, err := createHost(api, &defaultClusterConfig, &config.Node{Name: "minikube"})
if err != nil {
t.Fatalf("Error creating host: %v", err)
}
@ -142,7 +142,7 @@ func TestStartHostExists(t *testing.T) {
n := config.Node{Name: ih.Name}
// This should pass without calling Create because the host exists already.
h, _, err := StartHost(api, mc, n)
h, _, err := StartHost(api, &mc, &n)
if err != nil {
t.Fatalf("Error starting host: %v", err)
}
@ -161,7 +161,7 @@ func TestStartHostErrMachineNotExist(t *testing.T) {
api := tests.NewMockAPI(t)
// Create an incomplete host with machine does not exist error(i.e. User Interrupt Cancel)
api.NotExistError = true
h, err := createHost(api, defaultClusterConfig, config.Node{Name: "minikube"})
h, err := createHost(api, &defaultClusterConfig, &config.Node{Name: "minikube"})
if err != nil {
t.Fatalf("Error creating host: %v", err)
}
@ -175,7 +175,7 @@ func TestStartHostErrMachineNotExist(t *testing.T) {
n := config.Node{Name: h.Name}
// This should pass with creating host, while machine does not exist.
h, _, err = StartHost(api, mc, n)
h, _, err = StartHost(api, &mc, &n)
if err != nil {
if err != constants.ErrMachineMissing {
t.Fatalf("Error starting host: %v", err)
@ -188,7 +188,7 @@ func TestStartHostErrMachineNotExist(t *testing.T) {
n.Name = h.Name
// Second call. This should pass without calling Create because the host exists already.
h, _, err = StartHost(api, mc, n)
h, _, err = StartHost(api, &mc, &n)
if err != nil {
t.Fatalf("Error starting host: %v", err)
}
@ -207,7 +207,7 @@ func TestStartStoppedHost(t *testing.T) {
RegisterMockDriver(t)
api := tests.NewMockAPI(t)
// Create an initial host.
h, err := createHost(api, defaultClusterConfig, config.Node{Name: "minikube"})
h, err := createHost(api, &defaultClusterConfig, &config.Node{Name: "minikube"})
if err != nil {
t.Fatalf("Error creating host: %v", err)
}
@ -220,7 +220,7 @@ func TestStartStoppedHost(t *testing.T) {
mc := defaultClusterConfig
mc.Name = h.Name
n := config.Node{Name: h.Name}
h, _, err = StartHost(api, mc, n)
h, _, err = StartHost(api, &mc, &n)
if err != nil {
t.Fatal("Error starting host.")
}
@ -247,7 +247,7 @@ func TestStartHost(t *testing.T) {
md := &tests.MockDetector{Provisioner: &tests.MockProvisioner{}}
provision.SetDetector(md)
h, _, err := StartHost(api, defaultClusterConfig, config.Node{Name: "minikube"})
h, _, err := StartHost(api, &defaultClusterConfig, &config.Node{Name: "minikube"})
if err != nil {
t.Fatal("Error starting host.")
}
@ -283,14 +283,14 @@ func TestStartHostConfig(t *testing.T) {
DockerOpt: []string{"param=value"},
}
h, _, err := StartHost(api, cfg, config.Node{Name: "minikube"})
h, _, err := StartHost(api, &cfg, &config.Node{Name: "minikube"})
if err != nil {
t.Fatal("Error starting host.")
}
for i := range h.HostOptions.EngineOptions.Env {
if h.HostOptions.EngineOptions.Env[i] != cfg.DockerEnv[i] {
t.Fatal("Docker env variables were not set!")
t.Fatalf("Docker env variables were not set! got %+v but want %+v", h.HostOptions.EngineOptions.Env, cfg.DockerEnv)
}
}
@ -313,7 +313,7 @@ func TestStopHostError(t *testing.T) {
func TestStopHost(t *testing.T) {
RegisterMockDriver(t)
api := tests.NewMockAPI(t)
h, err := createHost(api, defaultClusterConfig, config.Node{Name: "minikube"})
h, err := createHost(api, &defaultClusterConfig, &config.Node{Name: "minikube"})
if err != nil {
t.Errorf("createHost failed: %v", err)
}
@ -332,7 +332,7 @@ func TestStopHost(t *testing.T) {
func TestDeleteHost(t *testing.T) {
RegisterMockDriver(t)
api := tests.NewMockAPI(t)
if _, err := createHost(api, defaultClusterConfig, config.Node{Name: "minikube"}); err != nil {
if _, err := createHost(api, &defaultClusterConfig, &config.Node{Name: "minikube"}); err != nil {
t.Errorf("createHost failed: %v", err)
}
@ -347,7 +347,7 @@ func TestDeleteHost(t *testing.T) {
func TestDeleteHostErrorDeletingVM(t *testing.T) {
RegisterMockDriver(t)
api := tests.NewMockAPI(t)
h, err := createHost(api, defaultClusterConfig, config.Node{Name: "minikube"})
h, err := createHost(api, &defaultClusterConfig, &config.Node{Name: "minikube"})
if err != nil {
t.Errorf("createHost failed: %v", err)
}
@ -364,7 +364,7 @@ func TestDeleteHostErrorDeletingFiles(t *testing.T) {
RegisterMockDriver(t)
api := tests.NewMockAPI(t)
api.RemoveError = true
if _, err := createHost(api, defaultClusterConfig, config.Node{Name: "minikube"}); err != nil {
if _, err := createHost(api, &defaultClusterConfig, &config.Node{Name: "minikube"}); err != nil {
t.Errorf("createHost failed: %v", err)
}
@ -378,7 +378,7 @@ func TestDeleteHostErrMachineNotExist(t *testing.T) {
api := tests.NewMockAPI(t)
// Create an incomplete host with machine does not exist error(i.e. User Interrupt Cancel)
api.NotExistError = true
_, err := createHost(api, defaultClusterConfig, config.Node{Name: "minikube"})
_, err := createHost(api, &defaultClusterConfig, &config.Node{Name: "minikube"})
if err != nil {
t.Errorf("createHost failed: %v", err)
}
@ -409,7 +409,7 @@ func TestStatus(t *testing.T) {
checkState(state.None.String(), m)
if _, err := createHost(api, cc, config.Node{Name: "minikube"}); err != nil {
if _, err := createHost(api, &cc, &config.Node{Name: "minikube"}); err != nil {
t.Errorf("createHost failed: %v", err)
}

2
pkg/minikube/machine/delete.go
View File

@ -99,7 +99,7 @@ func DeleteHost(api libmachine.API, machineName string, deleteAbandoned ...bool)
return delete(api, host, machineName)
}
// delete removes a host and it's local data files
// delete removes a host and its local data files
func delete(api libmachine.API, h *host.Host, machineName string) error {
if err := h.Driver.Remove(); err != nil {
glog.Warningf("remove failed, will retry: %v", err)

18
pkg/minikube/machine/fix.go
View File

@ -48,14 +48,14 @@ const (
)
// fixHost fixes up a previously configured VM so that it is ready to run Kubernetes
func fixHost(api libmachine.API, cc config.ClusterConfig, n config.Node) (*host.Host, error) {
func fixHost(api libmachine.API, cc *config.ClusterConfig, n *config.Node) (*host.Host, error) {
start := time.Now()
glog.Infof("fixHost starting: %s", n.Name)
defer func() {
glog.Infof("fixHost completed within %s", time.Since(start))
}()
h, err := api.Load(driver.MachineName(cc, n))
h, err := api.Load(driver.MachineName(*cc, *n))
if err != nil {
return h, errors.Wrap(err, "Error loading existing host. Please try running [minikube delete], then run [minikube start] again.")
}
@ -72,7 +72,7 @@ func fixHost(api libmachine.API, cc config.ClusterConfig, n config.Node) (*host.
// Avoid reprovisioning "none" driver because provision.Detect requires SSH
if !driver.BareMetal(h.Driver.DriverName()) {
e := engineOptions(cc)
e := engineOptions(*cc)
h.HostOptions.EngineOptions.Env = e.Env
err = provisionDockerMachine(h)
if err != nil {
@ -84,7 +84,7 @@ func fixHost(api libmachine.API, cc config.ClusterConfig, n config.Node) (*host.
return h, nil
}
if err := postStartSetup(h, cc); err != nil {
if err := postStartSetup(h, *cc); err != nil {
return h, errors.Wrap(err, "post-start")
}
@ -96,8 +96,8 @@ func fixHost(api libmachine.API, cc config.ClusterConfig, n config.Node) (*host.
return h, ensureSyncedGuestClock(h, driverName)
}
func recreateIfNeeded(api libmachine.API, cc config.ClusterConfig, n config.Node, h *host.Host) (*host.Host, error) {
machineName := driver.MachineName(cc, n)
func recreateIfNeeded(api libmachine.API, cc *config.ClusterConfig, n *config.Node, h *host.Host) (*host.Host, error) {
machineName := driver.MachineName(*cc, *n)
machineType := driver.MachineType(cc.Driver)
recreated := false
s, serr := h.Driver.GetState()
@ -112,7 +112,7 @@ func recreateIfNeeded(api libmachine.API, cc config.ClusterConfig, n config.Node
if !me || err == constants.ErrMachineMissing {
out.T(out.Shrug, `{{.driver_name}} "{{.cluster}}" {{.machine_type}} is missing, will recreate.`, out.V{"driver_name": cc.Driver, "cluster": cc.Name, "machine_type": machineType})
demolish(api, cc, n, h)
demolish(api, *cc, *n, h)
glog.Infof("Sleeping 1 second for extra luck!")
time.Sleep(1 * time.Second)
@ -144,8 +144,8 @@ func recreateIfNeeded(api libmachine.API, cc config.ClusterConfig, n config.Node
if err := h.Driver.Start(); err != nil {
return h, errors.Wrap(err, "driver start")
}
if err := api.Save(h); err != nil {
return h, errors.Wrap(err, "save")
if err := saveHost(api, h, cc, n); err != nil {
return h, err
}
return h, nil
}

17
pkg/minikube/machine/machine.go
View File

@ -19,10 +19,12 @@ package machine
import (
"time"
"github.com/docker/machine/libmachine"
"github.com/docker/machine/libmachine/host"
libprovision "github.com/docker/machine/libmachine/provision"
"github.com/golang/glog"
"github.com/pkg/errors"
"k8s.io/minikube/pkg/minikube/config"
"k8s.io/minikube/pkg/minikube/driver"
"k8s.io/minikube/pkg/provision"
)
@ -108,3 +110,18 @@ func fastDetectProvisioner(h *host.Host) (libprovision.Provisioner, error) {
return provision.NewBuildrootProvisioner(h.Driver), nil
}
}
// saveHost is a wrapper around libmachine's Save function to proactively update the node's IP whenever a host is saved
func saveHost(api libmachine.API, h *host.Host, cfg *config.ClusterConfig, n *config.Node) error {
if err := api.Save(h); err != nil {
return errors.Wrap(err, "save")
}
// Save IP to config file for subsequent use
ip, err := h.Driver.GetIP()
if err != nil {
return err
}
n.IP = ip
return config.SaveNode(cfg, n)
}

38
pkg/minikube/machine/start.go
View File

@ -39,6 +39,7 @@ import (
"k8s.io/minikube/pkg/minikube/driver"
"k8s.io/minikube/pkg/minikube/localpath"
"k8s.io/minikube/pkg/minikube/out"
"k8s.io/minikube/pkg/minikube/proxy"
"k8s.io/minikube/pkg/minikube/registry"
"k8s.io/minikube/pkg/minikube/vmpath"
"k8s.io/minikube/pkg/util/lock"
@ -61,8 +62,8 @@ var (
)
// StartHost starts a host VM.
func StartHost(api libmachine.API, cfg config.ClusterConfig, n config.Node) (*host.Host, bool, error) {
machineName := driver.MachineName(cfg, n)
func StartHost(api libmachine.API, cfg *config.ClusterConfig, n *config.Node) (*host.Host, bool, error) {
machineName := driver.MachineName(*cfg, *n)
// Prevent machine-driver boot races, as well as our own certificate race
releaser, err := acquireMachinesLock(machineName)
@ -89,9 +90,25 @@ func StartHost(api libmachine.API, cfg config.ClusterConfig, n config.Node) (*ho
return h, exists, err
}
// engineOptions returns docker engine options for the dockerd running inside minikube
func engineOptions(cfg config.ClusterConfig) *engine.Options {
// get docker env from user's proxy settings
dockerEnv := proxy.SetDockerEnv()
// get docker env from user specifiec config
dockerEnv = append(dockerEnv, cfg.DockerEnv...)
// remove duplicates
seen := map[string]bool{}
uniqueEnvs := []string{}
for e := range dockerEnv {
if !seen[dockerEnv[e]] {
seen[dockerEnv[e]] = true
uniqueEnvs = append(uniqueEnvs, dockerEnv[e])
}
}
o := engine.Options{
Env: cfg.DockerEnv,
Env: uniqueEnvs,
InsecureRegistry: append([]string{constants.DefaultServiceCIDR}, cfg.InsecureRegistry...),
RegistryMirror: cfg.RegistryMirror,
ArbitraryFlags: cfg.DockerOpt,
@ -100,7 +117,7 @@ func engineOptions(cfg config.ClusterConfig) *engine.Options {
return &o
}
func createHost(api libmachine.API, cfg config.ClusterConfig, n config.Node) (*host.Host, error) {
func createHost(api libmachine.API, cfg *config.ClusterConfig, n *config.Node) (*host.Host, error) {
glog.Infof("createHost starting for %q (driver=%q)", n.Name, cfg.Driver)
start := time.Now()
defer func() {
@ -113,12 +130,12 @@ func createHost(api libmachine.API, cfg config.ClusterConfig, n config.Node) (*h
See https://minikube.sigs.k8s.io/docs/reference/drivers/vmware/ for more information.
To disable this message, run [minikube config set ShowDriverDeprecationNotification false]`)
}
showHostInfo(cfg)
showHostInfo(*cfg)
def := registry.Driver(cfg.Driver)
if def.Empty() {
return nil, fmt.Errorf("unsupported/missing driver: %s", cfg.Driver)
}
dd, err := def.Config(cfg, n)
dd, err := def.Config(*cfg, *n)
if err != nil {
return nil, errors.Wrap(err, "config")
}
@ -134,7 +151,7 @@ func createHost(api libmachine.API, cfg config.ClusterConfig, n config.Node) (*h
h.HostOptions.AuthOptions.CertDir = localpath.MiniPath()
h.HostOptions.AuthOptions.StorePath = localpath.MiniPath()
h.HostOptions.EngineOptions = engineOptions(cfg)
h.HostOptions.EngineOptions = engineOptions(*cfg)
cstart := time.Now()
glog.Infof("libmachine.API.Create for %q (driver=%q)", cfg.Name, cfg.Driver)
@ -144,13 +161,14 @@ func createHost(api libmachine.API, cfg config.ClusterConfig, n config.Node) (*h
}
glog.Infof("duration metric: libmachine.API.Create for %q took %s", cfg.Name, time.Since(cstart))
if err := postStartSetup(h, cfg); err != nil {
if err := postStartSetup(h, *cfg); err != nil {
return h, errors.Wrap(err, "post-start")
}
if err := api.Save(h); err != nil {
return nil, errors.Wrap(err, "save")
if err := saveHost(api, h, cfg, n); err != nil {
return h, err
}
return h, nil
}

16
pkg/minikube/node/start.go
View File

@ -322,7 +322,7 @@ func startMachine(cfg *config.ClusterConfig, node *config.Node) (runner command.
if err != nil {
return runner, preExists, m, host, errors.Wrap(err, "Failed to get machine client")
}
host, preExists, err = startHost(m, *cfg, *node)
host, preExists, err = startHost(m, cfg, node)
if err != nil {
return runner, preExists, m, host, errors.Wrap(err, "Failed to start host")
}
@ -342,18 +342,11 @@ func startMachine(cfg *config.ClusterConfig, node *config.Node) (runner command.
out.FailureT("Failed to set NO_PROXY Env. Please use `export NO_PROXY=$NO_PROXY,{{.ip}}`.", out.V{"ip": ip})
}
// Save IP to config file for subsequent use
node.IP = ip
err = config.SaveNode(cfg, node)
if err != nil {
return runner, preExists, m, host, errors.Wrap(err, "saving node")
}
return runner, preExists, m, host, err
}
// startHost starts a new minikube host using a VM or None
func startHost(api libmachine.API, cc config.ClusterConfig, n config.Node) (*host.Host, bool, error) {
func startHost(api libmachine.API, cc *config.ClusterConfig, n *config.Node) (*host.Host, bool, error) {
host, exists, err := machine.StartHost(api, cc, n)
if err == nil {
return host, exists, nil
@ -361,7 +354,7 @@ func startHost(api libmachine.API, cc config.ClusterConfig, n config.Node) (*hos
// NOTE: People get very cranky if you delete their prexisting VM. Only delete new ones.
if !exists {
err := machine.DeleteHost(api, driver.MachineName(cc, n))
err := machine.DeleteHost(api, driver.MachineName(*cc, *n))
if err != nil {
glog.Warningf("delete host: %v", err)
}
@ -407,7 +400,8 @@ func validateNetwork(h *host.Host, r command.Runner, imageRepository string) (st
ipExcluded := proxy.IsIPExcluded(ip) // Skip warning if minikube ip is already in NO_PROXY
k = strings.ToUpper(k) // for http_proxy & https_proxy
if (k == "HTTP_PROXY" || k == "HTTPS_PROXY") && !ipExcluded && !warnedOnce {
out.WarningT("You appear to be using a proxy, but your NO_PROXY environment does not include the minikube IP ({{.ip_address}}). Please see {{.documentation_url}} for more details", out.V{"ip_address": ip, "documentation_url": "https://minikube.sigs.k8s.io/docs/handbook/vpn_and_proxy/"})
out.WarningT("You appear to be using a proxy, but your NO_PROXY environment does not include the minikube IP ({{.ip_address}}).", out.V{"ip_address": ip})
out.T(out.Documentation, "Please see {{.documentation_url}} for more details", out.V{"documentation_url": "https://minikube.sigs.k8s.io/docs/handbook/vpn_and_proxy/"})
warnedOnce = true
}
}

33
pkg/minikube/proxy/proxy.go
View File

@ -26,6 +26,8 @@ import (
"github.com/golang/glog"
"github.com/pkg/errors"
"k8s.io/client-go/rest"
"k8s.io/minikube/pkg/minikube/config"
"k8s.io/minikube/pkg/minikube/out"
)
// EnvVars are variables we plumb through to the underlying container runtime
@ -149,3 +151,34 @@ func UpdateTransport(cfg *rest.Config) *rest.Config {
}
return cfg
}
// SetDockerEnv sets the proxy environment variables in the docker environment.
func SetDockerEnv() []string {
for _, k := range EnvVars {
if v := os.Getenv(k); v != "" {
// convert https_proxy to HTTPS_PROXY for linux
// TODO (@medyagh): if user has both http_proxy & HTTPS_PROXY set merge them.
k = strings.ToUpper(k)
if k == "HTTP_PROXY" || k == "HTTPS_PROXY" {
if strings.HasPrefix(v, "localhost") || strings.HasPrefix(v, "127.0") {
out.WarningT("Not passing {{.name}}={{.value}} to docker env.", out.V{"name": k, "value": v})
continue
}
}
config.DockerEnv = append(config.DockerEnv, fmt.Sprintf("%s=%s", k, v))
}
}
// remove duplicates
seen := map[string]bool{}
uniqueEnvs := []string{}
for e := range config.DockerEnv {
if !seen[config.DockerEnv[e]] {
seen[config.DockerEnv[e]] = true
uniqueEnvs = append(uniqueEnvs, config.DockerEnv[e])
}
}
config.DockerEnv = uniqueEnvs
return config.DockerEnv
}

7
site/content/en/docs/start/_index.md
View File

@ -56,6 +56,13 @@ If the [Brew Package Manager](https://brew.sh/) installed:
brew install minikube
```
If `which minikube` fails after installation via brew, you may have to remove the minikube cask and link the binary:
```
brew cask remove minikube
brew link minikube
```
Otherwise, download minikube directly:
```shell