Guia Completo: Criando um Laboratório OpenStack com Kolla-Ansible

O que você vai aprender neste guia:

Ao final da leitura e execução deste laboratório, você será capaz de:

• Entender os Conceitos Fundamentais: Compreender o que é o OpenStack, por que ele é relevante e como o Kolla-Ansible simplifica sua implantação.
• Provisionar uma VM Completa: Utilizar o Vagrant para automatizar a criação de uma máquina virtual robusta, pronta para o OpenStack.
• Configurar a Rede e o Armazenamento: Preparar as interfaces de rede e o armazenamento LVM para os serviços do OpenStack.
• Implantar o OpenStack com Kolla-Ansible: Executar o passo a passo da implantação de uma nuvem OpenStack All-in-One (AIO) usando contêineres Podman.
• Criar a Imagem do Balanceador de Carga: Construir a imagem Amphora para o serviço de Load Balancer (Octavia).
• Validar a Nuvem: Verificar a saúde dos serviços e garantir que a implantação foi bem-sucedida.
• Criar sua Primeira Máquina Virtual: Lançar uma instância (VM) tanto pela linha de comando (CLI) quanto pela interface gráfica (Horizon).
• Acessar sua VM: Conectar-se à sua nova VM usando um IP flutuante.

Sobre a CodeSolve

┌─────────────────────────────────────────────────────────────────────────────┐
│                                                                             │
│      ██████╗ ██████╗ ██████╗ ███████╗███████╗ ██████╗ ██╗    ██╗   ██╗███████╗│
│     ██╔════╝██╔═══██╗██╔══██╗██╔════╝██╔════╝██╔═══██╗██║    ██║   ██║██╔════╝│
│     ██║     ██║   ██║██║  ██║█████╗  ███████╗██║   ██║██║    ██║   ██║█████╗  │
│     ██║     ██║   ██║██║  ██║██╔══╝  ╚════██║██║   ██║██║    ╚██╗ ██╔╝██╔══╝  │
│     ╚██████╗╚██████╔╝██████╔╝███████╗███████║╚██████╔╝███████╗╚████╔╝ ███████╗│
│      ╚═════╝ ╚═════╝ ╚═════╝ ╚══════╝╚══════╝ ╚═════╝ ╚══════╝ ╚═══╝  ╚══════╝│
│                                                                             │
│                      A Arte de Resolver Problemas                           │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

Minha profissão é resolver problemas. Há 22 anos uso tecnologia como ferramenta para isso.

Sou Alexandre Carvalho, fundador da CodeSolve. Ao longo dessas duas décadas, passei por infraestrutura, desenvolvimento, arquitetura e, mais recentemente, mergulhei fundo no universo DevOps e Cloud Native. A CodeSolve nasceu dessa jornada — da vontade de compartilhar conhecimento e ajudar empresas a modernizarem suas operações de forma prática e segura.

O que fazemos:

• Consultoria em DevOps, CI/CD e Kubernetes
• Implementação de pipelines com Tekton, GitLab CI, ArgoCD
• Migração e operação em Cloud (AWS, GCP, Azure, OCI)
• Observabilidade, Segurança e Infraestrutura como Código

Contato:

• Web: www.codesolve.com.br
• Email: alexandre@codesolve.com.br
• Instagram: @falarcomalexandreti

O que o OpenStack resolve?

Ele ataca exatamente essa lentidão. O OpenStack é uma plataforma de orquestração. Pense nele como um maestro que rege os três pilares da infraestrutura: Compute, Rede e Storage. Ele automatiza o processo, permitindo que você (ou seu dev) peça uma VM através de um portal (o Horizon) ou de uma API e a receba em minutos.

O Modelo IaaS (OpenStack) (O Portal Mágico):

Com o OpenStack, você não pede mais uma VM, você a cria. Você tem o poder de um “self-service” de IaaS, criando redes, volumes, e gerenciando todo o ciclo de vida dos seus recursos.

O que diabos é OpenStack e por que eu deveria me importar?

Imagine que você precisa de uma máquina virtual. Como é o processo hoje na sua empresa?

O Modelo Tradicional (O Labirinto):

Você abre um ticket. A equipe de Infraestrutura recebe. Alguém da equipe de Virtualização cria a VM. Outra pessoa, da equipe de Redes, configura o IP e as regras de firewall. A equipe de Storage aloca o disco. Dias (ou semanas) depois, a VM chega para você. Frustrante, né?

