I have several Docker images that I want to use with Minikube. I don't want to first have to upload and then download the same image instead of just using the local image directly. How do I do this?

我有几个Docker图像，我想用在Minikube上。我不想先上传然后下载相同的图像，而不是直接使用本地图像。我该怎么做呢？

Stuff I tried:

我试过的东西：

1. I tried running these commands (separately, deleting the instances of Minikube both times and starting fresh)

1.我尝试运行这些命令(分别删除Minikube实例两次并重新启动)

kubectl run hdfs --image=fluxcapacitor/hdfs:latest --port=8989
kubectl run hdfs --image=fluxcapacitor/hdfs:latest --port=8989 imagePullPolicy=Never

Output:

产出：

NAME                    READY     STATUS              RESTARTS   AGE
hdfs-2425930030-q0sdl   0/1       ContainerCreating   0          10m

It just gets stuck on some status but never reaches the ready state.

它只是停留在某些状态，但永远不会达到就绪状态。

2. I tried creating a registry and then putting images into it, but that didn't work either. I might've done that incorrectly but I can't find proper instructions to do this task.

2.我尝试创建一个注册表，然后将图像放入其中，但也不起作用。我可能做错了，但我找不到正确的指令来完成这项任务。

Please provide instructions to use local Docker images in a local Kubernetes instance.

请提供在本地Kubernetes实例中使用本地Docker镜像的说明。

OS: Ubuntu 16.04 (Xenial Xerus)

Docker: Docker version 1.13.1, build 092cba3

Kubernetes:

操作系统：Ubuntu 16.04(Xenial Xerus)Docker：Docker版本1.13.1，内部版本092cba3 Kubernetes：

Client Version: version.Info{Major:"1", Minor:"5", GitVersion:"v1.5.3", GitCommit:"029c3a408176b55c30846f0faedf56aae5992e9b", GitTreeState:"clean", BuildDate:"2017-02-15T06:40:50Z", GoVersion:"go1.7.4", Compiler:"gc", Platform:"linux/amd64"}
Server Version: version.Info{Major:"1", Minor:"5", GitVersion:"v1.5.2", GitCommit:"08e099554f3c31f6e6f07b448ab3ed78d0520507", GitTreeState:"clean", BuildDate:"1970-01-01T00:00:00Z", GoVersion:"go1.7.1", Compiler:"gc", Platform:"linux/amd64"}

What is a solution that uses docker-compose to do this?

使用docker-compose来完成此操作的解决方案是什么？

Images loaded in eval $(minikube docker-env):

已加载的图像在val$(mini kube docker-env)中：

Client Version: version.Info{Major:"1", Minor:"5", GitVersion:"v1.5.3", GitCommit:"029c3a408176b55c30846f0faedf56aae5992e9b", GitTreeState:"clean", BuildDate:"2017-02-15T06:40:50Z", GoVersion:"go1.7.4", Compiler:"gc", Platform:"linux/amd64"}
Server Version: version.Info{Major:"1", Minor:"5", GitVersion:"v1.5.2", GitCommit:"08e099554f3c31f6e6f07b448ab3ed78d0520507", GitTreeState:"clean", BuildDate:"1970-01-01T00:00:00Z", GoVersion:"go1.7.1", Compiler:"gc", Platform:"linux/amd64"}

What is a solution that uses docker-compose to do this?

使用docker-compose来完成此操作的解决方案是什么？

Images loaded in eval $(minikube docker-env):

已加载的图像在val$(mini kube docker-env)中：

