Nomad como solução de orquestração

Alexandre Sa. Ao pensar em criar um ambiente escalável, o Kubernetes é a primeira ferramenta que vem à mente. No entanto, existem outras soluções interessantes que atendem a esse propósito. Neste documento, apresentamos uma ferramenta muito robusta e com menos complexidade, o Nomad.

O Nomad é uma solução de orquestração de contêineres e de aplicativos desenvolvida pela HashiCorp. Ele foi projetado para ser flexível e fácil de usar, permitindo que os usuários implantem e gerenciem aplicativos em ambientes heterogêneos. O Nomad permite a execução de aplicativos em vários tipos de infraestrutura, incluindo servidores físicos, máquinas virtuais e contêineres. Ele também oferece recursos avançados de escalabilidade e failover, tornando-o uma ótima opção para ambientes de produção.

Uma das principais vantagens do Nomad é a sua capacidade de empacotar e distribuir aplicativos em vários formatos, incluindo containers Docker, arquivos executáveis e scripts. Isso permite que os usuários implantem aplicativos em qualquer ambiente, independentemente do formato que eles são criados. Além disso, o Nomad oferece recursos avançados de programação, permitindo que os usuários definam políticas de alocação de recursos e tolerância a falhas. Isso permite que os usuários criem aplicativos altamente resilientes e escaláveis.

Então, se você está procurando uma solução de orquestração de aplicativos poderosa e fácil de usar, o Nomad é a escolha certa para você. Com recursos avançados de escalabilidade e failover, suporte para vários formatos de aplicativos e uma comunidade ativa, o Nomad oferece tudo o que você precisa para gerenciar aplicativos em qualquer ambiente.

Conceitos do Nomad

Antes de iniciarmos, precisamos apresentar alguns conceitos importantes para o entendimento do Core da Solução.

Job

Job é uma carga de trabalho que precisa ser executada, composta por grupos de tarefas. O Nomad garante que o estado real corresponda ao estado desejado, por meio das alocações e avaliações, utilizando drivers flexíveis e agendamento de grupos de tarefas.

Task Group

Um grupo de tarefas é um conjunto de tarefas que precisam ser executadas juntas, como um servidor da Web que exige um processo de envio de logs em execução constante. O grupo de tarefas é a unidade de agendamento e deve ser executado em um único nó cliente, sem possibilidade de divisão em partes menores.

Driver

Um driver representa o meio básico de execução de suas tarefas. Alguns exemplos de drivers incluem Docker, QEMU, Java e binários estáticos.

Task

Uma Task é a menor unidade de trabalho no Nomad, executada por drivers que permitem ao Nomad suportar vários tipos de tarefas. As tarefas especificam o driver, a configuração, as restrições e os recursos necessários.

Client

Um cliente Nomad é um agente responsável por executar e gerenciar tarefas usando os recursos computacionais disponíveis em uma máquina. O agente registra-se nos servidores, monitora trabalhos atribuídos e executa tarefas. O agente Nomad é um processo de longa duração que se comunica com os servidores.

Allocation

Uma Allocation é um mapeamento entre um grupo de tarefas em uma tarefa e um nó cliente. Um único trabalho pode ter centenas ou milhares de grupos de tarefas, o que significa que deve existir um número equivalente de alocações para mapear o trabalho para as máquinas clientes. As alocações são criadas pelos servidores Nomad como parte das decisões de agendamento feitas durante uma avaliação.

Avaliação

As avaliações são o mecanismo pelo qual o Nomad toma decisões de agendamento. Quando o estado desejado (trabalhos) ou o estado real (clientes) muda, o Nomad cria uma nova avaliação para determinar se alguma ação deve ser tomada. Uma avaliação pode resultar em alterações nas alocações, se necessário.

Implantação

As implantações no Nomad alteram o estado do cluster passo a passo e estão disponíveis apenas para Jobs de serviço. Durante uma Avaliação, o escalonador cria apenas o número de Alocações permitidas pelo bloco de atualização e o estado atual do cluster. As implantações monitoram a integridade dessas alocações e emitem uma nova avaliação para a próxima etapa da atualização.

Server

Os servidores Nomad são os cérebros do cluster. Há um cluster de servidores por região e eles gerenciam todos os trabalhos e clientes, executam avaliações e criam alocações de tarefas. Os servidores replicam dados entre si e realizam a eleição do líder para garantir alta disponibilidade. Mais informações sobre requisitos de latência para servidores podem ser encontradas em Topologia de rede.

Regions

