How can I use local Docker images with Minikube?

Question

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?

Stuff I tried:

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

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.

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

OS: Ubuntu 16.04 (Xenial Xerus)
Docker: Docker version 1.13.1, build 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?

Images loaded in eval $(minikube 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?

Images loaded in eval $(minikube 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

Growing

Why doesn't the last row have values for the last four columns? – Schriever

OK, the OP has left the building: "Last seen more than 6 years ago" – Schriever

Answer 1

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

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.

Matildamatilde

How do I increase the space in docker after eval $(minikube docker-env)? After adding a few images, it says that no more space is available in the docker. – Growing

AFAIS you can only do that with a new minukube with minikube start --disk-size 100g. Another solution would be to delete old images with docker images and docker rmi. – Matildamatilde

Could't able to build image after step 1. then I did minikube stop and minikube start . I can now able to build image(step 2) – Elonore

Very important to remember to run eval $(minikube docker-env) after closing the terminal you're working in BEFORE you try to rebuild images... just burned 6 hours fighting with an image that was not updating in minikube... looked like a package was not updating... really just not updating the image that minikube was referencing. – Kingofarms

The default pull policy is IfNotPresent which means all we have to do is to set the environment variables. – Lymphocyte

If u wanna back or exit env from minikube.. eval $(minikube docker-env -u) – Canton

How can I "Set the imagePullPolicy to Never" using kubectl ? – Polythene

@nmxl look at here – Vaughan

Nowdays, you can also use minikube cache add imagename:tag to push the image to the minikube - be sure to include the tag as well. Docs – Pantalets

@Pantalets Very useful link. Full operational solution with add, delete and list options. For me, for now that is the best answear. – Cottonwood

For windows what do i do to run eval $(minikube docker-env) – Communistic

"minikube cache" will be deprecated in upcoming versions, please switch to "minikube image load" - just got it from my terminal. – Rhombohedron

The docs explains this way in here – Belga

What about docker desktop? How can we use local docker images in docker desktops kubernetes? – Grogram

@Grogram It works directly with dkr desktop k8s, just use image_name:tag (don't specify repo) and it will use local image – Macropterous

Use kubectl edit deployment <deployment_name> to edit the yaml file that contains the imagePullPolicy. This wasn't obvious from the official docs – Ewart

Answer 2

What worked for me, based on the solution by 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

Steradian

You can find the yml version of the above command line (in regards to the imagePullPolicy) here : kubernetes.io/docs/concepts/containers/images – Florie

On Windows eval $(minikube docker-env) was not working for me. minikube docker-env | Invoke-Expression seems to work in PowerShell. In other terminals one needs to read the last line returned by minikube docker-env. For example, in IntelliJ (on Windows) it is @FOR /f "tokens=*" %i IN ('minikube -p minikube docker-env') DO @%i You have to do this in any new terminal/session always before building the docker image. – Wavemeter

I am getting following error while doing eval $(minikube docker-env). "'none' driver does not support 'minikube docker-env' command" It is also logged on github it seems. github.com/kubernetes/minikube/issues/2443 – Hospitalet

Answer 3

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.

minikube image load <image name>

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

More details are here.

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

Faultfinder

This answer should be higher in the list, it is the more up-to-date solution. – Erickson

I wonder why it's so slow. Sometimes it gets cancelled. Maybe not enough RAM – Cysticercus

There are sorting tabs at the top of the answers section, you probably selected one you're not used to, the best to choose is "Trending" – Faultfinder

Is there a way to force a pod to pick up the new image when I upload it into minikube repeatedly? Every time I upload a new image version with the same name/tag the pod keeps working on the old image until I delete the image explicitly in minikube and load it again. – Bellanca

for anybody reading this anwer: it won't work without imagePullPolicy: Never If you check out the logs you'll see that minikube is trying to pull the image even if it knows about it (minikube image ls) – Distributary

Answer 4

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

• depending on your operative system, Minikube will automatically mount your homepath onto the 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.

---

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.

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.

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

Plush

| Now change your yaml file to use the local registry. Are you able to explain this a little bit? I pushed to the local registry (cool trick) but I have the same problem that I can't get minikube to connect to it. – Idou

@ZachEstela change the image name in the yaml to <registryIP>:5000/ubuntu – Plush

@FarhadFarahi Where can I find the "dns name of the machine running registry container"? – Requisition

@Requisition this is what you create so depending how you create it you should know it. – Plush

@FarhadFarahi If I give my laptop to you, how would you find out? I just want to know it. I followed docker tutorial steps to get docker for windows running. – Requisition

@daan if you run docker registry on your laptop it would be yourlaptopip:dockerregistryport – Plush

@FarhadFarahi: Please add to your answer that you'll need to add the local registry as insecure in order to use http: docs.docker.com/registry/insecure (may not apply when using localhost but does apply if using the local hostname). – Giovannagiovanni

Failed to pull image "localhost:5000/src_interface:latest" according to my minikube dashboard, this doesn't seem to work. How would kubectl even access port 5000? – Alecto

Great answer! Can you please elaborate about what to mount, in order to source (and backup) the images on the host machine? – E.g. minikube mounts macOS's /Users/ dir on the VM; so host folders become available for potentially being mounted further (via docker) on the local-registry container; see my edits to your answer. – Twinflower

I figured out! See my answer; hopefully will make life your travelling digital nomad life a little happier! 😉 – Twinflower

Answer 5

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:

docker.local 127.0.0.1

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

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

SSH into Minikube with: minukube ssh

Edit /etc/hosts to add this line:

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.

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 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

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)

--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.

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.

Mackmackay

What is "Docker serice file"? Is it "Docker service file"? Or something else? – Schriever

Answer 6

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

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.

Aceldama

this seems to be a great answer ... do you have any sources ? – Sidky

just found reference here:minikube.sigs.k8s.io/docs/handbook/pushing/… ... the --daemon option is not really needed. – Sidky

How long does it take? Its running since 20 minutes for 645MB image – Gingili

Answer 7

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 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.

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

Weddle

While this code may answer the question, providing additional context regarding why and/or how this code answers the question improves its long-term value. – Tjaden

Answer 8

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.

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)

Forejudge

The correct command is docker save imageNameGoesHere > pv | (eval $(minikube docker-env) && docker load) – Immunity

docker save imageNameGoesHere | (eval $(minikube docker-env) && docker load) worked for me – Trochilus

Answer 9

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:

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:

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

Sverre

Answer 10

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

eval $(docker-machine env -u)

Congregationalism

Already posted as #42564558 – Crozier

Would be eval $(minikube docker-env -u) for minikube – Dunlop

Answer 11

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:

# 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.

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

Pulsation

Well explained, worked like a charm. I only had to call docker save with sudo, and then set sudo chmod 664 my-image.tar to make it available for my current user. – Fritts

Answer 12

From the Kubernetes documentation:

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.

Saffier

Answer 13

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

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

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.

Fideicommissary

You still need the accepted answer's tip of Set the imagePullPolicy to Never. If your image is tagged with an address e.g. us.icr.io/mydiv/my-service:v0.0.1 then a deploy will try to remote pull this image. Since you've already manually copied the image, you need to suppress k8s from pulling the image from an address (container registry) it can't access. – Galer

@Galer The steps above worked for me but I had to replace the latest tag in the image with a specific version and select this version in the create deploy command. The imagePullPolicy was automatically set to IfNotPresent and the image was loaded correctly without further changes. – Monopolist

Answer 14

For Windows users, the way I do it.

I use the Docker Desktop to host my Minikube image and use PowerShell as a console.

First I create my Minikube cluster:

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

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

FROM nginx

Two steps way: Build an image and upload the image to Minikube

docker build -t mynginximage .
minikube image load mynginximage

Or a one-step way, build directly in Minikube:

minikube image build -t mynginximage .

To run my image in Minikube:

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

Or via the mynginxpod.yaml file:

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

And kubectl apply -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

Lucia

Answer 15

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.

Schipperke

How do u refer to the image in the k8s specs? By localhost:32769/ubuntu or with the minikube ip or the registry dns name? – Corene

Answer 16

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

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

Reimport

The link may or may not be half-broken (it redirects). – Schriever

Answer 17

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

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

minikube image load <IMAGE_NAME>

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

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

Montez

Error: unknown command "build" for "minikube"; what minikube version are you talking about? – Twinflower

@Twinflower minikube version: v1.28.0 commit: 986b1ebd987211ed16f8cc10aed7d2c42fc8392f you can install it from here – Montez

Oh, we are constrained to an earlier version at the moment, but thank you for the update I'll check it out! – Twinflower

Answer 18

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

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

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>

Example

minikube image load 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.

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.

General

minikube image build -t <IMAGE_NAME> <PATH_TO_DOCKERFILE>

Example

minikube image build -t pz/demo /New APP/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.

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:

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:

kubectl port-forward deployment/myapp 8080:8080

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

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

Dunson

Answer 19

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.

Quadrangular

Answer 20

Other answers suppose you use Minikube with a VM, so your local images are not accessible from the 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:

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

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

Haha

Answer 21

Steps to run local Docker images in Kubernetes:

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>

Discursion

Answer 22

For Minikube on Docker:

Option 1: Using the Minikube registry

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

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

Strategic

Answer 23

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

v1.24.0

Add --no-kubernetes flag to start minikube without Kubernetes
See PR 12848, for

That gives you:

mk start --no-kubernetes

Output:

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

Standin

Answer 24

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:

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.

Lemberg

Answer 25

Short version

Upload to the Minikube repository:

minikube image load imageName

Verify the upload:

minikube image ls

Alanaalanah

Answer 26

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.

• 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.

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.

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.

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

Vitriolize

I think I also had to set the imagePullPolicies to IfNotPresent as well – Vitriolize

The first link is (effectively) broken (it redirects to a generic page). – Schriever

Answer 27

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:

 "eval $(minikube docker-env)"

If you run the below command, it will show where your Minikube instance looks for 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.

Gemoets

Answer 28

Alternative solution:

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

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.

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

Millpond

Answer 29

Ugly But Effective

I use Minikube infrequently and often forget the nuances. So I just save the image to a file and load into Minikube from there...

docker save xxx:latest -o ~/Downloads/delme.img
minikube image load ~/Downloads/delme.img
minikube image ls

Your image should appear as docker.io/library/xxx:latest.

Athens

Answer 30

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

Convexity

Answer 31

I find this method from ClickHouse Operator Build From Sources and it helps and save my life!

docker save altinity/clickhouse-operator | (eval $(minikube docker-env) &&
docker load)

Coleencolella

Answer 32

In Minikube 1.20, minikube cache add imagename:tag is deprecated.

Instead, use minikube image load imagename:tag.

Raoul

Answer 33

If I understand, you have local images, maybe passed by a USB flash drive and want to load it in Minikube?

Just load the image like:

minikube image load my-local-image:0.1

With this, in the Kubernetes YAML file, you can change the imagePullPolicy to Never, and it will be found, because you just loaded it in Minikube.

I had this problem, have done this, and it worked.

Teutonize

This copies the image from local to minikube. To note, of course a 20GB image on local will allocate other 20GB inside minikube, when loaded. In my case would be useful to understand why the image is being built on local rather than inside Minikube. – Twinflower

Answer 34

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

(DOCKER_BUILDKIT=1)

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

So remove any of the references if you are using below

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

Mcnary