Come utilizzare le immagini docker locali con Minikube?

Ho diverse immagini docker con cui voglio usare minikube. Non voglio prima caricare e poi scaricare la stessa immagine invece di utilizzare direttamente l'immagine locale. Come faccio a fare questo?

Roba che ho provato:
1. Ho provato a eseguire questi comandi (separatamente, eliminando le istanze di minikube entrambe le volte e ricominciando da capo)

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

Produzione :

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

Si blocca solo su un certo stato ma non raggiunge mai lo stato pronto.

2. Ho provato a creare un registro e quindi a inserire immagini, ma non ha funzionato neanche. Potrei averlo fatto in modo errato, ma non riesco a trovare le istruzioni adeguate per eseguire questa operazione.

Fornisci le istruzioni per utilizzare le immagini della finestra mobile locale nell'istanza di kubernetes locale. Sistema
operativo: ubuntu 16.04
Docker: Docker versione 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"}

Se qualcuno potesse aiutarmi a ottenere una soluzione che utilizza docker-compose per farlo, sarebbe fantastico. Grazie.

Modificare :

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

Come descritto nel file README , è possibile riutilizzare il demone Docker da Minikube con eval $(minikube docker-env).

Quindi, per usare un'immagine senza caricarla, puoi seguire questi passaggi:

1. Impostare le variabili di ambiente con eval $(minikube docker-env)
2. Costruisci l'immagine con il demone Docker di Minikube (ad es. docker build -t my-image .)
3. Imposta l'immagine nelle specifiche del pod come il tag build (ad es. my-image)
4. Impostare imagePullPolicysu Never, altrimenti Kubernetes proverà a scaricare l'immagine.

Nota importante: è necessario eseguire eval $(minikube docker-env)su ciascun terminale che si desidera utilizzare, poiché imposta solo le variabili di ambiente per la sessione di shell corrente.

Cosa ha funzionato per me, basato sulla soluzione di @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

Questa risposta non è limitata a minikube!

Usa un registro locale:

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

Ora tagga correttamente l'immagine:

docker tag ubuntu localhost:5000/ubuntu

Si noti che localhost deve essere modificato in nome DNS della macchina che esegue il contenitore del registro.

Ora invia la tua immagine al registro locale:

docker push localhost:5000/ubuntu

Dovresti essere in grado di tirarlo indietro:

docker pull localhost:5000/ubuntu

Ora cambia il tuo file yaml per usare il registro locale.

Pensa al montaggio del volume nella posizione appropriata per rendere persistenti le immagini nel registro.

aggiornare:

come affermato da Eli, è necessario aggiungere il registro locale come non sicuro per utilizzare http (potrebbe non essere applicabile quando si utilizza localhost ma si applica se si utilizza il nome host locale)

Non utilizzare http nella produzione, fai lo sforzo di mettere in sicurezza le cose.

Aggiungendo alla risposta di @Farhad in base a questa risposta ,

Questi sono i passaggi per configurare un registro locale.

Installazione nella macchina locale

Imposta il nome host nel computer locale: modifica /etc/hostsper aggiungere questa riga

docker.local 127.0.0.1

Ora avvia un registro locale (rimuovi -d per eseguire la modalità non daemon):

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

Ora tagga correttamente l'immagine:

docker tag ubuntu docker.local:5000/ubuntu

Ora invia la tua immagine al registro locale:

docker push docker.local:5000/ubuntu

Verifica che l'immagine sia stata spinta:

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

Installazione in minikube

ssh in minikube con: minukube ssh

modifica /etc/hostsper aggiungere questa riga

docker.local <your host machine's ip>

Verifica accesso:

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

Ora, se si tenta di estrarre, è possibile che venga visualizzato un errore di accesso http.

Abilita accesso non sicuro :

Se si prevede sempre di utilizzare minkube con questa configurazione locale, creare un minikube per utilizzare il registro non sicuro per impostazione predefinita (non funzionerà sul cluster esistente).

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

altrimenti segui i passaggi seguenti:

systemctl stop docker

modificare il file serice docker: ottenere il percorso da systemctl status docker

può essere :

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

aggiungi questo testo (sostituisci 192.168.1.4 con il tuo ip)

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

a questa linea

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

prova a tirare:

docker pull docker.local:5000/ubuntu

Ora cambia il tuo file yaml per usare il registro locale.

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

per

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

Non utilizzare http nella produzione, fai lo sforzo di mettere in sicurezza le cose.

Oltre alla risposta accettata, puoi anche ottenere ciò che inizialmente volevi (creare una distribuzione usando il runcomando) con il seguente comando:

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

Ho trovato le informazioni sul generatore sul forum Kubernetes-dev:

Se lo stai usando kubectl run, genera un manifest per te che sembra essere stato imagePullPolicyimpostato di Alwaysdefault. È possibile utilizzare questo comando per ottenere un imagePullPolicydi IfNotPresent, che funzionerà per minikube:

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

Dan Lorenc

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

Un approccio è quello di costruire l'immagine localmente e quindi fare:

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

minikube docker-envpotrebbe non restituire le informazioni corrette in esecuzione con un altro utente / sudo. Invece puoi correre sudo -u yourUsername minikube docker-env.

Dovrebbe restituire qualcosa del tipo:

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)

