Además de la carga de minikube image load <image name> , echa un vistazo a la versión más reciente (noviembre de 2021 en el momento de escribir este artículo) de Minikube.

v1.24.0

Agregue el indicador --no-kubernetes para iniciar minikube sin Kubernetes
Ver PR 12848 , para

Eso te da:

 mk start --no-kubernetes minikube v1.24.0-beta.0 on Darwin 11.6 (arm64) Automatically selected the docker driver Starting minikube without Kubernetes minikube in cluster minikube Pulling base image ... Creating docker container (CPUs=2, Memory=1988MB) ... Done! minikube is ready without Kubernetes!

Cosas para probar sin Kubernetes

• " minikube ssh " a SSH en el nodo de minikube.
• " minikube docker-env " para crear imágenes apuntando a la ventana acoplable dentro de minikube
• " minikube image " para construir imágenes sin ventana acoplable

construyendo la respuesta anterior para usar eval $(minikube docker-env) para cargar el entorno docker de minikube, para una alternancia más fácil, agregue la siguiente función a su archivo shell rc:

 dockube() { if [[ $1 = 'which' ]]; then if [[ $MINIKUBE_ACTIVE_DOCKERD = 'minikube' ]]; then echo $MINIKUBE_ACTIVE_DOCKERD else echo 'system' fi return fi if [[ $MINIKUBE_ACTIVE_DOCKERD = 'minikube' ]]; then eval $(minikube docker-env -u) echo "now using system docker" else eval $(minikube -p minikube docker-env) echo "now using minikube docker" fi }

dockube sin argumento alternará entre el sistema y el entorno docker de minikube, y dockube which devolverá cuál está en uso.

En minikube 1.20, minikube cache add imagename:tag está en desuso.

En su lugar, use minikube image load imagename:tag

Las versiones más nuevas de minikube le permiten cargar imágenes desde la instancia de la ventana acoplable local ejecutando

 minikube image rm image <imagename>:<version> minikube image load <imagename>:<version> --daemon

el comando de carga puede mostrar un error, pero la imagen aún se carga en su instancia de minikube

¿Qué pasaría si pudiera ejecutar k8s dentro de la máquina virtual de docker? 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-ya-está-disponible-en-docker-desktop-stable-channel/ https://www.docker.com/blog/docker-windows-desktop-now- kubernetes/

como descubrí esto:

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

así que cuando llegó el momento de instalar mis gráficos de timón, no pude hacer que helm/k8s sacara las imágenes que había creado usando la ventana acoplable. así es como llegué aquí a esta pregunta.

entonces... si puede vivir con cualquier versión de k8s que venga con docker desktop, y puede vivir con ella ejecutándose en cualquier vm docker que tenga, 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 contenedores de Windows/Linux afectaría algo.

1. configurar minikube docker-env
2. vuelva a construir la misma imagen de la ventana acoplable (usando minikube docker-env)
3. cambie imagePullPolicy a Nunca en su implementación

en realidad, lo que sucede aquí, su Minikube no puede reconocer su daemon docker ya que es un servicio independiente. Primero debe configurar su entorno minikube-docker, use el siguiente comando para verificar

 "eval $(minikube docker-env)"

Si ejecuta el siguiente comando, se 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á.

¡Encuentro este método de ClickHouse Operator Build From Sources y me ayuda y me salva la vida!

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

Hay un ensayo y una forma efectiva de enviar su imagen Docker local directamente a minikube, lo que le ahorrará tiempo al volver a crear las imágenes en minikube.

 minikube image load <image name>

( minikube cache add <image name> - antigua forma obsoleta, como referencia)

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/

pasos para ejecutar imágenes docker locales 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: Nunca

 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 ejecute kubectl create -f <filename>

una cosa para recordar con respecto a 'minikube' es que el host de minikube no es el mismo que su host local, por lo tanto, me di cuenta de que para usar imágenes locales para probar con minikube, primero debe construir su imagen de ventana acoplable localmente o extraerla localmente y luego agréguelo usando el siguiente comando en el contexto de minikube, que es, nada más que otra instancia de Linux.

 minikube cache add <image>:<tag>

sin embargo, no olvide configurar imagePullPolicy: Never en sus yamls de implementación de kubernetes, ya que garantizará el uso de imágenes agregadas localmente en lugar de intentar extraerlas de forma remota del registro.

actualización : minikube cache quedará obsoleto en las próximas versiones, cambie a carga de minikube image load

minikube addons enable registry -p minikube

💡 El complemento de registro con docker usa 32769, utilícelo en lugar del 5000 predeterminado
📘 Para obtener más información, consulte: https://minikube.sigs.k8s.io/docs/drivers/docker

 docker tag ubuntu $(minikube ip -p minikube):32769/ubuntu docker push $(minikube ip -p minikube):32769/ubuntu

O

 minikube addons enable registry docker tag ubuntu $(minikube ip):32769/ubuntu docker push $(minikube ip):32769/ubuntu

Lo anterior es lo suficientemente bueno para fines de desarrollo. Estoy haciendo esto en archlinux.

