Como Instalar Software em Clusters Kubernetes com o Gerenciador de Pacotes Helm 3

Tutoriais

Introdução

Helm é um gerenciador de pacotes para Kubernetes que permite aos desenvolvedores e operadores configurar e implantar aplicativos em clusters Kubernetes com mais facilidade.

Os pacotes Helm são chamados de charts e contêm modelos de definições de recursos que implantam e configuram aplicativos específicos com o mínimo de esforço necessário do usuário. Com o uso de templates, você pode gerenciar o chart, suas configurações e comportamento passando definições de variáveis sem modificar o próprio chart. Definições de recursos personalizadas, assim como modificações em definições já implantadas, são gerenciadas automaticamente pelo Helm. Um chart implantado, com possíveis personalizações, é chamado de release.

Neste tutorial, você configurará o Helm 3 e aprenderá como instalar, atualizar, reverter e gerenciar charts e releases. Você também aprenderá a criar e empacotar seus próprios charts, além de configurar repositórios de charts, que hospedam charts que você pode instalar imediatamente.

Pré-requisitos

Um cluster Kubernetes com controle de acesso baseado em funções (RBAC) habilitado. Para mais informações sobre releases, você pode verificar a página de releases do Helm.
A ferramenta de linha de comando kubectl instalada no seu computador local, configurada para se conectar ao seu cluster. Você pode ler mais sobre a instalação do kubectl na documentação oficial.

Você pode testar sua conectividade com o seguinte comando:
```
kubectl cluster-info
```
Se você não receber erros, está conectado ao cluster. Se você acessa vários clusters com o kubectl, certifique-se de verificar se selecionou o contexto correto do cluster executando:
```
kubectl config get-contexts
```
A saída listará as configurações disponíveis:
```
SaídaCURRENT   NAME                    CLUSTER                 AUTHINFO                      NAMESPACE
*         do-fra1-helm3-example   do-fra1-helm3-example   do-fra1-helm3-example-admin
```
Aqui, o asterisco (*) indica que estamos conectados ao cluster do-fra1-helm3-example. Para trocar de clusters, execute:
```
kubectl config use-context nome-do-contexto
```

Quando estiver conectado ao cluster correto, continue no Passo 1 para começar a instalar o Helm.

Passo 1 — Instalando o Helm 3

Nesta seção, você instalará o Helm 3 usando o script shell fornecido oficialmente.

Comece navegando até /tmp, onde você armazenará o script de instalação executando:

cd /tmp

Baixe o script com o seguinte comando:

curl -fsSL -o get_helm.sh https://raw.githubusercontent.com/helm/helm/master/scripts/get-helm-3

Você pode examinar o get_helm.sh no seu editor de texto para garantir que seja seguro.

Torne-o executável definindo suas permissões para:

chmod u+x get_helm.sh

Finalmente, execute-o para instalar o Helm 3:

./get_helm.sh

Você receberá uma saída semelhante à seguinte:

OutputDownloading https://get.helm.sh/helm-v3.5.2-linux-amd64.tar.gz
Verifying checksum... Done.
Preparing to install helm into /usr/local/bin
helm installed into /usr/local/bin/helm

Você tem o Helm 3 instalado em sua máquina. Agora você aprenderá sobre repositórios de gráficos e como usá-los.

Passo 2 — Configurando Repositórios de Gráficos

Os gráficos Helm são armazenados em repositórios de gráficos que podem ser hospedados por qualquer pessoa. Por padrão, o Helm 3 não vem pré-configurado com nenhum repositório. As versões anteriores do Helm incluíam um repositório de gráficos centralizado e curado; no entanto, o design do Helm 3 evoluiu deliberadamente para os desenvolvedores de gráficos gerenciarem seu próprio repositório, permitindo mais liberdade e lançamentos mais rápidos. Isso significa que para cada gráfico que você deseja usar, você precisa garantir que adicione o repositório de hospedagem à sua instalação do Helm.

Para ajudá-lo a encontrar o repositório certo, você pode usar o ArtifactHub.io, um site de código aberto gerenciado pela CNCF que cataloga gráficos do Helm e seus repositórios. Ele também rastreia gráficos populares e úteis que outros projetos da CNCF usam, então ele difere do repositório stable com que as versões anteriores do Helm trabalhavam. Para projetos comuns, como ingressos Nginx ou ferramentas de monitoramento, é uma ótima fonte.

