¿Cómo usar las imágenes locales del acoplador con Minikube?


301

Tengo varias imágenes acoplables con las que quiero usar minikube. No quiero tener que cargar primero y luego descargar la misma imagen en lugar de usar la imagen local directamente. ¿Cómo hago esto?

Cosas que probé:
1. Intenté ejecutar estos comandos (por separado, eliminando las instancias de minikube en ambas ocasiones y comenzando de nuevo)

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

Salida:

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

Simplemente se atasca en algún estado, pero nunca alcanza el estado listo.


2. Intenté crear un registro y luego poner imágenes en él, pero tampoco funcionó. Podría haberlo hecho incorrectamente, pero no puedo encontrar las instrucciones adecuadas para realizar esta tarea.

Proporcione instrucciones para usar imágenes locales de acoplador en la instancia local de kubernetes.
SO: ubuntu 16.04
Docker: Docker versión 1.13.1, compilación 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 alguien pudiera ayudarme a obtener una solución que use docker-compose para hacer esto, sería increíble. Gracias.

Editar:

Imágenes cargadas en 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           

Respuestas:


408

Como describe el archivo README , puede reutilizar el demonio Docker de Minikube con eval $(minikube docker-env).

Entonces, para usar una imagen sin cargarla, puede seguir estos pasos:

  1. Establezca las variables de entorno con eval $(minikube docker-env)
  2. Construye la imagen con el Docker daemon de Minikube (por ejemplo docker build -t my-image .)
  3. Establezca la imagen en la especificación del pod como la etiqueta de compilación (por ejemplo my-image)
  4. Establezca imagePullPolicya Never, de lo contrario, Kubernetes intentará descargar la imagen.

Nota importante: debe ejecutar eval $(minikube docker-env)en cada terminal que desee usar, ya que solo establece las variables de entorno para la sesión de shell actual.


1
AFAIS solo puedes hacer eso con un nuevo minukube con minikube start --disk-size 100g. Otra solución sería eliminar imágenes antiguas con docker imagesy docker rmi.
svenwltr

66
Es muy importante recordar ejecutar eval $(minikube docker-env)después de cerrar la terminal en la que está trabajando ANTES de intentar reconstruir imágenes ... solo quemé 6 horas peleando con una imagen que no se estaba actualizando en minikube ... parecía que un paquete no se estaba actualizando ... Realmente no estoy actualizando la imagen a la que Minikube hacía referencia.
Mike

1
La política de extracción predeterminada es lo IfNotPresentque significa que todo lo que tenemos que hacer es establecer las variables de entorno.
Beygi

29
Si quieres regresar o salir de env de minikube ..eval $(minikube docker-env -u)
Budi Mulyo

1
@nmxl mira aquí
testuser

175

Lo que funcionó para mí, basado en la solución 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
Puede encontrar la versión yml de la línea de comandos anterior (en relación con la imagePullPolicy) aquí: kubernetes.io/docs/concepts/containers/images
granadaCoder

128

¡Esta respuesta no se limita al minikube!

Use un registro local:

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

Ahora etiquete su imagen correctamente:

docker tag ubuntu localhost:5000/ubuntu

Tenga en cuenta que localhost debe cambiarse al nombre dns de la máquina que ejecuta el contenedor de registro.

Ahora empuje su imagen al registro local:

docker push localhost:5000/ubuntu

Debería poder retirarlo:

docker pull localhost:5000/ubuntu

Ahora cambie su archivo yaml para usar el registro local.

Piense en el volumen de montaje en la ubicación adecuada para conservar las imágenes en el registro.

actualizar:

como dijo Eli, deberá agregar el registro local como inseguro para usar http (puede que no se aplique cuando se usa localhost pero se aplica si se usa el nombre de host local)

No use http en producción, haga el esfuerzo de asegurar las cosas.


2
El | Ahora cambie su archivo yaml para usar el registro local. ¿Eres capaz de explicar esto un poco? Empujé al registro local (truco genial) pero tengo el mismo problema que no puedo hacer que minikube se conecte a él.
Zach Estela

3
@ZachEstela cambia el nombre de la imagen en el yaml a<registryIP>:5000/ubuntu
Farhad Farahi

@FarhadFarahi ¿Dónde puedo encontrar el "nombre DNS de la máquina que ejecuta el contenedor de registro"?
Daan

