Como começar a escrever gráficos do Helm para seus aplicativos Kubernetes

0
21


O Helm é um gerenciador de pacotes para cargas de trabalho do Kubernetes. A criação de um gráfico Helm para seu aplicativo simplifica implantações reproduzíveis em um cluster Kubernetes. Os usuários podem instalar o gráfico inteiro com um único comando, em vez de aplicar manualmente manifestos de componentes individuais com o Kubectl.

Neste artigo, mostraremos como começar a usar o Helm escrevendo um gráfico para um aplicativo simples. Um “gráfico” é conceitualmente semelhante a um “pacote” de manifesto do Kubernetes que o Helm permite que você gerencie como uma entidade única.

O que é um gráfico de leme?

Os gráficos Helm aplicam o modelo familiar de gerenciamento de pacotes encontrado em sistemas operacionais e linguagens de programação para aplicativos executados em um cluster Kubernetes. Um gráfico Helm pode ter dependências e filhos; todos esses componentes são iniciados automaticamente em seu cluster quando você instala um gráfico de nível superior.

Os gráficos são totalmente versionados usando uma estratégia de publicação semântica. Semelhante a um módulo npm ou pacote de SO, você pode fixar gráficos em versões específicas e acompanhar suas alterações ao longo do tempo. Isso facilita a reversão de implantações de aplicativos para uma versão válida conhecida no caso de problemas em seu cluster.

Os gráficos do Helm também incorporam recursos de criação de modelos para fornecer valores dinâmicos no momento da instalação. Você pode configurar novos aplicativos sem editar diretamente seus arquivos de manifesto, usando variáveis ​​fornecidas pelo desenvolvedor do gráfico.

instalação do leme

O Helm é distribuído como um binário simples por meio da página de lançamentos do GitHub do projeto. Baixe a distribuição correta para o seu sistema, torne-a executável e mova-a para um local dentro do seu PATH.

O Helm também está presente nos repositórios de pacotes das distribuições Linux mais populares. Você pode encontrá-lo em Homebrew para macOS e Chocolatey e Scoop para Windows também.

Após a conclusão da instalação, execute helm version para verificar se tudo funciona:

$ helm version  --template="Version: {{.Version}}"
Version: v3.8.1

Os comandos do Helm apontam para sua conexão de cluster ativa do Kubernetes, conforme usado pelo Kubectl. O arquivo e o contexto Kubeconfig selecionados serão usados ​​para todos os comandos do Helm. Você pode referenciar um arquivo de configuração diferente com o padrão KUBECONFIG variável de ambiente ou --kubeconfig mecanismos de bandeira

Criando um gráfico de leme

Agora você pode começar a criar um gráfico Helm para seu aplicativo. Use o helm create comando para montar um novo gráfico em seu diretório de trabalho:

$ helm create my-app-chart

O conteúdo do gráfico será depositado dentro do my-app-chart diretório. Vamos inspecionar o que ele contém:

$ ls my-app-chart
Chart.yaml  charts  templates   values.yaml

Existem dois arquivos de nível superior e dois subdiretórios suplementares. É para isso que cada recurso é usado:

  • Chart.yaml – O manifesto do seu gráfico Helm que define as propriedades dos metadados, incluindo seu nome e versão.
  • values.yaml – Este arquivo armazena valores padrão para variáveis ​​que você pode referenciar em seu gráfico. É possível substituir os valores definidos aqui usando sinalizadores da CLI ao instalar o gráfico.
  • templates – O diretório de modelos contém os manifestos do objeto Kubernetes para seu gráfico. A instalação do gráfico aplicará todos esses manifestos ao seu cluster. Qualquer manifesto YAML válido do Kubernetes pode ser colocado aqui; você também pode usar funções adicionais, como referências a variáveis ​​definidas em seu values.yaml processos. Veremos essa habilidade a seguir.
  • charts – O charts O diretório contém outros gráficos do Helm dos quais o Helm depende. Ele é usado para configurar relacionamentos gráficos complexos entre pais e filhos. Não abordaremos esse recurso neste artigo, portanto, você pode excluir o diretório se não precisar dele.