REPOSITORY                                           TAG     IMAGE ID      CREATED       SIZE
fluxcapacitor/jupyterhub                             latest  e5175fb26522  4 weeks ago   9.59 GB
fluxcapacitor/zeppelin                               latest  fe4bc823e57d  4 weeks ago   4.12 GB
fluxcapacitor/prediction-pmml                        latest  cae5b2d9835b  4 weeks ago   973 MB
fluxcapacitor/scheduler-airflow                      latest  95adfd56f656  4 weeks ago   8.89 GB
fluxcapacitor/loadtest                               latest  6a777ab6167c  5 weeks ago   899 MB
fluxcapacitor/hdfs                                   latest  00fa0ed0064b  6 weeks ago   1.16 GB
fluxcapacitor/sql-mysql                              latest  804137671a8c  7 weeks ago   679 MB
fluxcapacitor/metastore-1.2.1                        latest  ea7ce8c5048f  7 weeks ago   1.35 GB
fluxcapacitor/cassandra                              latest  3cb5ff117283  7 weeks ago   953 MB
fluxcapacitor/apachespark-worker-2.0.1               latest  14ee3e4e337c  7 weeks ago   3.74 GB
fluxcapacitor/apachespark-master-2.0.1               latest  fe60b42d54e5  7 weeks ago   3.72 GB
fluxcapacitor/package-java-openjdk-1.8               latest  1db08965289d  7 weeks ago   841 MB
gcr.io/google_containers/kubernetes-dashboard-amd64  v1.5.1  1180413103fd  7 weeks ago   104 MB
fluxcapacitor/stream-kafka-0.10                      latest  f67750239f4d  2 months ago  1.14 GB
fluxcapacitor/pipeline                               latest  f6afd6c5745b  2 months ago  11.2 GB
gcr.io/google-containers/kube-addon-manager          v6.1    59e1315aa5ff  3 months ago  59.4 MB
gcr.io/google_containers/kubedns-amd64               1.9     26cf1ed9b144  3 months ago  47 MB
gcr.io/google_containers/kube-dnsmasq-amd64          1.4     3ec65756a89b  5 months ago  5.13 MB
gcr.io/google_containers/exechealthz-amd64           1.2     93a43bfb39bf  5 months ago  8.37 MB
gcr.io/google_containers/pause-amd64

优秀答案推荐

As the handbook describes, you can reuse the Docker daemon from Minikube with eval $(minikube docker-env).

正如手册中所描述的，您可以使用val$(mini kube docker-env)重用Minikube中的Docker守护进程。

So to use an image without uploading it, you can follow these steps:

因此，如果要在不上传图片的情况下使用图片，可以按照以下步骤操作：

1. Set the environment variables with eval $(minikube docker-env)


2. Build the image with the Docker daemon of Minikube (e.g., docker build -t my-image .)


3. Set the image in the pod specification like the build tag (e.g., my-image)


4. Set the imagePullPolicy to Never, otherwise Kubernetes will try to download the image.

Important note: You have to run eval $(minikube docker-env) on each terminal you want to use, since it only sets the environment variables for the current shell session.

重要提示：您必须在要使用的每个终端上运行val$(mini kube docker-env)，因为它只为当前的外壳会话设置环境变量。

What worked for me, based on the solution by svenwltr:

根据svenwltr的解决方案，对我起作用的是：

# Start minikube
minikube start

# Set docker env
eval $(minikube docker-env)             # Unix shells
minikube docker-env | Invoke-Expression # PowerShell

# Build image
docker build -t foo:0.0.1 .

# Run in Minikube
kubectl run hello-foo --image=foo:0.0.1 --image-pull-policy=Never

# Check that it's running
kubectl get pods

There is one easy and effective way to push your local Docker image directly to Minikube, which will save time from building the images in Minikube again.

有一种简单而有效的方法可以将您本地的Docker映像直接推送到Minikube，这将节省您再次在Minikube构建映像的时间。

minikube image load <image name>

(minikube cache add <image name>—the old deprecated way, for reference)

(Minikube缓存添加<图像名称>-旧的废弃方式，供参考)

More details are here.

更多细节在这里。

All possible method to push images to Minikube are mention here: Pushing images

这里提到了所有可能的将图片推送到Minikube的方法：推送图片

Notes:

• This answer isn’t limited to Minikube!

  这个答案并不局限于小久部！

  
  



• If wanting to create the registry on Minikube's Docker then run eval $(minikube docker-env) first (to make docker available on the host machine's terminal).
  
  Otherwise, enter in the virtual machine via minikube ssh, and then proceed with the following steps

  如果想要在Minikube的Docker上创建注册表，则首先运行val$(mini kube docker-env)(以使docker在主机的终端上可用)。否则，请通过mini kube ssh进入虚拟机，然后继续执行以下步骤

  
  



• depending on your operative system, Minikube will automatically mount your homepath onto the VM.

  根据您的操作系统，Minikube会自动将您的HomePath装载到VM上。

  
  



• as Eli stated, you'll need to add the local registry as insecure in order to use http (may not apply when using localhost, but it does apply if using the local hostname).
  Don't use http in production. Make the effort for securing things up.

  正如Eli所说，您需要将本地注册表添加为不安全才能使用http(使用本地主机时可能不适用，但如果使用本地主机名则适用)。在生产中不要使用http。尽最大努力把事情做好。

  
  