Você pode procurar por um gráfico que deseja instalar através da página inicial. Pesquisar por nginx mostrará todos os gráficos indexados relacionados a ele.

Você instalará a edição comunitária gerenciada pela equipe do Kubernetes. Procure por ingress-nginx para encontrá-lo nos seus resultados. Selecione-o para acessar sua página.

Cada gráfico deve ter uma descrição detalhando o que faz, juntamente com comandos para adicionar seu repositório à sua instalação e instalar o gráfico. Se não tiver, ainda é possível obter os comandos necessários pressionando o botão INSTALAR à direita da página.

Você pode clicar no botão azul ao lado de um comando para copiá-lo. Faça isso para o primeiro comando e execute-o:

helm repo add ingress-nginx https://kubernetes.github.io/ingress-nginx

Para adicionar um repositório ao Helm, você executa helm repo add. Os parâmetros que ele aceita são o nome do repositório e sua localização.

A saída será:

Output"ingress-nginx" has been added to your repositories

Ao adicionar um novo repositório, você precisa informar ao Helm o que ele contém executando:

helm repo update

Você receberá a seguinte saída, mostrando que a atualização foi bem-sucedida:

OutputHang tight while we grab the latest from your chart repositories...
...Successfully got an update from the "ingress-nginx" chart repository
Update Complete. ⎈Happy Helming!⎈

Neste passo, você aprendeu sobre o ArtifactHub e o que ele oferece. Você também adicionou um novo repositório à sua instalação do Helm. No próximo passo, você instalará um gráfico do Helm.

Passo 3 — Instalando um Gráfico do Helm

Na seção anterior, você adicionou o repositório para o gráfico ingress-nginx. Agora você o instalará no seu cluster.

Cada gráfico tem variáveis de configuração que você pode definir para modificar seu comportamento. Essas variáveis são armazenadas em um arquivo chamado values.yaml que faz parte do gráfico. A menos que você tenha baixado o gráfico para sua máquina, você terá que executar o seguinte comando para visualizá-lo:

helm show values chart_name

Para mostrar as variáveis disponíveis para ingress-nginx, substitua nome_do_gráfico:

helm show values ingress-nginx/ingress-nginx

O resultado será longo, mostrando o conteúdo de values.yaml para ingress-nginx.

Para instalar um gráfico, você pode usar helm install:

helm install release_name repository/chart_name

A release is a deployed instance of the chart, and here you’re calling it ingress-nginx.

Este comando instalaria o gráfico no seu cluster com os valores padrão das variáveis. Se você deseja modificar alguns deles, você pode passar os novos valores das variáveis usando --set:

helm install ingress-nginx/ingress-nginx --set variable_name=variable_value

Você pode repetir --set para quantas variáveis precisar. Como não estaremos personalizando agora, instale como está executando:

helm install ingress-nginx ingress-nginx/ingress-nginx

O resultado será semelhante ao seguinte:

Output
NAME: ingress-nginx
LAST DEPLOYED: Wed Feb 24 10:12:37 2021
NAMESPACE: default
STATUS: deployed
REVISION: 1
TEST SUITE: None
NOTES:
The ingress-nginx controller has been installed.
It may take a few minutes for the LoadBalancer IP to be available.
You can watch the status by running 'kubectl --namespace default get services -o wide -w ingress-nginx-controller'
...

Observe que o NOME corresponde ao nome do release que você especificou. O Helm também lista informações comuns, como o status do release e o namespace no qual está implantado. A seção NOTAS varia entre os gráficos e geralmente contém orientações de inicialização rápida ou alerta sobre algumas armadilhas comuns ao usar os recursos do gráfico. Aqui, observa-se que o Balanceador de Carga está sendo criado e que pode levar algum tempo para ser concluído.

Para verificar os gráficos implantados, use helm list:

helm list

Você verá que ingress-nginx é o único gráfico implantado no momento:

OutputNAME            NAMESPACE       REVISION        UPDATED                                 STATUS          CHART                   APP VERSION
ingress-nginx   default         1               2021-02-24 10:12:37.281049711 +0000 UTC deployed        ingress-nginx-3.23.0    0.44.0