A Bagunça Antes do Kolla: O “FrankenStack”

Instalar o OpenStack no passado era uma aventura. Cada serviço (Nova, Neutron, Cinder…) era um projeto separado, com suas próprias dependências e scripts de instalação. O resultado era um “FrankenStack”: uma colcha de retalhos de pacotes, configurações manuais e scripts frágeis. Manter isso atualizado era um pesadelo.

A Ordem com Kolla-Ansible: A Fábrica de Legos

É aqui que a mágica acontece. O Kolla é uma “fábrica de peças de Lego”. Ele cria contêineres perfeitos e prontos para produção para cada serviço do OpenStack. O Kolla-Ansible é o “manual de instruções”: ele pega essas peças e constrói sua nuvem de forma organizada, repetível e robusta.

Com o Kolla-Ansible, saímos do caos artesanal para uma linha de montagem automatizada. É por isso que vamos usá-lo nesta jornada.

Então, se você também quer desmistificar o OpenStack e aprender a construir sua própria nuvem privada, vem comigo. Este é o chamado para a nossa jornada. Bora?

Nosso Laboratório: A Estrutura do Host e da VM

Antes de mergulhar nos comandos, é crucial entender nosso campo de batalha. Aqui está um diagrama detalhado da nossa infraestrutura:

O Host (Máquina Física)

• Sistema Operacional: Pop!_OS 24.04 LTS (ou qualquer Linux moderno com KVM)
• Redes Libvirt: default (virbr0) e vagrant-libvirt (virbr1)
• Bridge Externa: br0 (conectada à sua LAN)
• Storage Pools (Libvirt): default e kolla_pool (apontando para o diretório onde os discos da VM serão armazenados)

A VM (Nosso Nó OpenStack All-in-One)

• Provisionamento: KVM/libvirt via Vagrant
• Recursos: 8 vCPUs, 16 GiB de RAM
• Discos: vda (80 GB para o SO) e vdb (60 GB para o Cinder)
• Redes: Duas interfaces (mgmt0 e ext0) conectadas à br0 do host.
• Usuário: infrastack com sudo sem senha.

Por que esse desenho de ambiente importa?

Este não é um laboratório de brinquedo. Ao conectar a VM diretamente à sua LAN (via bridge), garantimos que:

• O OpenStack não fique isolado em NAT.
• Floating IPs funcionem corretamente, permitindo acesso externo real às suas instâncias.
• Rede, compute e storage sigam o modelo IaaS real.
• O laboratório se comporte como um ambiente de produção, só que em escala reduzida.

Pré-requisitos do Kolla-Ansible

Com base na documentação oficial do Kolla-Ansible, estes são os requisitos para nosso nó. Validamos todos eles:

• Memória: Mínimo de 8 GB RAM. Nosso ambiente com 16 GB tem folga.
• Disco: Mínimo de 40 GB. Nosso ambiente tem 80 GB + 60 GB.
• Interfaces de Rede: Mínimo de 2. Nosso ambiente tem 2.
• Sistema Operacional: Suportados: Ubuntu, CentOS, Rocky Linux. Usaremos Ubuntu.
• Dependências de Sistema e Python: python3-dev, libffi-dev, gcc, etc. Todas essas dependências são instaladas automaticamente pelo script de provisionamento da VM.

Por que validar isso antes?

Porque a maioria dos problemas em instalações OpenStack começa aqui:

• memória insuficiente
• disco mal dimensionado
• rede incorreta
• SO incompatível
• dependências ausentes

Validando esses pontos antes, eliminamos erros difíceis de diagnosticar durante o deploy.

Parte 1 — Provisionando a VM com Vagrant (libvirt)

1.1 Vagrantfile (COMPLETO)

Crie um arquivo chamado Vagrantfile com exatamente este conteúdo. Ele contém todo o script de provisionamento da nossa VM.

Ajuste as MACs se quiser; usei MACs fixas para o netplan casar as NICs por macaddress (evita depender de nomes como enp1s0/enp7s0). O root disk será 80 GB; o disco extra de 60 GB será criado no seu pool kolla_pool. O arquivo globals.yml precisa estar ao lado do Vagrantfile.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

