Merge pull request #4251 from twz123/main

Remove Docker container runtime support

Author: twz123

docs/experimental-windows.md

@@ -15,7 +15,7 @@ During the first run, the calico install script is created as `C:\bootstrap.ps1`
 Install Mirantis Container Runtime on the Windows node(s), as it is required for the initial Calico set up).
 
 ```shell
-k0s worker --cri-socket=docker:tcp://127.0.0.1:2375 --cidr-range=<cidr_range> --cluster-dns=<clusterdns> --api-server=<k0s api> <token>
+k0s worker --cri-socket=remote:npipe:////./pipe/containerd-containerd --cidr-range=<cidr_range> --cluster-dns=<clusterdns> --api-server=<k0s api> <token>
 ```
 
 You must initiate the Cluster control with the correct config.
@@ -76,4 +76,4 @@ spec:
   - name: iis
     image: mcr.microsoft.com/windows/servercore/iis
     imagePullPolicy: IfNotPresent
-```
+```

docs/runtime.md

@@ -189,7 +189,7 @@ EOF
 
 **Warning**: You can use your own CRI runtime with k0s (for example, `docker`). However, k0s will not start or manage the runtime, and configuration is solely your responsibility.
 
-Use the option `--cri-socket` to run a k0s worker with a custom CRI runtime. the option takes input in the form of `<type>:<socket_path>` (for `type`, use `docker` for a pure Docker setup and `remote` for anything else).
+Use the option `--cri-socket` to run a k0s worker with a custom CRI runtime. the option takes input in the form of `<type>:<url>` (the only supported type is `remote`).
 
 ### Using Docker as the container runtime
 
@@ -216,25 +216,25 @@ need to be taken:
   located at `/var/run/cri-dockerd.sock`. For instance, the commands to start a
   node would be as follows:
   
-      k0s worker --cri-socket=docker:unix:///var/run/cri-dockerd.sock
+      k0s worker --cri-socket=remote:unix:///var/run/cri-dockerd.sock
   
   or, respectively
 
   ```console
-  k0s controller --enable-worker --cri-socket=docker:unix:///var/run/cri-dockerd.sock
+  k0s controller --enable-worker --cri-socket=remote:unix:///var/run/cri-dockerd.sock
   ```
 
   When running k0s [as a service](cli/k0s_install.md), consider reinstalling the
   service with the appropriate flags:
 
   ```console
-  sudo k0s install --force worker --cri-socket=docker:unix:///var/run/cri-dockerd.sock
+  sudo k0s install --force worker --cri-socket=remote:unix:///var/run/cri-dockerd.sock
   ```
 
   or, respectively
 
   ```console
-  sudo k0s install --force controller --enable-worker --cri-socket=docker:unix:///var/run/cri-dockerd.sock
+  sudo k0s install --force controller --enable-worker --cri-socket=remote:unix:///var/run/cri-dockerd.sock
   ```
 
 In scenarios where Docker is managed via systemd, it is crucial that the

pkg/cleanup/cleanup_unix.go

@@ -43,31 +43,26 @@ type containerdConfig struct {
 	socketPath string
 }
 
