Comment utiliser les images Docker locales avec Minikube?

J'ai plusieurs images de docker avec lesquelles je souhaite utiliser minikube. Je ne veux pas d'abord télécharger puis télécharger la même image au lieu d'utiliser simplement l'image locale directement. Comment puis-je faire cela?

Stuff J'ai essayé:
1. J'ai essayé d'exécuter ces commandes (séparément, en supprimant les instances de minikube à la fois et en recommençant)

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

Production :

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

Il reste bloqué sur un certain statut mais n'atteint jamais l'état prêt.

2. J'ai essayé de créer un registre puis d'y mettre des images mais cela n'a pas fonctionné non plus. J'ai peut-être mal fait cela, mais je ne trouve pas les instructions appropriées pour effectuer cette tâche.

Veuillez fournir des instructions pour utiliser des images de docker local dans l'instance kubernetes locale.
OS: ubuntu 16.04
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"}

Si quelqu'un pouvait m'aider à obtenir une solution qui utilise docker-compose pour ce faire, ce serait génial. Merci.

Éditer :

Images chargées dans 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           

Comme le README le décrit, vous pouvez réutiliser le démon Docker de Minikube avec eval $(minikube docker-env).

Donc, pour utiliser une image sans la télécharger, vous pouvez suivre ces étapes:

1. Définissez les variables d'environnement avec eval $(minikube docker-env)
2. Construisez l'image avec le démon Docker de Minikube (par exemple docker build -t my-image .)
3. Définissez l'image dans les spécifications du pod comme la balise de construction (par exemple my-image)
4. Réglez imagePullPolicysur Never, sinon Kubernetes essaiera de télécharger l'image.

Remarque importante: vous devez exécuter eval $(minikube docker-env)sur chaque terminal que vous souhaitez utiliser, car il définit uniquement les variables d'environnement pour la session shell actuelle.

Ce qui a fonctionné pour moi, basé sur la solution de @svenwltr:

# Start minikube
minikube start

# Set docker env
eval $(minikube docker-env)

# 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

Cette réponse n'est pas limitée au minikube!

Utilisez un registre local:

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

Maintenant, marquez correctement votre image:

docker tag ubuntu localhost:5000/ubuntu

Notez que localhost doit être remplacé par le nom DNS de la machine exécutant le conteneur de registre.

Poussez maintenant votre image vers le registre local:

docker push localhost:5000/ubuntu

Vous devriez pouvoir le retirer:

docker pull localhost:5000/ubuntu

Maintenant, changez votre fichier yaml pour utiliser le registre local.

Pensez à monter le volume à l'emplacement approprié pour conserver les images dans le registre.

mettre à jour:

comme l'a déclaré Eli, vous devrez ajouter le registre local comme non sécurisé afin d'utiliser http (peut ne pas s'appliquer lorsque vous utilisez localhost mais s'applique si vous utilisez le nom d'hôte local)

N'utilisez pas http dans la production, faites l'effort de sécuriser les choses.

Ajoutant à la réponse de @Farhad sur la base de cette réponse ,

Ce sont les étapes pour configurer un registre local.

Configuration sur la machine locale

Configurer le nom d'hôte sur la machine locale: modifier /etc/hostspour ajouter cette ligne

docker.local 127.0.0.1

Maintenant, démarrez un registre local (supprimez -d pour exécuter le mode non démon):

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

Maintenant, marquez correctement votre image:

docker tag ubuntu docker.local:5000/ubuntu

Poussez maintenant votre image vers le registre local:

docker push docker.local:5000/ubuntu

Vérifiez que l'image est poussée:

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

Configuration dans minikube

ssh en minikube avec: minukube ssh

modifier /etc/hostspour ajouter cette ligne

docker.local <your host machine's ip>

Vérifiez l'accès:

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

Maintenant, si vous essayez de tirer, vous pourriez obtenir une erreur d'accès http.

Activer l'accès non sécurisé :

Si vous prévoyez toujours d'utiliser minkube avec cette configuration locale, créez un minikube pour utiliser le registre non sécurisé par défaut (ne fonctionnera pas sur le cluster existant).

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

sinon suivez les étapes ci-dessous:

systemctl stop docker

modifier le fichier de service de docker: obtenir le chemin de systemctl status docker

Ça pourrait être :

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

ajoutez ce texte (remplacez 192.168.1.4 par votre ip)

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

à cette ligne

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

systemctl daemon-reload
systemctl start docker

essayez de tirer:

docker pull docker.local:5000/ubuntu

Maintenant, changez votre fichier yaml pour utiliser le registre local.

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

à

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

N'utilisez pas http dans la production, faites l'effort de sécuriser les choses.

En plus de la réponse acceptée, vous pouvez également obtenir ce que vous vouliez à l'origine (création d'un déploiement à l'aide de la runcommande) avec la commande suivante:

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

J'ai trouvé les informations sur le générateur sur le forum Kubernetes-dev:

Si vous utilisez kubectl run, il génère pour vous un manifeste qui se trouve avoir été imagePullPolicydéfini Alwayspar défaut. Vous pouvez utiliser cette commande pour obtenir un imagePullPolicyof IfNotPresent, qui fonctionnera pour minikube:

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

Dan Lorenc

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

Une approche consiste à créer l'image localement, puis à:

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

minikube docker-envpeut ne pas renvoyer les informations correctes exécutées sous un autre utilisateur / sudo. Au lieu de cela, vous pouvez exécutersudo -u yourUsername minikube docker-env .

Il devrait renvoyer quelque chose comme:

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)