O Nomad modela a infraestrutura como regiões e datacenters. Uma região conterá um ou mais datacenters. Um conjunto de servidores unidos representará uma única região. Os servidores são federados entre regiões para tornar o Nomad globalmente consciente.

Datacenters

O Nomad modela um datacenter como um agrupamento abstrato de clientes em uma região. Os clientes Nomad não precisam estar no mesmo datacenter que os servidores aos quais estão conectados, mas precisam estar na mesma região. Os datacenters fornecem uma maneira de expressar a tolerância a falhas entre os trabalhos, bem como o isolamento da infraestrutura.

Bin Packing

Bin Packing é o processo de enchimento de caixas com itens de forma a maximizar a utilização das caixas. Isso se estende ao Nomad, onde os clientes são "lixeiras" e os itens são grupos de tarefas. O Nomad otimiza recursos ao empacotar tarefas de maneira eficiente nas máquinas clientes.

Agora que entendemos os conceitos fundamentais, estamos prontos para configurar nosso ambiente.

Neste artigo iremos adotar uma distribuição Centos Linux na sua versão 9, atualizado e com o docker instalado. Se não tiver o docker instalado, recomendo executar o comando abaixo, isso irá permitir executar o nomad com o driver do Docker.

$ curl -fsSL https://get.docker.com -o get-docker.sh

$ sudo sh get-docker.sh

$ systemctl enable docker

$ systemctl start docker

Para as demais distribuições ou sistemas operacionais Windows ou MacOs, o processo de instalação é muito simples e bem explicado na página oficial da ferramenta, disponível em https://developer.hashicorp.com/nomad/downloads.

Passos para instalação no nosso ambiente

Instalação das dependências do projeto

$ sudo yum install -y yum-utils

Habilitar o repositório oficial

$ sudo yum-config-manager --add-repo https://rpm.releases.hashicorp.com/RHEL/hashicorp.repo

Agora que o Sistema Operacional consegue reconhecer o repositório da Hashicorp, podemos proceder à instalação com o comando:

$ sudo yum -y install nomad

Seguindo esse processo, o binário do Nomad será instalado na pasta /usr/bin/nomad, tornando o comando nomad acessível em qualquer parte do sistema operacional.

Agora que configuramos todo o ambiente, precisamos iniciar o nosso agente. Para que o serviço rode corretamente, execute o comando abaixo.

$ sudo nomad agent -dev -bind 0.0.0.0 -log-level INFO

Estamos iniciando o nomad em modo desenvolvedor, o que permite verificar os logs da aplicação diretamente na console. No entanto, tenha cuidado, pois esse modo não deve ser utilizado na produção. Mostrarei mais adiante como proceder corretamente nessa situação. Após a execução do comando acima, devemos esperar um resultado semelhante a esse:

Uma vez instalado, conseguimos acessar o nosso ambiente apenas localmente, ou seja, se acessarmos no navegador o endereço http://localhost:4646 teremos acesso ao serviço que acabamos de criar. Entretanto, se quisermos liberar para que o serviço esteja acessível pelo ip da máquina ou via fqdn (full qualified domain name), devemos liberar as portas no firewall do sistema operacional.

$ firewall-cmd --permanent --zone=public --add-port=4646-4647/tcp

$ firewall-cmd --permanent --zone=public --add-port=4648/tcp

$ firewall-cmd --permanent --zone=public --add-port=4648/udp

$ firewall-cmd --reload

$ firewall-cmd --zone=public --list-all

Esta é a tela inicial que você verá ao acessar a interface web pela primeira vez.

Configurando ambiente para produção

Após configurar e testar o ambiente, podemos criar um processo de inicialização automática com o sistema operacional.

$ sudo nano /etc/systemd/system/nomad-client.service

Precisamos colocar o texto abaixo para informar os parâmetros que serão utilizados pelo serviço.

[Unit]

Description=Nomad

Documentation=https://nomadproject.io/docs/

Wants=network-online.target

After=network-online.target

[Service]

ExecReload=/bin/kill -HUP $MAINPID

ExecStart=/usr/bin/nomad agent -config /etc/nomad.d

KillMode=process

KillSignal=SIGINT

LimitNOFILE=65536

LimitNPROC=infinity

Restart=on-failure

RestartSec=2

TasksMax=infinity

OOMScoreAdjust=-1000

[Install]

WantedBy=multi-user.target

Para dar início ao serviço, precisamos executar os comandos abaixo:

$ systemctl enable nomad  #Inicia o nomad junto com o sistema operacional.

