Como usar imagens de janela de encaixe local com o Minikube?


300

Tenho várias imagens do Docker com as quais quero usar minikube. Não quero primeiro fazer o upload e fazer o download da mesma imagem, em vez de apenas usar a imagem local diretamente. Como eu faço isso?

O que eu tentei:
1. Tentei executar esses comandos (separadamente, excluindo as instâncias do minikube duas vezes e começando do zero)

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

Resultado :

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

Apenas fica preso em algum status, mas nunca atinge o estado pronto.


2. Tentei criar um registro e depois colocar imagens nele, mas isso também não funcionou. Talvez eu tenha feito isso incorretamente, mas não consigo encontrar instruções adequadas para executar esta tarefa.

Forneça instruções para usar imagens de janela de encaixe local na instância local do kubernetes.
OS: ubuntu 16.04
Docker: Docker versão 1.13.1, construção 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 alguém pudesse me ajudar a obter uma solução que usa o docker-composite para fazer isso, isso seria incrível. Obrigado.

Editar:

Imagens carregadas em 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           

Respostas:


408

Conforme o README descreve, é possível reutilizar o daemon Docker do Minikube com eval $(minikube docker-env).

Portanto, para usar uma imagem sem carregá-la, siga estas etapas:

  1. Defina as variáveis ​​de ambiente com eval $(minikube docker-env)
  2. Crie a imagem com o daemon Docker do Minikube (por exemplo docker build -t my-image .)
  3. Defina a imagem nas especificações do pod como a tag build (por exemplo my-image)
  4. Defina imagePullPolicycomo Never, caso contrário, o Kubernetes tentará fazer o download da imagem.

Nota importante: Você precisa executar eval $(minikube docker-env)em cada terminal que deseja usar, pois ele define apenas as variáveis ​​de ambiente para a sessão atual do shell.


1
AFAIS você só pode fazer isso com um novo minukube com minikube start --disk-size 100g. Outra solução seria excluir imagens antigas com docker imagese docker rmi.
precisa saber é o seguinte

6
Muito importante lembrar de executar eval $(minikube docker-env)depois de fechar o terminal em que você está trabalhando ANTES de tentar reconstruir imagens ... queimou 6 horas lutando com uma imagem que não estava atualizando no minikube ... parecia que um pacote não estava atualizando .. realmente não atualizando a imagem que o minikube estava fazendo referência.
Mike

1
A política de recebimento padrão é o IfNotPresentque significa que tudo o que precisamos fazer é definir as variáveis ​​de ambiente.
Beygi 19/05/19

29
Se vc quiser voltar ou sair env de minikube ..eval $(minikube docker-env -u)
Budi Mulyo

1
@nmxl olha aqui
testuser

175

O que funcionou para mim, com base na solução 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
Você pode encontrar a versão yml da linha de comando acima (em relação à imagePullPolicy) aqui: kubernetes.io/docs/concepts/containers/images
granadaCoder

128

Esta resposta não está limitada ao minikube!

Use um registro local:

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

Agora marque sua imagem corretamente:

docker tag ubuntu localhost:5000/ubuntu

Observe que o host local deve ser alterado para o nome DNS da máquina que está executando o contêiner do registro.

Agora envie sua imagem para o registro local:

docker push localhost:5000/ubuntu

Você deve poder recuar:

docker pull localhost:5000/ubuntu

Agora mude seu arquivo yaml para usar o registro local.

Pense em montar o volume no local apropriado para manter as imagens no registro.

atualizar:

como Eli afirmou, você precisará adicionar o registro local como inseguro para usar o http (pode não se aplicar ao usar o host local, mas se aplica ao usar o nome do host local)

Não use http na produção, faça um esforço para proteger as coisas.


2
| Agora mude seu arquivo yaml para usar o registro local. Você é capaz de explicar isso um pouco? Enviei para o registro local (truque legal), mas tenho o mesmo problema que não consigo conectar o minikube a ele.
Zach Estela

3
@ZachEstela altere o nome da imagem no yaml para<registryIP>:5000/ubuntu
Farhad Farahi 24/10