Você pode encontrar os serviços que estão no seu cluster executando:

kubectl get services

A saída será semelhante a esta:

OutputNAME                                 TYPE           CLUSTER-IP      EXTERNAL-IP    PORT(S)                      AGE
ingress-nginx-controller             LoadBalancer   10.245.211.81   46.101.68.67   80:30704/TCP,443:30700/TCP   7m19s
ingress-nginx-controller-admission   ClusterIP      10.245.50.17    <none>         443/TCP                      7m19s
kubernetes                           ClusterIP      10.245.0.1      <none>         443/TCP                      83m

Agora que você implantou um lançamento no seu cluster, você modificará sua configuração enquanto está implantado.

Passo 4 — Atualizando um Lançamento

Uma vez que um lançamento é implantado, você não precisa derrubá-lo e implantá-lo novamente completamente quando precisar alterar sua configuração. Você pode usar o comando helm upgrade para atualizar o lançamento com uma nova versão do gráfico ou para definir novas configurações.

O gráfico ingress-nginx expõe a variável controller.replicaCount que controla o número de pods de controlador implantados. Por padrão, está definido como um, o que você pode verificar listando os pods disponíveis:

kubectl get pods

Você verá que há apenas um:

OutputNAME                                        READY   STATUS    RESTARTS   AGE
ingress-nginx-controller-7fc74cf778-kjtst   1/1     Running   0          12m

Se você deseja implantar mais pods para redundância (por exemplo, três), você pode atualizar o lançamento e definir a variável como 3 executando:

helm upgrade ingress-nginx ingress-nginx/ingress-nginx --set controller.replicaCount=3 --reuse-values

Você também passa --reuse-values, que instrui o Helm a basear suas alterações no lançamento implantado, preservando a configuração anterior.

Na saída, o Helm aumentará a revisão para sinalizar que o lançamento foi atualizado:

OutputNAME: ingress-nginx
LAST DEPLOYED: Wed Feb 24 12:07:54 2021
NAMESPACE: default
STATUS: deployed
REVISION: 2
TEST SUITE: None
NOTES:
...

Você pode listar os pods disponíveis executando:

kubectl get pods

Você encontrará três pods listados, em vez de um:

OutputNAME                                        READY   STATUS    RESTARTS   AGE
ingress-nginx-controller-7fc74cf778-4hk9g   1/1     Running   0          18s
ingress-nginx-controller-7fc74cf778-kjtst   1/1     Running   0          22m
ingress-nginx-controller-7fc74cf778-wz595   1/1     Running   0          18s

A seguir, você irá reverter as mudanças e excluir os lançamentos por completo.

Passo 5 — Revertendo e Excluindo um Lançamento

Ao atualizar um lançamento, seu número de revisão é incrementado. Internamente, o Helm armazena todas as revisões de um lançamento, permitindo que você retorne a uma revisão anterior, se necessário.

Para reverter o número de pods para apenas um, você poderia executar helm upgrade novamente e definir manualmente o número, porque é uma mudança pequena. No entanto, ao trabalhar com gráficos maiores com muitas variáveis, reverter manualmente não é viável e deve ser automatizado.

Para reverter um lançamento, use helm rollback:

helm rollback release_name release_revision

Você pode usá-lo para reverter as alterações que você fez no ingress-nginx ao voltar para a revisão 1:

helm rollback ingress-nginx 1

Você receberá a seguinte saída, indicando que a ação foi bem-sucedida:

OutputRollback was a success! Happy Helming!

Você pode verificar a revisão atual listando os lançamentos:

helm list

Você verá que a revisão agora é 3, e não 1:

OutputNAME            NAMESPACE       REVISION        UPDATED                                 STATUS          CHART                   APP VERSION
ingress-nginx   default         3               2021-02-24 12:43:21.523664768 +0000 UTC deployed        ingress-nginx-3.23.0    0.44.0

O Helm considera cada mudança, incluindo reversões, como uma nova revisão de um lançamento. Você pode verificar que a revisão 3 é igual à primeira, verificando o número de pods implantados executando:

kubectl get pods

Você verá que há apenas um:

OutputNAME                                        READY   STATUS    RESTARTS   AGE
ingress-nginx-controller-7fc74cf778-kjtst   1/1     Running   0          41m