-func NewConfig(k0sVars *config.CfgVars, cfgFile string, criSocketPath string) (*Config, error) {
+func NewConfig(k0sVars *config.CfgVars, cfgFile string, criSocketFlag string) (*Config, error) {
 	runDir := "/run/k0s" // https://github.com/k0sproject/k0s/pull/591/commits/c3f932de85a0b209908ad39b817750efc4987395
 
-	var err error
 	var containerdCfg *containerdConfig
-	var runtimeType string
 
-	if criSocketPath == "" {
-		criSocketPath = fmt.Sprintf("unix://%s/containerd.sock", runDir)
+	runtimeEndpoint, err := worker.GetContainerRuntimeEndpoint(criSocketFlag, runDir)
+	if err != nil {
+		return nil, err
+	}
+	if criSocketFlag == "" {
 		containerdCfg = &containerdConfig{
 			binPath:    fmt.Sprintf("%s/%s", k0sVars.DataDir, "bin/containerd"),
-			socketPath: fmt.Sprintf("%s/containerd.sock", runDir),
-		}
-		runtimeType = "cri"
-	} else {
-		runtimeType, criSocketPath, err = worker.SplitRuntimeConfig(criSocketPath)
-		if err != nil {
-			return nil, err
+			socketPath: runtimeEndpoint.Path,
 		}
 	}
 
 	return &Config{
 		cfgFile:          cfgFile,
 		containerd:       containerdCfg,
-		containerRuntime: runtime.NewContainerRuntime(runtimeType, criSocketPath),
+		containerRuntime: runtime.NewContainerRuntime(runtimeEndpoint),
 		dataDir:          k0sVars.DataDir,
 		runDir:           runDir,
 		k0sVars:          k0sVars,

pkg/component/worker/cri_runtime.go

@@ -17,23 +17,42 @@ limitations under the License.
 package worker
 
 import (
+	"errors"
 	"fmt"
+	"net/url"
+	"path/filepath"
+	"runtime"
 	"strings"
 )
 
-type RuntimeType = string
-type RuntimeSocket = string
+type RuntimeEndpoint = url.URL
+
+// Parses the CRI runtime flag and returns the parsed values.
+// If the flag is empty, provide k0s's defaults.
+func GetContainerRuntimeEndpoint(criSocketFlag, k0sRunDir string) (*RuntimeEndpoint, error) {
+	switch {
+	case criSocketFlag != "":
+		return parseCRISocketFlag(criSocketFlag)
+	case runtime.GOOS == "windows":
+		return &url.URL{Scheme: "npipe", Path: "//./pipe/containerd-containerd"}, nil
+	default:
+		socketPath := filepath.Join(k0sRunDir, "containerd.sock")
+		return &url.URL{Scheme: "unix", Path: filepath.ToSlash(socketPath)}, nil
+	}
+}
 
-func SplitRuntimeConfig(rtConfig string) (RuntimeType, RuntimeSocket, error) {
-	runtimeConfig := strings.SplitN(rtConfig, ":", 2)
-	if len(runtimeConfig) != 2 {
-		return "", "", fmt.Errorf("cannot parse CRI socket path")
+func parseCRISocketFlag(criSocketFlag string) (*RuntimeEndpoint, error) {
+	runtimeType, runtimeEndpoint, ok := strings.Cut(criSocketFlag, ":")
+	if !ok {
+		return nil, errors.New("CRI socket flag must be of the form <type>:<url>")
+	}
+	if runtimeType != "remote" {
+		return nil, fmt.Errorf(`unknown runtime type %q, only "remote" is supported`, runtimeType)
 	}
-	runtimeType := runtimeConfig[0]
-	runtimeSocket := runtimeConfig[1]
-	if runtimeType != "docker" && runtimeType != "remote" {
-		return "", "", fmt.Errorf("unknown runtime type %s, must be either of remote or docker", runtimeType)
+	parsedRuntimeEndpoint, err := url.Parse(runtimeEndpoint)
+	if err != nil {
+		return nil, fmt.Errorf("failed to parse runtime endpoint: %w", err)
 	}
 
-	return runtimeType, runtimeSocket, nil
+	return parsedRuntimeEndpoint, nil
 }

pkg/component/worker/cri_runtime_test.go

@@ -0,0 +1,102 @@
+/*
+Copyright 2024 k0s authors
+
+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 worker_test
+
+import (
+	"runtime"
+	"testing"
+
+	"github.com/k0sproject/k0s/pkg/component/worker"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestGetContainerRuntimeEndpoint_Defaults(t *testing.T) {
+	runtimeEndpoint, err := worker.GetContainerRuntimeEndpoint("", "/run/user/999")
+	assert.NoError(t, err)
+	if assert.NotNil(t, runtimeEndpoint) {
+		if runtime.GOOS == "windows" {
+			assert.Equal(t, "npipe:////./pipe/containerd-containerd", runtimeEndpoint.String())
+			assert.Equal(t, "//./pipe/containerd-containerd", runtimeEndpoint.Path)
+		} else {
+			assert.Equal(t, "unix:///run/user/999/containerd.sock", runtimeEndpoint.String())
+			assert.Equal(t, "/run/user/999/containerd.sock", runtimeEndpoint.Path)
+		}
+	}
+}
+
+func TestGetContainerRuntimeEndpoint_Flag(t *testing.T) {
+	cases := []struct {
+		name        string
+		flag        string
+		expEndpoint string
+		expPath     string
+		err         string
+	}{
+		{
+			name:        "containerd-unix",
+			flag:        "remote:unix:///var/run/mke/containerd.sock",
+			expEndpoint: "unix:///var/run/mke/containerd.sock",
+			expPath:     "/var/run/mke/containerd.sock",
+			err:         "",
+		},
+		{
+			name:        "containerd-windows",
+			flag:        "remote:npipe:////./pipe/containerd-containerd",
+			expEndpoint: "npipe:////./pipe/containerd-containerd",
+			expPath:     "//./pipe/containerd-containerd",
+			err:         "",
+		},
+		{
+			name:        "no-colon-in-flag",
+			flag:        "no-colon-in-flag",
+			expEndpoint: "",
+			expPath:     "",
+			err:         "CRI socket flag must be of the form <type>:<url>",
+		},
+		{
+			name:        "invalid-url",
+			flag:        "remote:u<nix:///foo",
+			expEndpoint: "",
+			expPath:     "",
+			err:         "failed to parse runtime endpoint: ",
+		},
+		{
+			name:        "unknown-type",
+			flag:        "foobar:unix:///var/run/mke/containerd.sock",
+			expEndpoint: "",
+			expPath:     "",
+			err:         `unknown runtime type "foobar", only "remote" is supported`,
+		},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			endpoint, err := worker.GetContainerRuntimeEndpoint(tc.flag, "y u use me?")
+			if tc.err != "" {
+				assert.ErrorContains(t, err, tc.err)
+				assert.Nil(t, endpoint)
+			} else {
+				assert.NoError(t, err)
+				if assert.NotNil(t, endpoint) {
+					assert.Equal(t, tc.expEndpoint, endpoint.String())
+					assert.Equal(t, tc.expPath, endpoint.Path)
+				}
+			}
+		})
+	}
+
+}

pkg/component/worker/kubelet.go

@@ -240,18 +240,11 @@ func (k *Kubelet) prepareLocalKubeletConfig(kubeletConfigData kubeletConfig) (st
 	preparedConfig.CgroupsPerQOS = ptr.To(kubeletConfigData.CgroupsPerQOS)
 	preparedConfig.StaticPodURL = kubeletConfigData.StaticPodURL
 
-	if k.CRISocket == "" && runtime.GOOS != "windows" {
-		socketPath := filepath.Join(k.K0sVars.RunDir, "containerd.sock")
-		preparedConfig.ContainerRuntimeEndpoint = "unix://" + filepath.ToSlash(socketPath)
-	} else if k.CRISocket == "" && runtime.GOOS == "windows" {
-		preparedConfig.ContainerRuntimeEndpoint = "npipe:////./pipe/containerd-containerd"
-	} else {
-		_, runtimeEndpoint, err := SplitRuntimeConfig(k.CRISocket)
-		if err != nil {
-			return "", err
-		}
-		preparedConfig.ContainerRuntimeEndpoint = runtimeEndpoint
+	containerRuntimeEndpoint, err := GetContainerRuntimeEndpoint(k.CRISocket, k.K0sVars.RunDir)
+	if err != nil {
+		return "", err
 	}
+	preparedConfig.ContainerRuntimeEndpoint = containerRuntimeEndpoint.String()
 
 	if len(k.Taints) > 0 {
 		var taints []corev1.Taint

pkg/component/worker/kubelet_test.go

@@ -27,51 +27,6 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-func TestCRISocketParsing(t *testing.T) {
-	cases := []struct {
-		name      string
-		input     string
-		expType   string
-		expSocket string
-		err       bool
-	}{
-		{
-			name:      "docker",
-			input:     "docker:unix:///var/run/docker.sock",
-			expType:   "docker",
-			expSocket: "unix:///var/run/docker.sock",
-			err:       false,
-		},
-		{
-			name:      "containerd",
-			input:     "remote:unix:///var/run/mke/containerd.sock",
-			expType:   "remote",
-			expSocket: "unix:///var/run/mke/containerd.sock",
-			err:       false,
-		},
-		{
-			name:      "unknown-type",
-			input:     "foobar:unix:///var/run/mke/containerd.sock",
-			expType:   "remote",
-			expSocket: "unix:///var/run/mke/containerd.sock",
-			err:       true,
-		},
-	}
-
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			criType, sock, err := SplitRuntimeConfig(tc.input)
-			if tc.err {
-				require.Error(t, err)
-			} else {
-				require.Equal(t, tc.expType, criType)
-				require.Equal(t, tc.expSocket, sock)
-			}
-		})
-	}
-
-}
-
 func TestParseTaints(t *testing.T) {
 	cases := []struct {
 		name          string