Primeiros passos com OpenStack

Primeiros passos com OpenStack

Sempre que falamos sobre “primeiros passos”  em alguma tecnologia, realizamos algum pequeno teste como um “Hello World” em uma linguagem ou um pequeno blog quando estamos estudando um framework web ou muitas vezes um playbook local, como no caso do Ansible para instalação do WordPress.

Mas e no caso do OpenStack ? Bem, não é fácil definir exatamente um primeiro passo. O OpenStack é uma plataforma IaaS (Infraestrutura como Serviço) para criação de cloud privada, onde basicamente tentamos trazer o gestão de recursos que existe em clouds como AWS e GCP para dentro de uma infraestrutura on-premises.

Existem muitas vantagens e desvantagens, algumas relacionadas a oportunidades de negócio, outras relacionadas ao trabalho com uma gama de tecnologias que variam de Infraestrutura de Redes, Virtualização, Alta Disponibilidade, Storage Distribuído até a gestão de APIs, fornecimento de serviços como DBaaS, VPNaaS, FWaaS, DNSaaS, Container as a Service (Docker, Swarm, K8s, Mesos) etc. Resumindo, o universo de possibilidade com cloud privada é vasto e cheio de riquezas.

Como solucionamos este problema ?

Primeiramente eu diria que precisamos entender o OpenStack, e quando digo isso, me refiro a validar se a solução resolve o seu problema ou não e se você entende como utilizá-lo. Portanto, vamos deixar todos esse pontos complexos relacionados a definições de infraestrutura, alta disponibilidade e deploy de lado e partir para uma solução prática que vai nos permitir utilizar o OpenStack diretamente sem preocupações com redes como Spine-Leaf ou alta disponibilidade de storages.

Para isso, criaremos um laboratório utilizando Vagrant e Ansible, realizando assim o deploy dos serviços que são considerados como o coração (Core) do OpenStack, utilizando para isso uma ferramenta já conhecida da comunidade, o Packstack.

Packstack

O Packstack é uma solução desenvolvida pela RDO [1], uma comunidade voltada para utilização do OpenStack sobre distribuições da família Red Hat como CentOS, Fedora e o próprio Red Hat Enterprise Linux. O objetivo do projeto Packstack é o de criar um ambiente para prova de conceito, permitindo que um usuário ou administrador que esteja pensando em realizar o deploy do OpenStack possa testar a solução em um ambiente controlado sem as preocupações mencionadas acima.

Criando o laboratório

Para esse laboratório iremos utilizar uma máquina virtual criada no VirtualBox. Caso não tenha o virtualizador instalado navegue até o link Download VirtualBox e realize o download de acordo com seu sistema operacional. Os requisitos de hardware dessa máquina são relativamente altos. O projeto Packstack pede pelo menos 16GB de memória RAM e alguns cores para ter uma ambiente minimamente funcional. Aqui, como estamos querendo entender o ambiente e não executar diversas máquinas virtuais, iremos utilizar 8GB de memória e 2 cores.

Se formos seguir os passos descritos no guia de instalação, será necessário fazer o download de um ISO do CentOS, instalar e seguir os 4 passos do processo:

  • Pré-requisitos, desativando SELinux, Firewalld e NetworkManater
  • Instalação do Repositório da versão do OpenStack
  • Instalação do Packstack
  • Instalação do ambiente all-in-one do OpenStack via Packstack

Como nossa proposta aqui é ter um ambiente de fácil criação, sem muitos passos manuais para que você possa simplesmente recriar o ambiente a qualquer momento, iremos substituir esses passos por uma playbook do Ansible integrado ao Vagrant, automatizando não só a criação do laboratório como a instalação do OpenStack.

Em um diretório à parte teremos a seguinte estrutura:


packstack 
├── packstack-answers.txt 
├── playbook.yml 
└── Vagrantfile


Basicamente, temos o Vagrantfile para criar o ambiente dentro do VirtualBox. A playbook utilizada pelo Ansible e o arquivo packstack-answers.txt com o questionário sobre os items que deve conter na instalação, esse arquivo é gerado pelo próprio Packstack utilizando a opção –gen-answer-filePara facilitar já iremos fornecer esses arquivo em um repositório no Github: https://github.com/jrballot/Packstack.git.

