Comando Kubernetes Run

Introdução

O comando kubectl run é uma das formas mais simples e versáteis de criar recursos no Kubernetes. Ele permite que você implante rapidamente contêineres, crie jobs para processamento em lote ou configure deployments para gerenciar múltiplas réplicas de uma aplicação. Este laboratório foi projetado para ajudar iniciantes a entender os fundamentos do comando kubectl run e como usá-lo de forma eficaz.

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

1. Iniciar e verificar um cluster Minikube.
2. Criar um pod usando kubectl run.
3. Criar um deployment com múltiplas réplicas.
4. Executar um job para processamento em lote.
5. Limpar recursos para manter seu cluster.

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.

1. Navegue para o seu diretório de trabalho:

   Abra o terminal e navegue até a pasta do projeto padrão:

   cd /home/labex/project

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

3. Verificar 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 run

O comando kubectl run é usado para criar e executar uma imagem específica em um pod. Ele oferece múltiplas 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 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 contêineres executando juntos. Nesta etapa, criaremos um pod executando um servidor web Nginx.

1. Criar 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 contêiner a ser usada. Aqui, usamos a imagem oficial do Nginx.

2. Verificar o pod:

   Verifique se o pod está em execução:

   kubectl get pods

   • Procure por nginx-pod na saída.
   • A coluna STATUS deve mostrar Running (Em execução) quando o pod estiver pronto.

Se o status do pod mostrar Pending (Pendente), o Kubernetes ainda pode estar baixando a imagem do contêiner. Aguarde alguns instantes e execute novamente kubectl get pods.

Criar um Deployment e Escalar Réplicas

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

1. Criar 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 contêiner a ser usada.

2. Dimensionar o deployment para 3 réplicas:

   Como a flag --replicas está obsoleta, dimensionaremos o deployment usando kubectl scale em vez disso.

   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 em execução como parte do deployment.

3. Verificar 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 (Em execução), pode ser devido a recursos de cluster insuficientes. Verifique os eventos do pod com:

kubectl describe pod <pod-name>

Criar um Job

Um job é usado para executar tarefas que precisam ser concluídas com sucesso. Por exemplo, jobs em lote ou tarefas de processamento de dados. Usaremos kubectl run para criar um job e verificar sua execução.

1. Criar o job

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

kubectl run busybox-job --image=busybox --restart=OnFailure -- echo "Hello from Kubernetes"

• A flag --restart=OnFailure especifica que este é um job.
• O comando echo define a tarefa que o job executará.

2. Verificar 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 executado com sucesso uma vez (1/1).
• Se nenhum job estiver listado, ele pode ter sido limpo automaticamente. Prossiga para a próxima etapa para verificar seu pod.

3. Verificar o pod do job

Como um job é executado 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        0/1     Completed   0          30s

• O campo STATUS deve exibir Completed (Concluído), indicando que o job foi finalizado.

4. Verificar a saída do job

Inspecione os logs do pod do job para verificar a saída:

kubectl logs 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.

1. Excluir os recursos:

   Execute os seguintes comandos:

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

2. Verificar a limpeza:

   Verifique se nenhum recurso permanece:

   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 como:

1. Iniciar e verificar um cluster Minikube.
2. Usar kubectl run para criar e gerenciar pods, deployments e jobs.
3. Limpar recursos para manter o cluster organizado.

O comando kubectl run fornece uma maneira simples e poderosa de implantar aplicações e gerenciar cargas de trabalho no Kubernetes. Ao praticar estas etapas, você pode construir uma base sólida para fluxos de trabalho Kubernetes mais avançados.