1
@FarhadFarahi Si te entrego mi computadora portátil, ¿cómo lo averiguarías? Solo quiero saberlo. Seguí los pasos del tutorial de Docker para ejecutar Docker para Windows.
Daan

1
@FarhadFarahi: agregue a su respuesta que deberá agregar el registro local como inseguro para usar http: docs.docker.com/registry/insecure (puede que no se aplique cuando se usa localhost pero se aplica si se usa el nombre de host local )
Eli Algranti

14

Agregando a la respuesta de @Farhad basada en esta respuesta ,

Estos son los pasos para configurar un registro local.

Configuración en máquina local

Configurar el nombre de host en la máquina local: edite /etc/hostspara agregar esta línea

docker.local 127.0.0.1

Ahora inicie un registro local (elimine -d para ejecutar el modo no demonio):

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

Ahora etiquete su imagen correctamente:

docker tag ubuntu docker.local:5000/ubuntu

Ahora empuje su imagen al registro local:

docker push docker.local:5000/ubuntu

Verifique que se empuje la imagen:

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

Configuración en minikube

ssh en minikube con: minukube ssh

editar /etc/hostspara agregar esta línea

docker.local <your host machine's ip>

Verificar acceso:

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

Ahora, si intenta tirar, es posible que obtenga un error de acceso http.

Habilitar acceso inseguro :

Si siempre planea usar minkube con esta configuración local, cree un minikube para usar el registro inseguro de forma predeterminada (no funcionará en el clúster existente).

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

de lo contrario, siga los pasos a continuación:

systemctl stop docker

edite el archivo docker serice: obtenga la ruta de systemctl status docker

puede ser :

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

agregue este texto (reemplace 192.168.1.4 con su ip)

--seguridad-registro docker.local: 5000 --seguridad-registro 192.168.1.4:5000

a esta línea

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

intenta tirar:

docker pull docker.local:5000/ubuntu

Ahora cambie su archivo yaml para usar el registro local.

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

a

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

No use http en producción, haga el esfuerzo de asegurar las cosas.


12

Además de la respuesta aceptada, también puede lograr lo que deseaba originalmente (crear una implementación con el runcomando) con el siguiente comando:

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

Encontré la información sobre el generador en el foro Kubernetes-dev:

Si está utilizando kubectl run, genera un manifiesto para usted que está imagePullPolicyconfigurado Alwaysde forma predeterminada. Puede usar este comando para obtener un imagePullPolicyof IfNotPresent, que funcionará para minikube:

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

Dan Lorenc

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


9

Un enfoque es construir la imagen localmente y luego hacer:

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

minikube docker-envEs posible que no devuelva la información correcta que se ejecuta bajo un usuario / sudo diferente. En cambio, puedes correr sudo -u yourUsername minikube docker-env.

Debería devolver algo como:

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)

El comando correcto esdocker save imageNameGoesHere > pv | (eval $(minikube docker-env) && docker load)
salvador

1
docker save imageNameGoesHere | (eval $(minikube docker-env) && docker load)funcionó para mí
lhaferkamp


4

De los documentos de kubernetes:

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

La política de extracción predeterminada es IfNotPresent, lo que hace que Kubelet omita extraer una imagen si ya existe. Si desea forzar siempre un tirón, puede realizar una de las siguientes acciones:

  • establezca la imagePullPolicy del contenedor en Siempre;
  • uso: último como la etiqueta para la imagen a utilizar;
  • habilite el controlador de admisión AlwaysPullImages.

O lea de la otra manera: el uso de: la última etiqueta obliga a las imágenes a extraerse siempre. Si usa lo eval $(minikube docker-env)que se mencionó anteriormente, entonces no use ninguna etiqueta o asigne una etiqueta a su imagen local, puede evitar que Kubernetes intente tirar de ella a la fuerza.



3

Un método más simple que responde a la pregunta original "¿Cómo usar imágenes locales de acoplador con Minikube?", Es guardar la imagen en un archivo tar y cargarla en 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

Luego, ejecutar la imagen implica un comando como el siguiente. Asegúrese de incluir el parámetro "--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 explicado, funcionó a las mil maravillas. Yo sólo tenía que llamar docker savecon sudo, y después fijar sudo chmod 664 my-image.tarpara que esté disponible para mi usuario actual.
Meir Gabay