Para clonar o repositório, basta executar o comando git clone de sua maquina: git clone https://github.com/jrballot/Packstack.git

Para o Vagrantfile temos a seguinte configuração:


Vagrant.configure("2") do |config| 
  config.vm.box = "generic/centos8" 

  config.vm.define "packstack" do |packstack| 

    config.vm.provider "virtualbox" do |vb| 
      vb.memory = 8192 
      vb.cpus = 2 
      vb.name = "packstack" 
    end 

    packstack.vm.hostname = "packstack.example.org" 
    packstack.vm.network "private_network", ip: "0.0.0.0", auto_network: true
    packstack.vm.network "forwarded_port", guest: 80, host: 8080
    packstack.vm.network "forwarded_port", guest: 6080, host: 6080
    
    packstack.vm.provision "ansible" do |ansible| 
      ansible.playbook = "playbook.yml" 
    end 
  end 

end

Nesse arquivo temos a definição da máquina virtual que estamos utilizando, junto da configuração de rede. Neste caso, estamos utilizando uma bridge sobre a interface eth1 da minha máquina – o que pode ser diferente em seu ambiente -, junto do IP da minha rede interna, que é 10.42.0.0/24. Alguns desses parâmetros podem ser diferentes em seu ambiente. Também temos a redefinição da rota default apontando para o gateway da minha rede. Por fim executamos a etapa de provisionamento, chamando uma playbook do Ansible, conforme abaixo:


---
- hosts: packstack
become: yes
become_method: sudo
gather_facts: true

tasks:
  - name: "[Prerequisites] Disable firewalld and NetworkManager."
    service: name={{item}} state=stopped enabled=no
    with_items:
    - "firewalld"
    - "NetworkManager"

  - name: "[Prerequisites] Disable SELinux"
    selinux:
      policy: targeted
      state: permissive
  - name: "Installing Network-scripts" 
    dnf: 
      name: "network-scripts" 
      state: present 

  - name: "Enabling Network" 
    systemd: 
      name: network 
      enabled: yes

  - name: "Garantee PowerTools repository enabled"
    command: dnf config-manager --enable PowerTools

  - name: "Garantee EPEL repository disabled"
    command: dnf config-manager --disable epel epel-modular

  - name: "Install repository packages for OpenStack"
    dnf:
      name: "{{item}}"
      state: present
    with_items:
      - "centos-release-openstack-ussuri"
      - "vim"
    register: result

  - name: "Updating packages"
    command: yum update -y
    when: result is success

  - name: "Installling OpenStack-Packstack package"
    dnf:
      name: openstack-packstack
      state: present
    when: result is success

  - name: "Copying PackStack Answers file"
    copy:
      src: "{{playbook_dir}}/packstack-answers.txt"
      dest: /root/packstack-answers.txt

  - name: "Installing packstack with --answer-file option"
    command: packstack --answer-file /root/packstack-answers.txt
    when: result is success

Nesse processo estamos desativando alguns recursos do CentOS como Firewalld e NetworkManager, junto de alguns repositórios como EPEL e habilitando o PowerTools. Ao final da playbook estamos instalando o repositório do OpenStack, atualizando o sistema e instalando o Packstack. Nosso último passo é executar o Packstack passando como parâmetro o arquivo de configuração packstack-answers.txt.

É muito importante que você já possua o Ansible instalado na máquina, caso contrário o provisionamento não irá funcionar. Caso não tenha ou não queira utilizar o Ansible comente o último bloco do Vagrantfile e descomente o bloco de código a seguir:

 


packstack.vm.provision "file", source: "./packstack-answers.txt", destination:"/tmp/packstack-answers.txt" 
packstack.vm.provision "shell", inline: <<-SHELL 
  dnf install network-scripts -y 
  systemctl disable firewalld 
  systemctl stop firewalld 
  systemctl disable NetworkManager 
  systemctl stop NetworkManager 
  systemctl enable network 
  systemctl start network 
 
  dnf update -y --exclude=kernel* 
  dnf config-manager --enable PowerTools 
  dnf config-manager --disable epel,epel-modular 
  dnf install -y centos-release-openstack-train 
  dnf update -y --exclude=kernel* 
  dnf install -y openstack-packstack 
  packstack --answer-file /tmp/packstack-answers.txt 
  
SHELL

 

