From 00763352b6860c5d340a55b4e87b142b7788b8e2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Anders=20F=20Bj=C3=B6rklund?= Date: Wed, 10 Jul 2019 21:44:26 +0200 Subject: [PATCH 01/28] Add minikube support for the "generic" VM driver This driver connects to an already existing virtual machine, using the provided IP address and SSH user/key/port parameters. On this machine, libmachine will provision the docker daemon and minikube will bootstrap the kubernetes cluster (as usual). --- cmd/minikube/cmd/start_flags.go | 15 +++++ pkg/minikube/cluster/ip.go | 6 ++ pkg/minikube/config/types.go | 4 ++ pkg/minikube/driver/driver.go | 2 + pkg/minikube/registry/drvs/generic/generic.go | 62 +++++++++++++++++++ pkg/minikube/registry/drvs/init.go | 1 + site/content/en/docs/commands/start.md | 4 ++ 7 files changed, 94 insertions(+) create mode 100644 pkg/minikube/registry/drvs/generic/generic.go diff --git a/cmd/minikube/cmd/start_flags.go b/cmd/minikube/cmd/start_flags.go index 1988677eeb42..7f659ceaf0ed 100644 --- a/cmd/minikube/cmd/start_flags.go +++ b/cmd/minikube/cmd/start_flags.go @@ -22,6 +22,7 @@ import ( "time" "github.com/blang/semver" + "github.com/docker/machine/libmachine/drivers" "github.com/pkg/errors" "github.com/spf13/cobra" "github.com/spf13/viper" @@ -110,6 +111,10 @@ const ( network = "network" startNamespace = "namespace" trace = "trace" + genericIPAddress = "generic-ip-address" + genericSSHUser = "generic-ssh-user" + genericSSHKey = "generic-ssh-key" + genericSSHPort = "generic-ssh-port" ) var ( @@ -221,6 +226,12 @@ func initNetworkingFlags() { startCmd.Flags().String(serviceCIDR, constants.DefaultServiceCIDR, "The CIDR to be used for service cluster IPs.") startCmd.Flags().StringArrayVar(&config.DockerEnv, "docker-env", nil, "Environment variables to pass to the Docker daemon. (format: key=value)") startCmd.Flags().StringArrayVar(&config.DockerOpt, "docker-opt", nil, "Specify arbitrary flags to pass to the Docker daemon. (format: key=value)") + + // generic + startCmd.Flags().String(genericIPAddress, "", "IP address (generic)") + startCmd.Flags().String(genericSSHUser, drivers.DefaultSSHUser, "SSH user (generic)") + startCmd.Flags().String(genericSSHKey, "", "SSH key (generic)") + startCmd.Flags().Int(genericSSHPort, drivers.DefaultSSHPort, "SSH port (generic)") } // ClusterFlagValue returns the current cluster name based on flags @@ -335,6 +346,10 @@ func generateClusterConfig(cmd *cobra.Command, existing *config.ClusterConfig, k NatNicType: viper.GetString(natNicType), StartHostTimeout: viper.GetDuration(waitTimeout), ExposedPorts: viper.GetStringSlice(ports), + GenericIPAddress: viper.GetString(genericIPAddress), + GenericSSHUser: viper.GetString(genericSSHUser), + GenericSSHKey: viper.GetString(genericSSHKey), + GenericSSHPort: viper.GetInt(genericSSHPort), KubernetesConfig: config.KubernetesConfig{ KubernetesVersion: k8sVersion, ClusterName: ClusterFlagValue(), diff --git a/pkg/minikube/cluster/ip.go b/pkg/minikube/cluster/ip.go index 891705e60c73..6a3522e67a61 100644 --- a/pkg/minikube/cluster/ip.go +++ b/pkg/minikube/cluster/ip.go @@ -40,6 +40,12 @@ func HostIP(host *host.Host, clusterName string) (net.IP, error) { return oci.RoutableHostIPFromInside(oci.Docker, clusterName, host.Name) case driver.Podman: return oci.RoutableHostIPFromInside(oci.Podman, clusterName, host.Name) + case driver.Generic: + ip, err := host.Driver.GetIP() + if err != nil { + return []byte{}, errors.Wrap(err, "Error getting VM/Host IP address") + } + return net.ParseIP(ip), nil case driver.KVM2: return net.ParseIP("192.168.39.1"), nil case driver.HyperV: diff --git a/pkg/minikube/config/types.go b/pkg/minikube/config/types.go index 00cc1b54d4d3..d4ccaa0555f2 100644 --- a/pkg/minikube/config/types.go +++ b/pkg/minikube/config/types.go @@ -66,6 +66,10 @@ type ClusterConfig struct { HostDNSResolver bool // Only used by virtualbox HostOnlyNicType string // Only used by virtualbox NatNicType string // Only used by virtualbox + GenericIPAddress string // Only used by generic + GenericSSHUser string // Only used by generic + GenericSSHKey string // Only used by generic + GenericSSHPort int // Only used by generic KubernetesConfig KubernetesConfig Nodes []Node Addons map[string]bool diff --git a/pkg/minikube/driver/driver.go b/pkg/minikube/driver/driver.go index 07974b9be132..6c9ff9935325 100644 --- a/pkg/minikube/driver/driver.go +++ b/pkg/minikube/driver/driver.go @@ -39,6 +39,8 @@ const ( Mock = "mock" // None driver None = "none" + // Generic driver + Generic = "generic" // KVM2 driver KVM2 = "kvm2" // VirtualBox driver diff --git a/pkg/minikube/registry/drvs/generic/generic.go b/pkg/minikube/registry/drvs/generic/generic.go new file mode 100644 index 000000000000..93afecc13355 --- /dev/null +++ b/pkg/minikube/registry/drvs/generic/generic.go @@ -0,0 +1,62 @@ +/* +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 generic + +import ( + "fmt" + + "github.com/docker/machine/drivers/generic" + "github.com/docker/machine/libmachine/drivers" + "github.com/pkg/errors" + + "k8s.io/minikube/pkg/minikube/config" + "k8s.io/minikube/pkg/minikube/driver" + "k8s.io/minikube/pkg/minikube/localpath" + "k8s.io/minikube/pkg/minikube/registry" +) + +func init() { + err := registry.Register(registry.DriverDef{ + Name: driver.Generic, + Config: configure, + Status: status, + Priority: registry.Fallback, + Init: func() drivers.Driver { return generic.NewDriver("", "") }, + }) + if err != nil { + panic(fmt.Sprintf("unable to register: %v", err)) + } +} + +func configure(cc config.ClusterConfig, n config.Node) (interface{}, error) { + d := generic.NewDriver(driver.MachineName(cc, n), localpath.MiniPath()) + + if cc.GenericIPAddress == "" { + return nil, errors.Errorf("please provide an IP address") + } + + d.(*generic.Driver).IPAddress = cc.GenericIPAddress + d.(*generic.Driver).SSHUser = cc.GenericSSHUser + d.(*generic.Driver).SSHKey = cc.GenericSSHKey + d.(*generic.Driver).SSHPort = cc.GenericSSHPort + + return d, nil +} + +func status() registry.State { + return registry.State{Installed: true, Healthy: true} +} diff --git a/pkg/minikube/registry/drvs/init.go b/pkg/minikube/registry/drvs/init.go index bca12775c3ff..2bd36761e79c 100644 --- a/pkg/minikube/registry/drvs/init.go +++ b/pkg/minikube/registry/drvs/init.go @@ -19,6 +19,7 @@ package drvs import ( // Register all of the drvs we know of _ "k8s.io/minikube/pkg/minikube/registry/drvs/docker" + _ "k8s.io/minikube/pkg/minikube/registry/drvs/generic" _ "k8s.io/minikube/pkg/minikube/registry/drvs/hyperkit" _ "k8s.io/minikube/pkg/minikube/registry/drvs/hyperv" _ "k8s.io/minikube/pkg/minikube/registry/drvs/kvm2" diff --git a/site/content/en/docs/commands/start.md b/site/content/en/docs/commands/start.md index edaea7cb3a19..e404b4a6a981 100644 --- a/site/content/en/docs/commands/start.md +++ b/site/content/en/docs/commands/start.md @@ -51,6 +51,10 @@ minikube start [flags] --feature-gates string A set of key=value pairs that describe feature gates for alpha/experimental features. --force Force minikube to perform possibly dangerous operations --force-systemd If set, force the container runtime to use sytemd as cgroup manager. Currently available for docker and crio. Defaults to false. + --generic-ip-address string IP address (generic) + --generic-ssh-key string SSH key (generic) + --generic-ssh-port int SSH port (generic) (default 22) + --generic-ssh-user string SSH user (generic) (default "root") --host-dns-resolver Enable host resolver for NAT DNS requests (virtualbox driver only) (default true) --host-only-cidr string The CIDR to be used for the minikube VM (virtualbox driver only) (default "192.168.99.1/24") --host-only-nic-type string NIC Type used for host only network. One of Am79C970A, Am79C973, 82540EM, 82543GC, 82545EM, or virtio (virtualbox driver only) (default "virtio") From c07666957a49e93a74d13847b183ba6986daeb35 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Anders=20F=20Bj=C3=B6rklund?= Date: Sun, 14 Jul 2019 16:03:28 +0200 Subject: [PATCH 02/28] Don't download ISO for the generic VM driver --- cmd/minikube/cmd/start.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cmd/minikube/cmd/start.go b/cmd/minikube/cmd/start.go index 5e40239fdc99..11a4b5227e16 100644 --- a/cmd/minikube/cmd/start.go +++ b/cmd/minikube/cmd/start.go @@ -306,7 +306,7 @@ func provisionWithDriver(cmd *cobra.Command, ds registry.DriverState, existing * os.Exit(0) } - if driver.IsVM(driverName) { + if driver.IsVM(driverName) && driverName != driver.Generic { url, err := download.ISO(viper.GetStringSlice(isoURL), cmd.Flags().Changed(isoURL)) if err != nil { return node.Starter{}, errors.Wrap(err, "Failed to cache ISO") From 7c5ba62e8d9eb812075b2c47e8638ccd7cc72082 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Anders=20F=20Bj=C3=B6rklund?= Date: Sun, 14 Jul 2019 16:34:24 +0200 Subject: [PATCH 03/28] Generic driver does not add user to docker group --- pkg/minikube/machine/fix.go | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/pkg/minikube/machine/fix.go b/pkg/minikube/machine/fix.go index 8e0eeb7f77e4..88027806faa6 100644 --- a/pkg/minikube/machine/fix.go +++ b/pkg/minikube/machine/fix.go @@ -95,6 +95,12 @@ func fixHost(api libmachine.API, cc *config.ClusterConfig, n *config.Node) (*hos return h, nil } + if h.Driver.DriverName() == driver.Generic { + if _, err := h.RunSSHCommand(fmt.Sprintf("sudo usermod -aG docker %s", h.Driver.GetSSHUsername())); err != nil { + return h, errors.Wrap(err, "usermod") + } + } + return h, ensureSyncedGuestClock(h, driverName) } From 2b5c5b92020d4eb2d5b895e7bba037d865ed0265 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Anders=20F=20Bj=C3=B6rklund?= Date: Sun, 14 Jul 2019 19:11:48 +0200 Subject: [PATCH 04/28] Try to uninstall kubernetes on delete, for generic --- cmd/minikube/cmd/delete.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cmd/minikube/cmd/delete.go b/cmd/minikube/cmd/delete.go index 7bfe9bfda21e..f24052c30596 100644 --- a/cmd/minikube/cmd/delete.go +++ b/cmd/minikube/cmd/delete.go @@ -309,7 +309,7 @@ func deleteProfile(profile *config.Profile) error { return DeletionError{Err: delErr, Errtype: MissingProfile} } - if err == nil && driver.BareMetal(cc.Driver) { + if err == nil && (driver.BareMetal(cc.Driver) || cc.Driver == driver.Generic) { if err := uninstallKubernetes(api, *cc, cc.Nodes[0], viper.GetString(cmdcfg.Bootstrapper)); err != nil { deletionError, ok := err.(DeletionError) if ok { From 6dad25898ed166956f2456be554a8767ef7fda6c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Anders=20F=20Bj=C3=B6rklund?= Date: Mon, 15 Jul 2019 16:14:58 +0200 Subject: [PATCH 05/28] Don't try to start/stop drivers without VMs It is not supported anyway, and just throws errors. There is no use to restart or to retry, just give up. This should never be a problem with "none", though. That always return running, while generic tests ssh. --- pkg/minikube/machine/fix.go | 9 +++++++++ pkg/minikube/machine/stop.go | 4 ++++ 2 files changed, 13 insertions(+) diff --git a/pkg/minikube/machine/fix.go b/pkg/minikube/machine/fix.go index 88027806faa6..ba99581f5e61 100644 --- a/pkg/minikube/machine/fix.go +++ b/pkg/minikube/machine/fix.go @@ -135,6 +135,15 @@ func recreateIfNeeded(api libmachine.API, cc *config.ClusterConfig, n *config.No } } + if h.Driver.DriverName() == driver.Generic { + if s == state.Running { + out.Step(style.Running, `Using the {{.driver_name}} "{{.cluster}}" {{.machine_type}} ...`, out.V{"driver_name": cc.Driver, "cluster": cc.Name, "machine_type": machineType}) + } else { + return h, errors.Errorf("not running") + } + return h, nil + } + if serr != constants.ErrMachineMissing { klog.Warningf("unexpected machine state, will restart: %v", serr) } diff --git a/pkg/minikube/machine/stop.go b/pkg/minikube/machine/stop.go index 3984f2e9aa0e..0526b08f7cb6 100644 --- a/pkg/minikube/machine/stop.go +++ b/pkg/minikube/machine/stop.go @@ -55,6 +55,10 @@ func stop(h *host.Host) error { } } + if h.DriverName == driver.Generic { + return nil + } + if err := h.Stop(); err != nil { klog.Infof("stop err: %v", err) st, ok := err.(mcnerror.ErrHostAlreadyInState) From d0260cca998d59b293a287027230f845c5957a9c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Anders=20F=20Bj=C3=B6rklund?= Date: Wed, 28 Oct 2020 22:08:45 +0100 Subject: [PATCH 06/28] Allow actually using the generic driver All drivers *must* be in "supportedDrivers" Delete Podman on Darwin (Mac), not available --- pkg/minikube/driver/driver_darwin.go | 2 +- pkg/minikube/driver/driver_linux.go | 1 + pkg/minikube/driver/driver_windows.go | 1 + 3 files changed, 3 insertions(+), 1 deletion(-) diff --git a/pkg/minikube/driver/driver_darwin.go b/pkg/minikube/driver/driver_darwin.go index f951177677c2..24a6e56d6c3d 100644 --- a/pkg/minikube/driver/driver_darwin.go +++ b/pkg/minikube/driver/driver_darwin.go @@ -26,7 +26,7 @@ var supportedDrivers = []string{ HyperKit, VMware, Docker, - Podman, + Generic, } func VBoxManagePath() string { diff --git a/pkg/minikube/driver/driver_linux.go b/pkg/minikube/driver/driver_linux.go index 16e7b5e706de..05784f946e08 100644 --- a/pkg/minikube/driver/driver_linux.go +++ b/pkg/minikube/driver/driver_linux.go @@ -29,6 +29,7 @@ var supportedDrivers = []string{ None, Docker, Podman, + Generic, } // VBoxManagePath returns the path to the VBoxManage command diff --git a/pkg/minikube/driver/driver_windows.go b/pkg/minikube/driver/driver_windows.go index 80ff83b825b2..8a2f5a6a2a5f 100644 --- a/pkg/minikube/driver/driver_windows.go +++ b/pkg/minikube/driver/driver_windows.go @@ -33,6 +33,7 @@ var supportedDrivers = []string{ HyperV, VMware, Docker, + Generic, } // TODO: medyagh add same check for kic docker From d3ea174619e0cdd9ebce7ccb5f469673aeca68fb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Anders=20F=20Bj=C3=B6rklund?= Date: Wed, 28 Oct 2020 22:23:29 +0100 Subject: [PATCH 07/28] Call DetectProvisioner for the generic driver It was failing to install the "docker" package Since the provisioning was defaulting to ISO --- pkg/minikube/machine/machine.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pkg/minikube/machine/machine.go b/pkg/minikube/machine/machine.go index d382041f6a04..cf27e81655d6 100644 --- a/pkg/minikube/machine/machine.go +++ b/pkg/minikube/machine/machine.go @@ -104,7 +104,7 @@ func fastDetectProvisioner(h *host.Host) (libprovision.Provisioner, error) { switch { case driver.IsKIC(d): return provision.NewUbuntuProvisioner(h.Driver), nil - case driver.BareMetal(d): + case driver.BareMetal(d), d == driver.Generic: return libprovision.DetectProvisioner(h.Driver) default: return provision.NewBuildrootProvisioner(h.Driver), nil From c3a23cd60a2982c3be5ce9caf1438ebe2e5f2b3b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Anders=20F=20Bj=C3=B6rklund?= Date: Thu, 29 Oct 2020 07:39:22 +0100 Subject: [PATCH 08/28] Fix failing unit test for MachineType Since we don't know the remote machine type anyway, it could be a virtual machine or a physical server. But we don't add any _extra_ isolation for minikube, so go with "bare metal machine" machine type for now. --- pkg/minikube/driver/driver.go | 4 ++++ pkg/minikube/driver/driver_test.go | 1 + 2 files changed, 5 insertions(+) diff --git a/pkg/minikube/driver/driver.go b/pkg/minikube/driver/driver.go index 6c9ff9935325..b66ad8aef5e7 100644 --- a/pkg/minikube/driver/driver.go +++ b/pkg/minikube/driver/driver.go @@ -99,6 +99,10 @@ func MachineType(name string) string { return "container" } + if name == Generic { + return "bare metal machine" + } + if IsVM(name) { return "VM" } diff --git a/pkg/minikube/driver/driver_test.go b/pkg/minikube/driver/driver_test.go index 1f6ab86f7446..79e6b77893e2 100644 --- a/pkg/minikube/driver/driver_test.go +++ b/pkg/minikube/driver/driver_test.go @@ -65,6 +65,7 @@ func TestMachineType(t *testing.T) { Docker: "container", Mock: "bare metal machine", None: "bare metal machine", + Generic: "bare metal machine", KVM2: "VM", VirtualBox: "VM", HyperKit: "VM", From d96d3befbe9927d4582c33934ff1f23b0a462e5b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Anders=20F=20Bj=C3=B6rklund?= Date: Thu, 29 Oct 2020 12:17:37 +0100 Subject: [PATCH 09/28] Log the os-release also for the generic driver --- pkg/minikube/machine/start.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pkg/minikube/machine/start.go b/pkg/minikube/machine/start.go index 7e0c3d795ccd..92e22efaf884 100644 --- a/pkg/minikube/machine/start.go +++ b/pkg/minikube/machine/start.go @@ -283,7 +283,7 @@ func postStartSetup(h *host.Host, mc config.ClusterConfig) error { if driver.BareMetal(mc.Driver) { showLocalOsRelease() } - if driver.IsVM(mc.Driver) || driver.IsKIC(mc.Driver) { + if driver.IsVM(mc.Driver) || driver.IsKIC(mc.Driver) || mc.Driver == driver.Generic { logRemoteOsRelease(r) } return syncLocalAssets(r) From a0d2c1a0c5b9d1f99fc607183d3043b0c5409b03 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Anders=20F=20Bj=C3=B6rklund?= Date: Thu, 29 Oct 2020 12:18:49 +0100 Subject: [PATCH 10/28] Need to set up docker group in start - not in fix It was only called for existing machines, not for new. But other commands expect to be able to run "docker". --- pkg/minikube/machine/fix.go | 6 ------ pkg/minikube/machine/start.go | 6 ++++++ 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/pkg/minikube/machine/fix.go b/pkg/minikube/machine/fix.go index ba99581f5e61..c4f986a12184 100644 --- a/pkg/minikube/machine/fix.go +++ b/pkg/minikube/machine/fix.go @@ -95,12 +95,6 @@ func fixHost(api libmachine.API, cc *config.ClusterConfig, n *config.Node) (*hos return h, nil } - if h.Driver.DriverName() == driver.Generic { - if _, err := h.RunSSHCommand(fmt.Sprintf("sudo usermod -aG docker %s", h.Driver.GetSSHUsername())); err != nil { - return h, errors.Wrap(err, "usermod") - } - } - return h, ensureSyncedGuestClock(h, driverName) } diff --git a/pkg/minikube/machine/start.go b/pkg/minikube/machine/start.go index 92e22efaf884..4a38966c760f 100644 --- a/pkg/minikube/machine/start.go +++ b/pkg/minikube/machine/start.go @@ -168,6 +168,12 @@ func createHost(api libmachine.API, cfg *config.ClusterConfig, n *config.Node) ( return h, errors.Wrap(err, "post-start") } + if h.Driver.DriverName() == driver.Generic { + if _, err := h.RunSSHCommand(fmt.Sprintf("sudo usermod -aG docker %s", h.Driver.GetSSHUsername())); err != nil { + return h, errors.Wrap(err, "usermod") + } + } + if err := saveHost(api, h, cfg, n); err != nil { return h, err } From a3b3b55ac03362057e5c7fe4adcaef5461eacdfb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Anders=20F=20Bj=C3=B6rklund?= Date: Sat, 14 Nov 2020 09:36:49 +0100 Subject: [PATCH 11/28] Add helper for checking the generic driver name --- cmd/minikube/cmd/delete.go | 2 +- cmd/minikube/cmd/start.go | 2 +- pkg/minikube/driver/driver.go | 7 ++++++- pkg/minikube/machine/fix.go | 2 +- pkg/minikube/machine/machine.go | 2 +- pkg/minikube/machine/start.go | 4 ++-- pkg/minikube/machine/stop.go | 2 +- 7 files changed, 13 insertions(+), 8 deletions(-) diff --git a/cmd/minikube/cmd/delete.go b/cmd/minikube/cmd/delete.go index f24052c30596..846d03d294cc 100644 --- a/cmd/minikube/cmd/delete.go +++ b/cmd/minikube/cmd/delete.go @@ -309,7 +309,7 @@ func deleteProfile(profile *config.Profile) error { return DeletionError{Err: delErr, Errtype: MissingProfile} } - if err == nil && (driver.BareMetal(cc.Driver) || cc.Driver == driver.Generic) { + if err == nil && (driver.BareMetal(cc.Driver) || driver.IsGeneric(cc.Driver)) { if err := uninstallKubernetes(api, *cc, cc.Nodes[0], viper.GetString(cmdcfg.Bootstrapper)); err != nil { deletionError, ok := err.(DeletionError) if ok { diff --git a/cmd/minikube/cmd/start.go b/cmd/minikube/cmd/start.go index 11a4b5227e16..62700e2231b0 100644 --- a/cmd/minikube/cmd/start.go +++ b/cmd/minikube/cmd/start.go @@ -306,7 +306,7 @@ func provisionWithDriver(cmd *cobra.Command, ds registry.DriverState, existing * os.Exit(0) } - if driver.IsVM(driverName) && driverName != driver.Generic { + if driver.IsVM(driverName) && !driver.IsGeneric(driverName) { url, err := download.ISO(viper.GetStringSlice(isoURL), cmd.Flags().Changed(isoURL)) if err != nil { return node.Starter{}, errors.Wrap(err, "Failed to cache ISO") diff --git a/pkg/minikube/driver/driver.go b/pkg/minikube/driver/driver.go index b66ad8aef5e7..c1783f8ca346 100644 --- a/pkg/minikube/driver/driver.go +++ b/pkg/minikube/driver/driver.go @@ -99,7 +99,7 @@ func MachineType(name string) string { return "container" } - if name == Generic { + if IsGeneric(name) { return "bare metal machine" } @@ -150,6 +150,11 @@ func BareMetal(name string) bool { return name == None || name == Mock } +// IsGeneric checks if the driver is generic +func IsGeneric(name string) bool { + return name == Generic +} + // NeedsPortForward returns true if driver is unable provide direct IP connectivity func NeedsPortForward(name string) bool { if !IsKIC(name) { diff --git a/pkg/minikube/machine/fix.go b/pkg/minikube/machine/fix.go index c4f986a12184..58e09eb8ee1e 100644 --- a/pkg/minikube/machine/fix.go +++ b/pkg/minikube/machine/fix.go @@ -129,7 +129,7 @@ func recreateIfNeeded(api libmachine.API, cc *config.ClusterConfig, n *config.No } } - if h.Driver.DriverName() == driver.Generic { + if driver.IsGeneric(h.Driver.DriverName()) { if s == state.Running { out.Step(style.Running, `Using the {{.driver_name}} "{{.cluster}}" {{.machine_type}} ...`, out.V{"driver_name": cc.Driver, "cluster": cc.Name, "machine_type": machineType}) } else { diff --git a/pkg/minikube/machine/machine.go b/pkg/minikube/machine/machine.go index cf27e81655d6..2fdf60ba693a 100644 --- a/pkg/minikube/machine/machine.go +++ b/pkg/minikube/machine/machine.go @@ -104,7 +104,7 @@ func fastDetectProvisioner(h *host.Host) (libprovision.Provisioner, error) { switch { case driver.IsKIC(d): return provision.NewUbuntuProvisioner(h.Driver), nil - case driver.BareMetal(d), d == driver.Generic: + case driver.BareMetal(d), driver.IsGeneric(d): return libprovision.DetectProvisioner(h.Driver) default: return provision.NewBuildrootProvisioner(h.Driver), nil diff --git a/pkg/minikube/machine/start.go b/pkg/minikube/machine/start.go index 4a38966c760f..689d1e90c2ec 100644 --- a/pkg/minikube/machine/start.go +++ b/pkg/minikube/machine/start.go @@ -168,7 +168,7 @@ func createHost(api libmachine.API, cfg *config.ClusterConfig, n *config.Node) ( return h, errors.Wrap(err, "post-start") } - if h.Driver.DriverName() == driver.Generic { + if driver.IsGeneric(h.Driver.DriverName()) { if _, err := h.RunSSHCommand(fmt.Sprintf("sudo usermod -aG docker %s", h.Driver.GetSSHUsername())); err != nil { return h, errors.Wrap(err, "usermod") } @@ -289,7 +289,7 @@ func postStartSetup(h *host.Host, mc config.ClusterConfig) error { if driver.BareMetal(mc.Driver) { showLocalOsRelease() } - if driver.IsVM(mc.Driver) || driver.IsKIC(mc.Driver) || mc.Driver == driver.Generic { + if driver.IsVM(mc.Driver) || driver.IsKIC(mc.Driver) || driver.IsGeneric(mc.Driver) { logRemoteOsRelease(r) } return syncLocalAssets(r) diff --git a/pkg/minikube/machine/stop.go b/pkg/minikube/machine/stop.go index 0526b08f7cb6..56623d353526 100644 --- a/pkg/minikube/machine/stop.go +++ b/pkg/minikube/machine/stop.go @@ -55,7 +55,7 @@ func stop(h *host.Host) error { } } - if h.DriverName == driver.Generic { + if driver.IsGeneric(h.DriverName) { return nil } From fa05fcd6d0ffbc237f4458d3fcd1c6a77afce5e8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Anders=20F=20Bj=C3=B6rklund?= Date: Wed, 6 Jan 2021 18:35:09 +0100 Subject: [PATCH 12/28] Fork the generic driver to the minikube code base --- pkg/drivers/generic/generic.go | 212 ++++++++++++++++++ pkg/minikube/registry/drvs/generic/generic.go | 2 +- 2 files changed, 213 insertions(+), 1 deletion(-) create mode 100644 pkg/drivers/generic/generic.go diff --git a/pkg/drivers/generic/generic.go b/pkg/drivers/generic/generic.go new file mode 100644 index 000000000000..b7a65e135f99 --- /dev/null +++ b/pkg/drivers/generic/generic.go @@ -0,0 +1,212 @@ +/* +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 generic + +import ( + "errors" + "fmt" + "net" + "os" + "path" + "strconv" + "time" + + "github.com/docker/machine/libmachine/drivers" + "github.com/docker/machine/libmachine/engine" + "github.com/docker/machine/libmachine/log" + "github.com/docker/machine/libmachine/mcnflag" + "github.com/docker/machine/libmachine/mcnutils" + "github.com/docker/machine/libmachine/state" +) + +type Driver struct { + *drivers.BaseDriver + EnginePort int + SSHKey string +} + +const ( + defaultTimeout = 15 * time.Second +) + +// GetCreateFlags registers the flags this driver adds to +// "docker hosts create" +func (d *Driver) GetCreateFlags() []mcnflag.Flag { + return []mcnflag.Flag{ + mcnflag.IntFlag{ + Name: "generic-engine-port", + Usage: "Docker engine port", + Value: engine.DefaultPort, + EnvVar: "GENERIC_ENGINE_PORT", + }, + mcnflag.StringFlag{ + Name: "generic-ip-address", + Usage: "IP Address of machine", + EnvVar: "GENERIC_IP_ADDRESS", + }, + mcnflag.StringFlag{ + Name: "generic-ssh-user", + Usage: "SSH user", + Value: drivers.DefaultSSHUser, + EnvVar: "GENERIC_SSH_USER", + }, + mcnflag.StringFlag{ + Name: "generic-ssh-key", + Usage: "SSH private key path (if not provided, default SSH key will be used)", + Value: "", + EnvVar: "GENERIC_SSH_KEY", + }, + mcnflag.IntFlag{ + Name: "generic-ssh-port", + Usage: "SSH port", + Value: drivers.DefaultSSHPort, + EnvVar: "GENERIC_SSH_PORT", + }, + } +} + +// NewDriver creates and returns a new instance of the driver +func NewDriver(hostName, storePath string) drivers.Driver { + return &Driver{ + EnginePort: engine.DefaultPort, + BaseDriver: &drivers.BaseDriver{ + MachineName: hostName, + StorePath: storePath, + }, + } +} + +// DriverName returns the name of the driver +func (d *Driver) DriverName() string { + return "generic" +} + +func (d *Driver) GetSSHHostname() (string, error) { + return d.GetIP() +} + +func (d *Driver) GetSSHUsername() string { + return d.SSHUser +} + +func (d *Driver) GetSSHKeyPath() string { + return d.SSHKeyPath +} + +func (d *Driver) SetConfigFromFlags(flags drivers.DriverOptions) error { + d.EnginePort = flags.Int("generic-engine-port") + d.IPAddress = flags.String("generic-ip-address") + d.SSHUser = flags.String("generic-ssh-user") + d.SSHKey = flags.String("generic-ssh-key") + d.SSHPort = flags.Int("generic-ssh-port") + + if d.IPAddress == "" { + return errors.New("generic driver requires the --generic-ip-address option") + } + + return nil +} + +func (d *Driver) PreCreateCheck() error { + if d.SSHKey != "" { + if _, err := os.Stat(d.SSHKey); os.IsNotExist(err) { + return fmt.Errorf("SSH key does not exist: %q", d.SSHKey) + } + + // TODO: validate the key is a valid key + } + + return nil +} + +func (d *Driver) Create() error { + if d.SSHKey == "" { + log.Info("No SSH key specified. Assuming an existing key at the default location.") + } else { + log.Info("Importing SSH key...") + + d.SSHKeyPath = d.ResolveStorePath(path.Base(d.SSHKey)) + if err := copySSHKey(d.SSHKey, d.SSHKeyPath); err != nil { + return err + } + + if err := copySSHKey(d.SSHKey+".pub", d.SSHKeyPath+".pub"); err != nil { + log.Infof("Couldn't copy SSH public key : %s", err) + } + } + + log.Debugf("IP: %s", d.IPAddress) + + return nil +} + +func (d *Driver) GetURL() (string, error) { + if err := drivers.MustBeRunning(d); err != nil { + return "", err + } + + ip, err := d.GetIP() + if err != nil { + return "", err + } + + return fmt.Sprintf("tcp://%s", net.JoinHostPort(ip, strconv.Itoa(d.EnginePort))), nil +} + +func (d *Driver) GetState() (state.State, error) { + address := net.JoinHostPort(d.IPAddress, strconv.Itoa(d.SSHPort)) + + _, err := net.DialTimeout("tcp", address, defaultTimeout) + if err != nil { + return state.Stopped, nil + } + + return state.Running, nil +} + +func (d *Driver) Start() error { + return errors.New("generic driver does not support start") +} + +func (d *Driver) Stop() error { + return errors.New("generic driver does not support stop") +} + +func (d *Driver) Restart() error { + _, err := drivers.RunSSHCommandFromDriver(d, "sudo shutdown -r now") + return err +} + +func (d *Driver) Kill() error { + return errors.New("generic driver does not support kill") +} + +func (d *Driver) Remove() error { + return nil +} + +func copySSHKey(src, dst string) error { + if err := mcnutils.CopyFile(src, dst); err != nil { + return fmt.Errorf("unable to copy ssh key: %s", err) + } + + if err := os.Chmod(dst, 0600); err != nil { + return fmt.Errorf("unable to set permissions on the ssh key: %s", err) + } + + return nil +} diff --git a/pkg/minikube/registry/drvs/generic/generic.go b/pkg/minikube/registry/drvs/generic/generic.go index 93afecc13355..c24d2dab1326 100644 --- a/pkg/minikube/registry/drvs/generic/generic.go +++ b/pkg/minikube/registry/drvs/generic/generic.go @@ -19,10 +19,10 @@ package generic import ( "fmt" - "github.com/docker/machine/drivers/generic" "github.com/docker/machine/libmachine/drivers" "github.com/pkg/errors" + "k8s.io/minikube/pkg/drivers/generic" "k8s.io/minikube/pkg/minikube/config" "k8s.io/minikube/pkg/minikube/driver" "k8s.io/minikube/pkg/minikube/localpath" From a77e3de85f3bdb4f189592b1dd49641d6f3ae17c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Anders=20F=20Bj=C3=B6rklund?= Date: Wed, 6 Jan 2021 18:41:54 +0100 Subject: [PATCH 13/28] Use CommonDrivers and drop machine GetCreateFlags This makes the machine driver specific to minikube --- pkg/drivers/generic/generic.go | 41 ++----------------- pkg/minikube/registry/drvs/generic/generic.go | 8 ++-- 2 files changed, 7 insertions(+), 42 deletions(-) diff --git a/pkg/drivers/generic/generic.go b/pkg/drivers/generic/generic.go index b7a65e135f99..809bab0ddfed 100644 --- a/pkg/drivers/generic/generic.go +++ b/pkg/drivers/generic/generic.go @@ -28,13 +28,14 @@ import ( "github.com/docker/machine/libmachine/drivers" "github.com/docker/machine/libmachine/engine" "github.com/docker/machine/libmachine/log" - "github.com/docker/machine/libmachine/mcnflag" "github.com/docker/machine/libmachine/mcnutils" "github.com/docker/machine/libmachine/state" + pkgdrivers "k8s.io/minikube/pkg/drivers" ) type Driver struct { *drivers.BaseDriver + *pkgdrivers.CommonDriver EnginePort int SSHKey string } @@ -43,44 +44,8 @@ const ( defaultTimeout = 15 * time.Second ) -// GetCreateFlags registers the flags this driver adds to -// "docker hosts create" -func (d *Driver) GetCreateFlags() []mcnflag.Flag { - return []mcnflag.Flag{ - mcnflag.IntFlag{ - Name: "generic-engine-port", - Usage: "Docker engine port", - Value: engine.DefaultPort, - EnvVar: "GENERIC_ENGINE_PORT", - }, - mcnflag.StringFlag{ - Name: "generic-ip-address", - Usage: "IP Address of machine", - EnvVar: "GENERIC_IP_ADDRESS", - }, - mcnflag.StringFlag{ - Name: "generic-ssh-user", - Usage: "SSH user", - Value: drivers.DefaultSSHUser, - EnvVar: "GENERIC_SSH_USER", - }, - mcnflag.StringFlag{ - Name: "generic-ssh-key", - Usage: "SSH private key path (if not provided, default SSH key will be used)", - Value: "", - EnvVar: "GENERIC_SSH_KEY", - }, - mcnflag.IntFlag{ - Name: "generic-ssh-port", - Usage: "SSH port", - Value: drivers.DefaultSSHPort, - EnvVar: "GENERIC_SSH_PORT", - }, - } -} - // NewDriver creates and returns a new instance of the driver -func NewDriver(hostName, storePath string) drivers.Driver { +func NewDriver(hostName, storePath string) *Driver { return &Driver{ EnginePort: engine.DefaultPort, BaseDriver: &drivers.BaseDriver{ diff --git a/pkg/minikube/registry/drvs/generic/generic.go b/pkg/minikube/registry/drvs/generic/generic.go index c24d2dab1326..fc123db61770 100644 --- a/pkg/minikube/registry/drvs/generic/generic.go +++ b/pkg/minikube/registry/drvs/generic/generic.go @@ -49,10 +49,10 @@ func configure(cc config.ClusterConfig, n config.Node) (interface{}, error) { return nil, errors.Errorf("please provide an IP address") } - d.(*generic.Driver).IPAddress = cc.GenericIPAddress - d.(*generic.Driver).SSHUser = cc.GenericSSHUser - d.(*generic.Driver).SSHKey = cc.GenericSSHKey - d.(*generic.Driver).SSHPort = cc.GenericSSHPort + d.IPAddress = cc.GenericIPAddress + d.SSHUser = cc.GenericSSHUser + d.SSHKey = cc.GenericSSHKey + d.SSHPort = cc.GenericSSHPort return d, nil } From a120c543bf6e878c5c7ffc780ef617927c0ed89c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Anders=20F=20Bj=C3=B6rklund?= Date: Wed, 6 Jan 2021 20:03:58 +0100 Subject: [PATCH 14/28] Change meaning of Stop/Start/Restart to minikube The "none" driver has redefined stop and start to mean the kubelet rather than the host itself. Use the same API here. Killing actual containers remotely remains to be implemented. Only stop the kubelet service for now, and assuming systemd. --- pkg/drivers/generic/generic.go | 78 +++++++++++++++++++++++++++++++--- pkg/minikube/machine/fix.go | 9 ---- 2 files changed, 73 insertions(+), 14 deletions(-) diff --git a/pkg/drivers/generic/generic.go b/pkg/drivers/generic/generic.go index 809bab0ddfed..dd17d3948892 100644 --- a/pkg/drivers/generic/generic.go +++ b/pkg/drivers/generic/generic.go @@ -21,6 +21,7 @@ import ( "fmt" "net" "os" + "os/exec" "path" "strconv" "time" @@ -30,7 +31,10 @@ import ( "github.com/docker/machine/libmachine/log" "github.com/docker/machine/libmachine/mcnutils" "github.com/docker/machine/libmachine/state" + "k8s.io/klog/v2" pkgdrivers "k8s.io/minikube/pkg/drivers" + "k8s.io/minikube/pkg/minikube/command" + "k8s.io/minikube/pkg/minikube/sysinit" ) type Driver struct { @@ -143,21 +147,75 @@ func (d *Driver) GetState() (state.State, error) { return state.Running, nil } +// Start a host func (d *Driver) Start() error { - return errors.New("generic driver does not support start") + return nil } +// Stop a host gracefully, including any containers that we are managing. func (d *Driver) Stop() error { - return errors.New("generic driver does not support stop") + exec := command.NewSSHRunner(d) + if err := sysinit.New(exec).Stop("kubelet"); err != nil { + klog.Warningf("couldn't stop kubelet. will continue with stop anyways: %v", err) + if err := sysinit.New(exec).ForceStop("kubelet"); err != nil { + klog.Warningf("couldn't force stop kubelet. will continue with stop anyways: %v", err) + } + } + /* TODO + containers, err := d.runtime.ListContainers(cruntime.ListOptions{}) + if err != nil { + return errors.Wrap(err, "containers") + } + if len(containers) > 0 { + if err := d.runtime.StopContainers(containers); err != nil { + return errors.Wrap(err, "stop containers") + } + } + */ + klog.Infof("generic driver is stopped!") + return nil } +// Restart a host func (d *Driver) Restart() error { - _, err := drivers.RunSSHCommandFromDriver(d, "sudo shutdown -r now") - return err + exec := command.NewSSHRunner(d) + return restartKubelet(exec) } +// Kill stops a host forcefully, including any containers that we are managing. func (d *Driver) Kill() error { - return errors.New("generic driver does not support kill") + exec := command.NewSSHRunner(d) + if err := sysinit.New(exec).ForceStop("kubelet"); err != nil { + klog.Warningf("couldn't force stop kubelet. will continue with kill anyways: %v", err) + } + + /* TODO + // First try to gracefully stop containers + containers, err := d.runtime.ListContainers(cruntime.ListOptions{}) + if err != nil { + return errors.Wrap(err, "containers") + } + if len(containers) == 0 { + return nil + } + // Try to be graceful before sending SIGKILL everywhere. + if err := d.runtime.StopContainers(containers); err != nil { + return errors.Wrap(err, "stop") + } + + containers, err = d.runtime.ListContainers(cruntime.ListOptions{}) + if err != nil { + return errors.Wrap(err, "containers") + } + if len(containers) == 0 { + return nil + } + if err := d.runtime.KillContainers(containers); err != nil { + return errors.Wrap(err, "kill") + } + */ + return nil + } func (d *Driver) Remove() error { @@ -175,3 +233,13 @@ func copySSHKey(src, dst string) error { return nil } + +// restartKubelet restarts the kubelet +func restartKubelet(cr command.Runner) error { + klog.Infof("restarting kubelet.service ...") + c := exec.Command("sudo", "systemctl", "restart", "kubelet.service") + if _, err := cr.RunCmd(c); err != nil { + return err + } + return nil +} diff --git a/pkg/minikube/machine/fix.go b/pkg/minikube/machine/fix.go index 58e09eb8ee1e..8e0eeb7f77e4 100644 --- a/pkg/minikube/machine/fix.go +++ b/pkg/minikube/machine/fix.go @@ -129,15 +129,6 @@ func recreateIfNeeded(api libmachine.API, cc *config.ClusterConfig, n *config.No } } - if driver.IsGeneric(h.Driver.DriverName()) { - if s == state.Running { - out.Step(style.Running, `Using the {{.driver_name}} "{{.cluster}}" {{.machine_type}} ...`, out.V{"driver_name": cc.Driver, "cluster": cc.Name, "machine_type": machineType}) - } else { - return h, errors.Errorf("not running") - } - return h, nil - } - if serr != constants.ErrMachineMissing { klog.Warningf("unexpected machine state, will restart: %v", serr) } From 72a0fd66421a12046b1287d1321a5ebd418decdf Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Anders=20F=20Bj=C3=B6rklund?= Date: Wed, 6 Jan 2021 20:23:39 +0100 Subject: [PATCH 15/28] Move the constants for flag defaults from drivers Not using the default libmachine drivers anymore --- cmd/minikube/cmd/start_flags.go | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/cmd/minikube/cmd/start_flags.go b/cmd/minikube/cmd/start_flags.go index 7f659ceaf0ed..0dd437296fb3 100644 --- a/cmd/minikube/cmd/start_flags.go +++ b/cmd/minikube/cmd/start_flags.go @@ -22,7 +22,6 @@ import ( "time" "github.com/blang/semver" - "github.com/docker/machine/libmachine/drivers" "github.com/pkg/errors" "github.com/spf13/cobra" "github.com/spf13/viper" @@ -115,6 +114,8 @@ const ( genericSSHUser = "generic-ssh-user" genericSSHKey = "generic-ssh-key" genericSSHPort = "generic-ssh-port" + defaultSSHUser = "root" + defaultSSHPort = 22 ) var ( @@ -229,9 +230,9 @@ func initNetworkingFlags() { // generic startCmd.Flags().String(genericIPAddress, "", "IP address (generic)") - startCmd.Flags().String(genericSSHUser, drivers.DefaultSSHUser, "SSH user (generic)") + startCmd.Flags().String(genericSSHUser, defaultSSHUser, "SSH user (generic)") startCmd.Flags().String(genericSSHKey, "", "SSH key (generic)") - startCmd.Flags().Int(genericSSHPort, drivers.DefaultSSHPort, "SSH port (generic)") + startCmd.Flags().Int(genericSSHPort, defaultSSHPort, "SSH port (generic)") } // ClusterFlagValue returns the current cluster name based on flags From 1d6c86c8b5a6cbd0f1c1fa4b4976fa8b7b773fba Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Anders=20F=20Bj=C3=B6rklund?= Date: Wed, 6 Jan 2021 21:05:14 +0100 Subject: [PATCH 16/28] Also remove unused machine SetConfigFromFlags Setting the config directly instead in minikube --- pkg/drivers/generic/generic.go | 15 --------------- 1 file changed, 15 deletions(-) diff --git a/pkg/drivers/generic/generic.go b/pkg/drivers/generic/generic.go index dd17d3948892..63093b586b4b 100644 --- a/pkg/drivers/generic/generic.go +++ b/pkg/drivers/generic/generic.go @@ -17,7 +17,6 @@ limitations under the License. package generic import ( - "errors" "fmt" "net" "os" @@ -76,20 +75,6 @@ func (d *Driver) GetSSHKeyPath() string { return d.SSHKeyPath } -func (d *Driver) SetConfigFromFlags(flags drivers.DriverOptions) error { - d.EnginePort = flags.Int("generic-engine-port") - d.IPAddress = flags.String("generic-ip-address") - d.SSHUser = flags.String("generic-ssh-user") - d.SSHKey = flags.String("generic-ssh-key") - d.SSHPort = flags.Int("generic-ssh-port") - - if d.IPAddress == "" { - return errors.New("generic driver requires the --generic-ip-address option") - } - - return nil -} - func (d *Driver) PreCreateCheck() error { if d.SSHKey != "" { if _, err := os.Stat(d.SSHKey); os.IsNotExist(err) { From 1d5ee9e02e2553350a6e0c0fdd5a70ce8505bfde Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Anders=20F=20Bj=C3=B6rklund?= Date: Wed, 6 Jan 2021 21:15:45 +0100 Subject: [PATCH 17/28] OK to call Stop when implementation is changed --- pkg/minikube/machine/stop.go | 4 ---- 1 file changed, 4 deletions(-) diff --git a/pkg/minikube/machine/stop.go b/pkg/minikube/machine/stop.go index 56623d353526..3984f2e9aa0e 100644 --- a/pkg/minikube/machine/stop.go +++ b/pkg/minikube/machine/stop.go @@ -55,10 +55,6 @@ func stop(h *host.Host) error { } } - if driver.IsGeneric(h.DriverName) { - return nil - } - if err := h.Stop(); err != nil { klog.Infof("stop err: %v", err) st, ok := err.(mcnerror.ErrHostAlreadyInState) From 39218369c0600b1e17247f71fe40073467c4b68c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Anders=20F=20Bj=C3=B6rklund?= Date: Fri, 8 Jan 2021 07:54:51 +0100 Subject: [PATCH 18/28] Improve help text for generic driver flags --- cmd/minikube/cmd/start_flags.go | 8 ++++---- site/content/en/docs/commands/start.md | 8 ++++---- 2 files changed, 8 insertions(+), 8 deletions(-) diff --git a/cmd/minikube/cmd/start_flags.go b/cmd/minikube/cmd/start_flags.go index 810e933d6d82..491d760cba20 100644 --- a/cmd/minikube/cmd/start_flags.go +++ b/cmd/minikube/cmd/start_flags.go @@ -229,10 +229,10 @@ func initNetworkingFlags() { startCmd.Flags().StringArrayVar(&config.DockerOpt, "docker-opt", nil, "Specify arbitrary flags to pass to the Docker daemon. (format: key=value)") // generic - startCmd.Flags().String(genericIPAddress, "", "IP address (generic)") - startCmd.Flags().String(genericSSHUser, defaultSSHUser, "SSH user (generic)") - startCmd.Flags().String(genericSSHKey, "", "SSH key (generic)") - startCmd.Flags().Int(genericSSHPort, defaultSSHPort, "SSH port (generic)") + startCmd.Flags().String(genericIPAddress, "", "IP address (generic driver only)") + startCmd.Flags().String(genericSSHUser, defaultSSHUser, "SSH user (generic driver only)") + startCmd.Flags().String(genericSSHKey, "", "SSH key (generic driver only)") + startCmd.Flags().Int(genericSSHPort, defaultSSHPort, "SSH port (generic driver only)") } // ClusterFlagValue returns the current cluster name based on flags diff --git a/site/content/en/docs/commands/start.md b/site/content/en/docs/commands/start.md index 173d08c1bf4c..8f53c8d60039 100644 --- a/site/content/en/docs/commands/start.md +++ b/site/content/en/docs/commands/start.md @@ -51,10 +51,10 @@ minikube start [flags] --feature-gates string A set of key=value pairs that describe feature gates for alpha/experimental features. --force Force minikube to perform possibly dangerous operations --force-systemd If set, force the container runtime to use sytemd as cgroup manager. Defaults to false. - --generic-ip-address string IP address (generic) - --generic-ssh-key string SSH key (generic) - --generic-ssh-port int SSH port (generic) (default 22) - --generic-ssh-user string SSH user (generic) (default "root") + --generic-ip-address string IP address (generic driver only) + --generic-ssh-key string SSH key (generic driver only) + --generic-ssh-port int SSH port (generic driver only) (default 22) + --generic-ssh-user string SSH user (generic driver only) (default "root") --host-dns-resolver Enable host resolver for NAT DNS requests (virtualbox driver only) (default true) --host-only-cidr string The CIDR to be used for the minikube VM (virtualbox driver only) (default "192.168.99.1/24") --host-only-nic-type string NIC Type used for host only network. One of Am79C970A, Am79C973, 82540EM, 82543GC, 82545EM, or virtio (virtualbox driver only) (default "virtio") From d51443bee1478eca1c89670d114ab0c8bc1f90d7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Anders=20F=20Bj=C3=B6rklund?= Date: Thu, 29 Oct 2020 07:23:51 +0100 Subject: [PATCH 19/28] Show remote host info and proper progress --- cmd/minikube/cmd/start.go | 2 +- pkg/minikube/machine/info.go | 84 ++++++++++++++++++++++++++- pkg/minikube/machine/start.go | 25 +++++++- pkg/minikube/out/register/register.go | 2 + pkg/minikube/style/style.go | 1 + pkg/minikube/style/style_enum.go | 1 + 6 files changed, 109 insertions(+), 6 deletions(-) diff --git a/cmd/minikube/cmd/start.go b/cmd/minikube/cmd/start.go index a1325b733f89..8dfe887f5245 100644 --- a/cmd/minikube/cmd/start.go +++ b/cmd/minikube/cmd/start.go @@ -851,7 +851,7 @@ func validateUser(drvName string) { // memoryLimits returns the amount of memory allocated to the system and hypervisor, the return value is in MiB func memoryLimits(drvName string) (int, int, error) { - info, cpuErr, memErr, diskErr := machine.CachedHostInfo() + info, cpuErr, memErr, diskErr := machine.LocalHostInfo() if cpuErr != nil { klog.Warningf("could not get system cpu info while verifying memory limits, which might be okay: %v", cpuErr) } diff --git a/pkg/minikube/machine/info.go b/pkg/minikube/machine/info.go index d2f3066a7ed7..8c39b9d2649b 100644 --- a/pkg/minikube/machine/info.go +++ b/pkg/minikube/machine/info.go @@ -19,6 +19,8 @@ package machine import ( "io/ioutil" "os/exec" + "strconv" + "strings" "github.com/docker/machine/libmachine/provision" "github.com/shirou/gopsutil/cpu" @@ -39,8 +41,8 @@ type HostInfo struct { DiskSize int64 } -// CachedHostInfo returns system information such as memory,CPU, DiskSize -func CachedHostInfo() (*HostInfo, error, error, error) { +// LocalHostInfo returns system information such as memory,CPU, DiskSize +func LocalHostInfo() (*HostInfo, error, error, error) { var cpuErr, memErr, diskErr error i, cpuErr := cachedCPUInfo() if cpuErr != nil { @@ -63,6 +65,43 @@ func CachedHostInfo() (*HostInfo, error, error, error) { return &info, cpuErr, memErr, diskErr } +// RemoteHostInfo returns system information such as memory,CPU, DiskSize +func RemoteHostInfo(r command.Runner) (*HostInfo, error, error, error) { + rr, cpuErr := r.RunCmd(exec.Command("nproc")) + if cpuErr != nil { + klog.Warningf("Unable to get CPU info: %v", cpuErr) + } + nproc := rr.Stdout.String() + ncpus, err := strconv.Atoi(strings.TrimSpace(nproc)) + if err != nil { + klog.Warningf("Failed to parse CPU info: %v", err) + } + rr, memErr := r.RunCmd(exec.Command("free", "-m")) + if memErr != nil { + klog.Warningf("Unable to get mem info: %v", memErr) + } + free := rr.Stdout.String() + memory, err := parseMemFree(free) + if err != nil { + klog.Warningf("Unable to parse mem info: %v", err) + } + rr, diskErr := r.RunCmd(exec.Command("df", "-m")) + if diskErr != nil { + klog.Warningf("Unable to get disk info: %v", diskErr) + } + df := rr.Stdout.String() + disksize, err := parseDiskFree(df) + if err != nil { + klog.Warningf("Unable to parse disk info: %v", err) + } + + var info HostInfo + info.CPUs = ncpus + info.Memory = memory + info.DiskSize = disksize + return &info, cpuErr, memErr, diskErr +} + // showLocalOsRelease shows systemd information about the current linux distribution, on the local host func showLocalOsRelease() { osReleaseOut, err := ioutil.ReadFile("/etc/os-release") @@ -150,3 +189,44 @@ func cachedCPUInfo() ([]cpu.InfoStat, error) { } return *cachedCPU, *cachedCPUErr } + +// ParseMemFree parses the output of the `free -m` command +func parseMemFree(out string) (int64, error) { + // total used free shared buff/cache available + //Mem: 1987 706 194 1 1086 1173 + //Swap: 0 0 0 + outlines := strings.Split(out, "\n") + l := len(outlines) + for _, line := range outlines[1 : l-1] { + parsedLine := strings.Fields(line) + t, err := strconv.ParseInt(parsedLine[1], 10, 64) + if err != nil { + return 0, err + } + m := strings.Trim(parsedLine[0], ":") + if m == "Mem" { + return t, nil + } + } + return 0, nil +} + +// ParseDiskFree parses the output of the `df -m` command +func parseDiskFree(out string) (int64, error) { + // Filesystem 1M-blocks Used Available Use% Mounted on + // /dev/sda1 39643 3705 35922 10% / + outlines := strings.Split(out, "\n") + l := len(outlines) + for _, line := range outlines[1 : l-1] { + parsedLine := strings.Fields(line) + t, err := strconv.ParseInt(parsedLine[1], 10, 64) + if err != nil { + return 0, err + } + m := parsedLine[5] + if m == "/" { + return t, nil + } + } + return 0, nil +} diff --git a/pkg/minikube/machine/start.go b/pkg/minikube/machine/start.go index 689d1e90c2ec..06176eede250 100644 --- a/pkg/minikube/machine/start.go +++ b/pkg/minikube/machine/start.go @@ -129,7 +129,10 @@ func createHost(api libmachine.API, cfg *config.ClusterConfig, n *config.Node) ( klog.Infof("duration metric: createHost completed in %s", time.Since(start)) }() - showHostInfo(*cfg) + if cfg.Driver != driver.Generic { + showHostInfo(nil, *cfg) + } + def := registry.Driver(cfg.Driver) if def.Empty() { return nil, fmt.Errorf("unsupported/missing driver: %s", cfg.Driver) @@ -163,6 +166,9 @@ func createHost(api libmachine.API, cfg *config.ClusterConfig, n *config.Node) ( return nil, errors.Wrap(err, "creating host") } klog.Infof("duration metric: libmachine.API.Create for %q took %s", cfg.Name, time.Since(cstart)) + if cfg.Driver == driver.Generic { + showHostInfo(h, *cfg) + } if err := postStartSetup(h, *cfg); err != nil { return h, errors.Wrap(err, "post-start") @@ -320,16 +326,29 @@ func acquireMachinesLock(name string, drv string) (mutex.Releaser, error) { } // showHostInfo shows host information -func showHostInfo(cfg config.ClusterConfig) { +func showHostInfo(h *host.Host, cfg config.ClusterConfig) { machineType := driver.MachineType(cfg.Driver) if driver.BareMetal(cfg.Driver) { - info, cpuErr, memErr, DiskErr := CachedHostInfo() + info, cpuErr, memErr, DiskErr := LocalHostInfo() if cpuErr == nil && memErr == nil && DiskErr == nil { register.Reg.SetStep(register.RunningLocalhost) out.Step(style.StartingNone, "Running on localhost (CPUs={{.number_of_cpus}}, Memory={{.memory_size}}MB, Disk={{.disk_size}}MB) ...", out.V{"number_of_cpus": info.CPUs, "memory_size": info.Memory, "disk_size": info.DiskSize}) } return } + if cfg.Driver == driver.Generic { + r, err := CommandRunner(h) + if err != nil { + klog.Warningf("error getting command runner: %v", err) + return + } + info, cpuErr, memErr, DiskErr := RemoteHostInfo(r) + if cpuErr == nil && memErr == nil && DiskErr == nil { + register.Reg.SetStep(register.RunningRemotely) + out.Step(style.StartingGeneric, "Running remotely (CPUs={{.number_of_cpus}}, Memory={{.memory_size}}MB, Disk={{.disk_size}}MB) ...", out.V{"number_of_cpus": info.CPUs, "memory_size": info.Memory, "disk_size": info.DiskSize}) + } + return + } if driver.IsKIC(cfg.Driver) { // TODO:medyagh add free disk space on docker machine register.Reg.SetStep(register.CreatingContainer) out.Step(style.StartingVM, "Creating {{.driver_name}} {{.machine_type}} (CPUs={{.number_of_cpus}}, Memory={{.memory_size}}MB) ...", out.V{"driver_name": cfg.Driver, "number_of_cpus": cfg.CPUs, "memory_size": cfg.Memory, "machine_type": machineType}) diff --git a/pkg/minikube/out/register/register.go b/pkg/minikube/out/register/register.go index ebb6c13a4cd7..6b810b0e3059 100644 --- a/pkg/minikube/out/register/register.go +++ b/pkg/minikube/out/register/register.go @@ -32,6 +32,7 @@ const ( StartingNode RegStep = "Starting Node" PullingBaseImage RegStep = "Pulling Base Image" RunningLocalhost RegStep = "Running on Localhost" + RunningRemotely RegStep = "Running Remotely" LocalOSRelease RegStep = "Local OS Release" CreatingContainer RegStep = "Creating Container" CreatingVM RegStep = "Creating VM" @@ -79,6 +80,7 @@ func init() { LocalOSRelease, CreatingContainer, CreatingVM, + RunningRemotely, PreparingKubernetes, PreparingKubernetesCerts, PreparingKubernetesControlPlane, diff --git a/pkg/minikube/style/style.go b/pkg/minikube/style/style.go index 6707ab4fe1e1..c32116c671cc 100644 --- a/pkg/minikube/style/style.go +++ b/pkg/minikube/style/style.go @@ -126,6 +126,7 @@ var Config = map[Enum]Options{ Resetting: {Prefix: "๐Ÿ”„ "}, Shutdown: {Prefix: "๐Ÿ›‘ "}, StartingNone: {Prefix: "๐Ÿคน "}, + StartingGeneric: {Prefix: "๐Ÿ”— "}, StartingVM: {Prefix: "๐Ÿ”ฅ ", OmitNewline: true, Spinner: true}, SubStep: {Prefix: " โ–ช ", LowPrefix: LowIndent, OmitNewline: true, Spinner: true}, // Indented bullet Tip: {Prefix: "๐Ÿ’ก "}, diff --git a/pkg/minikube/style/style_enum.go b/pkg/minikube/style/style_enum.go index 63a6c49e9fc7..7ff5da49f8ef 100644 --- a/pkg/minikube/style/style_enum.go +++ b/pkg/minikube/style/style_enum.go @@ -81,6 +81,7 @@ const ( Shutdown Sparkle StartingNone + StartingGeneric StartingVM Stopped Stopping From 010e5fb5b0140b5f0b5664e18eaa549deb54bd72 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Anders=20F=20Bj=C3=B6rklund?= Date: Fri, 30 Oct 2020 12:13:15 +0100 Subject: [PATCH 20/28] Add some error checking on the parsed data fields --- pkg/minikube/machine/info.go | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-) diff --git a/pkg/minikube/machine/info.go b/pkg/minikube/machine/info.go index 8c39b9d2649b..e10c611d4697 100644 --- a/pkg/minikube/machine/info.go +++ b/pkg/minikube/machine/info.go @@ -17,6 +17,7 @@ limitations under the License. package machine import ( + "errors" "io/ioutil" "os/exec" "strconv" @@ -199,6 +200,9 @@ func parseMemFree(out string) (int64, error) { l := len(outlines) for _, line := range outlines[1 : l-1] { parsedLine := strings.Fields(line) + if len(parsedLine) < 7 { + continue + } t, err := strconv.ParseInt(parsedLine[1], 10, 64) if err != nil { return 0, err @@ -208,7 +212,7 @@ func parseMemFree(out string) (int64, error) { return t, nil } } - return 0, nil + return 0, errors.New("no matching data found") } // ParseDiskFree parses the output of the `df -m` command @@ -219,6 +223,9 @@ func parseDiskFree(out string) (int64, error) { l := len(outlines) for _, line := range outlines[1 : l-1] { parsedLine := strings.Fields(line) + if len(parsedLine) < 6 { + continue + } t, err := strconv.ParseInt(parsedLine[1], 10, 64) if err != nil { return 0, err @@ -228,5 +235,5 @@ func parseDiskFree(out string) (int64, error) { return t, nil } } - return 0, nil + return 0, errors.New("no matching data found") } From e4ebaeabf640172eb6c9f4c09407763f93ff9525 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Anders=20F=20Bj=C3=B6rklund?= Date: Fri, 8 Jan 2021 17:36:23 +0100 Subject: [PATCH 21/28] Complete the container runtime and config change --- pkg/drivers/generic/generic.go | 44 ++++++++++++------- pkg/minikube/registry/drvs/generic/generic.go | 8 +++- 2 files changed, 34 insertions(+), 18 deletions(-) diff --git a/pkg/drivers/generic/generic.go b/pkg/drivers/generic/generic.go index 63093b586b4b..b04811c3f0a1 100644 --- a/pkg/drivers/generic/generic.go +++ b/pkg/drivers/generic/generic.go @@ -30,9 +30,11 @@ import ( "github.com/docker/machine/libmachine/log" "github.com/docker/machine/libmachine/mcnutils" "github.com/docker/machine/libmachine/state" + "github.com/pkg/errors" "k8s.io/klog/v2" pkgdrivers "k8s.io/minikube/pkg/drivers" "k8s.io/minikube/pkg/minikube/command" + "k8s.io/minikube/pkg/minikube/cruntime" "k8s.io/minikube/pkg/minikube/sysinit" ) @@ -41,6 +43,15 @@ type Driver struct { *pkgdrivers.CommonDriver EnginePort int SSHKey string + runtime cruntime.Manager + exec command.Runner +} + +// Config is configuration for the Generic driver +type Config struct { + MachineName string + StorePath string + ContainerRuntime string } const ( @@ -48,14 +59,23 @@ const ( ) // NewDriver creates and returns a new instance of the driver -func NewDriver(hostName, storePath string) *Driver { - return &Driver{ +func NewDriver(c Config) *Driver { + d := &Driver{ EnginePort: engine.DefaultPort, BaseDriver: &drivers.BaseDriver{ - MachineName: hostName, - StorePath: storePath, + MachineName: c.MachineName, + StorePath: c.StorePath, }, } + runner := command.NewSSHRunner(d) + runtime, err := cruntime.New(cruntime.Config{Type: c.ContainerRuntime, Runner: runner}) + // Libraries shouldn't panic, but there is no way for drivers to return error :( + if err != nil { + klog.Fatalf("unable to create container runtime: %v", err) + } + d.runtime = runtime + d.exec = runner + return d } // DriverName returns the name of the driver @@ -139,14 +159,12 @@ func (d *Driver) Start() error { // Stop a host gracefully, including any containers that we are managing. func (d *Driver) Stop() error { - exec := command.NewSSHRunner(d) - if err := sysinit.New(exec).Stop("kubelet"); err != nil { + if err := sysinit.New(d.exec).Stop("kubelet"); err != nil { klog.Warningf("couldn't stop kubelet. will continue with stop anyways: %v", err) - if err := sysinit.New(exec).ForceStop("kubelet"); err != nil { + if err := sysinit.New(d.exec).ForceStop("kubelet"); err != nil { klog.Warningf("couldn't force stop kubelet. will continue with stop anyways: %v", err) } } - /* TODO containers, err := d.runtime.ListContainers(cruntime.ListOptions{}) if err != nil { return errors.Wrap(err, "containers") @@ -156,25 +174,21 @@ func (d *Driver) Stop() error { return errors.Wrap(err, "stop containers") } } - */ klog.Infof("generic driver is stopped!") return nil } // Restart a host func (d *Driver) Restart() error { - exec := command.NewSSHRunner(d) - return restartKubelet(exec) + return restartKubelet(d.exec) } // Kill stops a host forcefully, including any containers that we are managing. func (d *Driver) Kill() error { - exec := command.NewSSHRunner(d) - if err := sysinit.New(exec).ForceStop("kubelet"); err != nil { + if err := sysinit.New(d.exec).ForceStop("kubelet"); err != nil { klog.Warningf("couldn't force stop kubelet. will continue with kill anyways: %v", err) } - /* TODO // First try to gracefully stop containers containers, err := d.runtime.ListContainers(cruntime.ListOptions{}) if err != nil { @@ -198,9 +212,7 @@ func (d *Driver) Kill() error { if err := d.runtime.KillContainers(containers); err != nil { return errors.Wrap(err, "kill") } - */ return nil - } func (d *Driver) Remove() error { diff --git a/pkg/minikube/registry/drvs/generic/generic.go b/pkg/minikube/registry/drvs/generic/generic.go index fc123db61770..87d4ae048537 100644 --- a/pkg/minikube/registry/drvs/generic/generic.go +++ b/pkg/minikube/registry/drvs/generic/generic.go @@ -35,7 +35,7 @@ func init() { Config: configure, Status: status, Priority: registry.Fallback, - Init: func() drivers.Driver { return generic.NewDriver("", "") }, + Init: func() drivers.Driver { return generic.NewDriver(generic.Config{}) }, }) if err != nil { panic(fmt.Sprintf("unable to register: %v", err)) @@ -43,7 +43,11 @@ func init() { } func configure(cc config.ClusterConfig, n config.Node) (interface{}, error) { - d := generic.NewDriver(driver.MachineName(cc, n), localpath.MiniPath()) + d := generic.NewDriver(generic.Config{ + MachineName: driver.MachineName(cc, n), + StorePath: localpath.MiniPath(), + ContainerRuntime: cc.KubernetesConfig.ContainerRuntime, + }) if cc.GenericIPAddress == "" { return nil, errors.Errorf("please provide an IP address") From fb6cf6b6b6511c93cf6f07c6d48411c0bc3184ca Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Anders=20F=20Bj=C3=B6rklund?= Date: Fri, 8 Jan 2021 18:09:21 +0100 Subject: [PATCH 22/28] Add placeholder for docs for the generic driver But most of it is identical to the "none" driver --- pkg/drivers/generic/generic.go | 2 ++ site/content/en/docs/drivers/generic.md | 22 ++++++++++++++++ .../docs/drivers/includes/generic_usage.inc | 25 +++++++++++++++++++ 3 files changed, 49 insertions(+) create mode 100644 site/content/en/docs/drivers/generic.md create mode 100644 site/content/en/docs/drivers/includes/generic_usage.inc diff --git a/pkg/drivers/generic/generic.go b/pkg/drivers/generic/generic.go index b04811c3f0a1..dd8f8ca3d8a8 100644 --- a/pkg/drivers/generic/generic.go +++ b/pkg/drivers/generic/generic.go @@ -38,6 +38,8 @@ import ( "k8s.io/minikube/pkg/minikube/sysinit" ) +// Driver is a driver designed to run kubeadm w/o VM management. +// https://minikube.sigs.k8s.io/docs/reference/drivers/generic/ type Driver struct { *drivers.BaseDriver *pkgdrivers.CommonDriver diff --git a/site/content/en/docs/drivers/generic.md b/site/content/en/docs/drivers/generic.md new file mode 100644 index 000000000000..558c25b1b512 --- /dev/null +++ b/site/content/en/docs/drivers/generic.md @@ -0,0 +1,22 @@ +--- +title: "generic" +weight: 3 +description: > + Linux generic (remote) driver +aliases: + - /docs/reference/drivers/generic +--- + +## Overview + +This document is written for system integrators who wish to run minikube within a customized VM environment. The `generic` driver allows advanced minikube users to skip VM creation, allowing minikube to be run on a user-supplied VM. + +{{% readfile file="/docs/drivers/includes/generic_usage.inc" %}} + +## Issues + +* [Full list of open 'generic' driver issues](https://github.com/kubernetes/minikube/labels/co%2Fgeneric-driver) + +## Troubleshooting + +* Run `minikube start --alsologtostderr -v=4` to debug crashes diff --git a/site/content/en/docs/drivers/includes/generic_usage.inc b/site/content/en/docs/drivers/includes/generic_usage.inc new file mode 100644 index 000000000000..3a0d8a3bf7bb --- /dev/null +++ b/site/content/en/docs/drivers/includes/generic_usage.inc @@ -0,0 +1,25 @@ +## Requirements + +A Linux VM with the following: + +* systemd or OpenRC +* a container runtime, such as Docker or CRIO + +This VM must also meet the [kubeadm requirements](https://kubernetes.io/docs/setup/production-environment/tools/kubeadm/install-kubeadm/), such as: + +* 2 CPU's +* 2GB RAM +* iptables (in legacy mode) +* conntrack +* crictl +* SELinux permissive +* cgroups v1 (v2 is not yet supported by Kubernetes) + +## Usage + +The generic driver requires the IP address of the VM to use. + +```shell +minikube start --driver=generic --generic-ip-address=vm.example.com +``` + From 40ec0e8015a66fb9341df8066071471cf0975dbe Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Anders=20F=20Bj=C3=B6rklund?= Date: Fri, 8 Jan 2021 18:30:19 +0100 Subject: [PATCH 23/28] Avoid the hard-coded dependency on systemctl --- pkg/drivers/generic/generic.go | 16 ++++------------ 1 file changed, 4 insertions(+), 12 deletions(-) diff --git a/pkg/drivers/generic/generic.go b/pkg/drivers/generic/generic.go index dd8f8ca3d8a8..caf7062d9ca2 100644 --- a/pkg/drivers/generic/generic.go +++ b/pkg/drivers/generic/generic.go @@ -20,7 +20,6 @@ import ( "fmt" "net" "os" - "os/exec" "path" "strconv" "time" @@ -182,7 +181,10 @@ func (d *Driver) Stop() error { // Restart a host func (d *Driver) Restart() error { - return restartKubelet(d.exec) + if err := sysinit.New(d.exec).Restart("kubelet"); err != nil { + return err + } + return nil } // Kill stops a host forcefully, including any containers that we are managing. @@ -232,13 +234,3 @@ func copySSHKey(src, dst string) error { return nil } - -// restartKubelet restarts the kubelet -func restartKubelet(cr command.Runner) error { - klog.Infof("restarting kubelet.service ...") - c := exec.Command("sudo", "systemctl", "restart", "kubelet.service") - if _, err := cr.RunCmd(c); err != nil { - return err - } - return nil -} From b2121eae39c44d52c6d45aea5e866d59b3facb6f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Anders=20F=20Bj=C3=B6rklund?= Date: Sat, 9 Jan 2021 14:31:58 +0100 Subject: [PATCH 24/28] Rename the generic driver to the ssh driver Now that we have forked the machine driver --- cmd/minikube/cmd/delete.go | 2 +- cmd/minikube/cmd/start.go | 2 +- cmd/minikube/cmd/start_flags.go | 26 +++++++++---------- .../{generic/generic.go => ssh/ssh.go} | 10 +++---- pkg/minikube/cluster/ip.go | 2 +- pkg/minikube/config/types.go | 8 +++--- pkg/minikube/driver/driver.go | 14 +++++----- pkg/minikube/driver/driver_darwin.go | 2 +- pkg/minikube/driver/driver_linux.go | 2 +- pkg/minikube/driver/driver_test.go | 2 +- pkg/minikube/driver/driver_windows.go | 2 +- pkg/minikube/machine/machine.go | 2 +- pkg/minikube/machine/start.go | 12 ++++----- pkg/minikube/registry/drvs/init.go | 2 +- .../drvs/{generic/generic.go => ssh/ssh.go} | 21 ++++++++------- pkg/minikube/style/style.go | 2 +- pkg/minikube/style/style_enum.go | 2 +- site/content/en/docs/commands/start.md | 8 +++--- site/content/en/docs/drivers/generic.md | 22 ---------------- .../{generic_usage.inc => ssh_usage.inc} | 4 +-- site/content/en/docs/drivers/ssh.md | 22 ++++++++++++++++ 21 files changed, 86 insertions(+), 83 deletions(-) rename pkg/drivers/{generic/generic.go => ssh/ssh.go} (96%) rename pkg/minikube/registry/drvs/{generic/generic.go => ssh/ssh.go} (80%) delete mode 100644 site/content/en/docs/drivers/generic.md rename site/content/en/docs/drivers/includes/{generic_usage.inc => ssh_usage.inc} (77%) create mode 100644 site/content/en/docs/drivers/ssh.md diff --git a/cmd/minikube/cmd/delete.go b/cmd/minikube/cmd/delete.go index 846d03d294cc..b343f307cd83 100644 --- a/cmd/minikube/cmd/delete.go +++ b/cmd/minikube/cmd/delete.go @@ -309,7 +309,7 @@ func deleteProfile(profile *config.Profile) error { return DeletionError{Err: delErr, Errtype: MissingProfile} } - if err == nil && (driver.BareMetal(cc.Driver) || driver.IsGeneric(cc.Driver)) { + if err == nil && (driver.BareMetal(cc.Driver) || driver.IsSSH(cc.Driver)) { if err := uninstallKubernetes(api, *cc, cc.Nodes[0], viper.GetString(cmdcfg.Bootstrapper)); err != nil { deletionError, ok := err.(DeletionError) if ok { diff --git a/cmd/minikube/cmd/start.go b/cmd/minikube/cmd/start.go index 8dfe887f5245..81d00c24ff50 100644 --- a/cmd/minikube/cmd/start.go +++ b/cmd/minikube/cmd/start.go @@ -306,7 +306,7 @@ func provisionWithDriver(cmd *cobra.Command, ds registry.DriverState, existing * os.Exit(0) } - if driver.IsVM(driverName) && !driver.IsGeneric(driverName) { + if driver.IsVM(driverName) && !driver.IsSSH(driverName) { url, err := download.ISO(viper.GetStringSlice(isoURL), cmd.Flags().Changed(isoURL)) if err != nil { return node.Starter{}, errors.Wrap(err, "Failed to cache ISO") diff --git a/cmd/minikube/cmd/start_flags.go b/cmd/minikube/cmd/start_flags.go index 491d760cba20..adebc115b7c6 100644 --- a/cmd/minikube/cmd/start_flags.go +++ b/cmd/minikube/cmd/start_flags.go @@ -110,10 +110,10 @@ const ( network = "network" startNamespace = "namespace" trace = "trace" - genericIPAddress = "generic-ip-address" - genericSSHUser = "generic-ssh-user" - genericSSHKey = "generic-ssh-key" - genericSSHPort = "generic-ssh-port" + sshIPAddress = "ip-address" + sshSSHUser = "ssh-user" + sshSSHKey = "ssh-key" + sshSSHPort = "ssh-port" defaultSSHUser = "root" defaultSSHPort = 22 ) @@ -228,11 +228,11 @@ func initNetworkingFlags() { startCmd.Flags().StringArrayVar(&config.DockerEnv, "docker-env", nil, "Environment variables to pass to the Docker daemon. (format: key=value)") startCmd.Flags().StringArrayVar(&config.DockerOpt, "docker-opt", nil, "Specify arbitrary flags to pass to the Docker daemon. (format: key=value)") - // generic - startCmd.Flags().String(genericIPAddress, "", "IP address (generic driver only)") - startCmd.Flags().String(genericSSHUser, defaultSSHUser, "SSH user (generic driver only)") - startCmd.Flags().String(genericSSHKey, "", "SSH key (generic driver only)") - startCmd.Flags().Int(genericSSHPort, defaultSSHPort, "SSH port (generic driver only)") + // ssh + startCmd.Flags().String(sshIPAddress, "", "IP address (ssh driver only)") + startCmd.Flags().String(sshSSHUser, defaultSSHUser, "SSH user (ssh driver only)") + startCmd.Flags().String(sshSSHKey, "", "SSH key (ssh driver only)") + startCmd.Flags().Int(sshSSHPort, defaultSSHPort, "SSH port (ssh driver only)") } // ClusterFlagValue returns the current cluster name based on flags @@ -347,10 +347,10 @@ func generateClusterConfig(cmd *cobra.Command, existing *config.ClusterConfig, k NatNicType: viper.GetString(natNicType), StartHostTimeout: viper.GetDuration(waitTimeout), ExposedPorts: viper.GetStringSlice(ports), - GenericIPAddress: viper.GetString(genericIPAddress), - GenericSSHUser: viper.GetString(genericSSHUser), - GenericSSHKey: viper.GetString(genericSSHKey), - GenericSSHPort: viper.GetInt(genericSSHPort), + IPAddress: viper.GetString(sshIPAddress), + SSHUser: viper.GetString(sshSSHUser), + SSHKey: viper.GetString(sshSSHKey), + SSHPort: viper.GetInt(sshSSHPort), KubernetesConfig: config.KubernetesConfig{ KubernetesVersion: k8sVersion, ClusterName: ClusterFlagValue(), diff --git a/pkg/drivers/generic/generic.go b/pkg/drivers/ssh/ssh.go similarity index 96% rename from pkg/drivers/generic/generic.go rename to pkg/drivers/ssh/ssh.go index caf7062d9ca2..b3228fc17b61 100644 --- a/pkg/drivers/generic/generic.go +++ b/pkg/drivers/ssh/ssh.go @@ -14,7 +14,7 @@ See the License for the specific language governing permissions and limitations under the License. */ -package generic +package ssh import ( "fmt" @@ -38,7 +38,7 @@ import ( ) // Driver is a driver designed to run kubeadm w/o VM management. -// https://minikube.sigs.k8s.io/docs/reference/drivers/generic/ +// https://minikube.sigs.k8s.io/docs/reference/drivers/ssh/ type Driver struct { *drivers.BaseDriver *pkgdrivers.CommonDriver @@ -48,7 +48,7 @@ type Driver struct { exec command.Runner } -// Config is configuration for the Generic driver +// Config is configuration for the SSH driver type Config struct { MachineName string StorePath string @@ -81,7 +81,7 @@ func NewDriver(c Config) *Driver { // DriverName returns the name of the driver func (d *Driver) DriverName() string { - return "generic" + return "ssh" } func (d *Driver) GetSSHHostname() (string, error) { @@ -175,7 +175,7 @@ func (d *Driver) Stop() error { return errors.Wrap(err, "stop containers") } } - klog.Infof("generic driver is stopped!") + klog.Infof("ssh driver is stopped!") return nil } diff --git a/pkg/minikube/cluster/ip.go b/pkg/minikube/cluster/ip.go index 6a3522e67a61..54a715c3bd75 100644 --- a/pkg/minikube/cluster/ip.go +++ b/pkg/minikube/cluster/ip.go @@ -40,7 +40,7 @@ func HostIP(host *host.Host, clusterName string) (net.IP, error) { return oci.RoutableHostIPFromInside(oci.Docker, clusterName, host.Name) case driver.Podman: return oci.RoutableHostIPFromInside(oci.Podman, clusterName, host.Name) - case driver.Generic: + case driver.SSH: ip, err := host.Driver.GetIP() if err != nil { return []byte{}, errors.Wrap(err, "Error getting VM/Host IP address") diff --git a/pkg/minikube/config/types.go b/pkg/minikube/config/types.go index d4ccaa0555f2..332fcc57ced4 100644 --- a/pkg/minikube/config/types.go +++ b/pkg/minikube/config/types.go @@ -66,10 +66,10 @@ type ClusterConfig struct { HostDNSResolver bool // Only used by virtualbox HostOnlyNicType string // Only used by virtualbox NatNicType string // Only used by virtualbox - GenericIPAddress string // Only used by generic - GenericSSHUser string // Only used by generic - GenericSSHKey string // Only used by generic - GenericSSHPort int // Only used by generic + IPAddress string // Only used by ssh + SSHUser string // Only used by ssh + SSHKey string // Only used by ssh + SSHPort int // Only used by ssh KubernetesConfig KubernetesConfig Nodes []Node Addons map[string]bool diff --git a/pkg/minikube/driver/driver.go b/pkg/minikube/driver/driver.go index c1783f8ca346..fab519c46dbe 100644 --- a/pkg/minikube/driver/driver.go +++ b/pkg/minikube/driver/driver.go @@ -39,8 +39,8 @@ const ( Mock = "mock" // None driver None = "none" - // Generic driver - Generic = "generic" + // SSH driver + SSH = "ssh" // KVM2 driver KVM2 = "kvm2" // VirtualBox driver @@ -58,6 +58,8 @@ const ( // AliasKVM is driver name alias for kvm2 AliasKVM = "kvm" + // AliasSSH is driver name alias for ssh + AliasSSH = "generic" ) var ( @@ -99,7 +101,7 @@ func MachineType(name string) string { return "container" } - if IsGeneric(name) { + if IsSSH(name) { return "bare metal machine" } @@ -150,9 +152,9 @@ func BareMetal(name string) bool { return name == None || name == Mock } -// IsGeneric checks if the driver is generic -func IsGeneric(name string) bool { - return name == Generic +// IsSSH checks if the driver is ssh +func IsSSH(name string) bool { + return name == SSH } // NeedsPortForward returns true if driver is unable provide direct IP connectivity diff --git a/pkg/minikube/driver/driver_darwin.go b/pkg/minikube/driver/driver_darwin.go index 24a6e56d6c3d..1eef33635ddc 100644 --- a/pkg/minikube/driver/driver_darwin.go +++ b/pkg/minikube/driver/driver_darwin.go @@ -26,7 +26,7 @@ var supportedDrivers = []string{ HyperKit, VMware, Docker, - Generic, + SSH, } func VBoxManagePath() string { diff --git a/pkg/minikube/driver/driver_linux.go b/pkg/minikube/driver/driver_linux.go index 05784f946e08..a428a9a2bfe0 100644 --- a/pkg/minikube/driver/driver_linux.go +++ b/pkg/minikube/driver/driver_linux.go @@ -29,7 +29,7 @@ var supportedDrivers = []string{ None, Docker, Podman, - Generic, + SSH, } // VBoxManagePath returns the path to the VBoxManage command diff --git a/pkg/minikube/driver/driver_test.go b/pkg/minikube/driver/driver_test.go index 79e6b77893e2..10421a476b0f 100644 --- a/pkg/minikube/driver/driver_test.go +++ b/pkg/minikube/driver/driver_test.go @@ -65,7 +65,7 @@ func TestMachineType(t *testing.T) { Docker: "container", Mock: "bare metal machine", None: "bare metal machine", - Generic: "bare metal machine", + SSH: "bare metal machine", KVM2: "VM", VirtualBox: "VM", HyperKit: "VM", diff --git a/pkg/minikube/driver/driver_windows.go b/pkg/minikube/driver/driver_windows.go index 8a2f5a6a2a5f..1ebc9d5f1d62 100644 --- a/pkg/minikube/driver/driver_windows.go +++ b/pkg/minikube/driver/driver_windows.go @@ -33,7 +33,7 @@ var supportedDrivers = []string{ HyperV, VMware, Docker, - Generic, + SSH, } // TODO: medyagh add same check for kic docker diff --git a/pkg/minikube/machine/machine.go b/pkg/minikube/machine/machine.go index 2fdf60ba693a..a465694e0bdb 100644 --- a/pkg/minikube/machine/machine.go +++ b/pkg/minikube/machine/machine.go @@ -104,7 +104,7 @@ func fastDetectProvisioner(h *host.Host) (libprovision.Provisioner, error) { switch { case driver.IsKIC(d): return provision.NewUbuntuProvisioner(h.Driver), nil - case driver.BareMetal(d), driver.IsGeneric(d): + case driver.BareMetal(d), driver.IsSSH(d): return libprovision.DetectProvisioner(h.Driver) default: return provision.NewBuildrootProvisioner(h.Driver), nil diff --git a/pkg/minikube/machine/start.go b/pkg/minikube/machine/start.go index 06176eede250..7dd59164c2eb 100644 --- a/pkg/minikube/machine/start.go +++ b/pkg/minikube/machine/start.go @@ -129,7 +129,7 @@ func createHost(api libmachine.API, cfg *config.ClusterConfig, n *config.Node) ( klog.Infof("duration metric: createHost completed in %s", time.Since(start)) }() - if cfg.Driver != driver.Generic { + if cfg.Driver != driver.SSH { showHostInfo(nil, *cfg) } @@ -166,7 +166,7 @@ func createHost(api libmachine.API, cfg *config.ClusterConfig, n *config.Node) ( return nil, errors.Wrap(err, "creating host") } klog.Infof("duration metric: libmachine.API.Create for %q took %s", cfg.Name, time.Since(cstart)) - if cfg.Driver == driver.Generic { + if cfg.Driver == driver.SSH { showHostInfo(h, *cfg) } @@ -174,7 +174,7 @@ func createHost(api libmachine.API, cfg *config.ClusterConfig, n *config.Node) ( return h, errors.Wrap(err, "post-start") } - if driver.IsGeneric(h.Driver.DriverName()) { + if driver.IsSSH(h.Driver.DriverName()) { if _, err := h.RunSSHCommand(fmt.Sprintf("sudo usermod -aG docker %s", h.Driver.GetSSHUsername())); err != nil { return h, errors.Wrap(err, "usermod") } @@ -295,7 +295,7 @@ func postStartSetup(h *host.Host, mc config.ClusterConfig) error { if driver.BareMetal(mc.Driver) { showLocalOsRelease() } - if driver.IsVM(mc.Driver) || driver.IsKIC(mc.Driver) || driver.IsGeneric(mc.Driver) { + if driver.IsVM(mc.Driver) || driver.IsKIC(mc.Driver) || driver.IsSSH(mc.Driver) { logRemoteOsRelease(r) } return syncLocalAssets(r) @@ -336,7 +336,7 @@ func showHostInfo(h *host.Host, cfg config.ClusterConfig) { } return } - if cfg.Driver == driver.Generic { + if driver.IsSSH(cfg.Driver) { r, err := CommandRunner(h) if err != nil { klog.Warningf("error getting command runner: %v", err) @@ -345,7 +345,7 @@ func showHostInfo(h *host.Host, cfg config.ClusterConfig) { info, cpuErr, memErr, DiskErr := RemoteHostInfo(r) if cpuErr == nil && memErr == nil && DiskErr == nil { register.Reg.SetStep(register.RunningRemotely) - out.Step(style.StartingGeneric, "Running remotely (CPUs={{.number_of_cpus}}, Memory={{.memory_size}}MB, Disk={{.disk_size}}MB) ...", out.V{"number_of_cpus": info.CPUs, "memory_size": info.Memory, "disk_size": info.DiskSize}) + out.Step(style.StartingSSH, "Running remotely (CPUs={{.number_of_cpus}}, Memory={{.memory_size}}MB, Disk={{.disk_size}}MB) ...", out.V{"number_of_cpus": info.CPUs, "memory_size": info.Memory, "disk_size": info.DiskSize}) } return } diff --git a/pkg/minikube/registry/drvs/init.go b/pkg/minikube/registry/drvs/init.go index 2bd36761e79c..06b11158273f 100644 --- a/pkg/minikube/registry/drvs/init.go +++ b/pkg/minikube/registry/drvs/init.go @@ -19,13 +19,13 @@ package drvs import ( // Register all of the drvs we know of _ "k8s.io/minikube/pkg/minikube/registry/drvs/docker" - _ "k8s.io/minikube/pkg/minikube/registry/drvs/generic" _ "k8s.io/minikube/pkg/minikube/registry/drvs/hyperkit" _ "k8s.io/minikube/pkg/minikube/registry/drvs/hyperv" _ "k8s.io/minikube/pkg/minikube/registry/drvs/kvm2" _ "k8s.io/minikube/pkg/minikube/registry/drvs/none" _ "k8s.io/minikube/pkg/minikube/registry/drvs/parallels" _ "k8s.io/minikube/pkg/minikube/registry/drvs/podman" + _ "k8s.io/minikube/pkg/minikube/registry/drvs/ssh" _ "k8s.io/minikube/pkg/minikube/registry/drvs/virtualbox" _ "k8s.io/minikube/pkg/minikube/registry/drvs/vmware" _ "k8s.io/minikube/pkg/minikube/registry/drvs/vmwarefusion" diff --git a/pkg/minikube/registry/drvs/generic/generic.go b/pkg/minikube/registry/drvs/ssh/ssh.go similarity index 80% rename from pkg/minikube/registry/drvs/generic/generic.go rename to pkg/minikube/registry/drvs/ssh/ssh.go index 87d4ae048537..ad915914a8dc 100644 --- a/pkg/minikube/registry/drvs/generic/generic.go +++ b/pkg/minikube/registry/drvs/ssh/ssh.go @@ -14,7 +14,7 @@ See the License for the specific language governing permissions and limitations under the License. */ -package generic +package ssh import ( "fmt" @@ -22,7 +22,7 @@ import ( "github.com/docker/machine/libmachine/drivers" "github.com/pkg/errors" - "k8s.io/minikube/pkg/drivers/generic" + "k8s.io/minikube/pkg/drivers/ssh" "k8s.io/minikube/pkg/minikube/config" "k8s.io/minikube/pkg/minikube/driver" "k8s.io/minikube/pkg/minikube/localpath" @@ -31,11 +31,12 @@ import ( func init() { err := registry.Register(registry.DriverDef{ - Name: driver.Generic, + Name: driver.SSH, + Alias: []string{driver.AliasSSH}, Config: configure, Status: status, Priority: registry.Fallback, - Init: func() drivers.Driver { return generic.NewDriver(generic.Config{}) }, + Init: func() drivers.Driver { return ssh.NewDriver(ssh.Config{}) }, }) if err != nil { panic(fmt.Sprintf("unable to register: %v", err)) @@ -43,20 +44,20 @@ func init() { } func configure(cc config.ClusterConfig, n config.Node) (interface{}, error) { - d := generic.NewDriver(generic.Config{ + d := ssh.NewDriver(ssh.Config{ MachineName: driver.MachineName(cc, n), StorePath: localpath.MiniPath(), ContainerRuntime: cc.KubernetesConfig.ContainerRuntime, }) - if cc.GenericIPAddress == "" { + if cc.IPAddress == "" { return nil, errors.Errorf("please provide an IP address") } - d.IPAddress = cc.GenericIPAddress - d.SSHUser = cc.GenericSSHUser - d.SSHKey = cc.GenericSSHKey - d.SSHPort = cc.GenericSSHPort + d.IPAddress = cc.IPAddress + d.SSHUser = cc.SSHUser + d.SSHKey = cc.SSHKey + d.SSHPort = cc.SSHPort return d, nil } diff --git a/pkg/minikube/style/style.go b/pkg/minikube/style/style.go index c32116c671cc..3adc368609cd 100644 --- a/pkg/minikube/style/style.go +++ b/pkg/minikube/style/style.go @@ -126,7 +126,7 @@ var Config = map[Enum]Options{ Resetting: {Prefix: "๐Ÿ”„ "}, Shutdown: {Prefix: "๐Ÿ›‘ "}, StartingNone: {Prefix: "๐Ÿคน "}, - StartingGeneric: {Prefix: "๐Ÿ”— "}, + StartingSSH: {Prefix: "๐Ÿ”— "}, StartingVM: {Prefix: "๐Ÿ”ฅ ", OmitNewline: true, Spinner: true}, SubStep: {Prefix: " โ–ช ", LowPrefix: LowIndent, OmitNewline: true, Spinner: true}, // Indented bullet Tip: {Prefix: "๐Ÿ’ก "}, diff --git a/pkg/minikube/style/style_enum.go b/pkg/minikube/style/style_enum.go index 7ff5da49f8ef..7647fba2ea6d 100644 --- a/pkg/minikube/style/style_enum.go +++ b/pkg/minikube/style/style_enum.go @@ -81,7 +81,7 @@ const ( Shutdown Sparkle StartingNone - StartingGeneric + StartingSSH StartingVM Stopped Stopping diff --git a/site/content/en/docs/commands/start.md b/site/content/en/docs/commands/start.md index 8f53c8d60039..8b36a10f561e 100644 --- a/site/content/en/docs/commands/start.md +++ b/site/content/en/docs/commands/start.md @@ -51,10 +51,6 @@ minikube start [flags] --feature-gates string A set of key=value pairs that describe feature gates for alpha/experimental features. --force Force minikube to perform possibly dangerous operations --force-systemd If set, force the container runtime to use sytemd as cgroup manager. Defaults to false. - --generic-ip-address string IP address (generic driver only) - --generic-ssh-key string SSH key (generic driver only) - --generic-ssh-port int SSH port (generic driver only) (default 22) - --generic-ssh-user string SSH user (generic driver only) (default "root") --host-dns-resolver Enable host resolver for NAT DNS requests (virtualbox driver only) (default true) --host-only-cidr string The CIDR to be used for the minikube VM (virtualbox driver only) (default "192.168.99.1/24") --host-only-nic-type string NIC Type used for host only network. One of Am79C970A, Am79C973, 82540EM, 82543GC, 82545EM, or virtio (virtualbox driver only) (default "virtio") @@ -68,6 +64,7 @@ minikube start [flags] --insecure-registry strings Insecure Docker registries to pass to the Docker daemon. The default service CIDR range will automatically be added. --install-addons If set, install addons. Defaults to true. (default true) --interactive Allow user prompts for more information (default true) + --ip-address string IP address (ssh driver only) --iso-url strings Locations to fetch the minikube ISO from. (default [https://storage.googleapis.com/minikube/iso/minikube-v1.16.0.iso,https://github.com/kubernetes/minikube/releases/download/v1.16.0/minikube-v1.16.0.iso,https://kubernetes.oss-cn-hangzhou.aliyuncs.com/minikube/iso/minikube-v1.16.0.iso]) --keep-context This will keep the existing kubectl context and will create a minikube context. --kubernetes-version string The Kubernetes version that the minikube VM will use (ex: v1.2.3, 'stable' for v1.20.0, 'latest' for v1.20.0). Defaults to 'stable'. @@ -92,6 +89,9 @@ minikube start [flags] --preload If set, download tarball of preloaded images if available to improve start time. Defaults to true. (default true) --registry-mirror strings Registry mirrors to pass to the Docker daemon --service-cluster-ip-range string The CIDR to be used for service cluster IPs. (default "10.96.0.0/12") + --ssh-key string SSH key (ssh driver only) + --ssh-port int SSH port (ssh driver only) (default 22) + --ssh-user string SSH user (ssh driver only) (default "root") --trace string Send trace events. Options include: [gcp] --uuid string Provide VM UUID to restore MAC address (hyperkit driver only) --vm Filter to use only VM Drivers diff --git a/site/content/en/docs/drivers/generic.md b/site/content/en/docs/drivers/generic.md deleted file mode 100644 index 558c25b1b512..000000000000 --- a/site/content/en/docs/drivers/generic.md +++ /dev/null @@ -1,22 +0,0 @@ ---- -title: "generic" -weight: 3 -description: > - Linux generic (remote) driver -aliases: - - /docs/reference/drivers/generic ---- - -## Overview - -This document is written for system integrators who wish to run minikube within a customized VM environment. The `generic` driver allows advanced minikube users to skip VM creation, allowing minikube to be run on a user-supplied VM. - -{{% readfile file="/docs/drivers/includes/generic_usage.inc" %}} - -## Issues - -* [Full list of open 'generic' driver issues](https://github.com/kubernetes/minikube/labels/co%2Fgeneric-driver) - -## Troubleshooting - -* Run `minikube start --alsologtostderr -v=4` to debug crashes diff --git a/site/content/en/docs/drivers/includes/generic_usage.inc b/site/content/en/docs/drivers/includes/ssh_usage.inc similarity index 77% rename from site/content/en/docs/drivers/includes/generic_usage.inc rename to site/content/en/docs/drivers/includes/ssh_usage.inc index 3a0d8a3bf7bb..d4b48b82dbbc 100644 --- a/site/content/en/docs/drivers/includes/generic_usage.inc +++ b/site/content/en/docs/drivers/includes/ssh_usage.inc @@ -17,9 +17,9 @@ This VM must also meet the [kubeadm requirements](https://kubernetes.io/docs/set ## Usage -The generic driver requires the IP address of the VM to use. +The ssh driver requires the IP address of the VM to use. ```shell -minikube start --driver=generic --generic-ip-address=vm.example.com +minikube start --driver=ssh --ip-address=vm.example.com ``` diff --git a/site/content/en/docs/drivers/ssh.md b/site/content/en/docs/drivers/ssh.md new file mode 100644 index 000000000000..50777aed6ae3 --- /dev/null +++ b/site/content/en/docs/drivers/ssh.md @@ -0,0 +1,22 @@ +--- +title: "ssh" +weight: 3 +description: > + Linux ssh (remote) driver +aliases: + - /docs/reference/drivers/ssh +--- + +## Overview + +This document is written for system integrators who wish to run minikube within a customized VM environment. The `ssh` driver allows advanced minikube users to skip VM creation, allowing minikube to be run on a user-supplied VM. + +{{% readfile file="/docs/drivers/includes/ssh_usage.inc" %}} + +## Issues + +* [Full list of open 'ssh' driver issues](https://github.com/kubernetes/minikube/labels/co%2Fssh-driver) + +## Troubleshooting + +* Run `minikube start --alsologtostderr -v=4` to debug crashes From 1663a030ed55edc8fdcb68b25e4859c4c24b298a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Anders=20F=20Bj=C3=B6rklund?= Date: Mon, 11 Jan 2021 18:12:06 +0100 Subject: [PATCH 25/28] Only add docker group for the docker runtime --- pkg/drivers/ssh/ssh.go | 7 +++++++ pkg/minikube/machine/start.go | 6 ------ 2 files changed, 7 insertions(+), 6 deletions(-) diff --git a/pkg/drivers/ssh/ssh.go b/pkg/drivers/ssh/ssh.go index b3228fc17b61..59cb8170f080 100644 --- a/pkg/drivers/ssh/ssh.go +++ b/pkg/drivers/ssh/ssh.go @@ -20,6 +20,7 @@ import ( "fmt" "net" "os" + "os/exec" "path" "strconv" "time" @@ -124,6 +125,12 @@ func (d *Driver) Create() error { } } + if d.runtime.Name() == "Docker" { + if _, err := d.exec.RunCmd(exec.Command("sudo", "usermod", "-aG", "docker", d.GetSSHUsername())); err != nil { + return errors.Wrap(err, "usermod") + } + } + log.Debugf("IP: %s", d.IPAddress) return nil diff --git a/pkg/minikube/machine/start.go b/pkg/minikube/machine/start.go index 7dd59164c2eb..c664d69fd5d6 100644 --- a/pkg/minikube/machine/start.go +++ b/pkg/minikube/machine/start.go @@ -174,12 +174,6 @@ func createHost(api libmachine.API, cfg *config.ClusterConfig, n *config.Node) ( return h, errors.Wrap(err, "post-start") } - if driver.IsSSH(h.Driver.DriverName()) { - if _, err := h.RunSSHCommand(fmt.Sprintf("sudo usermod -aG docker %s", h.Driver.GetSSHUsername())); err != nil { - return h, errors.Wrap(err, "usermod") - } - } - if err := saveHost(api, h, cfg, n); err != nil { return h, err } From 529d2c3dde3cc8dc43217169e027b2734981353f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Anders=20F=20Bj=C3=B6rklund?= Date: Mon, 11 Jan 2021 18:15:59 +0100 Subject: [PATCH 26/28] Prevent trying to use localhost as address --- pkg/minikube/registry/drvs/ssh/ssh.go | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/pkg/minikube/registry/drvs/ssh/ssh.go b/pkg/minikube/registry/drvs/ssh/ssh.go index ad915914a8dc..8e53dd8adc68 100644 --- a/pkg/minikube/registry/drvs/ssh/ssh.go +++ b/pkg/minikube/registry/drvs/ssh/ssh.go @@ -54,6 +54,12 @@ func configure(cc config.ClusterConfig, n config.Node) (interface{}, error) { return nil, errors.Errorf("please provide an IP address") } + // We don't want the API server listening on loopback interface, + // even if we might use a tunneled VM port for the SSH service + if cc.IPAddress == "127.0.0.1" || cc.IPAddress == "localhost" { + return nil, errors.Errorf("please provide real IP address") + } + d.IPAddress = cc.IPAddress d.SSHUser = cc.SSHUser d.SSHKey = cc.SSHKey From 099c6b72a64ec892ed4cdd72744100a2a86393f2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Anders=20F=20Bj=C3=B6rklund?= Date: Wed, 13 Jan 2021 20:20:10 +0100 Subject: [PATCH 27/28] The MachineName function was moved to config --- pkg/minikube/registry/drvs/ssh/ssh.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pkg/minikube/registry/drvs/ssh/ssh.go b/pkg/minikube/registry/drvs/ssh/ssh.go index 8e53dd8adc68..83b26da36d75 100644 --- a/pkg/minikube/registry/drvs/ssh/ssh.go +++ b/pkg/minikube/registry/drvs/ssh/ssh.go @@ -45,7 +45,7 @@ func init() { func configure(cc config.ClusterConfig, n config.Node) (interface{}, error) { d := ssh.NewDriver(ssh.Config{ - MachineName: driver.MachineName(cc, n), + MachineName: config.MachineName(cc, n), StorePath: localpath.MiniPath(), ContainerRuntime: cc.KubernetesConfig.ContainerRuntime, }) From 541193c9459e172b45f6bc164e28ed6717ae1c61 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Anders=20F=20Bj=C3=B6rklund?= Date: Sat, 16 Jan 2021 14:43:40 +0100 Subject: [PATCH 28/28] Address review comments, rename to ssh-ip-address --- cmd/minikube/cmd/start_flags.go | 4 ++-- pkg/drivers/ssh/ssh.go | 2 -- pkg/minikube/config/types.go | 8 ++++---- pkg/minikube/registry/drvs/ssh/ssh.go | 6 +++--- site/content/en/docs/commands/start.md | 2 +- site/content/en/docs/drivers/includes/ssh_usage.inc | 2 +- 6 files changed, 11 insertions(+), 13 deletions(-) diff --git a/cmd/minikube/cmd/start_flags.go b/cmd/minikube/cmd/start_flags.go index adebc115b7c6..4893ab671852 100644 --- a/cmd/minikube/cmd/start_flags.go +++ b/cmd/minikube/cmd/start_flags.go @@ -110,7 +110,7 @@ const ( network = "network" startNamespace = "namespace" trace = "trace" - sshIPAddress = "ip-address" + sshIPAddress = "ssh-ip-address" sshSSHUser = "ssh-user" sshSSHKey = "ssh-key" sshSSHPort = "ssh-port" @@ -347,7 +347,7 @@ func generateClusterConfig(cmd *cobra.Command, existing *config.ClusterConfig, k NatNicType: viper.GetString(natNicType), StartHostTimeout: viper.GetDuration(waitTimeout), ExposedPorts: viper.GetStringSlice(ports), - IPAddress: viper.GetString(sshIPAddress), + SSHIPAddress: viper.GetString(sshIPAddress), SSHUser: viper.GetString(sshSSHUser), SSHKey: viper.GetString(sshSSHKey), SSHPort: viper.GetInt(sshSSHPort), diff --git a/pkg/drivers/ssh/ssh.go b/pkg/drivers/ssh/ssh.go index 59cb8170f080..d36fd8b073cf 100644 --- a/pkg/drivers/ssh/ssh.go +++ b/pkg/drivers/ssh/ssh.go @@ -102,8 +102,6 @@ func (d *Driver) PreCreateCheck() error { if _, err := os.Stat(d.SSHKey); os.IsNotExist(err) { return fmt.Errorf("SSH key does not exist: %q", d.SSHKey) } - - // TODO: validate the key is a valid key } return nil diff --git a/pkg/minikube/config/types.go b/pkg/minikube/config/types.go index 332fcc57ced4..fe533bf0a7e9 100644 --- a/pkg/minikube/config/types.go +++ b/pkg/minikube/config/types.go @@ -66,10 +66,10 @@ type ClusterConfig struct { HostDNSResolver bool // Only used by virtualbox HostOnlyNicType string // Only used by virtualbox NatNicType string // Only used by virtualbox - IPAddress string // Only used by ssh - SSHUser string // Only used by ssh - SSHKey string // Only used by ssh - SSHPort int // Only used by ssh + SSHIPAddress string // Only used by ssh driver + SSHUser string // Only used by ssh driver + SSHKey string // Only used by ssh driver + SSHPort int // Only used by ssh driver KubernetesConfig KubernetesConfig Nodes []Node Addons map[string]bool diff --git a/pkg/minikube/registry/drvs/ssh/ssh.go b/pkg/minikube/registry/drvs/ssh/ssh.go index 83b26da36d75..4d7446d6265f 100644 --- a/pkg/minikube/registry/drvs/ssh/ssh.go +++ b/pkg/minikube/registry/drvs/ssh/ssh.go @@ -50,17 +50,17 @@ func configure(cc config.ClusterConfig, n config.Node) (interface{}, error) { ContainerRuntime: cc.KubernetesConfig.ContainerRuntime, }) - if cc.IPAddress == "" { + if cc.SSHIPAddress == "" { return nil, errors.Errorf("please provide an IP address") } // We don't want the API server listening on loopback interface, // even if we might use a tunneled VM port for the SSH service - if cc.IPAddress == "127.0.0.1" || cc.IPAddress == "localhost" { + if cc.SSHIPAddress == "127.0.0.1" || cc.SSHIPAddress == "localhost" { return nil, errors.Errorf("please provide real IP address") } - d.IPAddress = cc.IPAddress + d.IPAddress = cc.SSHIPAddress d.SSHUser = cc.SSHUser d.SSHKey = cc.SSHKey d.SSHPort = cc.SSHPort diff --git a/site/content/en/docs/commands/start.md b/site/content/en/docs/commands/start.md index 83639c9d4ffe..13505e4190d3 100644 --- a/site/content/en/docs/commands/start.md +++ b/site/content/en/docs/commands/start.md @@ -64,7 +64,6 @@ minikube start [flags] --insecure-registry strings Insecure Docker registries to pass to the Docker daemon. The default service CIDR range will automatically be added. --install-addons If set, install addons. Defaults to true. (default true) --interactive Allow user prompts for more information (default true) - --ip-address string IP address (ssh driver only) --iso-url strings Locations to fetch the minikube ISO from. (default [https://storage.googleapis.com/minikube/iso/minikube-v1.16.0.iso,https://github.com/kubernetes/minikube/releases/download/v1.16.0/minikube-v1.16.0.iso,https://kubernetes.oss-cn-hangzhou.aliyuncs.com/minikube/iso/minikube-v1.16.0.iso]) --keep-context This will keep the existing kubectl context and will create a minikube context. --kubernetes-version string The Kubernetes version that the minikube VM will use (ex: v1.2.3, 'stable' for v1.20.0, 'latest' for v1.20.0). Defaults to 'stable'. @@ -89,6 +88,7 @@ minikube start [flags] --preload If set, download tarball of preloaded images if available to improve start time. Defaults to true. (default true) --registry-mirror strings Registry mirrors to pass to the Docker daemon --service-cluster-ip-range string The CIDR to be used for service cluster IPs. (default "10.96.0.0/12") + --ssh-ip-address string IP address (ssh driver only) --ssh-key string SSH key (ssh driver only) --ssh-port int SSH port (ssh driver only) (default 22) --ssh-user string SSH user (ssh driver only) (default "root") diff --git a/site/content/en/docs/drivers/includes/ssh_usage.inc b/site/content/en/docs/drivers/includes/ssh_usage.inc index d4b48b82dbbc..608383fe81cc 100644 --- a/site/content/en/docs/drivers/includes/ssh_usage.inc +++ b/site/content/en/docs/drivers/includes/ssh_usage.inc @@ -20,6 +20,6 @@ This VM must also meet the [kubeadm requirements](https://kubernetes.io/docs/set The ssh driver requires the IP address of the VM to use. ```shell -minikube start --driver=ssh --ip-address=vm.example.com +minikube start --driver=ssh --ssh-ip-address=vm.example.com ```