---

Use a local registry:

使用本地注册表：

docker run -d -p 5000:5000 --restart=always --name local-registry registry:2

Now tag your image properly:

现在，正确地标记您的图像：

docker tag ubuntu localhost:5000/ubuntu

Note that localhost should be changed to the DNS name of the machine running registry container.

请注意，本地主机应该更改为运行注册表容器的计算机的DNS名称。

Now push your image to the local registry:

现在将您的映像推送到本地注册表：

docker push localhost:5000/ubuntu

You should be able to pull it back:

你应该可以把它拉回来：

docker pull localhost:5000/ubuntu

Now change your YAML file to use the local registry.

现在更改您的YAML文件以使用本地注册表。

Think about mounting volumes at appropriate location, to persist the images on the registry.

考虑在适当的位置装入卷，以将映像持久保存在注册表中。

Adding to to Farhad's answer based on this answer,

除了法哈德基于这个答案的回答之外，

These are the steps to set up a local registry.

以下是设置本地注册表的步骤。

Set up in local machine

在本地计算机中设置

Set up the hostname in the local machine: edit /etc/hosts to add this line:

在本地计算机中设置主机名：编辑/etc/hosts以添加以下行：

docker.local 127.0.0.1

Now start a local registry (remove -d to run non-daemon mode):

现在启动本地注册表(删除-d以运行非守护程序模式)：

docker run -d -p 5000:5000 --restart=always --name registry registry:2

Now tag your image properly:

现在，正确地标记您的图像：

docker tag ubuntu docker.local:5000/ubuntu

Now push your image to the local registry:

现在将您的映像推送到本地注册表：

docker push docker.local:5000/ubuntu

Verify that the image is pushed:

验证是否推送了该镜像：

curl -X GET http://docker.local:5000/v2/ubuntu/tags/list

Set up in Minikube

在Minkube设立

SSH into Minikube with: minukube ssh

使用SSH进入minkube：minukube ssh

Edit /etc/hosts to add this line:

编辑/ETC/Hosts以添加此行：

docker.local <your host machine's IP address>

Verify access:

验证访问权限：

curl -X GET http://docker.local:5000/v2/ubuntu/tags/list

Now if you try to pull, yo might get an http access error.

现在，如果您尝试拉，您可能会得到一个http访问错误。

Enable insecure access:

启用不安全访问：

If you are always planning to use Minikube with this local setup then create a Minikube instance to use the insecure registry by default (it won’t work on an existing cluster).

如果您总是计划在此本地设置中使用Minikube，那么创建一个Minikube实例以在默认情况下使用不安全的注册表(它不能在现有集群上工作)。

minikube start --insecure-registry="docker.local:5000"

Else follow the below steps:

否则，请执行以下步骤：

systemctl stop docker

Edit the Docker serice file: get path from systemctl status docker

编辑Docker服务文件：从系统ctl状态docker获取路径

It might be:

它可能是：

/etc/systemd/system/docker.service.d/10-machine.conf or
/usr/lib/systemd/system/docker.service

Append this text (replace 192.168.1.4 with your IP address)

追加此文本(将192.168.1.4替换为您的IP地址)

--insecure-registry docker.local:5000 --insecure-registry 192.168.1.4:5000

to this line

到这条线上

ExecStart=/usr/bin/docker daemon -H tcp://0.0.0.0:2376 -H unix:///var/run/docker.sock --tlsverify --tlscacert /etc/docker/ca.pem --tlscert /etc/docker/server.pem --tlskey /etc/docker/server-key.pem --label provider=virtualbox --insecure-registry 10.0.0.0/24

And:

以及：

systemctl daemon-reload
systemctl start docker

Try pulling:

试着拉：

docker pull docker.local:5000/ubuntu

Now change your YAML file to use the local registry.

现在更改您的YAML文件以使用本地注册表。

containers:
  - name: ampl-django
       image: dockerhub/ubuntu

to

至

containers:
  - name: ampl-django
    image: docker.local:5000/nymbleup

Don't use http in production. Make the effort for securing things up.

在生产中不要使用http。尽最大努力把事情做好。

Newer versions of Minikube allows you to load an image from the local Docker instance by running:

较新版本的Minikube允许您通过运行以下命令从本地Docker实例加载镜像：

minikube image rm image <imagename>:<version>
minikube image load <imagename>:<version> --daemon

The load command might show an error, but the image still gets loaded to your Minikube instance.

