
Dando continuidade a série “evolução”, hoje, vou partilhar o que já aprendi sobre Ansible, que é uma das ferramentas de Infraestrutura como código (IaC) mais populares no mundo de automação.
Então você já parou para pensar ou imaginar como faria para responder a um pedido ou cenário de criação e configuração de um ambiente composto por vários servidores, plataformas… ou em caso de desastre e tivesse que recriar todo ambiente com os mesmos recursos, aplicações, configurações, um autêntico espelho do ambiente destruído. Quanto tempo levaria? Você tem toda a configuração documentada? outra pessoa além de você pode efectuar essa tarefa sem errar? Todos os passos estão automatizados, desde criação de servidores até configuração das aplicações “full stack automation“?
Infrastructure as Code (IaC)
IaC termo usado para descrever infraestrutura construída ou definida por código, processo de implantação e configuração de infraestrutura, recursos de forma automática, via ficheiro de código. Essa automação permite construir, configurar infraestrutura de forma rápida, consistente.
IaC é uma práctica essencial, que faz parte do DevOps pipeline que consiste em automatizar fluxo de trabalho de implantação, substitui operações manuais de infraestrutura por automação.
E uma das ferramentas IaC mais usada é Ansible. O post é sobre ansible, mas existem outras ferramentas populares e poderosas como Terraform.
Ansible
Ansible: É uma ferramenta de automação, gestão de configuração e implantação de app sem agente “agentless”. Ansible é open source e free, mas também existe a versão comercial Red Hat Ansible Tower que oferece uma interface gráfica de administração, dashboard, suporte, RBAC, etc. Uma das grandes diferenças entre ansible e outras ferramentas, é que ansible não requer instalação de nenhum programa/agente ou cliente no host que deseja controlar. Por exemplo, Ansible usa protocolo SSH para linux, windows (winrm ou powershell), container (docker), APIs, etc sem necessidade de instalar um agente especial.
Componentes
Ansible Control Node: host em que está instalado o ansible. E o host que o ansible controla é Managed node.
Inventory: Ficheiro usado para definir os sistemas/hosts que o ansible controla.
Playbook: Ficheiro YAML que contém um ou mais plays. É um Manual, todas as instruções de automatização ficam neste ficheiro.
Play: Lista ordenada de tarefas tasks a serem executadas em hosts definidos num inventário.
Task: Descreve a ação a ser tomada. E cada task executa um módulo.
Modules: São pequenos pedaços de código que são executados nas máquinas remotas.
Demo
Para demo de ansible, vou criar um ambiente virtual baseado em Vagrant.
Vagrant?
Ferramenta para criação de ambiente virtual. Vagrant orquestra/automatiza criação e configuração de VM em hypervisors (VMware, Virtualbox, KVM). Todas instruções e configurações para criação do ambiente virtual ficam guardadas no ficheiro denominado Vagrantfile que usa sintaxe ruby. Outro componente fundamental do vagrant é box.
Box é um ficheiro que contém image do OS pré-configurado, semelhante a um template. É a partir da box que vagrant cria VMs.
Lista de boxes disponíveis: https://app.vagrantup.com/boxes/search
NOTA: Não é obrigatório usar vagrant para criar um ambiente de testes para ansible. o importante é ter ansible instalado em um servidor, e este servidor poder se comunicar com os outros hosts.
Ambiente de teste
OS | APP | Hostname | IP | Managed by Vagrant/BOX |
CentOS 7 | VirtualBox & Vagrant | Vagrant | 192.168.1.131 | No |
CentOS 7 | Ansible | ansible | 192.168.10.30 | Yes |
CentOS 7 | Apache | web | 192.168.10.50 | Yes |
CentOS 7 | PostgreSQL | db01 | 192.168.10.40 | yes |
Para este ambiente de teste:
- Irei usar CentOS “sou mais da família YUM/RPM e gosto da distro pois é mais enterprise por ser semelhante Red Hat”.
- A criação das VMs (Ansible, web, db01) será orquestrada pelo vagrant.
- Instalação e configuração de apache e postgresql será efectuada via ansible.
O objectivo é demonstrar como ansible é simples, uma ferramenta de automação de alto nível, poderosa e pode ser usado para automatizar ou orquestrar instalação e configuração de multi-tier apps e muito mais. Será uma demo básica, sem abordar conceitos avançados.
Pré-requisito
Antes de instalar o vagrant, é necessário já ter instalado um hypervisor na máquina que o mesmo será instalado. Então o primeiro passo vai ser instalar VirtualBox.
Escolhi virtualbox pois para vagrant orquestrar VMware é necessário 1 plugin comercial, não é free.
#add virtualbox repository
$ sudo wget https://download.virtualbox.org/virtualbox/rpm/el/virtualbox.repo -P /etc/yum.repos.d
#Instalar virtualbox
$ sudo yum install VirtualBox-6.0
#verificar estado serviço virtualbox
$ systemctl status vboxdrv
#Vagrant
#Pre requisite rsync
yum install -y rsync
#Instalação do Vagrant
sudo yum install https://releases.hashicorp.com/vagrant/2.2.6/vagrant_2.2.6_x86_64.rpm
# check Versão
$ vagrant –version
#inicializar ficheiro Vagrant, cria VagrantFile
$ mkdir Vagrant_POC
$ cd Vagrant_POC/
$ vagrant init
#Criar VMs
Para criar VMs vamos editar o ficheiro Vagrantfile que foi criado após a execução do comando anterior, e neste ficheiro vamos declarar recursos e config. das vms. Encontre mais detalhes aqui.
$ vim Vagrantfile
# -*- mode: ruby -*- # vi: set ft=ruby : # All Vagrant configuration is done below. The "2" in Vagrant.configure # configures the configuration version (we support older styles for # backwards compatibility). Please don't change it unless you know what # you're doing. Vagrant.configure("2") do |config| config.vm.define "ansible" do |ansible| ansible.vm.box = "centos/7" ansible.vm.hostname = "ansible" ansible.vm.network "private_network", ip: "192.168.1.30" end config.vm.define "db01" do |db01| db01.vm.box = "centos/7" db01.vm.hostname = "db01" db01.vm.network "private_network", ip: "192.168.1.40" end config.vm.define "web" do |web| web.vm.box = "centos/7" web.vm.hostname = "web" web.vm.network "private_network", ip: "192.168.1.50" web.vm.network "forwarded_port", guest: 80, host:8080 end end
#Start VMs, executar na pasta que contém Vagrantfile
$ vagrant up
#Listar VMs em execução
$ vboxmanage list runningvms
#aceder vm via ssh
$ vagrant ssh ansible
#Ansible
Para começar com a instalação do ansible vamos efectuar SSH para VM com hostname ansible. Por padrão user e passwd vagrant para logar nas vms.
#instalar EPEL repo
$ yum install epel-release
#instalar Ansible
$ sudo yum install ansible
# Criar inventory file
$ sudo mkdir hands_on
$ sudo vi inventory
db01 ansible_ssh_host=192.168.1.40
web ansible_ssh_host=192.168.1.50
[dbservers]
db01
[webservers]
web
[datacenter:children]
dbservers
webservers
[datacenter:vars]
ansible_ssh_user=vagrant
ansible_ssh_pass=vagrant
No ficheiro inventory declaramos IP dos hosts que desejamos conectar, e dividimos em grupos DBSERVERS composto por (db01) e WEBSERVERS composto por (web), e estes dois grupos pertencem ao DATACENTER que também é um grupo. E por fim declaramos variáveis nesse caso user e password que serão usados para conexão ssh. Não é uma boa prática declarar password em texto claro no inventário, e ansible possui outros mecanismos de gestão chaves “ansible vault”, mas é um ambiente de teste penso que não tem problema.
Depois de criar o inventário, podemos efectuar teste de conectivitidade as VMs com comando ad hoc usando modulo ping.
#Ping
$ ansible datacenter -i inventory -m ping
output:

