Wie verwende ich lokale Docker-Bilder mit Minikube?

Ich habe mehrere Docker-Bilder, mit denen ich arbeiten möchte minikube. Ich möchte nicht zuerst dasselbe Bild hochladen und dann herunterladen müssen, anstatt nur das lokale Bild direkt zu verwenden. Wie mache ich das?

Dinge, die ich versucht habe:
1. Ich habe versucht, diese Befehle auszuführen (separat, beide Male die Instanzen von minikube löschen und neu starten)

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

Ausgabe :

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

Es bleibt nur bei einem bestimmten Status hängen, erreicht aber nie den Bereitschaftszustand.

2. Ich habe versucht, eine Registrierung zu erstellen und dann Bilder darin abzulegen, aber das hat auch nicht funktioniert. Ich habe das möglicherweise falsch gemacht, aber ich kann keine richtigen Anweisungen für diese Aufgabe finden.

Bitte geben Sie Anweisungen zur Verwendung lokaler Docker-Images in der lokalen Kubernetes-Instanz.
Betriebssystem: 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"}

Wenn mir jemand helfen könnte, eine Lösung zu finden, die Docker-Compose verwendet, wäre das großartig. Vielen Dank.

Bearbeiten:

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

Wie in der README beschrieben, können Sie den Docker-Daemon von Minikube mit wiederverwenden eval $(minikube docker-env).

Um ein Bild zu verwenden, ohne es hochzuladen, können Sie die folgenden Schritte ausführen:

1. Stellen Sie die Umgebungsvariablen mit ein eval $(minikube docker-env)
2. Erstellen Sie das Bild mit der Docker - Daemon von Minikube (zB docker build -t my-image .)
3. Stellen Sie das Bild in der Schote spec wie der Build - Tag (zB my-image)
4. Stellen Sie das imagePullPolicyauf ein Never, andernfalls versucht Kubernetes, das Bild herunterzuladen.

Wichtiger Hinweis: Sie müssen eval $(minikube docker-env)auf jedem Terminal ausgeführt werden, das Sie verwenden möchten, da nur die Umgebungsvariablen für die aktuelle Shell-Sitzung festgelegt werden.

Was für mich funktioniert hat, basierend auf der Lösung von @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

Diese Antwort ist nicht auf Minikube beschränkt!

Verwenden Sie eine lokale Registrierung:

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

Kennzeichnen Sie nun Ihr Bild richtig:

docker tag ubuntu localhost:5000/ubuntu

Beachten Sie, dass localhost in DNS-Name des Computers geändert werden sollte, auf dem der Registrierungscontainer ausgeführt wird.

Schieben Sie nun Ihr Bild in die lokale Registrierung:

docker push localhost:5000/ubuntu

Sie sollten es zurückziehen können:

docker pull localhost:5000/ubuntu

Ändern Sie nun Ihre yaml-Datei, um die lokale Registrierung zu verwenden.

Überlegen Sie, ob Sie das Volume an einer geeigneten Stelle bereitstellen möchten, um die Images in der Registrierung beizubehalten.

aktualisieren:

Wie Eli angegeben hat, müssen Sie die lokale Registrierung als unsicher hinzufügen, um http verwenden zu können (gilt möglicherweise nicht bei Verwendung von localhost, gilt jedoch bei Verwendung des lokalen Hostnamens).

Verwenden Sie http nicht in der Produktion, sondern bemühen Sie sich, die Dinge zu sichern.

Hinzufügen zu @Farhads Antwort basierend auf dieser Antwort ,

Dies sind die Schritte zum Einrichten einer lokalen Registrierung.

Einrichtung auf dem lokalen Computer

Hostnamen auf lokalem Computer einrichten: Bearbeiten /etc/hosts, um diese Zeile hinzuzufügen

docker.local 127.0.0.1

Starten Sie nun eine lokale Registrierung (entfernen Sie -d, um den Nicht-Daemon-Modus auszuführen):

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

Kennzeichnen Sie nun Ihr Bild richtig:

docker tag ubuntu docker.local:5000/ubuntu

Schieben Sie nun Ihr Bild in die lokale Registrierung:

docker push docker.local:5000/ubuntu

Stellen Sie sicher, dass das Bild verschoben wird:

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

Setup in Minikube

ssh in minikube mit: minukube ssh

