diff --git a/pkg/cleanup/cleanup_unix.go b/pkg/cleanup/cleanup_unix.go
index 50c92195eadd..1679bdaf623e 100644
--- a/pkg/cleanup/cleanup_unix.go
+++ b/pkg/cleanup/cleanup_unix.go
@@ -48,11 +48,11 @@ func NewConfig(k0sVars *config.CfgVars, cfgFile string, criSocketFlag string) (*
 
 	var containerdCfg *containerdConfig
 
-	runtimeType, runtimeEndpoint, err := worker.GetContainerRuntimeEndpoint(criSocketFlag, runDir)
+	runtimeEndpoint, err := worker.GetContainerRuntimeEndpoint(criSocketFlag, runDir)
 	if err != nil {
 		return nil, err
 	}
-	if runtimeType == "" {
+	if criSocketFlag == "" {
 		containerdCfg = &containerdConfig{
 			binPath:    fmt.Sprintf("%s/%s", k0sVars.DataDir, "bin/containerd"),
 			socketPath: runtimeEndpoint.Path,
@@ -62,7 +62,7 @@ func NewConfig(k0sVars *config.CfgVars, cfgFile string, criSocketFlag string) (*
 	return &Config{
 		cfgFile:          cfgFile,
 		containerd:       containerdCfg,
-		containerRuntime: runtime.NewContainerRuntime(runtimeType, runtimeEndpoint),
+		containerRuntime: runtime.NewContainerRuntime(runtimeEndpoint),
 		dataDir:          k0sVars.DataDir,
 		runDir:           runDir,
 		k0sVars:          k0sVars,
diff --git a/pkg/component/worker/cri_runtime.go b/pkg/component/worker/cri_runtime.go
index 2ef6caeb527a..161651f2ee20 100644
--- a/pkg/component/worker/cri_runtime.go
+++ b/pkg/component/worker/cri_runtime.go
@@ -17,6 +17,7 @@ limitations under the License.
 package worker
 
 import (
+	"errors"
 	"fmt"
 	"net/url"
 	"path/filepath"
@@ -24,38 +25,34 @@ import (
 	"strings"
 )
 
-type RuntimeType = 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) (RuntimeType, *RuntimeEndpoint, error) {
+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
+		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
+		return &url.URL{Scheme: "unix", Path: filepath.ToSlash(socketPath)}, nil
 	}
 }
 
-func parseCRISocketFlag(criSocketFlag string) (RuntimeType, *RuntimeEndpoint, error) {
-	runtimeConfig := strings.SplitN(criSocketFlag, ":", 2)
-	if len(runtimeConfig) != 2 {
-		return "", nil, fmt.Errorf("cannot parse CRI socket flag")
+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>")
 	}
-	runtimeType := runtimeConfig[0]
-	runtimeEndpoint := runtimeConfig[1]
-	if runtimeType != "docker" && runtimeType != "remote" {
-		return "", nil, fmt.Errorf("unknown runtime type %s, must be either of remote or docker", runtimeType)
+	if runtimeType != "remote" {
+		return nil, fmt.Errorf(`unknown runtime type %q, only "remote" is supported`, runtimeType)
 	}
-
 	parsedRuntimeEndpoint, err := url.Parse(runtimeEndpoint)
 	if err != nil {
-		return "", nil, fmt.Errorf("failed to parse runtime endpoint: %w", err)
+		return nil, fmt.Errorf("failed to parse runtime endpoint: %w", err)
 	}
 
-	return runtimeType, parsedRuntimeEndpoint, nil
+	return parsedRuntimeEndpoint, nil
 }
diff --git a/pkg/component/worker/cri_runtime_test.go b/pkg/component/worker/cri_runtime_test.go
index 5962a4f06e74..c3f8d822551a 100644
--- a/pkg/component/worker/cri_runtime_test.go
+++ b/pkg/component/worker/cri_runtime_test.go
@@ -25,9 +25,8 @@ import (
 )
 
 func TestGetContainerRuntimeEndpoint_Defaults(t *testing.T) {
-	runtimeType, runtimeEndpoint, err := worker.GetContainerRuntimeEndpoint("", "/run/user/999")
+	runtimeEndpoint, err := worker.GetContainerRuntimeEndpoint("", "/run/user/999")
 	assert.NoError(t, err)
-	assert.Empty(t, runtimeType)
 	if assert.NotNil(t, runtimeEndpoint) {
 		if runtime.GOOS == "windows" {
 			assert.Equal(t, "npipe:////./pipe/containerd-containerd", runtimeEndpoint.String())
@@ -43,23 +42,13 @@ func TestGetContainerRuntimeEndpoint_Flag(t *testing.T) {
 	cases := []struct {
 		name        string
 		flag        string
-		expType     string
 		expEndpoint string
 		expPath     string
 		err         string
 	}{
-		{
-			name:        "docker",
-			flag:        "docker:unix:///var/run/docker.sock",
-			expType:     "docker",
-			expEndpoint: "unix:///var/run/docker.sock",
-			expPath:     "/var/run/docker.sock",
-			err:         "",
-		},
 		{
 			name:        "containerd-unix",
 			flag:        "remote:unix:///var/run/mke/containerd.sock",
-			expType:     "remote",
 			expEndpoint: "unix:///var/run/mke/containerd.sock",
 			expPath:     "/var/run/mke/containerd.sock",
 			err:         "",
@@ -74,15 +63,13 @@ func TestGetContainerRuntimeEndpoint_Flag(t *testing.T) {
 		{
 			name:        "no-colon-in-flag",
 			flag:        "no-colon-in-flag",
-			expType:     "",
 			expEndpoint: "",
 			expPath:     "",
-			err:         "cannot parse CRI socket flag",
+			err:         "CRI socket flag must be of the form <type>:<url>",
 		},
 		{
 			name:        "invalid-url",
 			flag:        "remote:u<nix:///foo",
-			expType:     "",
 			expEndpoint: "",
 			expPath:     "",
 			err:         "failed to parse runtime endpoint: ",
@@ -90,23 +77,20 @@ func TestGetContainerRuntimeEndpoint_Flag(t *testing.T) {
 		{
 			name:        "unknown-type",
 			flag:        "foobar:unix:///var/run/mke/containerd.sock",
-			expType:     "",
 			expEndpoint: "",
 			expPath:     "",
-			err:         "unknown runtime type foobar, must be either of remote or docker",
+			err:         `unknown runtime type "foobar", only "remote" is supported`,
 		},
 	}
 
 	for _, tc := range cases {
 		t.Run(tc.name, func(t *testing.T) {
-			criType, endpoint, err := worker.GetContainerRuntimeEndpoint(tc.flag, "y u use me?")
+			endpoint, err := worker.GetContainerRuntimeEndpoint(tc.flag, "y u use me?")
 			if tc.err != "" {
 				assert.ErrorContains(t, err, tc.err)
-				assert.Empty(t, criType)
 				assert.Nil(t, endpoint)
 			} else {
 				assert.NoError(t, err)
-				assert.Equal(t, tc.expType, criType)
 				if assert.NotNil(t, endpoint) {
 					assert.Equal(t, tc.expEndpoint, endpoint.String())
 					assert.Equal(t, tc.expPath, endpoint.Path)
diff --git a/pkg/component/worker/kubelet.go b/pkg/component/worker/kubelet.go
index f642d139e352..e7ffafdfa8c7 100644
--- a/pkg/component/worker/kubelet.go
+++ b/pkg/component/worker/kubelet.go
@@ -240,7 +240,7 @@ func (k *Kubelet) prepareLocalKubeletConfig(kubeletConfigData kubeletConfig) (st
 	preparedConfig.CgroupsPerQOS = ptr.To(kubeletConfigData.CgroupsPerQOS)
 	preparedConfig.StaticPodURL = kubeletConfigData.StaticPodURL
 
-	_, containerRuntimeEndpoint, err := GetContainerRuntimeEndpoint(k.CRISocket, k.K0sVars.RunDir)
+	containerRuntimeEndpoint, err := GetContainerRuntimeEndpoint(k.CRISocket, k.K0sVars.RunDir)
 	if err != nil {
 		return "", err
 	}
diff --git a/pkg/container/runtime/docker.go b/pkg/container/runtime/docker.go
deleted file mode 100644
index 208b38951fbe..000000000000
--- a/pkg/container/runtime/docker.go
+++ /dev/null
@@ -1,53 +0,0 @@
-/*
-Copyright 2021 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 runtime
-
-import (
-	"fmt"
-	"os/exec"
-	"strings"
-)
-
-var _ ContainerRuntime = (*DockerRuntime)(nil)
-
-type DockerRuntime struct {
-	criSocketPath string
-}
-
-func (d *DockerRuntime) ListContainers() ([]string, error) {
-	out, err := exec.Command("docker", "--host", d.criSocketPath, "ps", "-a", "--filter", "name=k8s_", "-q").CombinedOutput()
-	if err != nil {
-		return nil, fmt.Errorf("failed to list containers: output: %s: %w", string(out), err)
-	}
-	return strings.Fields(string(out)), nil
-}
-
-func (d *DockerRuntime) RemoveContainer(id string) error {
-	out, err := exec.Command("docker", "--host", d.criSocketPath, "rm", "--volumes", id).CombinedOutput()
-	if err != nil {
-		return fmt.Errorf("failed to remove container %s: output: %s: %w", id, string(out), err)
-	}
-	return nil
-}
-
-func (d *DockerRuntime) StopContainer(id string) error {
-	out, err := exec.Command("docker", "--host", d.criSocketPath, "stop", id).CombinedOutput()
-	if err != nil {
-		return fmt.Errorf("failed to stop running container %s: output: %s: %w", id, string(out), err)
-	}
-	return nil
-}
diff --git a/pkg/container/runtime/runtime.go b/pkg/container/runtime/runtime.go
index dd27a436e573..c2d9fa600041 100644
--- a/pkg/container/runtime/runtime.go
+++ b/pkg/container/runtime/runtime.go
@@ -24,9 +24,6 @@ type ContainerRuntime interface {
 	StopContainer(id string) error
 }
 
-func NewContainerRuntime(runtimeType string, runtimeEndpoint *url.URL) ContainerRuntime {
-	if runtimeType == "docker" {
-		return &DockerRuntime{runtimeEndpoint.String()}
-	}
+func NewContainerRuntime(runtimeEndpoint *url.URL) ContainerRuntime {
 	return &CRIRuntime{runtimeEndpoint.String()}
 }