LOAD命令可能会显示错误，但图像仍会加载到您的Minikube实例中。

One thing to remember regarding Minikube is that Minikube's host is not the same as your local host, therefore, what I realized, that in order to use local images for testing with Minikube you must build your Docker image first locally or pull it locally and then add it using the command below into the Minikube context which is, nothing else as another Linux instance.

关于Minikube需要记住的一件事是，Minikube的主机与您的本地主机不同，因此，我意识到，为了使用本地映像进行Minikube测试，您必须首先在本地构建您的Docker映像，或者在本地拉入它，然后使用下面的命令将其添加到Minikube上下文中，也就是说，没有其他内容作为另一个Linux实例。

 minikube cache add <image>:<tag>

Yet, don't forget to set the imagePullPolicy: Never in your Kubernetes deployment YAML files, as it will ensure using locally added images instead of trying pull it remotely from the registry.

但是，不要忘记在您的Kubernetes部署YAML文件中设置ImagePullPolicy：Never，因为它将确保使用本地添加的映像，而不是尝试从注册表远程拉取它。

Note: minikube cache will be deprecated in upcoming versions. Please switch to minikube image load

注意：Minikube缓存将在即将发布的版本中弃用。请切换到mini kube图像加载

One approach is to build the image locally and then do:

一种方法是在本地构建映像，然后执行以下操作：

docker save imageNameGoesHere | pv | (eval $(minikube docker-env) && docker load)

minikube docker-env might not return the correct info running under a different user / sudo. Instead you can run sudo -u yourUsername minikube docker-env.

Mini kube docker-env可能无法返回在不同用户/sudo下运行的正确信息。相反，您可以运行sudo-u YourUserName mini kube docker-env。

It should return something like:

它应该返回如下内容：

export DOCKER_TLS_VERIFY="1"
export DOCKER_HOST="tcp://192.168.99.100:2376"
export DOCKER_CERT_PATH="/home/chris/.minikube/certs"
export DOCKER_API_VERSION="1.23"
# Run this command to configure your shell:
# eval $(minikube docker-env)

In addition to the accepted answer, you can also achieve what you originally wanted (creating a deployment using the run command) with the following command:

除了接受的答案之外，您还可以使用以下命令实现您最初想要的结果(使用Run命令创建展开)：

kubectl run hdfs --image=fluxcapacitor/hdfs:latest --port=8989 --generator=run-pod/v1

I found the information about the generator on the Kubernetes-dev forum:

我在Kubernetes-dev论坛上找到了关于生成器的信息：

If you're using kubectl run, it generates a manifest for you that happens to have imagePullPolicy set to Always by default. You can use this command to get an imagePullPolicy of IfNotPresent, which will work for minikube:

kubectl run --image=<container> --generator=run-pod/v1

Dan Lorenc

https://groups.google.com/forum/#!topic/kubernetes-dev/YfvWuFr_XOM

Https://groups.google.com/forum/#！topic/kubernetes-dev/YfvWuFr_XOM

If anyone is looking to come back to the local environment after setting the Minikube environment, use the following command.

如果任何人希望在设置Minikube环境后返回到本地环境，请使用以下命令。

eval $(docker-machine env -u)

A simpler method that answers the question "How can I use local docker images with Minikube?", is to save the image to a tar file and load it into Minikube:

更简单的方法是将图像保存到tar文件中，然后将其加载到Minikube中：

# Export the Docker image to a tar file
docker save --output my-image.tar the.full.path.to/the/docker/image:the-tag
# Set local environment variables so that docker commands go to the Docker in Minikube
eval $(minikube docker-env)
# Or if on Windows: @FOR /f "tokens=*" %i IN ('minikube docker-env') DO @%i
# Import the Docker image from the tar file into Minikube
docker load --input my-image.tar
# Cleanup - put Docker back to normal
eval $(minikube docker-env -u)
# Or if on Windows: @FOR /f "tokens=*" %i IN ('minikube docker-env -u') DO @%i

Then running the image involves a command like the following. Make sure to include the "--image-pull-policy=Never" parameter.

然后，运行映像涉及到如下命令。确保包含“--image-pull-policy=Never”参数。

kubectl run my-image --image=the.full.path.to/the/docker/image:the-tag --image-pull-policy=Never --port=80

For Windows users, the way I do it.

对于Windows用户，我做到了这一点。

I use the docker desktop to host my MiniKube image and use PowerShell as a console.