Se qualcuno sta cercando di tornare nell'ambiente locale dopo aver impostato il minikube env, utilizzare il comando seguente.

eval $(docker-machine env -u)

Dai documenti di kubernetes:

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

Il criterio pull predefinito è IfNotPresent che fa sì che Kubelet salti il ​​pull di un'immagine se esiste già. Se si desidera forzare sempre un pull, è possibile effettuare una delle seguenti operazioni:

• impostare imagePullPolicy del contenitore su Sempre;
• uso: ultimo come tag per l'immagine da usare;
• abilitare il controller di ammissione AlwaysPullImages.

Oppure leggi nell'altro modo: L'uso del tag: latest impone che le immagini vengano sempre estratte. Se usi il eval $(minikube docker-env)metodo sopra menzionato, o non usi alcun tag o assegni un tag alla tua immagine locale, puoi evitare che Kubernetes cerchi di estrarlo forzatamente.

Ora c'è un addon del Registro di sistema Minikube, questo è probabilmente il modo più semplice. Ecco come usarlo: https://minikube.sigs.k8s.io/docs/tasks/registry/insecure/

Si noti che ho avuto problemi DNS, potrebbe essere un bug.

Un metodo più semplice che risponde alla domanda originale "Come utilizzare le immagini della finestra mobile locale con Minikube?", È salvare l'immagine in un file tar e caricarla in 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

Quindi l'esecuzione dell'immagine comporta un comando come il seguente. Assicurati di includere il parametro "--image-pull-policy = Never".

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

Per aggiungere alle risposte precedenti, se hai un'immagine tarball, puoi semplicemente caricarla sul tuo set di immagini docker locale docker image load -i /path/image.tar. Ricordati di eseguirlo dopo eval $(minikube docker-env) , poiché minikube non condivide le immagini con il motore docker installato localmente.

Altre risposte suppongono che tu usi minikube con VM, quindi le tue immagini locali non sono accessibili da minikube VM.

Nel caso in cui usi minikube con --vm-driver=none, puoi facilmente riutilizzare le immagini locali impostando image_pull_policysu Mai:

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

o imagePullPolicycampo di impostazione per cotainer nei .yamlmanifesti corrispondenti .

Un'idea sarebbe quella di salvare l'immagine docker localmente e successivamente caricarla nel minikube come segue:

Supponiamo, ad esempio, che tu abbia già un'immagine puckel / docker-airflow.

1. Salva quell'immagine sul disco locale -

   docker save puckel/docker-airflow > puckel_docker_airflow.tar

2. Ora entra in minikube docker env -

   eval $(minikube docker-env)

3. Carica l'immagine salvata localmente -

   docker load < puckel_docker_airflow.tar

È così semplice e funziona come un fascino.

cosa succederebbe se potessi semplicemente eseguire k8s nella finestra mobile di Docker? c'è supporto nativo per questo con le versioni più recenti del desktop docker ... devi solo abilitare quel supporto.

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

come l'ho scoperto:

durante la lettura dei documenti per helm, ti forniscono un breve tutorial su come installare minikube. quel tutorial installa minikube in un VM diverso / separato dalla finestra mobile.

così quando è arrivato il momento di installare i miei grafici del timone, non sono riuscito a ottenere helm / k8s per estrarre le immagini che avevo creato usando la finestra mobile. è così che sono arrivato qui a questa domanda.

quindi ... se puoi vivere con qualsiasi versione di k8s viene fornito con il desktop docker, e puoi vivere con esso in esecuzione in qualsiasi vm docker, allora forse questa soluzione è un po 'più semplice di alcune delle altre.

dichiarazione di non responsabilità: non sono sicuro di come il passaggio tra i contenitori Windows / Linux influirebbe su qualsiasi cosa.

Esiste un saggio ed un modo efficace per inviare l'immagine Docker locale direttamente al minikube, che consentirà di risparmiare tempo dalla creazione delle immagini nel minikube.

minikube cache add <Image name>

Maggiori dettagli qui

Tutti i possibili metodi per inviare le immagini al minikube sono menzionati qui: https://minikube.sigs.k8s.io/docs/handbook/pushing/

puoi riutilizzare la shell docker e eval $(minikube docker-env), in alternativa, puoi sfruttare docker save | docker loadle shell.

1. imposta minikube docker-env
2. crea nuovamente la stessa immagine finestra mobile (usando minikube docker-env)
3. cambia imagePullPolicy su Mai nella tua distribuzione

in realtà cosa succede qui, il tuo Minikube non è in grado di riconoscere il tuo demone docker in quanto è un servizio indipendente. Devi prima impostare il tuo ambiente minikube-docker usando il comando sotto per controllare

 "eval $(minikube docker-env)"

Se si esegue sotto il comando mostrerà dove il tuo minikube cerca 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)

Devi creare di nuovo le immagini dopo aver installato minikube docker-env, altrimenti fallirà.

trovo questo metodo da ClickHouse Operator Build From Sources e mi aiuta a salvarmi la vita!

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

passaggi per eseguire le immagini della finestra mobile locale in kubernetes
1. eval $ (minikube -p minikube docker-env)
2. nel file artefatto, nella sezione specifica -> contenitori
aggiungi imagePullPolicy: IfNotPresent
o imagePullPolicy: Mai

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. quindi esegui kubectl create -f <filename>