bearbeiten /etc/hosts, um diese Zeile hinzuzufügen

docker.local <your host machine's ip>

Überprüfen Sie den Zugriff:

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

Wenn Sie jetzt versuchen zu ziehen, wird möglicherweise ein http-Zugriffsfehler angezeigt.

Unsicheren Zugriff aktivieren :

Wenn Sie immer planen, minkube mit diesem lokalen Setup zu verwenden, erstellen Sie einen Minikube, um standardmäßig eine unsichere Registrierung zu verwenden (funktioniert nicht in vorhandenen Clustern).

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

Andernfalls befolgen Sie die folgenden Schritte:

systemctl stop docker

Bearbeiten Sie die Docker-Serice-Datei: Pfad abrufen von systemctl status docker

es könnte sein :

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

füge diesen Text hinzu (ersetze 192.168.1.4 durch deine IP)

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

zu dieser Zeile

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

versuchen Sie zu ziehen:

docker pull docker.local:5000/ubuntu

Ändern Sie nun Ihre yaml-Datei, um die lokale Registrierung zu verwenden.

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

zu

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

Verwenden Sie http nicht in der Produktion, sondern bemühen Sie sich, die Dinge zu sichern.

Neben der akzeptierten Antwort können Sie runmit dem folgenden Befehl auch das erreichen, was Sie ursprünglich wollten (Erstellen einer Bereitstellung mit dem Befehl):

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

Ich habe die Informationen zum Generator im Kubernetes-dev-Forum gefunden:

Wenn Sie verwenden kubectl run, erzeugt er ein Manifest für Sie zu haben , geschieht imagePullPolicygesetzt Alwaysstandardmäßig. Mit diesem Befehl können Sie ein imagePullPolicyvon abrufen IfNotPresent, das für Folgendes funktioniert minikube:

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

Dan Lorenc

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

Ein Ansatz besteht darin, das Image lokal zu erstellen und dann Folgendes zu tun:

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

minikube docker-envMöglicherweise werden nicht die richtigen Informationen zurückgegeben, die unter einem anderen Benutzer / sudo ausgeführt werden. Stattdessen kannst du rennensudo -u yourUsername minikube docker-env .

Es sollte etwas zurückgeben wie:

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)

Wenn jemand nach dem Festlegen der Minikube-Umgebung in die lokale Umgebung zurückkehren möchte, verwenden Sie den folgenden Befehl.

eval $(docker-machine env -u)

Aus den kubernetes-Dokumenten:

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

Die Standard-Pull-Richtlinie ist IfNotPresent, wodurch das Kubelet das Abrufen eines Bildes überspringt, wenn es bereits vorhanden ist. Wenn Sie immer einen Zug erzwingen möchten, können Sie einen der folgenden Schritte ausführen:

• Setzen Sie die imagePullPolicy des Containers auf Always.
• Verwenden Sie: spätestens als Tag für das zu verwendende Bild.
• Aktivieren Sie den Zulassungscontroller AlwaysPullImages.

Oder lesen Sie anders herum: Wenn Sie das Tag: latest verwenden, werden Bilder immer gezogen. Wenn Sie das eval $(minikube docker-env)oben erwähnte verwenden, verwenden Sie entweder kein Tag oder weisen Sie Ihrem lokalen Image ein Tag zu. Sie können vermeiden, dass Kubernetes versucht, es gewaltsam abzurufen.

Es gibt jetzt ein Minikube-Registrierungs-Addon. Dies ist wahrscheinlich der einfachste Weg. So verwenden Sie es: https://minikube.sigs.k8s.io/docs/tasks/registry/insecure/

Beachten Sie, dass ich DNS-Probleme hatte, möglicherweise ein Fehler.

Eine einfachere Methode, die die ursprüngliche Frage "Wie werden lokale Docker-Bilder mit Minikube verwendet?" Beantwortet, besteht darin, das Bild in einer TAR-Datei zu speichern und in Minikube zu laden:

# 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

Das Ausführen des Images umfasst dann einen Befehl wie den folgenden. Stellen Sie sicher, dass Sie den Parameter "--image-pull-policy = Never" angeben.

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

Wenn Sie ein Tarball-Image haben, können Sie es einfach in docker image load -i /path/image.tarIhren lokalen Docker-Satz von Bildern laden. Bitte denken Sie daran, es danach eval $(minikube docker-env) auszuführen, da minikube keine Bilder für die lokal installierte Docker-Engine freigibt.

