Comando Exec do Kubernetes: Guia Prático

Introdução

Neste laboratório, você aprenderá como usar o comando exec do Kubernetes para executar comandos dentro de um container em execução em um pod do Kubernetes. Você começará com exemplos simples e progredirá gradualmente para cenários mais complexos.

Iniciar o Cluster Minikube

Antes de criar recursos, você precisa de um cluster Kubernetes em execução. Minikube é um ambiente Kubernetes leve que roda em sua máquina local.

Navegue para o seu diretório de trabalho:

Abra o terminal e navegue até a pasta do projeto padrão:
```
cd /home/labex/project
```
Iniciar Minikube:

Inicie o Minikube para inicializar um cluster Kubernetes:
```
minikube start
```
- Este comando configura um cluster Kubernetes de nó único em sua máquina local.
- O Minikube pode levar alguns minutos para iniciar, dependendo do desempenho do seu sistema.
Verifique se o Minikube está em execução:

Verifique o status do cluster Minikube:
```
minikube status
```
- Procure por componentes como kubelet e apiserver listados como Running (Em execução).
- Se o cluster não estiver em execução, execute novamente minikube start.

Se você encontrar problemas ao iniciar o Minikube. Use minikube delete para redefinir o ambiente, se necessário.

Explorar o Comando kubectl exec

O comando kubectl exec é usado para executar comandos diretamente dentro de um container em um pod. Ele é particularmente útil para depurar e inspecionar ambientes de container.

Execute o seguinte comando para visualizar as opções disponíveis para kubectl exec:

kubectl exec -h

Você verá a seguinte saída:

Execute a command in a container.

Examples:
  ## Get output from running the 'date' command from pod mypod, using the first container by default
  kubectl exec mypod -- date

  ## Get output from running the 'date' command in ruby-container from pod mypod
  kubectl exec mypod -c ruby-container -- date

  ## Switch to raw terminal mode; sends stdin to 'bash' in ruby-container from pod mypod
  ## and sends stdout/stderr from 'bash' back to the client
  kubectl exec mypod -c ruby-container -i -t -- bash -il

  ## List contents of /usr from the first container of pod mypod and sort by modification time
  ## If the command you want to execute in the pod has any flags in common (e.g. -i),
  ## you must use two dashes (--) to separate your command's flags/arguments
  ## Also note, do not surround your command and its flags/arguments with quotes
  ## unless that is how you would execute it normally (i.e., do ls -t /usr, not "ls -t /usr")
  kubectl exec mypod -i -t -- ls -t /usr

  ## Get output from running 'date' command from the first pod of the deployment mydeployment, using the first container by default
  kubectl exec deploy/mydeployment -- date

  ## Get output from running 'date' command from the first pod of the service myservice, using the first container by default
  kubectl exec svc/myservice -- date

Executando um Comando em um Container

Nesta etapa, você aprenderá como executar um comando em um container em execução em um pod.

Comece criando um deployment com uma réplica e um container Nginx:
```
kubectl create deployment nginx --image=nginx --replicas=1
```

Aguarde o pod ficar pronto:

kubectl wait --for=condition=Ready pod -l app=nginx

Use o comando kubectl exec para executar um comando dentro do container Nginx:
```
kubectl exec -it POD_NAME -- /bin/bash
```
Substitua POD_NAME pelo nome do pod criado na etapa 1, e você pode obter o POD_NAME com o comando kubectl get pod -l app=nginx.

Executando um Comando em um Container Específico

Nesta etapa, você aprenderá como executar um comando em um container específico em execução em um pod com múltiplos containers.

Crie um pod com dois containers: Nginx e BusyBox:

cat << EOF | kubectl apply -f -
apiVersion: v1
kind: Pod
metadata:
  name: nginx-busybox
spec:
  containers:
  - name: nginx
    image: nginx
  - name: busybox
    image: busybox
    command:
      - sleep
      - "3600"
EOF

Aguarde o pod ficar pronto:

kubectl wait --for=condition=Ready pod nginx-busybox

Use o comando kubectl exec para executar um comando dentro do container BusyBox:
```
kubectl exec nginx-busybox -c busybox -- ls /bin
```

Executando um Comando com um Tty

Nesta etapa, você aprenderá como executar um comando com um tty em um container.

Use o comando kubectl exec com as opções -it para executar um comando com um tty:
```
kubectl exec -it nginx-busybox -- /bin/sh
```
Uma vez dentro do shell do container, execute um comando:
```
echo "Hello, world!"
```
Saia do shell do container:
```
exit
```

Executando um Comando com Variáveis de Ambiente

Nesta etapa, você aprenderá como executar um comando com variáveis de ambiente dentro de um container.

Crie um deployment com uma réplica e um container Nginx com uma variável de ambiente:
```
kubectl run nginx-env --image=nginx --env="MY_VAR=my-value"
```

Aguarde o pod ficar pronto:

kubectl wait --for=condition=Ready pod -l run=nginx-env

Use o comando kubectl exec para executar um comando dentro do container Nginx que exibe a variável de ambiente:
```
kubectl exec nginx-env -- sh -c 'echo $MY_VAR'
```
Substitua nginx-env pelo nome do pod criado na etapa 1.

Resumo

Parabéns, você concluiu com sucesso o laboratório do comando exec do Kubernetes! Neste laboratório, você aprendeu como usar o comando kubectl exec para executar comandos dentro de containers em execução em pods do Kubernetes. Você também aprendeu como executar comandos em containers específicos, executar comandos com um tty e executar comandos com variáveis de ambiente. Essas habilidades são essenciais para depurar problemas em um cluster Kubernetes.