@FarhadFarahi Onde posso encontrar o "nome DNS da máquina que está executando o contêiner de registro"?
Daan

1
@FarhadFarahi Se eu der meu laptop para você, como você descobriria? Eu só quero saber disso. Segui as etapas do tutorial do docker para que o docker para Windows seja executado.
Daan

1
@FarhadFarahi: adicione à sua resposta que você precisará adicionar o registro local como inseguro para usar o http: docs.docker.com/registry/insecure (pode não se aplicar ao usar o host local, mas se o nome do host local )
Eli Algranti

14

Adicionando à resposta do @Farhad com base nessa resposta ,

Estas são as etapas para configurar um registro local.

Configuração na máquina local

Configurar nome do host na máquina local: edite /etc/hostspara adicionar esta linha

docker.local 127.0.0.1

Agora inicie um registro local (remova -d para executar o modo não daemon):

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

Agora marque sua imagem corretamente:

docker tag ubuntu docker.local:5000/ubuntu

Agora envie sua imagem para o registro local:

docker push docker.local:5000/ubuntu

Verifique se a imagem foi enviada por push:

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

Instalação no minikube

ssh no minikube com: minukube ssh

edite /etc/hostspara adicionar esta linha

docker.local <your host machine's ip>

Verifique o acesso:

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

Agora, se você tentar puxar, poderá receber um erro de acesso http.

Ativar acesso não seguro :

Se você sempre planeja usar o minkube com essa configuração local, crie um minikube para usar o registro inseguro por padrão (não funcionará no cluster existente).

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

caso contrário, siga as etapas abaixo:

systemctl stop docker

edite o arquivo serice do docker: obtenha o caminho de systemctl status docker

pode ser :

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

acrescente este texto (substitua 192.168.1.4 pelo seu ip)

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

para esta linha

ExecStart = daemon / usr / bin / docker -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

tente puxar:

docker pull docker.local:5000/ubuntu

Agora mude seu arquivo yaml para usar o registro local.

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

para

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

Não use http na produção, faça um esforço para proteger as coisas.


12

Além da resposta aceita, você também pode obter o que queria originalmente (criando uma implantação usando o runcomando) com o seguinte comando:

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

Encontrei as informações sobre o gerador no fórum Kubernetes-dev:

Se você estiver usando kubectl run, ele gera um manifesto imagePullPolicydefinido Alwayspor padrão. Você pode usar este comando para obter um imagePullPolicydos 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

Uma abordagem é criar a imagem localmente e depois:

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

minikube docker-envpode não retornar as informações corretas em execução em um usuário / sudo diferente. Em vez disso, você pode executar sudo -u yourUsername minikube docker-env.

Deve retornar 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)

O comando correto édocker save imageNameGoesHere > pv | (eval $(minikube docker-env) && docker load)
salvador

1
docker save imageNameGoesHere | (eval $(minikube docker-env) && docker load)trabalhou para mim
lhaferkamp


4

Nos documentos do kubernetes:

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

A política de extração padrão é IfNotPresent, que faz com que o Kubelet ignore a extração de uma imagem, se ela já existir. Se você deseja sempre forçar uma atração, siga um destes procedimentos:

  • defina o imagePullPolicy do contêiner como Always;
  • use: latest como a tag para a imagem usar;
  • habilite o controlador de admissão AlwaysPullImages.

Ou leia de outra maneira: Usar a tag: latest faz com que as imagens sejam sempre puxadas. Se você usar o eval $(minikube docker-env)mencionado acima, não use nenhuma marca ou atribua uma marca à sua imagem local, para evitar que o Kubernetes tente puxá-la à força.



3

Um método mais simples que responde à pergunta original "Como usar imagens de janela de encaixe local com o Minikube?" É salvar a imagem em um arquivo tar e carregá-la no 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

A execução da imagem envolve um comando como o seguinte. Certifique-se de incluir o 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

Bem explicado, funcionou como um encanto. Eu só tinha que ligar docker savecom sudo, e em seguida, defina sudo chmod 664 my-image.tarpara torná-lo disponível para o meu usuário atual.
Meir Gabay 15/01