Si quelqu'un cherche à revenir à l'environnement local après avoir défini l'env minikube, utilisez la commande suivante.

eval $(docker-machine env -u)

Depuis les documents de kubernetes:

https://kubernetes.io/docs/concepts/containers/images/#updating-images

La stratégie d'extraction par défaut est IfNotPresent, ce qui fait que le Kubelet saute l'extraction d'une image si elle existe déjà. Si vous souhaitez toujours forcer une traction, vous pouvez effectuer l'une des opérations suivantes:

• définissez l'imagePullPolicy du conteneur sur Always;
• use: latest comme balise de l'image à utiliser;
• activer le contrôleur d'admission AlwaysPullImages.

Ou lisez dans l'autre sens: L'utilisation de la dernière balise force les images à toujours être tirées. Si vous utilisez le eval $(minikube docker-env)comme mentionné ci-dessus, alors n'utilisez pas de balise ou affectez une balise à votre image locale, vous pouvez éviter que Kubernetes essaie de la tirer de force.

Il y a maintenant un addon Minikube Registry, c'est probablement le moyen le plus simple. Voici comment l'utiliser: https://minikube.sigs.k8s.io/docs/tasks/registry/insecure/

Notez que j'ai eu des problèmes DNS, peut-être un bug.

Une méthode plus simple qui répond à la question d'origine "Comment utiliser des images de docker local avec Minikube?", Consiste à enregistrer l'image dans un fichier tar et à la charger dans le 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

L'exécution de l'image implique ensuite une commande comme celle-ci. Assurez-vous d'inclure le paramètre "--image-pull-policy = Never".

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

Pour ajouter aux réponses précédentes, si vous avez une image tarball, vous pouvez simplement la charger dans votre jeu d'images docker image load -i /path/image.tarDocker local . N'oubliez pas de l'exécuter après eval $(minikube docker-env) , car minikube ne partage pas d'images avec le moteur Docker installé localement.

D'autres réponses supposent que vous utilisez minikube avec VM, donc vos images locales ne sont pas accessibles depuis minikube VM.

Si vous utilisez minikube avec --vm-driver=none, vous pouvez facilement réutiliser les images locales en définissant image_pull_policysur Jamais:

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

ou en définissant un imagePullPolicychamp pour les cotainers dans les .yamlmanifestes correspondants .

Une idée serait d'enregistrer l'image docker localement et de la charger plus tard dans le mini-cube comme suit:

Disons, par exemple, que vous avez déjà une image puckel / docker-airflow.

1. Enregistrez cette image sur le disque local -

   docker save puckel/docker-airflow > puckel_docker_airflow.tar

2. Entrez maintenant dans minikube docker env -

   eval $(minikube docker-env)

3. Chargez cette image enregistrée localement -

   docker load < puckel_docker_airflow.tar

C'est aussi simple que ça et ça fonctionne comme un charme.

Et si vous pouviez simplement exécuter des k8 dans la VM de Docker? il existe un support natif pour cela avec les versions les plus récentes de docker desktop ... il vous suffit d'activer ce support.

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

comment je l'ai découvert:

en lisant les documents pour Helm, ils vous donnent un bref tutoriel sur l'installation de minikube. ce tutoriel installe minikube dans un vm différent / séparé de docker.

donc quand est venu le temps d'installer mes graphiques de barre, je n'ai pas pu obtenir la barre / k8 pour tirer les images que j'avais construites en utilisant docker. c'est comme ça que je suis arrivé ici à cette question.

donc ... si vous pouvez vivre avec n'importe quelle version de k8s fournie avec docker desktop, et que vous pouvez vivre avec celle-ci dans n'importe quel vm docker, alors peut-être que cette solution est un peu plus facile que certaines des autres.

Avertissement: je ne sais pas comment la commutation entre les conteneurs Windows / Linux affecterait quoi que ce soit.

Il y a un essai et un moyen efficace de pousser votre image Docker locale directement vers minikube, ce qui vous fera gagner du temps pour reconstruire les images dans minikube.

minikube cache add <Image name>

Plus de détails ici

Toutes les méthodes possibles pour pousser des images vers un minikube sont mentionnées ici: https://minikube.sigs.k8s.io/docs/handbook/pushing/

vous pouvez soit réutiliser le shell docker, avec eval $(minikube docker-env), alternativement, vous pouvez tirer parti de l' docker save | docker loadensemble des shells.

1. configuration minikube docker-env
2. construire à nouveau la même image docker (en utilisant minikube docker-env)
3. changez imagePullPolicy en Never dans votre déploiement

en fait ce qui se passe ici, votre Minikube ne peut pas reconnaître votre démon docker car il s'agit d'un service indépendant. Vous devez d'abord définir votre environnement minikube-docker utiliser la commande ci-dessous pour vérifier

 "eval $(minikube docker-env)"

Si vous exécutez la commande ci-dessous, elle indiquera où votre minikube recherche docker.

~$ minikube docker-env
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)

Vous devez à nouveau créer des images une fois que vous avez configuré minikube docker-env, sinon cela échouera.

je trouve cette méthode de ClickHouse Operator Build From Sources et elle aide et sauve ma vie!

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

étapes pour exécuter des images de docker local dans kubernetes
1. eval $ (minikube -p minikube docker-env)
2. dans le fichier d'artefact, sous la section spec -> conteneurs
ajouter imagePullPolicy: IfNotPresent
ou 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. puis exécutez kubectl create -f <filename>

cela marche

 minikube cache add <image>:<tag>