我使用docker桌面来托管我的MiniKube映像，并使用PowerShell作为控制台。

First I create my MiniKube cluster:

首先，我创建了我的MiniKube集群：

minikube start --bootstrapper=kubeadm --vm-driver=docker --profile "cluster1"

For instance, let's say I have a Dockerfile contains:

例如，假设我有一个包含以下内容的Dockerfile：

FROM nginx

2 steps way, Build an image and Upload the image to minikube

两步法，构建镜像并将镜像上传到mini kube

docker build -t mynginximage .
minikube image load mynginximage

Or 1 step way, Build directly in MiniKube

或者一步一步，直接在MiniKube中构建

minikube image build -t mynginximage .

To run my image in MiniKube

在MiniKube中运行我的图像

kubectl run myweb --image=mynginximage --image-pull-policy=Never

or via mynginxpod.yaml file:

或通过mynginxpod.yaml文件：

apiVersion: v1
kind: Pod
metadata:
  name: myweb
spec:
  containers:
    - name: myweb
      image: mynginximage
      imagePullPolicy: Never
      ports:
        - containerPort: 80

And kubectl apply -f .\mynginxpod.yaml

和kubectl应用-f.\mynginxpod.yaml

Now to test it, run:

现在要测试它，运行：

kubectl get pods myweb
NAME    READY   STATUS    RESTARTS   AGE
myweb   1/1     Running   0          25s

To access it:

要访问它，请执行以下操作：

kubectl exec --stdin --tty myweb -- /bin/bash

To expose it:

要揭露它：

kubectl port-forward nginx 3333:80

From the Kubernetes documentation:

来自Kubernetes文档：

Updating images

正在更新图像

The default pull policy is IfNotPresent which causes the Kubelet to skip pulling an image if it already exists. If you would like to always force a pull, you can do one of the following:

• set the imagePullPolicy of the container to Always;


• use :latest as the tag for the image to use;


• enable the AlwaysPullImages admission controller.

Or read the other way: Using the :latest tag forces images to always be pulled. If you use the eval $(minikube docker-env) as mentioned in other answers, then either don't use any tag, or assign a tag to your local image you can avoid Kubernetes trying to forcibly pull it.

或者以另一种方式阅读：使用：Latest标记强制始终拉出图像。如果你像在其他答案中提到的那样使用val$(mini kube docker-env)，那么要么不使用任何标签，要么给你的本地镜像分配一个标签，这样你就可以避免Kubernetes试图强行拉出它。

One idea would be to save the Docker image locally and later load it into Minikube as follows:

一个想法是将Docker映像保存在本地，然后将其加载到Minikube中，如下所示：

Let’s say, for example, you already have puckel/docker-airflow image.

例如，假设您已经有了Puckel/docker-气流图像。

1. Save that image to local disk -

   
   

   docker save puckel/docker-airflow > puckel_docker_airflow.tar

   
   



2. Now enter into the Minikube Docker environment -

   
   

   eval $(minikube docker-env)

   
   



3. Load that locally-saved image -

   
   

   docker load < puckel_docker_airflow.tar

   
   

It is that simple, and it works like a charm.

就是这么简单，它的效果就像一种护身符。

Use:

使用：

minikube addons enable registry -p minikube

Output:

产出：

💡  Registry addon on with docker uses 32769 please use that instead
  of default 5000 <br>
📘  For more information see:
  https://minikube.sigs.k8s.io/docs/drivers/docker

And:

以及：

docker tag ubuntu $(minikube ip -p minikube):32769/ubuntu
docker push $(minikube ip -p minikube):32769/ubuntu

Or

或

minikube addons enable registry
docker tag ubuntu $(minikube ip):32769/ubuntu
docker push $(minikube ip):32769/ubuntu

The above is good enough for development purposes. I am doing this on Arch Linux.

以上内容对于开发目的来说已经足够好了。我是在Arch Linux上这样做的。

There are two easy ways to load local images to Minikube.

有两种简单的方法可以将本地图像加载到Minikube。

Always make sure to set imagePullPolicy: Never in your deployment yaml.

始终确保在部署YAML中设置ImagePullPolicy：Never。

Eg:

例如：

spec:
  containers:
    - name: myapp
      image: pz/demo
      imagePullPolicy: Never
      ports:
        - containerPort: 8080

Luckily, there are two straightforward commands to help with this.

幸运的是，有两个简单的命令可以帮助您做到这一点。

