Comment utiliser les images Docker locales avec Minikube?


301

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           

Réponses:


408

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.


1
AFAIS vous ne pouvez le faire qu'avec un nouveau minukube avec minikube start --disk-size 100g. Une autre solution serait de supprimer les anciennes images avec docker imageset docker rmi.
svenwltr

6
Il est très important de se rappeler de courir eval $(minikube docker-env)après avoir fermé le terminal dans lequel vous travaillez AVANT d'essayer de reconstruire des images ... juste brûlé 6 heures de combat avec une image qui ne se mettait pas à jour dans minikube ... on aurait dit qu'un paquet ne se mettait pas à jour .. Vraiment tout simplement pas mettre à jour l'image référencée par minikube.
Mike

1
La politique d'extraction par défaut est IfNotPresentce qui signifie que tout ce que nous avons à faire est de définir les variables d'environnement.
Beygi

29
Si tu veux revenir ou quitter env de minikube ..eval $(minikube docker-env -u)
Budi Mulyo

1
@nmxl regardez ici
testuser

175

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

3
Vous pouvez trouver la version yml de la ligne de commande ci-dessus (en ce qui concerne l'imagePullPolicy) ici: kubernetes.io/docs/concepts/containers/images
granadaCoder

128

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.


2
| Modifiez maintenant votre fichier yaml pour utiliser le registre local. Pouvez-vous expliquer cela un peu? J'ai poussé vers le registre local (astuce cool) mais j'ai le même problème que je ne peux pas obtenir de mini-cube pour s'y connecter.
Zach Estela du

3
@ZachEstela change le nom de l'image dans le yaml en<registryIP>:5000/ubuntu
Farhad Farahi

@FarhadFarahi Où puis-je trouver le "nom DNS de la machine exécutant le conteneur de registre"?
Daan

1
@FarhadFarahi Si je vous donne mon ordinateur portable, comment le découvririez-vous? Je veux juste le savoir. J'ai suivi les étapes du didacticiel Docker pour exécuter Docker pour Windows.
Daan

1
@FarhadFarahi: veuillez ajouter à votre réponse que vous devrez ajouter le registre local comme non sécurisé afin d'utiliser http: docs.docker.com/registry/insecure (peut ne pas s'appliquer lorsque vous utilisez localhost mais s'applique si vous utilisez le nom d'hôte local ).
Eli Algranti

14

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.


12

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


9

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)

La commande correcte estdocker save imageNameGoesHere > pv | (eval $(minikube docker-env) && docker load)
salvador

1
docker save imageNameGoesHere | (eval $(minikube docker-env) && docker load)a travaillé pour moi
lhaferkamp


4

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.



3

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

Bien expliqué, fonctionnait comme un charme. Je ne devais appeler docker saveavec sudo, puis mis sudo chmod 664 my-image.tarà le rendre disponible pour mon utilisateur actuel.
Meir Gabay

Cela devrait être l'approche la plus rapide, je crois.
Shiwakant Bharti

2

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.


2

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 .


2

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.


Vous avez toujours besoin de la pointe de la réponse acceptée de Set the imagePullPolicy to Never. Si votre image est étiquetée avec une adresse, par exemple, us.icr.io/mydiv/my-service:v0.0.1un déploiement essaiera d'extraire cette image à distance. Comme vous avez déjà copié manuellement l'image, vous devez empêcher k8 de tirer l'image d'une adresse (registre de conteneurs) à laquelle elle ne peut pas accéder.
colm.anseo

1

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.


Je pense que je devais également définir l'imagePullPolicies sur IfNotPresent
tchad

1

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/


0

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.


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



0

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


0

cela marche

 minikube cache add <image>:<tag> 
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.