Jak korzystać z lokalnych obrazów dokerów w Minikube?

Mam kilka obrazów dokerów, z którymi chcę korzystać minikube. Nie chcę najpierw przesyłać, a następnie pobierać tego samego obrazu, zamiast bezpośrednio używać lokalnego obrazu. Jak mam to zrobic?

Rzeczy, które próbowałem:
1. Próbowałem uruchomić te polecenia (osobno, usuwając instancje minikube za każdym razem i zaczynając od nowa)

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

Wynik :

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

Po prostu blokuje się na jakimś statusie, ale nigdy nie osiąga stanu gotowości.

2. Próbowałem utworzyć rejestr, a następnie umieścić w nim obrazy, ale to też nie zadziałało. Mogłem to zrobić niepoprawnie, ale nie mogę znaleźć odpowiednich instrukcji, aby wykonać to zadanie.

Podaj instrukcje dotyczące używania lokalnych obrazów dokerów w lokalnej instancji kubernetes.
System operacyjny: ubuntu 16.04
Docker: Docker wersja 1.13.1, kompilacja 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"}

Gdyby ktoś mógł mi pomóc w uzyskaniu rozwiązania wykorzystującego kompozycję dokującą, byłoby to niesamowite. Dzięki.

Edytować :

Obrazy załadowane 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           

Jak opisano w README , możesz ponownie użyć demona Docker z Minikube za pomocą eval $(minikube docker-env).

Aby użyć obrazu bez przesyłania, możesz wykonać następujące czynności:

1. Ustaw zmienne środowiskowe za pomocą eval $(minikube docker-env)
2. Zbuduj obraz za pomocą demona Docker z Minikube (np. docker build -t my-image .)
3. Ustaw obraz w specyfikacji pod jak na przykład tag budowania (np. my-image)
4. Ustaw imagePullPolicysię Never, inaczej Kubernetes spróbuje pobrać obraz.

Ważna uwaga: Musisz uruchomić eval $(minikube docker-env)na każdym terminalu, którego chcesz użyć, ponieważ ustawia on tylko zmienne środowiskowe dla bieżącej sesji powłoki.

Co dla mnie zadziałało, w oparciu o rozwiązanie @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

Ta odpowiedź nie jest ograniczona do minikube!

Użyj rejestru lokalnego:

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

Teraz poprawnie oznacz swoje zdjęcie:

docker tag ubuntu localhost:5000/ubuntu

Zauważ, że localhost powinien zostać zmieniony na nazwę dns komputera z uruchomionym kontenerem rejestru.

Teraz wypchnij obraz do lokalnego rejestru:

docker push localhost:5000/ubuntu

Powinieneś być w stanie to cofnąć:

docker pull localhost:5000/ubuntu

Teraz zmień plik yaml, aby korzystać z rejestru lokalnego.

Pomyśl o zamontowaniu woluminu w odpowiedniej lokalizacji, aby zachować obrazy w rejestrze.

aktualizacja:

jak stwierdził Eli, musisz dodać rejestr lokalny jako niezabezpieczony, aby używać http (może nie mieć zastosowania, gdy używasz localhost, ale dotyczy, jeśli używasz lokalnej nazwy hosta)

Nie używaj http w produkcji, staraj się zabezpieczyć wszystko.

Dodając do odpowiedzi @Farhad na podstawie tej odpowiedzi ,

Oto kroki, aby skonfigurować rejestr lokalny.

Konfiguracja na komputerze lokalnym

Ustaw nazwę hosta na komputerze lokalnym: edytuj, /etc/hostsaby dodać ten wiersz

docker.local 127.0.0.1

Teraz uruchom rejestr lokalny (usuń -d, aby uruchomić tryb inny niż demon):

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

Teraz poprawnie oznacz swoje zdjęcie:

docker tag ubuntu docker.local:5000/ubuntu

Teraz wypchnij obraz do lokalnego rejestru:

docker push docker.local:5000/ubuntu