1. The first one is the image load command. You can load a Docker image from your local machine into the Minikube cluster with the following command.

General

minikube image load <IMAGE_NAME>

Mini kube镜像加载

Example

minikube image load pz/demo

Mini kube图像加载pz/demo

After loading the image to your Minikube cluster, you can restart your Pods of the above Deployment and notice that they are starting fine.

将映像加载到Minikube集群后，您可以重新启动上述部署的Pod，并注意到它们启动得很好。

2. With the previous way, you always build the Docker image on your local machine and then move it to the Minikube container, which again takes a bit of time, even though not a lot.

Using the image build command of Minikube, we can build the image directly inside the Minikube container.

使用Minikube的映像构建命令，我们可以直接在Minikube容器中构建映像。

General

minikube image build -t <IMAGE_NAME> <PATH_TO_DOCKERFILE>

Mini kube镜像版本-t

Example

minikube image build -t pz/demo /New APP/Dockerfile

Mini kube镜像构建-t pz/demo/新应用程序/Dockerfile

Using the minikube image build command the image is instantly available to Minikkube and doesn't have to be explicitly loaded in a second step via the minikube image load command.

使用mini kube镜像构建命令，Minikube可以立即使用镜像，而不必在第二步中通过mini kube镜像加载命令显式地加载镜像。

Using one of both methods to get our application Docker image into Minikube and restart the Pods, we can recheck the logs of the Deployment:

使用这两种方法之一将我们的应用程序Docker镜像放入Minikube并重启Pods，我们可以重新检查部署的日志：

Further, to verify end to end that everything is working as expected, we can port forward our local port 8080 to the 8080 of the Deployment by using:

此外，要端到端验证一切是否按预期运行，我们可以使用以下命令将本地端口8080转发到部署的8080：

kubectl port-forward deployment/myapp 8080:8080

kubectl port-forward deployment/myapp 8080：8080

Rechecking the browser, we see that the locally built application runs fine on the Minikube cluster.

重新检查浏览器，我们看到本地构建的应用程序在Minikube集群上运行良好。

Ref: https://levelup.gitconnected.com/two-easy-ways-to-use-local-docker-images-in-minikube-cd4dcb1a5379

参考：https://levelup.gitconnected.com/two-easy-ways-to-use-local-docker-images-in-minikube-cd4dcb1a5379

There is now a Minikube Registry addon, and this is probably the easiest way. Here is how to use it: Registries

现在有了一个Minikube注册表插件，这可能是最简单的方法。以下是如何使用它：注册表

Note that I had DNS issues, and it might be a bug.

请注意，我遇到了DNS问题，这可能是一个错误。

You should know that docker in your local machine is separated from the docker in your minikube cluster.

您应该知道，您本地计算机中的docker与您的mini kube集群中的docker是分开的。

So you should load/copy a Docker image from your local machine into the minikube cluster:

因此，您应该将本地机器上的Docker镜像加载/复制到mini kube集群：

minikube image load <IMAGE_NAME>

or alternatively when working with minikube, you can build images directly inside it:

或者，在使用mini kube时，您可以直接在其内部构建映像：

#instead of:
docker image build -t <IMAGE_NAME> .
#do:
minikube image build -t <IMAGE_NAME> .

In addition of minikube image load <image name>, check out the latest (Nov 2021 at the time of writing) release of Minikube.

除了Minikube图像加载<图像名称>之外，请查看最新发布的Minikube(撰写本文时是2021年11月)。

v1.24.0

V1.24.0

Add --no-kubernetes flag to start minikube without Kubernetes

See PR 12848, for

That gives you:

这为您提供了：

mk start --no-kubernetes
minikube v1.24.0-beta.0 on Darwin 11.6 (arm64)
Automatically selected the docker driver
Starting minikube without Kubernetes minikube in cluster minikube
Pulling base image ...
Creating docker container (CPUs=2, Memory=1988MB) ...
Done! minikube is ready without Kubernetes!

Things to try without Kubernetes

• "minikube ssh" to SSH into minikube's node.


• "minikube docker-env" to build images by pointing to the docker inside minikube


• "minikube image" to build images without docker

To add to the previous answers, if you have a tarball image, you can simply load it to you local Docker set of images docker image load -i /path/image.tar. Please remember to run it after eval $(minikube docker-env), since Minikube does not share images with the locally-installed Docker engine.

