Como subir um ambiente usando orquestração (Heat) no BCOS?

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:

Baixe o script de orquestração (Heat) .YAML

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!

Baixe o script de orquestração (Heat) .YAML

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;

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/