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

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           

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.

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

¡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.

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.

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

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)

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

eval $(docker-machine env -u)

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.

Ahora hay un complemento de Registro Minikube, esta es probablemente la forma más fácil. Aquí está 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 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

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.

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 .

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.

¿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.

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/

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.

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á.

¡Encuentro este método de ClickHouse Operator Build From Sources y me ayuda a salvar mi vida!

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

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>