# -*- mode: ruby -*-
Vagrant.configure("2") do |config|
  config.vm.box = "bento/ubuntu-24.04"
  config.vm.hostname = "gandhivastack"

  # 2 NICs em bridge real do host (br0)
  config.vm.network "public_network",
    dev: "br0",
    type: "bridge",
    mac: "52:54:00:aa:11:01",
    auto_config: false

  config.vm.network "public_network",
    dev: "br0",
    type: "bridge",
    mac: "52:54:00:aa:11:02",
    auto_config: false

  # Copia o globals.yml
  config.vm.provision "file", source: "./globals.yml", destination: "/tmp/globals.yml"

  config.vm.provision "shell", inline: <<-'SHELL'
	set -euo pipefail
	
	# cria usuário infrastack
	id infrastack >/dev/null 2>&1 || adduser --disabled-password --gecos "" infrastack
	
	# >>> SENHA (HASH SHA-512) <<< SENHA=12345678
	usermod --password '$6$sc3Ls9XqczCrwP1G$i7XlBUK.JDPvWxKH7LIRrT1qwiyOCXJu02djGj/XIb.U3HojORrBrRASv1O/bZMyxwu5RDkt9RlbUWEyy8WbG0' infrastack
	
	# sudo sem senha
	usermod -aG sudo infrastack
	echo "infrastack ALL=(ALL) NOPASSWD:ALL" > /etc/sudoers.d/99-infrastack
	chmod 440 /etc/sudoers.d/99-infrastack
	
	# SSH key
	install -d -m 700 -o infrastack -g infrastack /home/infrastack/.ssh
	cp ~vagrant/.ssh/authorized_keys /home/infrastack/.ssh/authorized_keys
	chown infrastack:infrastack /home/infrastack/.ssh/authorized_keys
	chmod 600 /home/infrastack/.ssh/authorized_keys
	
	# desabilita cloud-init network
	mkdir -p /etc/cloud/cloud.cfg.d
	echo 'network: {config: disabled}' > /etc/cloud/cloud.cfg.d/99-disable-network-config.cfg
	rm -f /etc/netplan/50-cloud-init.yaml
	rm -f /etc/netplan/01-netcfg.yaml
	
	# netplan
	cat >/etc/netplan/50-gandhivastack.yaml <<-'NP'
	network:
	  version: 2
	  renderer: networkd
	  ethernets:
	    mgmt:
	      match:
	        macaddress: "52:54:00:aa:11:01"
	      set-name: mgmt0
	      dhcp4: false
	      dhcp6: false
	      accept-ra: no 
	      link-local: [ipv4]            
	      addresses:
	        - "192.168.2.35/24"
	      routes:
	        - to: default
	          via: 192.168.2.1
	      nameservers:
	        addresses:
	          - 8.8.8.8
	          - 1.1.1.1
	    ext:
	      match:
	        macaddress: "52:54:00:aa:11:02"
	      set-name: ext0
	      dhcp4: false
	      dhcp6: false
	      accept-ra: no          # <— imprescindível na externa do Neutron
	      link-local: []        
	NP
	
	chmod 600 /etc/netplan/*.yaml
	
	# sysctl — mata IPv6 nas ifaces relevantes
	cat >/etc/sysctl.d/70-kolla-disable-ipv6.conf <<EOF
	net.ipv6.conf.mgmt0.disable_ipv6=1
	net.ipv6.conf.ext0.disable_ipv6=1
	net.ipv6.conf.br-ex.disable_ipv6=1
	EOF
	sysctl --system
	
	# pacotes base
	apt-get update
	apt-get install -y python3-venv python3-dev gcc libffi-dev libssl-dev \
	  libdbus-1-dev libdbus-glib-1-dev libglib2.0-dev \
	  lvm2 open-iscsi podman pkg-config build-essential git
	
	systemctl enable --now iscsid || true
	
	mkdir -p /etc/kolla /opt/kolla
	chown infrastack:infrastack /etc/kolla /opt/kolla
	
	# globals.yml
	mv /tmp/globals.yml /etc/kolla/globals.yml
	chown root:root /etc/kolla/globals.yml
	chmod 0644 /etc/kolla/globals.yml
	
	netplan generate && netplan apply
	
	SHELL

  config.vm.provider :libvirt do |lv|
    lv.memory = 16384
    lv.cpus = 8

    lv.storage_pool_name = "kolla_pool"
    lv.machine_virtual_size = 80

    lv.storage :file,
      size: "60G",
      type: "qcow2",
      target: "vdb",
      name: "cinder-backend.qcow2"
  end
end

1.2 globals.yml (mínimo obrigatório do lab)

Crie um arquivo globals.yml ao lado do Vagrantfile com os overrides essenciais. É isso que você precisa garantir.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

---
# Arquitetura e Distro
kolla_base_distro: "ubuntu"
kolla_container_engine: "podman"

# VIP para acessar Horizon/API (IP LIVRE na sua LAN)
kolla_internal_vip_address: "192.168.2.250"

# Interface de gestão/API (tem IP)
network_interface: "mgmt0"

# Interface externa do Neutron (recomendado SEM IP)
neutron_external_interface: "ext0"

# Neutron com OVN
neutron_plugin_agent: "ovn"

# Core + Dashboard
enable_openstack_core: "yes"
enable_horizon: "yes"

# Cinder LVM em /dev/vdb (VG cinder-volumes) + iSCSI
enable_cinder: "yes"
enable_cinder_backend_lvm: "yes"
enable_iscsid: "yes"

# Octavia + Valkey
enable_octavia: "yes"
enable_valkey: "yes"

# Certificados Octavia (opcional, mas você já padronizou)
octavia_certs_country: "BR"
octavia_certs_state: "SP"
octavia_certs_organization: "Lab"
octavia_certs_organizational_unit: "Octavia"

1.3 Subindo a VM

No diretório do projeto, execute:

1

vagrant up --provider=libvirt

Para acessar a VM:

1

vagrant ssh

Ou direto:

1

ssh infrastack@192.168.2.35

Parte 2 — Instalando OpenStack (Kolla-Ansible AIO) dentro da VM

Daqui pra frente, tudo é dentro da VM, logado como infrastack.

2.1 Venv + Kolla-Ansible + SDK Podman

1
2
3
4
5

python3 -m venv ~/kolla-venv
source ~/kolla-venv/bin/activate
pip install -U pip
pip install "git+https://opendev.org/openstack/kolla-ansible@master"
pip install "podman>=4.0.0" dbus-python

2.2 Inventário + passwords.yml + geração de segredos

1
2
3
4

sudo chown infrastack:infrastack /etc/kolla
sudo cp -r ~/kolla-venv/share/kolla-ansible/etc_examples/kolla/passwords.yml /etc/kolla
sudo cp ~/kolla-venv/share/kolla-ansible/ansible/inventory/all-in-one ~/all-in-one
kolla-genpwd

(Nosso /etc/kolla/globals.yml já foi copiado pelo Vagrantfile.) OpenStack Docs

2.3 Cinder LVM: preparar /dev/vdb (60 GB)

1
2
3

sudo pvcreate /dev/vdb
sudo vgcreate cinder-volumes /dev/vdb
sudo vgs cinder-volumes

2.4 Ajuste de hostname no /etc/hosts (evita dor de cabeça)

1
2
3

sudo sed -i -E '/\s+gandhivastack($|\s)/d' /etc/hosts
echo '192.168.2.35 gandhivastack' | sudo tee -a /etc/hosts
grep -nE 'localhost|gandhivastack' /etc/hosts

2.5 Bootstrap + certs do Octavia + prechecks

1
2
3
4

kolla-ansible install-deps -i ./all-in-one
kolla-ansible bootstrap-servers -i ./all-in-one
kolla-ansible octavia-certificates -i ./all-in-one
kolla-ansible prechecks -i ./all-in-one

(O precheck do Octavia falha se Valkey não estiver habilitado; nós habilitamos. Certs são gerados pelo comando acima.) OpenStack Docs

2.6 Deploy + Post-deploy

1
2

kolla-ansible deploy -i ./all-in-one
kolla-ansible post-deploy -i ./all-in-one

Depois do post-deploy, o Kolla-Ansible gera dois arquivos de credenciais para você usar a CLI do OpenStack sem dor de cabeça:

• /etc/kolla/admin-openrc.sh — script que exporta variáveis OS_* para a conta admin.
• /etc/kolla/clouds.yaml — arquivo de configuração para o cliente moderno (multi-cloud, mais limpo).

2.7 Instalar OpenStackClient + autocomplete

Dentro do mesmo venv:

1

pip install python-openstackclient

Autocomplete:

1
2
3

sudo apt-y install bash-completion
openstack complete | sudo tee /etc/bash_completion.d/osc
source /etc/bash_completion

2.8 Octavia: criar imagem Amphora

Opção oficial (recomendada) — construir e enviar com a tag amphora:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

git clone https://opendev.org/openstack/octavia.git
cd octavia/diskimage-create
sudo apt -y install --no-install-recommends git kpartx debootstrap
pip install -r requirements.txt

./diskimage-create.sh -b haproxy -t qcow2 -o /tmp/amphora-haproxy.qcow2

source /etc/kolla/admin-openrc.sh
openstack image create amphora-x64-haproxy \
  --disk-format qcow2 --container-format bare \
  --property hw_architecture='x86_64' \
  --tag amphora \
  --file /tmp/amphora-haproxy.qcow2 --public

2.9 init-runonce: deixar a nuvem pronta para teste (rede, CirrOS, router, FIPs, keypair)

O init-runonce é um script opcional de demonstração que “deixa tudo pronto” para você testar a nuvem logo após o deploy. Ele:

• Baixa e registra uma imagem CirrOS no Glance.
• Cria rede externa (pública) com CIDR/pool de Floating IPs e gateway.
• Cria rede interna (ex: demo-net) e roteador conectando interna ↔ externa.
• Ajusta regras de Security Group (ICMP/SSH) e gera um keypair.
• Cria flavors básicos (m1.tiny/small/…).

Atenção (dos próprios docs): é para demo/lab; dependendo das suas customizações, pode conflitar com o que você quer. Edite as variáveis de rede (CIDR/range/gateway) se precisar. OpenStack Docs

1

source /etc/kolla/admin-openrc.sh

Depois, execute o init-runonce com os parâmetros da tua rede:

Ajuste EXT_NET_* para a tua realidade (CIDR, pool e gateway). O conceito é: rede externa = “public”, pool de Floating IPs.

Exemplo (modelo):

1
2
3
4
5

ENABLE_EXT_NET=1 \
EXT_NET_CIDR='192.168.1.0/24' \
EXT_NET_RANGE='start=192.168.2.200,end=192.168.2.230' \
EXT_NET_GATEWAY='192.168.2.1' \
~/kolla-venv/share/kolla-ansible/init-runonce

Parte 3 — Validar serviços e criar a primeira VM (CLI + Horizon)

3.1 Validar saúde geral

1
2
3
4
5

source /etc/kolla/admin-openrc.sh
openstack service list
openstack compute service list
openstack network agent list
openstack volume service list

3.2 Criar VM via CLI (CirrOS)

Se o init-runonce for aplicado, você já deve ter: cirros, flavor m1.tiny, rede demo-net, keypair mykey (é exatamente o objetivo dele).

Criar instância:

1
2
3
4
5
6

openstack server create \
  --image cirros \
  --flavor m1.tiny \
  --key-name mykey \
  --network demo-net \
  demo1

Criar um Floating IP na rede externa:

1

openstack floating ip create public1

Associar o Floating IP:

1
2

openstack server add floating ip demo1 \
  $(openstack floating ip list -f value -c "Floating IP Address" | head -1)

Verificar:

1

openstack server list

3.3 Acessar Horizon (Dashboard)

Acesse:

• URL: http://192.168.2.250/ (seu VIP)
• Usuário: admin
• Senha: procurar em /etc/kolla/passwords.yml a chave keystone_admin_password

No Horizon, o caminho clássico pra criar VM:

1. Project → Compute → Instances
2. Launch Instance
3. Selecionar:
   • Imagem: cirros
   • Flavor: m1.tiny
   • Network: demo-net
4. Launch

Depois, associe um Floating IP na própria interface.

Conclusão

Se você chegou até aqui, seu lab está pronto de verdade:

• Provisionamento automatizado (Vagrant/libvirt)
• OpenStack conteinerizado (Kolla + Ansible + Podman)
• Rede separada mgmt/external (mgmt0/ext0)
• VIP para Horizon/API
• Cinder LVM em disco dedicado
• Octavia preparado (com Amphora)
• Fluxo de uso real: CLI + dashboard

Este guia forneceu um caminho completo e validado para criar um ambiente OpenStack robusto e funcional. Agora você tem uma base sólida para explorar, aprender e se aprofundar no vasto ecossistema OpenStack. Parabéns pela conquista!