为了补充前面的答案，如果你有一个tarball镜像，你可以简单地将它加载到你的本地Docker镜像集中docker image load -i/path/image.tar。请记住在eval $（minikube docker-env）之后运行它，因为Minikube不与本地安装的Docker引擎共享图像。

Other answers suppose you use Minikube with a VM, so your local images are not accessible from the Minikube VM.

其他答案假设您将Minikube与一个VM一起使用，因此您的本地映像不能从Minikube VM访问。

In case if you use Minikube with --vm-driver=none, you can easily reuse local images by setting image_pull_policy to Never:

如果您将Minikube与--vm-drive=NONE一起使用，则可以通过将IMAGE_PULL_POLICY设置为NEVER来轻松重用本地映像：

kubectl run hello-foo --image=foo --image-pull-policy=Never

Or setting the imagePullPolicy field for containers in corresponding .yaml manifests.

或者为相应的.yaml清单中的容器设置ImagePullPolicy字段。

Steps to run local Docker images in Kubernetes:

在Kubernetes中运行本地Docker镜像的步骤：

1. eval $(minikube -p minikube docker-env)

   
   



2. In the artifact file, under the spec section → *containers.

   
   

   Add:

   
   

   imagePullPolicy: IfNotPresent
   

   
   

   or

   
   

   imagePullPolicy: Never
   

   
   

   apiVersion: "v1"
   kind: Pod
   metadata:
       name: web
       labels:
           name: web
           app: demo
   spec:
       containers:
           - name: web
             image: web:latest
             imagePullPolicy: IfNotPresent
             ports:
                 - containerPort: 5000
                   name: http
                   protocol: TCP
   

   
   



3. Then run kubectl create -f <filename>

   
   

For Minikube on Docker:

对于Docker上的Minikube：

Option 1: Using the Minikube registry

备选方案1：使用Minikube登记处

1. Check your Minikube ports

   
   

   docker ps

   
   

   You will see something like: 127.0.0.1:32769->5000/tcp
   It means that your Minikube registry is on the 32769 port for external usage, but internally it's on the 5000 port.

   
   



2. Build your Docker image tagging it:

   
   

   docker build -t 127.0.0.1:32769/hello .

   
   



3. Push the image to the Minikube registry:

   
   

   docker push 127.0.0.1:32769/hello

   
   



4. Check if it's there:

   
   

   curl http://localhost:32769/v2/_catalog

   
   



5. Build some deployment using the internal port:

   
   

   kubectl create deployment hello --image=127.0.0.1:5000/hello

   
   

   Your image is right now in the Minikube container. To see it, write:

   
   

   eval $(minikube -p <PROFILE> docker-env)
   docker images
   

   
   

   Caveat: if using only one profile named "minikube" then "-p " section is redundant, but if using more then don't forget about it. Personally I delete the standard one (Minikube) not to make mistakes.

   
   

Option 2: Not using the registry

备选案文2：不使用登记处

1. Switch to Minikube container Docker:

   
   

   eval $(minikube -p <PROFILE> docker-env)

   
   



2. Build your image:

   
   

   docker build -t hello .

   
   



3. Create some deployment:

   
   

   kubectl create deployment hello --image=hello

   
   

   At the end, change the deployment ImagePullPolicy from Always to IfNotPresent:

   
   

   kubectl edit deployment hello

   
   

Building off the earlier answer to use eval $(minikube docker-env) in order to load up Minikube's Docker environment, for an easier toggle, add the following function to your shell rc file:

在前面的答案的基础上使用eval $（minikube docker-env）来加载Minikube的Docker环境，为了更容易切换，将以下函数添加到shell rc文件中：

dockube() {
  if [[ $1 = 'which' ]]; then
    if [[ $MINIKUBE_ACTIVE_DOCKERD = 'minikube' ]]; then
      echo $MINIKUBE_ACTIVE_DOCKERD
    else
      echo 'system'
    fi
    return
  fi

  if [[ $MINIKUBE_ACTIVE_DOCKERD = 'minikube' ]]; then
    eval $(minikube docker-env -u)
    echo "now using system docker"
  else
    eval $(minikube -p minikube docker-env)
    echo "now using minikube docker"
  fi
}

dockube without any argument will toggle between the system and Minikube Docker environment, and dockube which will return which one is in use.

没有任何参数的dockube将在系统和Minikube Docker环境之间切换，而哪一个dockube将返回哪个正在使用中。

Short version

简短版本

Upload to minikube repository:

上传到mini kube存储库：

