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

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           

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.

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

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.

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.

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

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)

Se alguém estiver olhando para retornar ao ambiente local após definir o ambiente do minikube, use o seguinte comando.

eval $(docker-machine env -u)

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.

Agora existe um complemento do Minikube Registry, essa é provavelmente a maneira mais fácil. Aqui está como usá-lo: https://minikube.sigs.k8s.io/docs/tasks/registry/insecure/

Observe que eu tinha problemas de DNS, pode ser um bug.

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

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.

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 .

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.

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.

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/

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

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

Eu encontro esse método no ClickHouse Operator Build From Sources e isso ajuda e salva minha vida!

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

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>