Para excluir um lançamento e todas as suas revisões, você pode usar helm delete:

helm delete release_name

Uma vez que você não precisará mais dele, exclua ingress-nginx executando o seguinte comando:

helm delete ingress-nginx

A saída será:

Outputrelease "ingress-nginx" uninstalled

Você pode listar as versões para verificar que não há nenhuma:

helm list

A tabela de saída não terá linhas:

OutputNAME    NAMESPACE       REVISION        UPDATED STATUS  CHART   APP VERSION

Agora que a versão foi excluída, você pode reutilizar seu nome para implantações futuras.

Passo 6 — (Opcional) Criando Gráficos Personalizados

Neste passo opcional, você aprenderá como criar um gráfico personalizado, onde colocar suas definições de recursos e como empacotá-lo para distribuição posterior.

Você criará um novo gráfico chamado exemplo-gráfico. Execute o seguinte comando para criá-lo:

helm create example-chart

Isso criará um novo diretório chamado exemplo-gráfico com os seguintes arquivos e estrutura:

example-chart/

charts/
templates/
├─ tests/
│  ├─ test-connection.yaml
├─ deployment.yaml
├─ hpa.yaml
├─ ingress.yaml
├─ NOTES.txt
├─ service.yaml
├─ serviceaccount.yaml
├─ _helpers.tpl
Chart.yaml
values.yaml

As definições de recursos que seu gráfico instalará nos clusters de destino estão localizadas no diretório templates. As predefinições que o Helm criou como ponto de partida implantam um controlador de ingresso Nginx. Embora a extensão do arquivo seja YAML, elas usam a sintaxe de modelagem do Go para permanecerem personalizáveis por meio de variáveis expostas que você pode passar. Você pode verificar mostrando o conteúdo de service.yaml executando:

cat example-chart/templates/service.yaml

Você verá que ele possui diretrizes de modelagem para gerar valores cercados por chaves duplas:

Output
apiVersion: v1
kind: Service
metadata:
  name: {{ include "mychart.fullname" . }}
  labels:
    {{- include "mychart.labels" . | nindent 4 }}
spec:
  type: {{ .Values.service.type }}
  ports:
    - port: {{ .Values.service.port }}
      targetPort: http
      protocol: TCP
      name: http
  selector:
    {{- include "mychart.selectorLabels" . | nindent 4 }}

As variáveis referenciadas são expostas ao usuário e definidas em values.yaml. O texto NOTES que o Helm mostra após a implantação é armazenado em NOTES.txt, e também é modelado. Metadados do gráfico, como nome, versão e versão do software sendo implantado, são especificados em Chart.yaml:

example-chart/Chart.yaml

apiVersion: v2
name: mychart
description: A Helm chart for Kubernetes

...
type: application

...
version: 0.1.0

...
appVersion: "1.16.0"

Para verificar o que o Helm implantaria, você pode passar --dry-run e --debug para helm install apontando para o diretório do gráfico:

helm install example-chart --dry-run --debug ./example-chart

A saída será longa e conterá todas as definições de recursos finais que seriam aplicadas ao seu cluster. Enquanto estiver trabalhando no seu gráfico, você pode usar helm upgrade para enviar novas versões para o Kubernetes.

Quando chegar a hora de compartilhar seu gráfico finalizado, você pode empacotá-lo para distribuição executando:

helm package ./example-chart

A saída será:

OutputSuccessfully packaged chart and saved it to: .../example-chart-0.1.0.tgz

O gráfico empacotado pode ser instalado da mesma forma que os de repositórios adicionados:

helm install example-chart example-chart-0.1.0.tgz

Neste passo, você criou um gráfico personalizado e o implantou. Você também o empacotou e aprendeu sobre sua estrutura.

Conclusão

Agora você sabe como usar o Helm para instalar e atualizar software implantado no seu cluster Kubernetes. Você adicionou repositórios de gráficos e aprendeu por que são importantes e como o ArtifactHub pode ajudá-lo a encontrá-los. Você também criou um novo gráfico personalizado e aprendeu sobre revisões de lançamento e como reverter, se necessário.

Para obter mais informações sobre como criar gráficos personalizados, visite o guia oficial.

Source:
https://www.digitalocean.com/community/tutorials/how-to-install-software-on-kubernetes-clusters-with-the-helm-3-package-manager