Essa deve ser a abordagem mais rápida que eu acredito.
Shiwakant Bharti

2

Para adicionar às respostas anteriores, se você tiver uma imagem tarball, basta carregá-la no conjunto de imagens do docker local docker image load -i /path/image.tar. Lembre-se de executá-lo depois eval $(minikube docker-env) , pois o minikube não compartilha imagens com o mecanismo do docker instalado localmente.


2

Outras respostas supõem que você use o minikube com VM, para que suas imagens locais não sejam acessíveis a partir da minikube VM.

Caso você use o minikube --vm-driver=none, poderá reutilizar facilmente imagens locais configurando image_pull_policypara Nunca:

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

ou imagePullPolicycampo de configuração para cotainers nos .yamlmanifestos correspondentes .


2

Uma idéia seria salvar a imagem do docker localmente e carregá-la no minikube da seguinte maneira:

Digamos, por exemplo, que você já tenha uma imagem de puckel / docker-airflow.

  1. Salve essa imagem no disco local -

    docker save puckel/docker-airflow > puckel_docker_airflow.tar

  2. Agora entre no minikube docker env -

    eval $(minikube docker-env)

  3. Carregue a imagem salva localmente -

    docker load < puckel_docker_airflow.tar

É simples assim e funciona como um encanto.


Você ainda precisa da dica da resposta aceita Set the imagePullPolicy to Never. Se sua imagem estiver marcada com um endereço, por exemplo us.icr.io/mydiv/my-service:v0.0.1, uma implantação tentará puxar remotamente essa imagem. Como você já copiou a imagem manualmente, é necessário suprimir o k8s de extrair a imagem de um endereço (registro de contêiner) que não pode acessar.
colm.anseo

1

e se você pudesse executar o k8s no vm do docker? há suporte nativo para isso nas versões mais recentes da área de trabalho do docker ... você só precisa ativar esse suporte.

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

como eu descobri isso:

ao ler os documentos do helm, eles fornecem um breve tutorial sobre como instalar o minikube. esse tutorial instala o minikube em uma VM diferente / separada da janela de encaixe.

portanto, quando chegou a hora de instalar meus gráficos de leme, não consegui que o leme / k8s puxasse as imagens que eu havia construído usando o docker. foi assim que cheguei aqui a esta pergunta.

então ... se você pode viver com qualquer versão do k8s que vem com a área de trabalho do docker, e pode ser executado com qualquer que seja o vm docker, talvez essa solução seja um pouco mais fácil do que outras.

isenção de responsabilidade: não tenho certeza de como a alternância entre os contêineres Windows / Linux afetaria qualquer coisa.


Acho que também tive que definir o imagePullPolicies como IfNotPresent
chad

1

Existe um ensaio e uma maneira eficaz de enviar sua imagem do Docker local diretamente para o minikube, o que economizará tempo ao criar as imagens no minikube novamente.

minikube cache add <Image name>

Mais detalhes aqui

Todos os métodos possíveis para enviar imagens ao minikube são mencionados aqui: https://minikube.sigs.k8s.io/docs/handbook/pushing/


0

você pode reutilizar o shell da janela de encaixe e eval $(minikube docker-env), alternativamente, pode aproveitar docker save | docker loadas conchas.


0
  1. instalação minikube docker-env
  2. crie novamente a mesma imagem do docker (usando o minikube docker-env)
  3. alterar imagePullPolicy para Nunca em sua implantação

Na verdade, o que acontece aqui, o Minikube não consegue reconhecer o daemon do docker, pois é um serviço independente.

 "eval $(minikube docker-env)"

Se você executar o comando abaixo, ele mostrará onde o seu minikube procura a janela de encaixe.

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

Você precisa criar imagens novamente depois de configurar o minikube docker-env, caso contrário, ela falhará.



0

etapas para executar imagens do docker local no kubernetes
1. eval $ (minikube -p minikube docker-env)
2. no arquivo de artefato, na seção de especificações -> containers
add imagePullPolicy: IfNotPresent
ou 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. depois corra kubectl create -f <filename>

Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.