Este debería ser el enfoque más rápido, creo.
Shiwakant Bharti

2

Para agregar a las respuestas anteriores, si tiene una imagen tarball, simplemente puede cargarla en su conjunto local de imágenes de docker docker image load -i /path/image.tar. Recuerde ejecutarla después eval $(minikube docker-env) , ya que minikube no comparte imágenes con el motor de docker instalado localmente.


2

Otras respuestas suponen que usa minikube con VM, por lo que sus imágenes locales no son accesibles desde minikube VM.

En caso de que use minikube con --vm-driver=none, puede reutilizar fácilmente las imágenes locales configurando image_pull_policyNunca:

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

o establecer el imagePullPolicycampo para cotainers en los .yamlmanifiestos correspondientes .


2

Una idea sería guardar la imagen del acoplador localmente y luego cargarla en minikube de la siguiente manera:

Digamos, por ejemplo, que ya tiene una imagen puckel / docker-airflow.

  1. Guarde esa imagen en el disco local.

    docker save puckel/docker-airflow > puckel_docker_airflow.tar

  2. Ahora entra en minikube docker env -

    eval $(minikube docker-env)

  3. Cargue esa imagen guardada localmente

    docker load < puckel_docker_airflow.tar

Es así de simple y funciona como un encanto.


Todavía necesita la sugerencia de la respuesta aceptada Set the imagePullPolicy to Never. Si su imagen está etiquetada con una dirección, por ejemplo us.icr.io/mydiv/my-service:v0.0.1, una implementación intentará extraer esta imagen de forma remota. Como ya ha copiado manualmente la imagen, debe evitar que k8s extraiga la imagen de una dirección (registro de contenedor) a la que no puede acceder.
colm.anseo

1

¿Qué pasaría si pudieras ejecutar k8s dentro de Docker's VM? Hay soporte nativo para esto con las versiones más recientes de Docker Desktop ... solo necesita habilitar ese soporte.

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

cómo descubrí esto:

mientras lee los documentos de helm, le dan un breve tutorial sobre cómo instalar minikube. ese tutorial instala minikube en una máquina virtual que es diferente / separada de Docker.

así que cuando llegó el momento de instalar mis gráficos de timón, no pude hacer que helm / k8s extrajera las imágenes que había construido con Docker. así es como llegué aquí a esta pregunta.

entonces ... si puede vivir con cualquier versión de k8 que venga con el escritorio de Docker, y puede vivir con ella ejecutándose en cualquier Docker vm, entonces tal vez esta solución sea un poco más fácil que algunas de las otras.

Descargo de responsabilidad: no estoy seguro de cómo cambiar entre los contenedores de Windows / Linux afectaría algo.


Creo que también tuve que configurar imagePullPolicies en IfNotPresent
chad

1

Hay un ensayo y una forma efectiva de llevar su imagen local de Docker directamente al minikube, lo que le ahorrará tiempo al construir las imágenes en minikube nuevamente.

minikube cache add <Image name>

Más detalles aquí

Todos los métodos posibles para enviar imágenes a minikube se mencionan aquí: https://minikube.sigs.k8s.io/docs/handbook/pushing/


0

puede reutilizar la carcasa de la ventana acoplable y eval $(minikube docker-env), alternativamente, puede aprovecharla a docker save | docker loadtravés de las carcasas.


0
  1. configurar minikube docker-env
  2. nuevamente construya la misma imagen de docker (usando minikube docker-env)
  3. cambie imagePullPolicy a Never en su implementación

En realidad, lo que sucede aquí, su Minikube no puede reconocer su Docker Daemon, ya que es un servicio independiente. Primero debe configurar su entorno Minikube-Docker.

 "eval $(minikube docker-env)"

Si ejecuta el siguiente comando, mostrará dónde busca su minikube 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)

Debe volver a crear imágenes una vez que configure minikube docker-env, de lo contrario, fallará.



0

pasos para ejecutar imágenes locales de acoplador en kubernetes
1. eval $ (minikube -p minikube docker-env)
2. en el archivo de artefactos, en la sección de especificaciones -> contenedores
agregue imagePullPolicy: IfNotPresent
o 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. luego corre kubectl create -f <filename>

Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.