add ability to pass nolimit value to memory and cpus flags

Author: spowelljr

cmd/minikube/cmd/config/config.go

@@ -76,7 +76,7 @@ var settings = []Setting{
 	{
 		name:        "cpus",
 		set:         SetInt,
-		validations: []setFn{IsPositive},
+		validations: []setFn{IsValidCPUs},
 		callbacks:   []setFn{RequiresRestartMsg},
 	},
 	{

cmd/minikube/cmd/config/validations.go

@@ -25,6 +25,7 @@ import (
 	"strings"
 
 	units "github.com/docker/go-units"
+	"k8s.io/minikube/pkg/minikube/constants"
 	"k8s.io/minikube/pkg/minikube/cruntime"
 	"k8s.io/minikube/pkg/minikube/driver"
 	"k8s.io/minikube/pkg/minikube/out"
@@ -53,8 +54,19 @@ func IsValidDiskSize(name string, disksize string) error {
 	return nil
 }
 
+// IsValidCPUs checks if a string is a valid number of CPUs
+func IsValidCPUs(name string, cpus string) error {
+	if cpus == constants.NoLimit {
+		return nil
+	}
+	return IsPositive(name, cpus)
+}
+
 // IsValidMemory checks if a string is a valid memory size
 func IsValidMemory(name string, memsize string) error {
+	if memsize == constants.NoLimit {
+		return nil
+	}
 	_, err := units.FromHumanSize(memsize)
 	if err != nil {
 		return fmt.Errorf("invalid memory size: %v", err)

cmd/minikube/cmd/start.go

@@ -1045,11 +1045,8 @@ func validateCPUCount(drvName string) {
 		cpuCount = viper.GetInt(cpus)
 	}
 
-	if cpuCount < minimumCPUS {
-		exitIfNotForced(reason.RsrcInsufficientCores, "Requested cpu count {{.requested_cpus}} is less than the minimum allowed of {{.minimum_cpus}}", out.V{"requested_cpus": cpuCount, "minimum_cpus": minimumCPUS})
-	}
-
-	if !driver.IsKIC((drvName)) {
+	if !driver.IsKIC(drvName) {
+		validateMeetsMinimumCPURequirements(cpuCount, minimumCPUS)
 		return
 	}
 
@@ -1063,16 +1060,23 @@ func validateCPUCount(drvName string) {
 
 	}
 
+	if viper.GetString(cpus) == constants.NoLimit {
+		cpuCount = si.CPUs
+		viper.Set(cpus, cpuCount)
+	}
+
+	validateMeetsMinimumCPURequirements(cpuCount, minimumCPUS)
+
 	if si.CPUs < cpuCount {
 
 		if driver.IsDockerDesktop(drvName) {
 			out.Styled(style.Empty, `- Ensure your {{.driver_name}} daemon has access to enough CPU/memory resources.`, out.V{"driver_name": drvName})
 			if runtime.GOOS == "darwin" {
-				out.Styled(style.Empty, `- Docs https://docs.docker.com/docker-for-mac/#resources`, out.V{"driver_name": drvName})
+				out.Styled(style.Empty, `- Docs https://docs.docker.com/docker-for-mac/#resources`)
 			}
 			if runtime.GOOS == "windows" {
 				out.String("\n\t")
-				out.Styled(style.Empty, `- Docs https://docs.docker.com/docker-for-windows/#resources`, out.V{"driver_name": drvName})
+				out.Styled(style.Empty, `- Docs https://docs.docker.com/docker-for-windows/#resources`)
 			}
 		}
 
@@ -1093,6 +1097,12 @@ func validateCPUCount(drvName string) {
 	}
 }
 
+func validateMeetsMinimumCPURequirements(cpuCount int, minimumCPUs int) {
+	if cpuCount < minimumCPUS {
+		exitIfNotForced(reason.RsrcInsufficientCores, "Requested cpu count {{.requested_cpus}} is less than the minimum allowed of {{.minimum_cpus}}", out.V{"requested_cpus": cpuCount, "minimum_cpus": minimumCPUS})
+	}
+}
+
 // validateFlags validates the supplied flags against known bad combinations
 func validateFlags(cmd *cobra.Command, drvName string) {
 	if cmd.Flags().Changed(humanReadableDiskSize) {
@@ -1237,13 +1247,32 @@ func validateChangedMemoryFlags(drvName string) {
 	if !driver.HasResourceLimits(drvName) {
 		out.WarningT("The '{{.name}}' driver does not respect the --memory flag", out.V{"name": drvName})
 	}
-	req, err := util.CalculateSizeInMB(viper.GetString(memory))
-	if err != nil {
-		exitIfNotForced(reason.Usage, "Unable to parse memory '{{.memory}}': {{.error}}", out.V{"memory": viper.GetString(memory), "error": err})
+	var req int
+	var err error
+	memString := viper.GetString(memory)
+	if memString == constants.NoLimit {
+		sysLimit, containerLimit, err := memoryLimits(drvName)
+		if err != nil {
+			klog.Warningf("Unable to query memory limits: %+v", err)
+		}
+		req = noLimitMemory(sysLimit, containerLimit)
+	} else {
+		req, err = util.CalculateSizeInMB(memString)
+		if err != nil {
+			exitIfNotForced(reason.Usage, "Unable to parse memory '{{.memory}}': {{.error}}", out.V{"memory": memString, "error": err})
+		}
 	}
 	validateRequestedMemorySize(req, drvName)
 }
 
+func noLimitMemory(sysLimit int, containerLimit int) int {
+	if containerLimit != 0 {
+		return containerLimit
+	}
+	// Recommend 1GB to handle OS/VM overhead
+	return sysLimit - 1024
+}
+
 // This function validates if the --registry-mirror
 // args match the format of http://localhost
 func validateRegistryMirror() {

cmd/minikube/cmd/start_flags.go

@@ -135,8 +135,8 @@ func initMinikubeFlags() {
 	startCmd.Flags().Bool(interactive, true, "Allow user prompts for more information")
 	startCmd.Flags().Bool(dryRun, false, "dry-run mode. Validates configuration, but does not mutate system state")
 
-	startCmd.Flags().Int(cpus, 2, "Number of CPUs allocated to Kubernetes.")
-	startCmd.Flags().String(memory, "", "Amount of RAM to allocate to Kubernetes (format: <number>[<unit>], where unit = b, k, m or g).")
+	startCmd.Flags().String(cpus, "2", "Number of CPUs allocated to Kubernetes. Use 'nolimit' to use the maximum number of CPUs.")
+	startCmd.Flags().String(memory, "", "Amount of RAM to allocate to Kubernetes (format: <number>[<unit>], where unit = b, k, m or g). Use 'nolimit' to use the maximum amount of memory.")
 	startCmd.Flags().String(humanReadableDiskSize, defaultDiskSize, "Disk size allocated to the minikube VM (format: <number>[<unit>], where unit = b, k, m or g).")
 	startCmd.Flags().Bool(downloadOnly, false, "If true, only download and cache files for later use - don't install or start anything.")
 	startCmd.Flags().Bool(cacheImages, true, "If true, cache docker images for the current bootstrapper and load them into the machine. Always false with --driver=none.")
@@ -298,10 +298,15 @@ func getMemorySize(cmd *cobra.Command, drvName string) int {
 
 	mem := suggestMemoryAllocation(sysLimit, containerLimit, viper.GetInt(nodes))
 	if cmd.Flags().Changed(memory) || viper.IsSet(memory) {
+		memString := viper.GetString(memory)
 		var err error
-		mem, err = pkgutil.CalculateSizeInMB(viper.GetString(memory))
-		if err != nil {
-			exit.Message(reason.Usage, "Generate unable to parse memory '{{.memory}}': {{.error}}", out.V{"memory": viper.GetString(memory), "error": err})
+		if memString == constants.NoLimit {
+			mem = noLimitMemory(sysLimit, containerLimit)
+		} else {
+			mem, err = pkgutil.CalculateSizeInMB(memString)
+			if err != nil {
+				exit.Message(reason.Usage, "Generate unable to parse memory '{{.memory}}': {{.error}}", out.V{"memory": memString, "error": err})
+			}
 		}
 		if driver.IsKIC(drvName) && mem > containerLimit {
 			exit.Message(reason.Usage, "{{.driver_name}} has only {{.container_limit}}MB memory but you specified {{.specified_memory}}MB", out.V{"container_limit": containerLimit, "specified_memory": mem, "driver_name": driver.FullName(drvName)})

pkg/minikube/constants/constants.go

@@ -114,6 +114,8 @@ const (
 
 	// TimeFormat is the format that should be used when outputting time
 	TimeFormat = time.RFC1123
+	// NoLimit is the value that can be passed into the memory and cpus flags to specifiy to use maximum resources
+	NoLimit = "nolimit"
 )
 
 var (

site/content/en/docs/faq/_index.md

@@ -105,3 +105,9 @@ For the docker and podman driver, use `--listen-address` flag:
 minikube start --listen-address=0.0.0.0
 ```
 
+## How can I allocate maximum resources to minikube?
+
+Setting the `memory` and `cpus` flags on the start command to `nolimit` will use maximum available resources:
+```
+minikube start --memory=nolimit --cpus=nolimit
+```