Kubernetes : Definindo o ambiente e criando Pods

Kubernetes : Definindo o ambiente e criando Pods

Hoje vamos definir o ambiente de estudo do Kubernetes e iniciar criando Pods.

Vamos iniciar definindo o nosso ambiente onde vamos estudar alguns recursos do Kubernetes. Neste primeiro contato com o Kubernetes vamos usar um ambiente bem simples que vai exigir os seguintes recursos instalados:

- Docker - É o container runtime. Link para download: https://www.docker.com/products/docker-desktop/

- Minikube - É um Utilitário que é uma implementação leve do Kubernetes usado executar o Kubernetes (k8s) em sua máquina local. Link com instruções para instalação : https://minikube.sigs.k8s.io/docs/start/

- Kubectl - É a ferramenta de linha de comando do Kubernetes. O kubectl, permite executar comandos em clusters do Kubernetes. Você pode usar o kubectl para implantar aplicativos, inspecionar e gerenciar recursos de cluster e visualizar logs. Link com instruções para instalação: https://kubernetes.io/docs/tasks/tools/

Naturalmente existem diversas outras ferramentas que podemos usar para estudar o Kubernetes sendo as mais conhecidas :

O Kind - É uma ferramenta para rodar o clusters k8s localmente usando Docker; é mais rápido que o minikube;
O k3s - Suporta vários nos e leve e facil de instalar mas possui menos recursos;
O Kubeadm - É a ferramenta recomendada oficialmente na documentação do kubernetes; ela é mais pesada e complexa de usar;

Usando o Minikube e modos de interação

Vamos usar o Minikube neste primeiro contato com o Kubernetes.

O minikube é um utilitário que você pode usar para executar o Kubernetes (k8s) em sua máquina local. Ele cria um cluster de nó único contido em uma máquina virtual (VM). Esse cluster permite que você demonstre as operações do K8s de forma leve e fácil.

Assim em nossos estudos iniciais estaremos executando um cluster de nó único contido em uma VM. Antes de por a mão na massa vamos entender os modos de interação possíveis com o Kubernetes.

Existem duas maneiras de interagir com o kubernetes :

1- Imperativa : Usando o kubectl e os seus diversos parâmetros;

- Diz ao K8s o que fazer.
- É Ideal para aprendizado, fazer experimentos, debugar serviços, etc.
- Exemplo: kubectl run nginx --image nginx

2- Declarativa : Usa arquivos de manifesto no formato YAML (ou JSON) e os aplica usando o comando kubectl apply;

- Diz ao K8s o que você quer;
- Ideal para implantar serviços de forma controlada;
- Recomendada para gerenciar aplicações K8s em produção;
- Exemplo: kubectl apply -f pod1.yaml

Embora o método imperativo possa ser mais rápido inicialmente, ele tem algumas desvantagens. É difícil ver o que mudou quando você gerencia implantações usando comandos imperativos.

O método declarativo, por outro lado, é auto-documentado. Cada configuração está em um arquivo e esse arquivo pode ser gerenciado. Muitos desenvolvedores podem trabalhar nas mesmas implantações e há um histórico claro de quem mudou o quê.

Arquivos de manifesto YAML

Os arquivos de manifesto ou configuração são onde fazemos as declarações sobre o que desejamos que o Kubernetes faça. Para isso podemos usar o formato JSON mas o formato YAML é o mais usado pois sua forma de apresentação e indentação facilita a leitura e permite adicionar comentários.

Os arquivos YAML para o kubernetes contém as definições dos diversos tipos de objetos que são usados pelo Kubernetes como: Services, Deployments, Pods, Namespaces, Configmaps, Secrets, dentre outros.

Para entender como o YAML funciona vamos ver como criar um pod usando um arquivo de manifesto ou configuração YAML chamado pod1.yaml :

apiVersion: v1

kind: Pod
metadata: 
      name: pod-nginx
spec:
     containers:
        - image: cont-nginx
          name: nginx
          ports: 
            - containerPort: 80

De forma geral um arquivo YAML para o Kubernetes sempre vai ter quatro campos no nível definidos:

apiVersion:
kind:
metadada:

spec:

Onde:

apiVersion : Indica a versão da API Kubernetes usada para criar o objeto
kind : Define o tipo de objeto a ser criado : Pod, Deployment, ReplicaSet, Service, Namespace
metadata : Define os dados do objeto como: name, labels, etc. É um dicionário. Tudo dentro do metadata tem que ser indentado a direita, eles são filhos do objeto metadata, e não importa a quantidade de espaços que você use para indentar; o ponto de atenção é que eles tem que ter sempre o mesmo espaçamento para indicar que são campos do mesmo nível.
spec : Define as especificações do objeto que desejamos criar e varia conforme o objeto. Também é um dicionário, então precisamos adicionar as propriedades que vão resolver o que você precisa fazer.

No arquivo pod1.yaml usado como exemplo temos definido em spec os containers usados para criar a aplicação. Aqui ele é um a lista ou Array pois um Pod pode ter mais de um container, e, isso é representado com um traço '-'.

Nota: No VS Code podemos instalar a extensão Kubernetes que nos auxilia a criar os arquivos YAML

Prática - Criando um Pod de forma imperativa e declarativa

Para por a mão na massa neste primeiro contato vamos criar um Pod usando as abordagens imperativa e declarativa.

1- Verificando o ambiente

Primeiro vamos verificar se o nosso ambiente esta preparado. O Docker tem que estar em execução e o Minikube e o Kubectl tem que estar instalados.

Vamos verificar o status do minikube : minikube status

Vamos iniciar o minikube : minikube start

E agora podemos verificar que o minikube esta em execução: minikube status

Temos assim o Cluster contendo o Control Plane, com a API Server, o Kubelet todos em execução.

Agora vamos verificar o cluster Kubernetes : kubectl cluster-info

Vamos agora cariar um Pod de forma imperativa usando o comando: kubectl run nginx --image nginx

A seguir vamos emitir o comando : kubectl get all para exibir as informações:

Temos o pod criado com o status ContainerCreating e a informação do cluster Kubernetes.

Repetindo o comando : kubectl get all

Temos agora o Pod no status Running.

Vamos deletar este Pod e a seguir consultar o status usando os comandos :
kubectl delete pod nginx
kubectl get all

Vamos agora criar um Pod usando a forma declarativa.

Para isso vamos criar o arquivo pod1.yaml contendo as seguintes instruções :

apiVersion: v1
Kind: Pod
metadata:
    name: pod-nginx

spec:
    containers:
       - image: nginx
         name: cont-nginx
         ports:
           - containterPort: 80

A seguir vamos aplicar este arquivo de manifesto e consultar o ambiente usando os comandos:
kubectl apply -f pod1.yam
kubectl get all

Obtemos o mesmo resultado que a forma imperativa.

Podemos usar os comandos abaixo para consultar o ambiente:

kubectl describe pods
kubectl describe nodes
kubectl get all
kubectl get pods
kubectl get nodes
kubectl get pods -o wide

Vamos agora verificar se o container esta em execução usando o comando: kubectl exec -ti pod-nginx -- sh

A seguir vamos emitir um comando ls -l e sair o container:

Com isso vemos que o container esta em execução no Pod.

Vamos deletar este Pod usando o comando : kubectl delete pod pod-nginx

Assim tanto na abordagem imperativa como na declarativa obtemos os mesmos resultados.

No entanto usar esta abordagem não faz muito sentido, pois se o pod morrer sua aplicação pára, e além disso, não temos escalabilidade e nenhuma inteligência na aplicação.

Assim, executar a aplicação através do Pod não é a abordagem ideal, pois precisamos de um objeto que cuide dos Pods, que mantenha os seus estados, e que escale a quantidade de Pods quando necessário.

É aqui que entra o ReplicaSet.

No próximo artigo iremos apresentar e usar o objeto ReplicaSet.

"Vigiai, estai firmes na fé; portai-vos varonilmente, e fortalecei-vos.
Todas as vossas coisas sejam feitas com amor."
1 Coríntios 16:13,14

Referências:

Docker - Criando uma imagem com Dockerfile

José Carlos Macoratti