Testando Ansible

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 APPHostnameIPManaged by Vagrant/BOX
CentOS 7VirtualBox & VagrantVagrant192.168.1.131No
CentOS 7Ansibleansible192.168.10.30Yes
CentOS 7Apacheweb192.168.10.50Yes
CentOS 7PostgreSQLdb01192.168.10.40yes

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://docs.ansible.com/

https://www.redhat.com/en/services/training/do007-ansible-essentials-simplicity-automation-technical-overview

https://www.vagrantup.com/docs/virtualbox/configuration.html

https://www.vagrantup.com/docs/vagrantfile/machine_settings.html

https://www.ansiblefordevops.com/

Deixe uma Resposta

Preencha os seus detalhes abaixo ou clique num ícone para iniciar sessão:

Logótipo da WordPress.com

Está a comentar usando a sua conta WordPress.com Terminar Sessão /  Alterar )

Google photo

Está a comentar usando a sua conta Google Terminar Sessão /  Alterar )

Imagem do Twitter

Está a comentar usando a sua conta Twitter Terminar Sessão /  Alterar )

Facebook photo

Está a comentar usando a sua conta Facebook Terminar Sessão /  Alterar )

Connecting to %s