Por último e mais importante, temos o arquivo packstack-anwsers.txt que possui todas as definições de configuração que o ambiente Packstack precisa ter. Entre essas definições temos os serviços que devem ser instalados a quantidade de réplicas de cada processo, qual ntp deve ser utilizado, qual endereçamento de rede para rede privada e pública etc. O arquivo é extenso e servirá de template para configurar o Puppet que o Packstack utiliza durante a instalação e configuração de todos os serviços.


[general]

# Path to a public key to install on servers. If a usable key has not
# been installed on the remote servers, the user is prompted for a
# password and this key is installed so the password will not be
# required again.
CONFIG_SSH_KEY=/root/.ssh/id_rsa.pub

# Default password to be used everywhere (overridden by passwords set
# for individual services or users).
CONFIG_DEFAULT_PASSWORD=

# The amount of service workers/threads to use for each service.
# Useful to tweak when you have memory constraints. Defaults to the
# amount of cores on the system.
#CONFIG_SERVICE_WORKERS=%{::processorcount}
CONFIG_SERVICE_WORKERS=1
...

Algumas das variáveis importantes estão no início do arquivo como apresentado acima:

  • CONFIG_SERVICE_WORKERS: vai definir o número de threads que iremos utilizar no laboratório, defina como 1.
  • CONFIG_DEFAULT_PASSWORD: senha padrão utilizada em todo ambiente, caso não seja informada, será gerada uma senha automaticamente.

Outras configurações de rede também precisarão ser alteradas:

  • CONFIG_CONTROLLER_HOST=10.0.2.15
  • CONFIG_COMPUTE_HOSTS=10.0.2.15
  • CONFIG_NETWORK_HOSTS=10.0.2.15
  • CONFIG_STORAGE_HOST=10.0.2.15
  • CONFIG_SAHARA_HOST=10.0.2.15
  • CONFIG_AMQP_HOST=10.0.2.15
  • CONFIG_MARIADB_HOST=10.0.2.15
  • CONFIG_REDIS_HOST=10.0.2.15
  • CONFIG_PROVISION_DEMO_FLOATRANGE=172.16.20.0/24
  • CONFIG_PROVISION_TEMPEST_FLOATRANGE=172.16.20.0/24

Todas essas variáveis definem os hosts de cada serviço utilizado pelo OpenStack. Como em nosso Vagrantfile temos o endereço 172.20., todos os serviços serão executados sobre essa única máquina. As duas últimas variáveis são utilizadas para definir o range de Floating IPs,  endereços da rede pública do OpenStack.

É hora de criarmos esse laboratório. No diretório onde estiver localizado seu Vagrantfile, execute o comando:


cd Packstack
vagrant up

Na sequência teremos os processos do Vagrant criando a máquina virtual e posteriormente o Ansible executando a playbook, como mostra a figura abaixo:

 

O processo todo de instalação deve demorar algum tempo: aproximadamente 1h para finalizar e seguirmos para os próximos pontos.

 

Primeiro acesso ao Packstack

Assim que a instalação for concluída conseguiremos acessar o endereço http://localhost:8080 abrindo assim a interface de login do Horizon,  projeto relacionado ao desenvolvimento do dashboard do OpenStack.

 

 

 

 

Para acessar esse painel, precisaremos dos dados de acesso. Por padrão o usuário administrador do OpenStack é o admin e o PackStack cria então um senha no processo de instalação. Essa senha estará salva no arquivo keystonerc_admin presente no diretório home do usuário root da máquina virtual.

 

 

 

 

Explorando o ambiente CLI

Para explorarmos o lado CLI (linha de comando) do OpenStack precisamos carregar as variáveis de autenticação. Assim que a instalação foi finalizada, teremos um arquivo keystonerc_admin no diretório home do usuário root. Esse arquivo contem as variáveis de ambiente que iremos utilizar na autenticação do usuário admin da plataforma.

[root@packstack ~]# cat keystonerc_admin


unset OS_SERVICE_TOKEN 
export OS_USERNAME=admin 
export OS_PASSWORD='bc5623d041d04262' 
export OS_REGION_NAME=RegionOne 
export OS_AUTH_URL=http://10.0.2.15:5000/v3 
export PS1='[\u@\h \W(keystone_admin)]\$ ' 
export OS_PROJECT_NAME=admin 
export OS_USER_DOMAIN_NAME=Default 
export OS_PROJECT_DOMAIN_NAME=Default 
export OS_IDENTITY_API_VERSION=3