Sprawdź, czy obraz został wypchnięty:

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

Konfiguracja w minikube

ssh do minikube z: minukube ssh

edytuj, /etc/hostsaby dodać ten wiersz

docker.local <your host machine's ip>

Sprawdź dostęp:

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

Teraz, jeśli spróbujesz wyciągnąć, możesz dostać błąd dostępu http.

Włącz niepewny dostęp :

Jeśli zawsze planujesz używać Minkube z tą lokalną konfiguracją, utwórz minikube, aby domyślnie używać niezabezpieczonego rejestru (nie będzie działać na istniejącym klastrze).

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

w przeciwnym razie wykonaj poniższe kroki:

systemctl stop docker

edytuj plik usługi dokera: pobierz ścieżkę z systemctl status docker

może być :

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

dołącz ten tekst (zamień 192.168.1.4 na ip)

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

do tej linii

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-register 10.0.0.0/24

systemctl daemon-reload
systemctl start docker

spróbuj pociągnąć:

docker pull docker.local:5000/ubuntu

Teraz zmień plik yaml, aby korzystać z rejestru lokalnego.

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

do

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

Nie używaj http w produkcji, staraj się zabezpieczyć wszystko.

Oprócz zaakceptowanej odpowiedzi możesz również osiągnąć to, czego pierwotnie chciałeś (tworzenie wdrożenia za pomocą runpolecenia) za pomocą następującego polecenia:

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

Informacje o generatorze znalazłem na forum Kubernetes-dev:

Jeśli używasz kubectl run, generuje manifest, dla którego akurat jest imagePullPolicyustawiony Alwaysdomyślnie. Można użyć tego polecenia, aby uzyskać imagePullPolicySIĘ GO IfNotPresent, która będzie pracować dla minikube:

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

Dan Lorenc

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

Jednym podejściem jest zbudowanie obrazu lokalnie, a następnie:

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

minikube docker-envmoże nie zwrócić poprawnych informacji działających pod innym użytkownikiem / sudo. Zamiast tego możesz biegać sudo -u yourUsername minikube docker-env.

Powinien zwrócić coś takiego:

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)

Jeśli ktoś chce wrócić do środowiska lokalnego po ustawieniu env minikube, użyj następującego polecenia.

eval $(docker-machine env -u)

Z dokumentów kubernetes:

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

Domyślna zasada ściągania to IfNotPresent, która powoduje, że Kubelet pomija ciągnięcie obrazu, jeśli już istnieje. Jeśli chcesz zawsze wymuszać pociągnięcie, możesz wykonać jedną z następujących czynności:

• ustaw imagePullPolicy kontenera na Always;
• użyj: najnowszy jako znacznik obrazu do użycia;
• włącz kontroler dostępu AlwaysPullImages.

Lub przeczytaj inaczej: użycie: najnowszego znacznika zmusza obrazy do ciągnięcia. Jeśli użyjesz eval $(minikube docker-env)powyższego, to albo nie używaj żadnego znacznika, albo przypisaj znacznik do swojego lokalnego obrazu, możesz uniknąć Kubernetes próbującego go wymusić.

Jest teraz dodatek do rejestru Minikube, jest to prawdopodobnie najłatwiejszy sposób. Oto jak z niego korzystać: https://minikube.sigs.k8s.io/docs/tasks/registry/insecure/

Pamiętaj, że miałem problemy z DNS, może to być błąd.

Prostszą metodą, która odpowiada na pierwotne pytanie „Jak korzystać z lokalnych obrazów dokerów w Minikube?”, Jest zapisanie obrazu w pliku tar i załadowanie go do 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

Następnie uruchomienie obrazu wiąże się z następującą komendą. Pamiętaj, aby dołączyć parametr „--image-pull-policy = Never”.

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

Aby dodać do poprzednich odpowiedzi, jeśli masz obraz tarballa, możesz po prostu załadować go do lokalnego zestawu dokerów obrazów. docker image load -i /path/image.tarPamiętaj, aby go uruchomić później eval $(minikube docker-env) , ponieważ minikube nie udostępnia zdjęć lokalnie zainstalowanemu silnikowi dokera.

