Comando Run do Kubernetes

Introdução

O comando kubectl run é uma maneira simples de criar um Pod no Kubernetes. As versões modernas do Kubernetes não utilizam o kubectl run para criar Deployments ou Jobs, portanto, este laboratório associa o kubectl run aos comandos dedicados para esses recursos. Este laboratório foi projetado para ajudar iniciantes a entender qual comando utilizar para cada tipo de carga de trabalho.

Ao final deste laboratório, você aprenderá a:

Iniciar e verificar um cluster Minikube.
Criar um pod usando kubectl run.
Criar um deployment com múltiplas réplicas.
Criar e inspecionar um Job para processamento em lote (batch).
Limpar os recursos para manter seu cluster organizado.

Iniciar o Cluster Minikube

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

Navegue até o seu diretório de trabalho:

Abra o terminal e navegue até a pasta padrão do projeto:
```
cd /home/labex/project
```
Inicie o 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.
- Se o cluster não estiver em execução, execute minikube start novamente.

Caso encontre problemas ao iniciar o Minikube, utilize minikube delete para redefinir o ambiente, se necessário.

Explorar o comando kubectl run

O comando kubectl run é utilizado para criar e executar uma imagem específica em um pod. Ele oferece várias opções para personalizar o comportamento, o ambiente e as especificações do pod.

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

kubectl run -h

Você verá a seguinte saída:

Create and run a particular image in a pod.

Examples:
## Start a nginx pod
kubectl run nginx --image=nginx

## Start a hazelcast pod and let the container expose port 5701
kubectl run hazelcast --image=hazelcast/hazelcast --port=5701

## Start a hazelcast pod and set environment variables "DNS_DOMAIN=cluster" and "POD_NAMESPACE=default" in the container
kubectl run hazelcast --image=hazelcast/hazelcast --env="DNS_DOMAIN=cluster" --env="POD_NAMESPACE=default"

## Start a hazelcast pod and set labels "app=hazelcast" and "env=prod" in the container
kubectl run hazelcast --image=hazelcast/hazelcast --labels="app=hazelcast,env=prod"

## Dry run; print the corresponding API objects without creating them
kubectl run nginx --image=nginx --dry-run=client

## Start a nginx pod, but overload the spec with a partial set of values parsed from JSON
kubectl run nginx --image=nginx --overrides='{ "apiVersion": "v1", "spec": { ... } }'

## Start a busybox pod and keep it in the foreground, don't restart it if it exits
kubectl run -i -t busybox --image=busybox --restart=Never

## Start the nginx pod using the default command, but use custom arguments (arg1 .. argN) for that command
kubectl run nginx --image=nginx -- <arg1> <arg2> ... <argN>

## Start the nginx pod using a different command and custom arguments
kubectl run nginx --image=nginx --command -- <cmd> <arg1> ... <argN>

Criar um Pod

Um pod é a menor unidade implantável no Kubernetes e representa um ou mais containers rodando juntos. Nesta etapa, criaremos um pod executando um servidor web Nginx.

Crie o pod:

Execute o seguinte comando para criar um pod chamado nginx-pod:
```
kubectl run nginx-pod --image=nginx
```
- A opção --image especifica a imagem do container a ser utilizada. Aqui, usamos a imagem oficial do Nginx.
Verifique o pod:

Verifique se o pod está em execução:
```
kubectl get pods
```
- Procure por nginx-pod na saída.
- A coluna STATUS deve exibir Running quando o pod estiver pronto.

Se o status do pod exibir Pending, o Kubernetes pode ainda estar baixando a imagem do container. Aguarde alguns instantes e execute kubectl get pods novamente.

Criar um Deployment e escalar réplicas

Um deployment gerencia um conjunto de pods e garante que eles estejam rodando conforme o desejado. É útil para escalar e atualizar aplicações.

Crie o deployment:

Execute o seguinte comando para criar um deployment chamado nginx-deployment:
```
kubectl create deployment nginx-deployment --image=nginx
```
- A opção --image especifica a imagem do container a ser utilizada.
Escale o deployment para 3 réplicas:

Como a flag --replicas foi descontinuada, escalaremos o deployment usando kubectl scale.

Use o comando kubectl scale para ajustar o número de réplicas:
```
kubectl scale deployment nginx-deployment --replicas=3
```
- Isso garante que três pods estejam rodando como parte do deployment.
Verifique o deployment e suas réplicas:

Verifique o status do deployment e dos pods:
```
kubectl get deployments
kubectl get pods
```
- Certifique-se de que o deployment mostre 3 réplicas na coluna READY.
- Verifique se três pods estão listados na saída de kubectl get pods.

Se um pod não estiver no estado Running, pode ser devido à falta de recursos no cluster. Verifique os eventos do pod com:

kubectl describe pod <pod-name>

Criar um Job

Nesta etapa, você criará um Job do Kubernetes para executar uma tarefa curta em lote. Um Job rastreia a conclusão bem-sucedida, sendo o recurso ideal quando um comando deve ser executado e encerrado, em vez de permanecer ativo como um Pod de longa duração.

Crie o job

Execute o seguinte comando para criar um job chamado busybox-job:

kubectl create job busybox-job --image=busybox -- echo "Hello from Kubernetes"

kubectl create job cria um recurso de Job em vez de um Pod independente.
O comando echo define a tarefa que o Job executará.

Verifique o status do job

Execute o seguinte comando para verificar o job:

kubectl get jobs

Saída esperada:

NAME          COMPLETIONS   DURATION   AGE
busybox-job   1/1           5s         10s

COMPLETIONS: Mostra que o Job foi concluído com sucesso uma vez (1/1).
Se nenhum Job for listado ainda, aguarde alguns segundos e execute kubectl get jobs novamente.

Verifique o pod do job

Como um job roda dentro de um pod, use o seguinte comando para verificar o pod:

kubectl get pods

Saída esperada:

NAME                      READY   STATUS      RESTARTS   AGE
busybox-job-abcde         0/1     Completed   0          30s

O nome do Pod inclui um sufixo gerado porque ele é controlado pelo Job.
O campo STATUS deve exibir Completed, indicando que o Pod do Job terminou com sucesso.

Verifique a saída do job

Inspecione os logs do Job para verificar a saída:

kubectl logs job/busybox-job

Saída esperada:

Hello from Kubernetes

Isso confirma que o job foi executado com sucesso.

Limpeza

Para manter seu cluster limpo, exclua os recursos que você criou durante o laboratório.

Exclua os recursos:

Execute os seguintes comandos:

kubectl delete pod nginx-pod
kubectl delete deployment nginx-deployment
kubectl delete job busybox-job

Verifique a limpeza:

Verifique se não restou nenhum recurso:
```
kubectl get pods
kubectl get deployments
```
- Certifique-se de que a saída não liste os recursos que você criou.

Resumo

Neste laboratório, você aprendeu a:

Iniciar e verificar um cluster Minikube.
Usar kubectl run para criar um Pod e usar comandos dedicados para criar Deployments e Jobs.
Limpar recursos para manter o cluster organizado.

Você também viu como o Kubernetes utiliza comandos diferentes para diferentes tipos de carga de trabalho. Ao praticar essas etapas, você constrói uma base sólida para fluxos de trabalho mais avançados no Kubernetes.