puede reutilizar el shell de la ventana acoplable, con eval $(minikube docker-env) , alternativamente, puede aprovechar en docker save | docker load a través de las conchas.

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

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

1. Guarde esa imagen en el disco local -

   docker save puckel/docker-airflow > puckel_docker_airflow.tar

2. Ahora ingrese 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 a las mil maravillas.

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

Configure el nombre de host en la máquina local: edite /etc/hosts para 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 la imagen sea empujada:

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

Configuración en minikube

ssh en minikube con: minukube ssh

edite /etc/hosts para 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 extraer, es posible que obtenga un error de acceso http.

Habilitar el acceso no seguro :

Si siempre planea usar minkube con esta configuración local, cree un minikube para usar un 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 de servicio de docker: obtenga la ruta desde 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)

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

a esta 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 proveedor=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

para

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

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

Para minikube en Docker:

Opción 1: usar el registro de minikube

1. Comprueba tus puertos minikube docker ps

Verá algo como: 127.0.0.1:32769->5000/tcp Significa que su registro de minikube está en el puerto 32769 para uso externo, pero internamente está en el puerto 5000.

2. Cree su imagen acoplable etiquetándola: docker build -t 127.0.0.1:32769/hello .

3. Empuje la imagen al registro de minikube: docker push 127.0.0.1:32769/hello

4. Compruebe si está allí: curl http://localhost:32769/v2/_catalog

5. Cree alguna implementación utilizando el puerto interno: kubectl create deployment hello --image=127.0.0.1:5000/hello

Tu imagen está ahora mismo en el contenedor de minikube, para verla escribe:

 eval $(minikube -p <PROFILE> docker-env) docker images

advertencia: si usa solo un perfil llamado "minikube", entonces la sección "-p" es redundante, pero si usa más, no lo olvide; Personalmente elimino el estándar (minikube) para no cometer errores.

Opción 2: No usar el registro

1. Cambie al contenedor minikube Docker: eval $(minikube -p <PROFILE> docker-env)
2. Crea tu imagen: docker build -t hello .
3. Cree alguna implementación: kubectl create deployment hello --image=hello

Al final, cambie la implementación ImagePullPolicy de Siempre a IfNotPresent:

kubectl edit deployment hello

Si alguien está buscando volver al entorno local después de configurar el entorno de minikube, use el siguiente comando.

 eval $(docker-machine env -u)

Otras respuestas suponen que usa minikube con VM, por lo que no se puede acceder a sus imágenes locales desde minikube VM.

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

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

o configurar el campo imagePullPolicy para cotainers en los manifiestos .yaml correspondientes.

Ahora hay un complemento de registro de Minikube, esta es probablemente la forma más fácil. Aquí se explica cómo usarlo: https://minikube.sigs.k8s.io/docs/tasks/registry/insecure/

Tenga en cuenta que tuve problemas de DNS, podría ser un error.

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

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

Notas:

• ¡Esta respuesta no se limita a minikube!

• Si desea crear el registro en Docker de minikube, ejecute eval $(minikube docker-env) (para que docker esté disponible en la terminal de la máquina host).
  De lo contrario, ingrese a la máquina virtual a través de minikube ssh y luego continúe con los siguientes pasos

• dependiendo de su sistema operativo, minikube montará automáticamente su ruta de inicio en la VM.

• como dijo Eli, deberá agregar el registro local como inseguro para usar http (es posible que no se aplique cuando se usa localhost pero sí se aplica si se usa el nombre de host local)
  No use http en producción, haga el esfuerzo de asegurar las cosas.

Utilice un registro local:

 docker run -d -p 5000:5000 --restart=always --name local-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 montar volúmenes en la ubicación adecuada para conservar las imágenes en el registro.

Como se describe en 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. Establece las variables de entorno con eval $(minikube docker-env)
2. Cree la imagen con el demonio Docker 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 imagePullPolicy en 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.

Además de la respuesta aceptada, también puede lograr lo que quería originalmente (crear una implementación con el comando run ) 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 de Kubernetes-dev:

Si está utilizando kubectl run , genera un manifiesto para usted que tiene imagePullPolicy configurado en Always de forma predeterminada. Puede usar este comando para obtener una imagePullPolicy de 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

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 la extracción de 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;
• use :latest como la etiqueta para que la imagen la use;
• habilite el controlador de admisión AlwaysPullImages.

O léase al revés: el uso de la etiqueta :latest obliga a que las imágenes se extraigan siempre. Si usa eval $(minikube docker-env) como se mencionó anteriormente, entonces no use ninguna etiqueta o asigne una etiqueta a su imagen local, puede evitar que Kubernetes intente extraerla por la fuerza.

Lo que funcionó para mí, basado en la solución de @svenwltr:

 # Start minikube minikube start # Set docker env eval $(minikube docker-env) # unix shells minikube docker-env | Invoke-Expression # PowerShell # 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

Un enfoque es construir la imagen localmente y luego hacer:

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

minikube docker-env podría no devolver la información correcta ejecutándose bajo un usuario diferente/sudo. En su lugar, puede ejecutar 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)