As variáveis acima definem o usuário, senha, região, endereço, projeto e domínio para autenticação. Esse tipo de arquivo sempre estará presente na instalação em um ambiente OpenStack. Para carregá-lo, utilize o comando source do Shell Bash:

 

 source keystonerc_admin 

 

Assim que o comando terminar de carregar o conteúdo do arquivo, você notará uma alteração no prompt do seu terminal, indicando que agora você está utilizando o usuário admin.

Nossa primeira ação no modo CLI será configurar o bash_completion do comando openstack, executando o comando abaixo e redirecionando para o arquivo /etc/bash_completion.d/openstack:

 


openstack complete >> /etc/bash_completion.d/openstack

source /etc/bash_completion.d/openstack

openstack <TAB><TAB>

Depois do último comando teremos como resultado uma listagem com as diversas opções do modo CLI:

Muitas dessas opções estão relacionadas a recursos internos do OpenStack e outras a serviços como, por exemplo, o comando server para gerenciar VMs ou o comando router  para configuração de roteadores virtuais. Temos também o comando image para administrar as images que serão a base para criação das VMs, o comando volume para definição de blocos de disco que poderemos utilizar, entre muitos outros. Por exemplo a saída do comando hypervisor mostra os Compute Nodes, servidores dedicados a executar as máquinas virtuais:

Ainda na opção do comando hypervisor podemos verificar as configurações desse servidor utilizando os parâmetros show 1:

Com isso conseguimos ver informações importantes, como por exemplo: vcpus, free_ram_mb, free_disk_gb e load_average.

Criando o “Hello World” do OpenStack

Como um exemplo equivalente a um “Hello World” só que dentro do ambiente OpenStack, iremos criar uma rede anexa ao nosso roteador e criar uma instância de teste utilizando uma imagem. Essa estrutura já irá apresentar os elementos básicos dos serviços do OpenStack. Veremos com estes elementos interagem com Neutron, Nova, Glance e Cinder.

 

Criando a rede via CLI

Do seu terminal e utilizando o arquivo de autenticação keystonerc_admin, vamos criar um infraestrutura contendo a rede pública, um roteador virtual e uma rede tenant (rede virtual interna ao ambiente do OpenStack).

source keystonerc_admin

openstack network create local

openstack subnet create --network local --subnet-range 192.168.10.0/24 --allocation-pool start=192.168.10.10,end=192.168.10.30 --dhcp local_subnet


 

Com esses comandos estamos criando uma rede de nome local  e na sequência criando uma subnet local_subnet  com as configurações de rede do nosso ambiente. Vemos configurada a rede –subnet-range seguida do range do dhcp –allocation-pool. Por padrão de instalação o Packstack irá criar um rede pública com uma subnet também pública utilizando os IPs configurados no arquivo packstack-anwsers.txt e podemos visualizar suas configurações com os comandos abaixo:

 


openstack network show public

openstack subnet show public_subnet

 

Agora que temos nossas duas redes, iremos criar o roteador que irá conectar a rede tenant local com a pública. A configuração do roteador é bem simples, basta criar e adicionar as interfaces de cada uma  das redes, somente especificando qual é a pública.

 


openstack router create router01

openstack router add subnet router01 local_subnet

openstack router set router01 --external-gateway public

openstack router show router01

Agora com a rede criada e o roteador conectando as duas redes, podemos criar nossa instância.

 

Criando uma instância Cirros

O primeiro ponto sobre a criação de uma instância é que precisaremos de uma imagem voltada para cloud. Todas as distribuições possuem versões de imagens para o OpenStack. Até mesmo o Windows possui uma imagem de testes que não precisa de licença. Para nosso teste vamos baixar uma imagem do Cirros no link http://download.cirros-cloud.net/0.5.1/cirros-0.5.1-x86_64-disk.img. O Cirros é uma imagem utilizada para criar instâncias de teste e não possui muitos recursos. Conseguimos executar rapidamente uma instância consumindo pouca memória e CPU, o que é excelente para testes de aprovação de um ambiente OpenStack.