O gráfico Helm padrão vem pré-configurado para implantar uma instância de servidor web NGINX. O Kubernetes se manifesta na templates O diretório cria os vários componentes constituintes, como uma implementação, um serviço e uma entrada. A aplicação é configurada usando variáveis ​​definidas em values.yaml; aqui você encontrará configurações para a tag de imagem, porta de serviço e host de entrada, entre outros:

$ cat values.yaml
# Default values for my-app-chart.
# This is a YAML-formatted file.
# Declare variables to be passed into your templates.

replicaCount: 1

image:
  repository: nginx
  pullPolicy: IfNotPresent
  # Overrides the image tag whose default is the chart appVersion.
  tag: ""
...

Instalando o gráfico

Para adicionar o aplicativo ao seu cluster, use o helm install domínio:

$ helm install my-app .
NAME: foo
LAST DEPLOYED: Tue Mar 29 14:47:48 2022
NAMESPACE: default
STATUS: deployed
REVISION: 1
NOTES:
...

O primeiro argumento do comando define o nome do seu lançamento. O segundo argumento refere-se ao caminho do diretório do qual carregar o gráfico Helm. Você pode usar . quando seu diretório de trabalho já está definido para a raiz do seu gráfico.

Você receberá uma saída de terminal descrevendo a versão instalada. a NOTES A seção consiste em informações fornecidas pelo gráfico.

substituir values.yaml variáveis, forneça uma ou mais instâncias da --set bandeira:

$ helm install my-app . --set replicaCount=3 --set image.tag=1.20

Este exemplo implantaria três réplicas de um contêiner executando o nginx:1.20 imagem. Você pode verificar isso listando os pods em seu cluster usando o Kubectl:

$ kubectl get pods
NAME                                   READY   STATUS    RESTARTS   AGE
my-app-my-app-chart-6d6577749c-2qbhb   1/1     Running   0          61s
my-app-my-app-chart-6d6577749c-wdmgv   1/1     Running   0          44s
my-app-my-app-chart-6d6577749c-x5wp7   1/1     Running   0          40s

Atualizando, recuperando e excluindo versões gráficas

Em seguida, faça algumas alterações no gráfico ou modifique o valor de uma variável:

$ helm install my-app . --set replicaCount=5
Error: INSTALLATION FAILED: cannot re-use a name that is still in use

repetindo o install o comando não funciona Para aplicar as alterações em um gráfico já implantado, use o comando upgrade comando em vez disso. Isso cria um novo “lançamento” dentro do cluster.

$ helm upgrade my-app . --set replicaCount=5
Release "my-app" has been upgraded. Happy Helming!

Você pode listar todas as versões de gráfico implantadas em seu cluster com helm list:

$ helm list
NAME    NAMESPACE   REVISION    UPDATED                                 STATUS      CHART               APP VERSION
my-app  default     2           2022-03-30 15:09:34.370758719 +0100 BST deployed    my-app-chart-0.1.0  1.16.0

Os detalhes de cada versão incluem seu nome, o número de vezes que foi implantado, a hora em que foi atualizado pela última vez e os números de versão do gráfico e do aplicativo que ele fornece.

Para remover uma versão e destruir seus objetos Kubernetes, passe seu nome para o uninstall domínio:

$ helm uninstall my-app
release "my-app" uninstalled

Escreva seu próprio gráfico do zero

Agora vamos ver como escrever um gráfico básico do zero. Crie um novo diretório para seu gráfico; estamos chamando de nosso cloudsavvy-chart. Adicionar um Chart.yaml arquivo dentro com o seguinte conteúdo:

apiVersion: v2
name: cloudsavvy-chart
description: An example Helm chart.
type: application
version: 0.1.0
appVersion: 1.1.0

a type o campo geralmente deve ser definido como application. O outro tipo suportado é library. Funcionalidade do pacote de gráficos da biblioteca que pode ser incluída como uma dependência de outros gráficos. Eles não contêm nenhum Kubernetes. templates eles mesmos.

a version campo refere-se à versão da sua carta. Você deve incrementá-lo sempre que modificar os modelos de gráfico. appVersion indica a versão do principal componente de software que fornece seu gráfico. Aponta os usuários do gráfico para o que será executado em seu cluster após a instalação do gráfico. Como exemplo, se você estiver criando um gráfico que distribui o WordPress, seria apropriado definir appVersion para o número da versão do WordPress que você está fornecendo.

A seguir, crie um values.yaml arquivo com algumas variáveis ​​simples:

deploymentName: cloudsavvy
image: nginx:latest
replicas: 1

Essas variáveis ​​serão referenciadas em seu modelo de gráfico. Adicione este modelo agora como templates/deployment.yaml. Nosso gráfico básico implementará um único Pod, portanto, terá apenas um arquivo de modelo. Em uma situação do mundo real, é uma boa prática criar arquivos de manifesto individuais para cada um dos componentes do seu aplicativo.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: {{ .Values.deploymentName }}-deployment
spec:
  selector:
    matchLabels:
      app: {{ .Values.deploymentName }}
  replicas: {{ .Values.replicas }}
  template:
    metadata:
      labels:
        app: {{ .Values.deploymentName }}
    spec:
      containers:
        - name: {{ .Values.deploymentName }}
          image: {{ .Values.image }}

A implantação usa valores de values.yaml para configurar a referência de imagem e a contagem de réplicas. a deploymentName A variável é usada em todos os momentos para que quaisquer alterações futuras possam ser feitas em um só lugar. campos em values.yaml são referenciados por {{ .Values.FIELD_NAME }} sintaxe.

Agora use o Helm para instalar o gráfico:

$ helm install cloudsavvy-app . --set replicas=3
NAME: cloudsavvy-app
LAST DEPLOYED: Tue Mar 29 15:43:21 2022
NAMESPACE: default
STATUS: deployed
REVISION: 1
TEST SUITE: None

a --set sinalizador substitui o valor padrão de replicas isso está ligado values.yaml. Depois que as substituições são aplicadas, o Helm injeta os valores resolvidos nos locais corretos em seus modelos YAML. Os manifestos finais do Kubernetes são então aplicados ao seu cluster. Agora você pode verificar se três contêineres estão em execução usando o Kubectl para listar os pods em seu cluster.

$ kubectl get pods
NAME                                     READY   STATUS              RESTARTS   AGE
cloudsavvy-deployment-7b975bd985-5r7dc   0/1     ContainerCreating   0          15s
cloudsavvy-deployment-7b975bd985-bpbkm   0/1     ContainerCreating   0          15s
cloudsavvy-deployment-7b975bd985-jzb5q   0/1     ContainerCreating   0          15s

Resumo

Os gráficos do Helm permitem que você empacote coleções de manifestos do Kubernetes como aplicativos completos prontos para implantação. Você pode criar configurações de modelo que os usuários finais podem alterar facilmente antes de instalar uma versão em um cluster.

Neste guia, explicamos os fundamentos da funcionalidade do Helm e mostramos como você pode criar seus próprios gráficos simples para seus aplicativos. No entanto, mal arranhamos a superfície do que o Helm pode realizar: depois de escrever um gráfico, você pode enviá-lo para um repositório para outros usarem, adicionar outros gráficos como dependências e criar gráficos mais avançados usando funções, pipelines e expressões de fluxo de controle. Dedicar um tempo para aprender o Helm torna suas implantações do Kubernetes mais flexíveis, poderosas e reutilizáveis.