Usar o Controlador StatefulSets

Introdução

No Kubernetes, os StatefulSets são utilizados para gerenciar aplicações com estado (stateful applications). Diferentemente das aplicações sem estado (stateless applications) tradicionais, as aplicações com estado requerem identificadores de rede estáveis e únicos, além de armazenamento persistente. Neste laboratório, aprenderemos como modelar a estabilidade com StatefulSets no Kubernetes.

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

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

Criar PV e PVC

O primeiro passo é criar um Pod com um Volume Persistente (PV - Persistent Volume) e uma Declaração de Volume Persistente (PVC - Persistent Volume Claim). PVs e PVCs são usados para armazenar e acessar dados de forma persistente em reinicializações de Pods.

Para fazer isso, você primeiro criará um PV.

apiVersion: v1
kind: PersistentVolume
metadata:
  name: my-pv
spec:
  capacity:
    storage: 1Gi
  accessModes:
    - ReadWriteOnce
  hostPath:
    path: "/mnt/data"

Salve o código acima em um arquivo chamado /home/labex/project/pv.yaml e execute o seguinte comando:

cd /home/labex/project
kubectl apply -f pv.yaml

Este comando criará um PV chamado my-pv com uma capacidade de 1Gi e um caminho do host de /mnt/data.

Em seguida, você criará um PVC que solicita 1Gi de armazenamento do PV.

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: my-pvc
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 1Gi

Salve o código acima em um arquivo chamado /home/labex/project/pvc.yaml e execute o seguinte comando:

kubectl apply -f pvc.yaml

Este comando criará um PVC chamado my-pvc que solicita 1Gi de armazenamento.

Criar um StatefulSet

Crie um arquivo chamado /home/labex/project/statefulset.yaml com o seguinte conteúdo:

apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: web
spec:
  serviceName: "web"
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
        - name: nginx
          image: nginx:1.19.7
          ports:
            - containerPort: 80
          volumeMounts:
            - name: www
              mountPath: /usr/share/nginx/html
  volumeClaimTemplates:
    - metadata:
        name: www
      spec:
        accessModes: ["ReadWriteOnce"]
        resources:
          requests:
            storage: 1Gi

Neste arquivo, definimos um StatefulSet chamado web que cria três réplicas de um pod NGINX. Também definimos um serviço chamado web que seleciona os pods NGINX usando o rótulo app: nginx. Finalmente, definimos um modelo de declaração de volume persistente para os dados do pod NGINX.

Para criar o StatefulSet, execute o seguinte comando:

kubectl apply -f statefulset.yaml

Você pode verificar o status do StatefulSet executando o seguinte comando:

kubectl get statefulsets

Depois que o StatefulSet estiver em execução, você pode acessar os pods NGINX executando o seguinte comando:

kubectl get pods
kubectl exec -it web-0 -- /bin/bash

Substitua web-0 pelo nome de qualquer pod NGINX criado pelo StatefulSet.

Parabéns, você criou com sucesso um StatefulSet no Kubernetes!

Atualizar um StatefulSet

No Kubernetes, você pode atualizar os pods de um StatefulSet atualizando seu template. Vamos atualizar o arquivo statefulset.yaml para usar a versão 1.20.0 do NGINX.

Atualize o arquivo /home/labex/project/statefulset.yaml para o seguinte:

apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: web
spec:
  serviceName: "web"
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
        - name: nginx
          image: nginx:1.20.0
          ports:
            - containerPort: 80
          volumeMounts:
            - name: www
              mountPath: /usr/share/nginx/html
  volumeClaimTemplates:
    - metadata:
        name: www
      spec:
        accessModes: ["ReadWriteOnce"]
        resources:
          requests:
            storage: 1Gi

Para atualizar o StatefulSet, execute o seguinte comando:

kubectl apply -f statefulset.yaml

Você pode verificar o status do StatefulSet executando o seguinte comando:

kubectl get statefulsets

Parabéns, você atualizou com sucesso um StatefulSet no Kubernetes!

Escalar um StatefulSet

No Kubernetes, você pode dimensionar um StatefulSet para cima ou para baixo alterando seu campo replicas. Vamos dimensionar nosso StatefulSet web para cinco réplicas.

Atualize o arquivo /home/labex/project/statefulset.yaml para o seguinte:

apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: web
spec:
  serviceName: "web"
  replicas: 5
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
        - name: nginx
          image: nginx:1.20.0
          ports:
            - containerPort: 80
          volumeMounts:
            - name: www
              mountPath: /usr/share/nginx/html
  volumeClaimTemplates:
    - metadata:
        name: www
      spec:
        accessModes: ["ReadWriteOnce"]
        resources:
          requests:
            storage: 1Gi

Para atualizar o StatefulSet, execute o seguinte comando:

kubectl apply -f statefulset.yaml

Você pode verificar o status do StatefulSet executando o seguinte comando:

kubectl get statefulsets

Parabéns, você dimensionou com sucesso um StatefulSet no Kubernetes!

Excluir um StatefulSet

No Kubernetes, você pode excluir um StatefulSet executando o seguinte comando:

kubectl delete statefulset web

Isso excluirá o StatefulSet web e todos os seus pods.

Parabéns, você concluiu o laboratório sobre modelagem de estabilidade com StatefulSets no Kubernetes!

Resumo

Neste laboratório, aprendemos como modelar a estabilidade com StatefulSets no Kubernetes. Criamos um StatefulSet, atualizamos um StatefulSet, escalamos um StatefulSet e excluímos um StatefulSet. Estas são as operações básicas que você precisará realizar ao trabalhar com StatefulSets no Kubernetes.