curl -OL http://download.cirros-cloud.net/0.5.1/cirros-0.5.1-x86_64-disk.img

 

Assim que o download concluir basta adicionar a imagem ao OpenStack:

 


openstack image create --public --disk-format qcow2 --container-format bare --file cirros-0.5.1-x86_64-disk.img cirros051

Aqui estamos adicionando uma imagem de formato QCOW2 utilizando o arquivo baixado e dando a ela o nome de cirros051.

Para criar a instância também precisaremos de um flavor: tipos de máquinas que temos na AWS e GCP.  Como o PackStack já cria alguns flavors, vamos ver nossas opções com comando flavor list:

 


openstack flavor list

Para esse exemplo o m1.tiny será mais do que suficiente. Já podemos criar nossa instância.

Caso algum erro ocorra devido ao security-group de nome default existir em mais de uma local, utilize o comando openstack security group list, identifique aquele relacionado ao seu projeto e utilize seu IP no lugar.

 


openstack security group list

openstack project list


 

 

Se tudo deu certo até esse ponto teremos uma instância criada após o comando:


openstack server create --flavor m1.tiny --image cirros051 --nic net-id=local --security-group 293a65e4-9e5d-4871-857a-d4d3acb68926 cirros-teste

 

 

Podemos confirmar tudo o que foi feito com os comandos abaixo:

 


openstack server list

openstack server show cirros-teste


Olhe também pelo dashboard:


Com isso temos nossa instância executando no OpenStack, dentro de uma rede tenant  isolada da rede “física”. No menu Network > Network Topology podemos visualizar a infraestrutura que criamos.

 

 

Com isso chegamos ao final desse post. Temos uma ambiente de testes do OpenStack funcional, onde podemos estudar todo seu funcionamento criando redes, máquinas virtuais e provisionando infraestruturas inteiras. Claramente o aprendizado não termina aqui, podemos ainda adicionar mais elementos como Floating IPs que funcionam como endereços públicos e volumes como dispositivos de bloco, que serão tópicos para outro post.

Mais informações:

[1] Projeto RDO: https://www.rdoproject.org

 

 

Líder em Treinamento e serviços de Consultoria, Suporte e Implantação para o mundo open source. Conheça nossas soluções:

CURSOSCONSULTORIA

Anterior Instalando o Zabbix 5.0 LTS com o TimescaleDB
Próxima Gerenciando identidades e acessos com Keycloak - parte 1

About author

Julio Ballot
Julio Ballot 6 posts

Júlio Rangel Ballot, atua como Consultor de TI em Software Livre, formado em Engenharia de Computação pela Universidade de Taubaté. Possui experiência em Administração de Sistemas Open Source e ferramentas voltadas a práticas DevOps, com ênfase em CI/CD (Continuous Integration / Continuous Delivery), atuando há 13 anos na área de Tecnologia da Informação. Detém expertise como instrutor de cursos voltados ao Sistema Operacional Linux, sendo certificado LPIC-2, LPIC - DevOps Tools Engineer, Exin DevOps Master e MongoDB Administrator.

View all posts by this author →

Editor review

Summary

Sempre que falamos sobre “primeiros passos” em alguma tecnologia, realizamos algum pequeno teste como um “Hello World” em uma linguagem ou um pequeno blog quando estamos estudando um framework web ou muitas vezes um playbook local, como no caso do Ansible para instalação do WordPress. Mas e no caso do OpenStack? Aprenda agora.

Você pode gostar também

Infraestrutura

Sysadmin e sysadmins que valem por 1000.

  Durante muito tempo o cotidiano do sysadmin de soluções Open Source foi regido por scripts caseiros que, aparentemente, eram capazes de solucionar todas as questões do dia a dia

Infraestrutura

Reduza custos com instâncias AWS

Acabe com desperdícios com instâncias ligadas sem uso. Projeto de análise e automação da 4Linux permite reduzir gastos com serviços da nuvem AWS Certamente sua empresa possui instâncias na AWS

Infraestrutura

Instalação do Cuda 9 em distribuições Linux baseadas no Ubuntu

Se você deseja trabalhar com algoritmos de Machine Learning, provavelmente precisará usar processamento paralelo para acelerar os resultados dos seus algoritmos. Muitos frameworks como por exemplo, o TensorFlow, já possuem