Após o a execução do ping com sucesso, é tempo de proceder com a criação do playbook que vai:
- Instalar apache
- Iniciar serviço apache e garantir que levante após boot
- Instalar PostgreSQL
- Verificar se PostgreSQL está inicializado e inicializar caso não estiver
- Iniciar serviço PostgreSQL
- Criar DB teste_db
- Criar user e role boss, atribuir role CREATEDB
- Atribuir acesso a teste_db
- Criar Tabela Pessoa
# Criar playbook
$ vi apache_postgresql.yaml
--- - hosts: webservers tasks: - name: Garantir instalacao APACHE yum: name=httpd state=present - name: iniciar servico Apache boot service: name=httpd enabled=yes state=started - hosts: dbservers become: yes tasks: - name: Instalar PostgreSQL e psycopg2 yum: name: - postgresql-server - python-psycopg2 state: present - name: Verificar se postgreSQL ja esta inicializado stat: path: /var/lib/pgsql/data register: folder_details - name: Inicializar PostgreSQL DB command: sudo /usr/bin/postgresql-setup initdb when: folder_details.stat.isdir == false - name: Iniciar servico PostgreSQL service: name=postgresql state=started enabled=yes - name: Criar user PostgreSQL boss e atribuir role CREATEDB become_user: postgres postgresql_user: name: boss password: Boss role_attr_flags: CREATEDB - name: Criar DB teste become_user: postgres postgresql_db: name: teste_db state: present - name: Atribuindo Acesso a DB become_user: postgres postgresql_privs: db: teste_db objs: ALL_IN_SCHEMA role: boss privs: ALL - name: Mudar Owner become_user: postgres postgresql_owner: db: teste_db new_owner: boss - name: Criar tabela pessoa become_user: postgres postgresql_table: db: teste_db table: pessoa columns: - id int primary key - nome varchar
#Executar playbook
$ ansible-playbook apache_postgresql.yaml -i inventory
output:

Depois do executar o playbook podemos validar instalação de apache e postgresql.
webserver 192.168.1.50

PostgreSQL
Foi criada teste_db

user role boss

Tabela pessoa

Finalizando…
Após o teste, conseguimos verificar que o playbook criado executa todas as tarefas definidas. Também é possível notar que a sintaxe de YAML é bastante simples, e torna fácil escrever e entender playbooks para ansible.
Espero que esse post tenha deixado as pessoas com mais curiosidade intelectual sobre essa trend IaC/Ansible. Também lembrar que automação já não é coisa do futuro, é uma prática muito usada em ambientes ágeis, e todo sysadmin que quiser evoluir para sysadmin/SE versão 2.0 recomendo começar a aprender e dominar essas ferramentas.
Áte a próxima.
Sharing is caring!
Referências
https://www.ansible.com/overview/how-ansible-works
https://www.redhat.com/en/about/videos/how-ansible-works
https://www.vagrantup.com/docs/virtualbox/configuration.html
https://www.vagrantup.com/docs/vagrantfile/machine_settings.html