Implantar aplicativos em clusters Kubernetes

Em um artigo anterior, implantamos um cluster Kubernetes com um nó mestre e um nó de trabalho. Os clusters do Kubernetes tratam principalmente de duas coisas; Nós e Pods. Os pods são os aplicativos em contêineres que você deseja implantar no cluster e os nós são os servidores de computação individuais responsáveis por gerenciar o cluster ou executar os aplicativos. Para tornar as coisas mais simples, começamos com um aplicativo sem estado e introduzimos vários conceitos, como rótulos e seletores, que são usados para vincular pods entre si.

Existem outros conceitos importantes, como conjuntos de réplicas, serviços e implantações, todos os quais aprenderemos neste artigo.

Implantação de aplicativo tradicional

Se você olhar para a abordagem tradicional para implantar um aplicativo da web, a escalabilidade é algo que você deve considerar antes de começar. Se você precisa de um banco de dados separado do front-end da web, é melhor fazê-lo agora do que depois. Você planeja executar mais de um aplicativo da web? É melhor configurar um servidor proxy reverso com antecedência.

Com o Kubernetes, a abordagem mudou. A implantação pode ser feita com as necessidades atuais em mente e pode posteriormente ser escalonada conforme sua empresa cresce. A conteinerização permite que você separe componentes essenciais de seus serviços da web, mesmo quando eles estão sendo executados em um único nó. Posteriormente, quando você escalonar horizontalmente (o que significa que você adiciona mais servidores ao seu ambiente), você simplesmente precisa girar mais contêineres, e o Kubernetes irá agendá-lo nos nós apropriados para você. Proxy reverso? Os serviços do Kubernetes viriam para resolver esse problema.

Pods

Como primeira etapa, vamos girar um pod. Para fazer isso, precisaríamos de um arquivo YAML definindo vários atributos do pod.

apiVersion: v1
tipo: Pod
metadados:
nome: nginx
especificação:
recipientes:
- nome: nginx
imagem: nginx: 1.7.9
portas:
- containerPort: 80

Adicione o conteúdo acima em um vagem.yaml arquivo e salve-o. Olhando para o texto acima, você pode ver que o Gentil do recurso que estamos criando é um vagem. Nós nomeamos isso nginx, e a imagem é nginx: 1.7.9 o que, por padrão, significa que o Kubernetes buscará a imagem nginx apropriada nas imagens publicamente disponíveis do hub do Docker.

Em organizações de grande escala, o K8 é frequentemente configurado para apontar para um registro privado do qual pode extrair as imagens de contêiner apropriadas.

Agora, para iniciar a execução do pod:

$ kubectl create -f pod.yaml

Você não pode acessar o pod de fora do cluster. Ainda não está exposto e só existe como uma cápsula solitária. Para garantir que ele seja realmente implantado, execute:

$ kubectl get pods

Para se livrar do pod chamado nginx, execute o comando:

$ kubectl delete pod nginx

Implantações

Conseguir apenas um pod em funcionamento não é o objetivo do Kubernetes, o que desejaríamos, idealmente, são várias réplicas de um pod, geralmente programadas em nós diferentes, portanto, se um ou mais nós falharem, o restante dos pods ainda estará lá para pegar aumentar a carga de trabalho adicional.

Além disso, do ponto de vista do desenvolvimento, precisaríamos ter alguma maneira de lançar pods com uma versão mais recente do software e tornar os pods mais antigos inativos. Caso haja um problema com o pod mais recente, podemos reverter, trazendo de volta os pods mais antigos e excluindo a versão com falha. As implantações nos permitem fazer isso.

A seguir, uma maneira muito comum de definir uma implantação:

apiVersion: apps / v1beta1
tipo: implantação
metadados:
nome: nginx-deployment
especificação:
réplicas: 2
modelo:
metadados:
etiquetas:
app: nginx
especificação:
recipientes:
- nome: nginx
imagem: nginx: 1.7.9
portas:
- containerPort: 80

Você notará, entre outras coisas, um par de valores-chave que é:

etiquetas:
aplicativo: nginx

Os rótulos são importantes para o gerenciamento do cluster, pois ajudam a controlar um grande número de pods, todos com a mesma função. Os pods são criados sob o comando do nó mestre e se comunicam com o nó mestre. No entanto, ainda precisamos de uma maneira eficaz para eles conversarem e trabalharem juntos como uma equipe.

Serviços

Cada pod tem seu próprio endereço IP interno e uma camada de comunicação como Flannel ajuda os pods a se comunicarem entre si. Esse endereço IP, no entanto, muda um pouco e, afinal, o objetivo de ter muitos pods é deixá-los descartáveis. Os vagens são mortos e ressuscitados com frequência.

A questão que agora se levanta é: como os pods de front-end se comunicam com os pods de back-end quando as coisas são tão dinâmicas no cluster?

Os serviços entram em cena para resolver essa complexidade. Um serviço é outro pod que atua como um balanceador de carga entre um subconjunto de pods e o resto do cluster Kubernetes. Ele se liga a todos os pods que têm um rótulo específico anexado a eles, por exemplo, banco de dados, e os expõe para o resto do cluster.

Por exemplo, se tivermos um serviço de banco de dados com 10 pods de banco de dados, alguns dos pods de banco de dados podem surgir ou morrer, mas o serviço garantiria que o resto do cluster obtivesse o 'serviço' que é um banco de dados. Os serviços também podem ser usados para expor o front-end para o resto da Internet.

Aqui está uma definição típica de um serviço.

apiVersion: v1
tipo: serviço
metadados:
nome: wordpress-mysql
etiquetas:
app: wordpress
especificação:
portas:
- porta: 3306
seletor:
app: wordpress
camada: mysql
clusterIP: Nenhum

Os pods rotulados como WordPress com a camada mysql especificada são aqueles que serão selecionados por este serviço e expostos aos pods do servidor da web para uma configuração típica do WordPress feita no Kubernetes.

Palavra de cautela

Ao implantar um aplicativo gigante de várias camadas voltado para uma grande base de consumidores, torna-se muito tentador escrever muitos serviços (ou microsserviços, como são conhecidos popularmente). Embora esta seja uma solução elegante para a maioria dos casos de uso, as coisas podem rapidamente sair do controle.

Serviços, como pods, estão sujeitos a falhas. A única diferença é que, quando um serviço falha, muitos pods, que são perfeitamente funcionais, tornam-se inúteis. Consequentemente, se você tiver uma grande interconexão de serviços (internos e externos) e algo falhar, descobrir o ponto de falha se tornaria impossível.

Como regra geral, se você tiver uma visualização aproximada do cluster, ou se puder usar um software como o cockpit para ver o cluster e entendê-lo, sua configuração está bem. O Kubernetes, no final do dia, foi projetado para reduzir a complexidade, não aprimorá-la.