Como posso manter um contêiner em execução no Kubernetes?

Agora estou tentando executar um contêiner simples com shell (/ bin / bash) em um cluster Kubernetes.

Eu pensei que havia uma maneira de manter um contêiner em execução em um contêiner do Docker usando pseudo-ttye desanexando a opção ( -tdopção no docker runcomando).

Por exemplo,

$ sudo docker run -td ubuntu:latest

Existe uma opção como esta no Kubernetes?

Eu tentei executar um contêiner usando um kubectl run-containercomando como:

kubectl run-container test_container ubuntu:latest --replicas=1

Mas o contêiner sai por alguns segundos (como iniciar com o docker runcomando sem as opções mencionadas acima). E o ReplicationController o lança novamente repetidamente.

Existe uma maneira de manter um contêiner em execução no Kubernetes como as -tdopções no docker runcomando?

Um contêiner sai quando seu processo principal termina. Fazendo algo como:

docker run -itd debian

manter o contêiner aberto é francamente um truque que deve ser usado apenas para testes e exemplos rápidos. Se você quiser apenas um contêiner para teste por alguns minutos, eu faria:

docker run -d debian sleep 300

O que tem a vantagem de o contêiner sair automaticamente se você o esquecer. Como alternativa, você pode colocar algo assim em um whileloop para mantê-lo em execução para sempre ou apenas executar um aplicativo como o top. Tudo isso deve ser fácil no Kubernetes.

A verdadeira questão é por que você quer fazer isso? Seu contêiner deve estar fornecendo um serviço, cujo processo manterá o contêiner em execução em segundo plano.

Os contêineres devem ser executados até a conclusão. Você precisa fornecer ao seu contêiner uma tarefa que nunca será concluída. Algo assim deve funcionar:

apiVersion: v1
kind: Pod
metadata:
  name: ubuntu
spec:
  containers:
  - name: ubuntu
    image: ubuntu:latest
    # Just spin & wait forever
    command: [ "/bin/bash", "-c", "--" ]
    args: [ "while true; do sleep 30; done;" ]

Você pode usar esse CMD em Dockerfile:

CMD exec /bin/bash -c "trap : TERM INT; sleep infinity & wait"

Isso manterá seu recipiente vivo até que seja solicitado que ele pare. O uso de trap and wait fará com que seu contêiner reaja imediatamente a uma solicitação de parada . Sem parar a captura / espera, levará alguns segundos.

Para imagens baseadas em busybox (usadas em imagens alpinas), o sono não conhece o argumento infinito. Esta solução alternativa fornece a mesma resposta imediata a um docker stopexemplo no exemplo acima:

CMD exec /bin/sh -c "trap : TERM INT; (while true; do sleep 1000; done) & wait"

1. No seu Dockerfile, use este comando:

   CMD ["sh", "-c", "tail -f /dev/null"]
   

2. Crie sua imagem do Docker.

3. Empurre-o para o cluster ou similar, apenas para garantir que a imagem esteja disponível.

4. kubectl run debug-container -it --image=<your-image>
   

Para manter um POD em execução, o POD deve executar determinadas tarefas, caso contrário, o Kubernetes achará desnecessário e, portanto, será encerrado. Existem muitas maneiras de manter um POD em execução.

Eu enfrentei problemas semelhantes quando precisei de um POD apenas para executar continuamente sem fazer nada. A seguir, estão as duas maneiras pelas quais isso funcionou para mim:

1. Ativando um comando de suspensão durante a execução do contêiner.
2. Executando um loop infinito dentro do contêiner.

Embora a primeira opção seja mais fácil que a segunda e possa ser suficiente, não é a melhor opção. Como, há um limite até o número de segundos que você irá atribuir no comando de suspensão. Mas um contêiner com loop infinito rodando dentro dele nunca sai.

No entanto, descreverei as duas maneiras (considerando que você está executando o container busybox):

1. Comando de suspensão

apiVersion: v1
kind: Pod
metadata:
  name: busybox
  labels:
    app: busybox
spec:
  containers:
  - name: busybox
    image: busybox
    ports:
    - containerPort: 80
    command: ["/bin/sh", "-ec", "sleep 1000"]
  nodeSelector:
    beta.kubernetes.io/os: linux

2. Loop infinito

apiVersion: v1
kind: Pod
metadata:
  name: busybox
  labels:
    app: busybox
spec:
  containers:
  - name: busybox
    image: busybox
    ports:
    - containerPort: 80
    command: ["/bin/sh", "-ec", "while :; do echo '.'; sleep 5 ; done"]
  nodeSelector:
    beta.kubernetes.io/os: linux

Execute o seguinte comando para executar o pod:

kubectl apply -f <pod-yaml-file-name>.yaml

Espero que ajude!

Consegui fazer isso funcionar com o comando sleep infinityno Kubernetes, que manterá o contêiner aberto. Veja esta resposta para alternativas quando isso não funcionar.

O comando mais simples possível para o k8s pod manifest executar o contêiner para sempre:

apiVersion: v1
kind: Pod
metadata:
  name: ubuntu
spec:
  containers:
  - name: ubuntu
    image: ubuntu:latest
    # Just sleep forever
    command: [ "sleep" ]
    args: [ "infinity" ]

Use este comando dentro do Dockerfile para manter o contêiner em execução no cluster do K8s:

• Cauda CMD -f / dev / null

No meu caso, um pod com um initContainer falhou ao inicializar. Em execução docker ps -ae, em seguida, docker logs exited-container-id-hereme deu uma mensagem de log que kubectl logs podnamenão foi exibida. Mistério resolvido :-)

Existem muitas maneiras diferentes de conseguir isso, mas uma das mais elegantes é:

kubectl run -i --tty --image ubuntu:latest ubuntu-test --restart=Never --rm /bin/sh

Meus poucos centavos sobre o assunto. Supondo que kubectlesteja funcionando, o comando mais próximo que seria equivalente ao comando docker que você mencionou na sua pergunta seria algo parecido com isto.

$ kubectl run ubuntu --image=ubuntu --restart=Never --command sleep infinity

O comando acima criará um único Podno defaultespaço para nome e executará o sleepcomando com o infinityargumento - dessa forma, você terá um processo que é executado em primeiro plano, mantendo o contêiner ativo.

Afterwords, você pode interagir Podexecutando o kubectl execcomando

$ kubectl exec ubuntu -it -- bash

Essa técnica é muito útil para criar um recurso de Pod e depuração ad-hoc.