O que é orquestração?
A orquestração é uma forma de criar um ambiente através de scripts, cuja base é o Red Hat Heat. Com ele é possível configurar diversos tipos de serviços, como redes, máquinas virtuais, storage, entre outros.
Neste tutorial vamos montar um web chat como exemplo, além de conhecer os caminhos de consulta e aplicação do código. Vamos lá?
Como funciona um script Heat?
O Heat é um código no formato .yaml, o qual pode ser editado no Notepad++.
Ele trabalha com uma estrutura única, que dividimos em Propriedades (como Nova, Neutron, Cinder entre outros) para, então, indicarmos o caminho de cada serviço desejado (como criar VMs, atribuir um IP público, definir grupo de segurança) e aplicarmos seus parâmetros.
Para executar este passo a passo, disponibilizamos um script .yaml que você poderá baixar aqui:
Veja como fazer isso na prática!
1. Configurar os parâmetros padrão
Antes de qualquer coisa, o primeiro passo é configurar os parâmetros padrão. Isso inclui parâmetros, como:
Imagem
Rede Pública do seu console
Flavor padrão
Chave de segurança
Com isso definido no script, poderemos aplicar as propriedades.
2. Aplicar as propriedade de configuração
Seguindo um caminho lógico de infraestrutura, a primeira propriedade que deve ser configurada é a da Rede (Neutron). Depois, precisamos configurar as Máquinas Virtuais (Nova).
Outras propriedades podem ser aplicadas posteriormente, por exemplo, para criar novos Storages (Cinder). No nosso caso, nós também vamos aplicar a propriedade do Load Balancer (Octavia).
Exemplo de código para configurar os parâmetros padrão
Para ilustrar, usaremos trechos do código como exemplo. A seguir você verá o começo dele, onde definimos os parâmetros padrão:
heat_template_version: 2017-09-01
description: Infra LBaaS
parameters:
public_net:
label: Public network address
default: “ID da sua Rede pública IPV4”
description: Public Network ID
type: string
dmz_network_net:
label: DMZ network address
default: “rede interna das suas máquinas, pode ser a 192.168.0.0/24”
description: Private network address (e.g. 192.168.0.0/24)
type: string
db_network_net:
label: Database network address
default: “outra rede interna das suas máquinas, deve ser diferente da anterior,
192.168.1.0/24, por exemplo”
description: Private network address (e.g. 192.168.0.0/24)
type: string
flavor:
default: “Flavor que você irá utilizar”
description: Flavor of the servers
type: string
constraints:
- custom_constraint: nova.flavor
image:
default: “ID da imagem que você irá utilizar”
description: Image to use to boot the servers
type: string
constraints:
- custom_constraint: glance.image
web_keypair:
default: “Nome da sua chave de segurança”
description: Please create the keypair before launching this stack
type: string
constraints:
- custom_constraint: nova.keypair
db_keypair:
default: “Nome da sua chave de segurança, indicado usar uma diferente”
description: Please create the keypair before launching this stack
type: string
constraints:
- custom_constraint: nova.keypair
lb_port:
label: Load balancer Port
default: “Porta padrão do load Balancer, no nosso caso a 80”
description: Port used by the load balancer
type: number
app_port:
label: Application Port
default: “Porta padrão das máquinas, deve ser a mesma que a do load Balancer, no nosso caso a 80”
description: Port used by the servers
type: number
resources:
Agora, vamos entender as etapas contidas neste trecho.
Primeiro foi definido o modelo de Heat usado da seguinte forma (esse quesito é obrigatório):
heat_template_version: 2017-09-01
Existem diversos modelos que podem ser vistos no próprio console, na aba Orquestração > Versões de Modelos, mas nós usamos a versão de template de 2017.
A seguir aplicamos os parâmetros padrão, para isso escrevemos “parameters:”, sendo que, dentro dele vão ficar os parâmetros, da seguinte forma:
No parâmetro 1 nós definimos a Rede pública que será utilizada.
No parâmetro 2 definimos a rede interna das máquinas web.
No parâmetro 3 definimos a rede interna das máquinas DataBase do nosso exemplo (no seu código você pode definir quantas redes quiser, com o nome que quiser).
Observação: no código foram definidos diversos outros parâmetros que funcionam na mesma estrutura.
Por fim abrimos um parâmetro “resources:” e, dentro dele, colocaremos todas as nossas propriedades.
Exemplo de código para configurar as propriedades de configuração
Vamos pegar um trecho da propriedade do Nova como exemplo, que é feita da seguinte forma:
#-----------------------#
# Nova properties #
#-----------------------#
db_srv_1:
type: OS::Nova::Server
depends_on: db_subnet
properties:
name: db-srv-1
image: { get_param: image }
flavor: { get_param: flavor }
key_name: { get_param: db_keypair }
security_groups: [ { get_resource: db_security_group } ]
networks: [{ network: { get_resource: db_network }} ]
user_data_format: RAW
user_data:
str_replace:
template: |
#! /bin/sh -v
sudo -i
apt update
params:
$shared_ip: { get_param: flavor }
web_srv_1:
type: OS::Nova::Server
depends_on: dmz_subnet
properties:
name: web-srv-1
image: { get_param: image }
flavor: { get_param: flavor }
key_name: { get_param: web_keypair }
security_groups: [ { get_resource: dmz_security_group } ]
networks: [{ network: { get_resource: dmz_network }} ]
user_data_format: RAW
user_data:
str_replace:
template: |
#! /bin/sh -v
sudo -i
apt update
sudo add-apt-repository ppa:ondrej/php
apt install -y apache2 git php php7.2-mcrypt php-mysql libapache2-mod-php
rm -rf /var/www/html
git clone https://github.com/binariocloud/chat.git -l /var/www
touch /var/www/html/assets/chat.txt
chmod 666 /var/www/html/assets/chat.txt
echo { get_attr: [ web_srv_1, first_address ]} web-srv-1 >> /etc/hosts
params:
$shared_ip: { get_param: flavor }
No trecho da propriedade do Nova acima há dois caminhos aplicados com os seus respectivos parâmetros. Vamos entender melhor a estrutura de um desses caminhos, a seguir:
Como podemos ver na estrutura acima, neste conjunto criamos uma máquina virtual, no caso a db-srv-1.
A primeira etapa é colocarmos o caminho dentro da variável — normalmente o caminho é definido por OS::“a sua propriedade”::“o serviço desejado”.
Existem diversos caminhos que podem ser vistos no console. Porém, no nosso caso, o caminho usado é o OS::Nova::Server.
Por fim, agregamos a máquina à subnet desejada e aplicamos os parâmetros necessários.
Toda vez que usamos a função get_ estamos usando algum dos parâmetros padrão, por exemplo, no “key_name” nós buscamos o parâmetro da chave de segurança que definimos nos parâmetros padrão.
O heat possui uma estrutura bem modular e esse é o princípio básico de funcionamento dele.
Baixe agora o código completo de exemplo para a cloud 2.0!
3. Como aplicar a orquestração no console
Com o código exemplo em mãos no formato .yaml, vamos aplicá-lo no console BCOS. Para isso, siga os seguintes passos:
I. No console, vá em Orquestração > Pilhas.
II. Selecione a opção Disparar Pilha.
III. Ao abrir o menu interativo, você poderá escolher entre duas opções em Origem do modelo:
A – importar para o console o arquivo .yaml na opção Arquivo;
OU
B – colar o conteúdo do seu script dentro da caixa de texto em Dados do Modelo, na opção Entrada Direta.
IV. Avançando no menu interativo, é necessário checar e preencher corretamente todos os dados do seu login, como mostra a imagem a seguir:
V. Feito isso, é só ativar e esperar a pilha ser finalizada.
VI. Pronto, coloque o IP público que o Heat alocou na chamada do seu navegador e você terá acesso a um web chat teste da Binario Cloud.
Observação: para verificar o IP público, vá em Rede > IPs Flutuantes.
4. Onde consultar os caminhos e parâmetros
Caso queira diversificar e criar novas pilhas, você pode verificar todos os caminhos e os parâmetros de cada caminho no próprio console.
Para isso, vá em Orquestração > Tipos de Recursos. Lá você encontrará tudo que precisa para desenvolver um script Heat.
Para mais informações, acesse: https://docs.openstack.org/heat/latest/