Inne odpowiedzi przypuszczają, że używasz minikube z VM, więc twoje lokalne obrazy nie są dostępne z minikube VM.

Jeśli używasz Minikube z --vm-driver=none, możesz łatwo ponownie użyć lokalnych obrazów, ustawiając image_pull_policyNigdy:

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

lub ustawienie imagePullPolicypola dla cotainerów w odpowiednich .yamlmanifestach.

Jednym z pomysłów byłoby lokalne zapisanie obrazu dokera, a następnie załadowanie go do minikube w następujący sposób:

Załóżmy na przykład, że masz już obraz puckel / docker-airflow.

1. Zapisz ten obraz na dysku lokalnym -

   docker save puckel/docker-airflow > puckel_docker_airflow.tar

2. Teraz wejdź do minikube docker env -

   eval $(minikube docker-env)

3. Załaduj ten lokalnie zapisany obraz -

   docker load < puckel_docker_airflow.tar

To takie proste i działa jak urok.

co jeśli możesz po prostu uruchomić K8 w vm dockera? istnieje natywna obsługa tego z nowszymi wersjami pulpitu dokującego ... wystarczy włączyć tę obsługę.

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

jak się tego dowiedziałem:

podczas czytania dokumentacji dla sternika, dają ci krótki tutorial jak zainstalować minikube. ten samouczek instaluje minikube w vm, który jest inny / niezależny od dokera.

więc kiedy nadszedł czas, aby zainstalować moje tabele sterów, nie mogłem zmusić steru / k8 do ściągnięcia obrazów, które zbudowałem przy użyciu Dockera. tak doszedłem do tego pytania.

więc ... jeśli możesz żyć z dowolną wersją K8s dostarczaną z pulpitem dokera, i możesz żyć z nią, działając w dowolnym oknie dokera vm, to może to rozwiązanie jest nieco łatwiejsze niż niektóre inne.

zrzeczenie się odpowiedzialności: nie jestem pewien, w jaki sposób przełączanie między kontenerami Windows / Linux może mieć wpływ na cokolwiek.

Jest jeden esej i skuteczny sposób na przesłanie lokalnego obrazu Dockera bezpośrednio do minikube, który pozwoli zaoszczędzić czas na ponownym budowaniu obrazów w minikube.

minikube cache add <Image name>

Więcej informacji tutaj

Wszystkie możliwe metody przesyłania obrazów do minikube są wymienione tutaj: https://minikube.sigs.k8s.io/docs/handbook/pushing/

możesz albo ponownie użyć powłoki dokera, albo eval $(minikube docker-env)możesz użyć dźwigni w docker save | docker loadpoprzek powłok.

1. setup minikube docker-env
2. ponownie zbuduj ten sam obraz dokera (używając minikube docker-env)
3. zmień imagePullPolicy na Never we wdrożeniu

tak naprawdę to, co się tutaj dzieje, twój Minikube nie może rozpoznać twojego demona dokera, ponieważ jest to niezależna usługa. Musisz najpierw ustawić środowisko minikube-dokera, używając poniższego polecenia, aby sprawdzić

 "eval $(minikube docker-env)"

Jeśli uruchomisz poniżej polecenia, pokaże, gdzie twój minikube szuka dokera.

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

Musisz ponownie zbudować obrazy po skonfigurowaniu Minikube docker-env, inaczej to się nie powiedzie.

znajduję tę metodę od ClickHouse Operator Build From Sources i pomaga i ratuje mi życie!

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

kroki do uruchomienia lokalnych obrazów dokera w kubernetes
1. eval $ (minikube -p minikube docker-env)
2. w pliku artefaktu, w sekcji specyfikacji -> pojemniki
dodaj imagePullPolicy: IfNotPresent
lub imagePullPolicy: Nigdy

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. następnie uruchom kubectl create -f <filename>