Andere Antworten setzen voraus, dass Sie Minikube mit VM verwenden, sodass auf Ihre lokalen Images von Minikube VM nicht zugegriffen werden kann.

Wenn Sie minikube mit verwenden --vm-driver=none, können Sie lokale Bilder einfach wiederverwenden, indem Sie image_pull_policyauf Nie einstellen :

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

oder Einstellfeld imagePullPolicyfür Cotainer in entsprechenden .yamlManifesten.

Eine Idee wäre, das Docker-Image lokal zu speichern und später wie folgt in minikube zu laden:

Nehmen wir zum Beispiel an, Sie haben bereits ein Puckel / Docker-Luftstrom-Bild.

1. Speichern Sie das Image auf der lokalen Festplatte -

   docker save puckel/docker-airflow > puckel_docker_airflow.tar

2. Geben Sie jetzt in Minikube Docker env -

   eval $(minikube docker-env)

3. Laden Sie das lokal gespeicherte Bild -

   docker load < puckel_docker_airflow.tar

So einfach ist das und es wirkt wie ein Zauber.

Was wäre, wenn Sie nur k8s in Dockers VM ausführen könnten? Es gibt native Unterstützung dafür mit den neueren Versionen von Docker Desktop ... Sie müssen nur diese Unterstützung aktivieren.

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

wie ich das herausgefunden habe:

Während Sie die Dokumente für helm lesen, erhalten Sie eine kurze Anleitung zur Installation von minikube. Dieses Tutorial installiert Minikube in einer VM, die sich vom Docker unterscheidet.

Als es an der Zeit war, meine Helmkarten zu installieren, konnte ich helm / k8s nicht dazu bringen, die Bilder abzurufen, die ich mit Docker erstellt hatte. So bin ich hier zu dieser Frage gekommen.

Also ... wenn Sie mit jeder Version von k8s leben können, die mit Docker Desktop geliefert wird, und Sie damit leben können, was auch immer mit VM Docker läuft, dann ist diese Lösung vielleicht ein bisschen einfacher als einige der anderen.

Haftungsausschluss: Ich bin mir nicht sicher, wie sich das Wechseln zwischen Windows- / Linux-Containern auf irgendetwas auswirken würde.

Es gibt einen Aufsatz und eine effektive Möglichkeit, Ihr lokales Docker-Image direkt in die Minikube zu verschieben. Dies spart Zeit beim erneuten Erstellen der Bilder in der Minikube.

minikube cache add <Image name>

Weitere Details hier

Alle möglichen Methoden zum Verschieben von Bildern in den Minikube werden hier erwähnt: https://minikube.sigs.k8s.io/docs/handbook/pushing/

Sie können die Docker-Shell entweder wiederverwenden eval $(minikube docker-env)oder alternativ docker save | docker loadüber die Shells hinweg nutzen.

1. Setup Minikube Docker-Env
2. Erstellen Sie erneut dasselbe Docker-Image (mit minikube docker-env).
3. Ändern Sie imagePullPolicy in Ihrer Bereitstellung in Nie

Was hier tatsächlich passiert, ist, dass Ihr Minikube Ihren Docker-Daemon nicht erkennen kann, da es sich um einen unabhängigen Dienst handelt. Sie müssen zuerst Ihre Minikube-Docker-Umgebung festlegen, indem Sie den folgenden Befehl verwenden, um dies zu überprüfen

 "eval $(minikube docker-env)"

Wenn Sie den folgenden Befehl ausführen, wird angezeigt, wo Ihre Minikube nach Docker sucht.

~$ 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)

Sie müssen erneut Images erstellen, sobald Sie minikube docker-env eingerichtet haben, sonst schlägt es fehl.

Ich finde diese Methode von ClickHouse Operator Build From Sources und sie hilft und rettet mein Leben!

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

Schritte zum Ausführen lokaler Docker-Images in Kubernetes
1. eval $ (minikube -p minikube docker-env)
2. Fügen Sie in der Artefaktdatei unter Spezifikationsabschnitt -> Container
imagePullPolicy: IfNotPresent
oder imagePullPolicy: Never hinzu

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. dann laufen kubectl create -f <filename>