$ systemctl start nomad #Inicia o serviço.

$ systemctl status nomad #Verificar se o serviço está configurado corretamente.

Se tudo ocorreu bem, o resultado esperado ao executarmos o comando no servidor do nomad($ systemctl status nomad) é ter o status de Active (running), conforme mostrado na imagem abaixo.

HCL, a linguagem da Hashicorp

HCL é uma linguagem de codificação desenvolvida pela Hashicorp, uma empresa de software de infraestrutura, que é projetada para fornecer uma sintaxe simples e clara para definir recursos de infraestrutura em serviços de nuvem e outras plataformas.

HCL permite que os usuários definam recursos usando blocos de código, com cada bloco representando um recurso específico, como uma instância do servidor ou uma rede virtual. Além disso, HCL fornece uma variedade de recursos avançados, como a capacidade de usar variáveis e funções, para tornar a codificação mais eficiente e flexível. Com sua sintaxe intuitiva e recursos avançados, HCL é uma escolha popular entre desenvolvedores e engenheiros de infraestrutura que trabalham com serviços de nuvem e outras plataformas modernas.

Agora que já conhecemos as principais características do Nomad e a linguagem HCL, vamos entender um pouco mais sobre o arquivo de configuração base do Nomad. Para acessá-lo, basta abrir o arquivo localizado em /etc/nomad.d/nomad.hcl e devemos ter uma configuração semelhante a esta:

```bash

Full configuration options can be found at [https://www.nomadproject.io/docs/configuration](https://www.nomadproject.io/docs/configuration)

data_dir  = "/opt/nomad/data" # Pasta onde se encontra o arquivo de configuração do Nomad

bind_addr = "0.0.0.0" # Informa que a solução pode ser visível na sua rede.

server { # Se quisermos que essa solução funcione como servidor, devemos preencher as informações abaixo.

license_path is required for Nomad Enterprise as of Nomad v1.1.1+

#license_path = "/etc/nomad.d/license.hclic" # Utilizado se adquirida a versão corporativa

enabled          = true # Informa se o servidor deve estar ativo

bootstrap_expect = 1 # Quantas máquinas são esperadas para que o serviço funcione

}

client {# Se quisermos que essa solução funcione como cliente, devemos preencher as informações abaixo.

enabled = true # Dizemos que queremos que esse servidor se comporte como Cliente da solução.

servers = ["10.0.254.254"] # IP dos servidores que serão cadastrados como Cliente.

}

```

Deploy de uma aplicação

Para executar um trabalho, existem 2 formas, sendo a primeira pela interface web acessando a guia Jobs e clicando no botão Run Job, como mostrado na imagem abaixo.

Ao inserir o código abaixo na tela de execução do Job, iremos especificar os seguintes parâmetros:

```bash

job "revelo-http-echo" { # Nome do Job

datacenters = ["dc1"] # Nome do Datacenter

group "http-echo" { # Nome do Task Group

task "server" { # Definição da Task

driver = "docker" # Diz para usar o docker para provisionar o nosso serviço

config { # Aqui definimos os nossos parâmetros, assim como fazemos no docker

image = "hashicorp/http-echo:latest" # Imagem docker que será usada

args  = [ # Esses argumentos podem ser identificados para parâmetros que serão enviados para a variável de ambiente

"-listen", ":8067", # Diz para a aplicação ser executada na porta 8067

"-text", "Meu primeiro serviço no Nomad.", # Qual o texto que deve ser apresentado ao iniciar o serviço

]

}

resources { #Definimos os parâmetros do nosso ambiente

network { # Configuração das portas de rede(assim como no docker)

mode = "bridge" # Iremos usar o default, modo bridge

port "http" { # Criando um alias para o mapeamento de portas (host:container)

static = 8067 # Porta que será utillizada de forma públlica

to = 8067 # Porta do container que será exposta

}

}

}

}

}

}

```

Agora, nossa aplicação está pronta e acessível para nossos clientes, com os parâmetros que configuramos em nosso Job e você deve visualizar uma tela igual a apresentada na imagem abaixo.

A segunda forma de execução da aplicação seria através da CLI (Command Line Interface). Para isso, é necessário salvar o Job configurado no servidor com a extensão .hcl e, em seguida, executar o comando correspondente.

`nomad run <nome-do-arquivo-que-voce-salvou>.hcl`

Isso foi apenas uma breve introdução da ferramenta Nomad da Hashicorp. Espero que tenham gostado e até a próxima.