minikube image load imageName

Verify upload:

验证上载：

minikube image ls

Alternative solution:

Let's say I already have the Nginx image locally.

假设我在本地已经有了nginx映像。

docker save -o nginx.tar nginx:1.19.0-alpine   
minikube ssh
docker load -i /path/to/nginx.tar

Now, you can create a Kubernetes deployment using the local docker image.

现在，您可以使用本地docker镜像创建一个Kubernetes部署。

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      containers:
      - name: nginx
        image: nginx:1.19.0-alpine
        imagePullPolicy: IfNotPresent  # Note: you can also user 'Never'
        ports:
        - containerPort: 80

Finally:

最后：

kubectl apply -f my-deployment.yml

What if you could just run Kubernetes within Docker's virtual machine? There's native support for this with the more recent versions of Docker Desktop... You just need to enable that support.

如果您只需在Docker的虚拟机中运行Kubernetes会怎么样？较新版本的Docker Desktop对此有本机支持...您只需启用该支持。

• https://www.docker.com/blog/kubernetes-is-now-available-in-docker-desktop-stable-channel/


• Docker for Windows Desktop… Now With Kubernetes!

How I found this out:

我是如何发现的：

While reading the documentation for Helm, they give you a brief tutorial how to install Minikube.
That tutorial installs Minikube in a virtual machine that's different/separate from Docker.

在阅读Helm的文档时，他们会为您提供如何安装Minikube的简短教程。该教程将Minikube安装在与Docker不同/独立的虚拟机中。

So when it came time to install my Helm charts, I couldn't get Helm/Kubernetes to pull the images I had built using Docker. That's how I arrived here at this question.

因此，当需要安装我的Helm图表时，我无法让Helm/Kubernetes获取我使用Docker构建的图像。这就是我提出这个问题的原因。

So... if you can live with whatever version of Kubernetes comes with Docker Desktop, and you can live with it running in whatever VM Docker has, then maybe this solution is a bit easier than some of the others.

所以..。如果您可以接受Docker Desktop附带的Kubernetes的任何版本，并且可以在Docker拥有的任何VM上运行它，那么这个解决方案可能比其他一些解决方案更容易一些。

Disclaimer: I am not sure how switching between Windows/Linux containers would impact anything.

免责声明：我不确定在Windows/Linux容器之间切换会有什么影响。

1. setup: minikube docker-env


2. again build the same Docker image (using minikube docker-env)


3. change imagePullPolicy to Never in your deployment

Actually, your Minikube can't recognise your Docker daemon as it is ab independent service. You have to first set your Minikube-Docker environment use the below command to check:

事实上，你的Minikube无法识别你的Docker守护进程，因为它是一个独立的服务。您必须首先设置您的Minikube-Docker环境，使用以下命令进行检查：

 "eval $(minikube docker-env)"

If you run the below command, it will show where your Minikube instance looks for Docker.

如果您运行下面的命令，它将显示您的Minikube实例查找Docker的位置。

cd ~
minikube docker-env

Output:

产出：

export DOCKER_TLS_VERIFY="1"
export DOCKER_HOST="tcp://192.168.37.192:2376"
export DOCKER_CERT_PATH="/home/ubuntu/.minikube/certs"
export MINIKUBE_ACTIVE_DOCKERD="minikube"

**# To point your shell to minikube's docker-daemon, run:**
# eval $(minikube -p minikube docker-env)

You have to again build images once you set up the Minikube docker-env. Else, it will fail.

一旦设置了mini kube docker-env，您必须再次构建映像。否则，它将失败。

Most of the answers are already great.
But one important thing I have faced is that if you are using BuildKit

大多数答案都已经很棒了。但我面临的一个重要问题是，如果您使用的是BuildKit

(DOCKER_BUILDKIT=1)

then the images created after executing the eval $(minkube docker-env) will not go to minikube docker engine. Instead it will go to your docker engine on local.

则在执行val$(minkube docker-env)之后创建的图像将不会被转到mini kube docker引擎。取而代之的是，它将在本地连接到您的对接引擎。

So remove any of the references if you are using below

因此，如果您使用的是以下内容，请删除所有引用

-mount=type=cache,target=/root/.m2

You can reuse the Docker shell, with eval $(minikube docker-env). Alternatively, you can leverage docker save | docker load across the shells.

您可以使用val$(mini kube docker-env)重用Docker外壳。或者，您可以跨壳利用停靠保存|停靠加载。