Para começar, vamos mostrar alguns exemplos e ver como as duas ferramentas lidam com as coisas mais simples como facts, serviços, pacotes, arquivos e usuários.

Facts

As duas ferramentas possuem facts. Facts são informações coletadas do sistema que podem ser usadas dentro das regras à serem aplicadas. Por exemplo: dependendo da distribuição Linux, arquivos de configuração podem estar em lugares diferentes. É usando facts que você vai saber em qual distribuição a regra está rodando para poder tratar essa diferença.

Exemplo de facts relacionados ao sistema operacional no Ansible:

“facter_os": {
            "architecture": "x86_64", 
            "family": "RedHat", 
            "hardware": "x86_64", 
            "name": "CentOS", 
            "release": {
                "full": "7.3.1611", 
                "major": "7", 
                "minor": "3"
            }, 
            "selinux": {
                "enabled": false
            }
        },

 

No Puppet:

os => {
  architecture => "x86_64",
  family => "RedHat",
  hardware => "x86_64",
  name => "CentOS",
  release => {
    full => "7.3.1611",
    major => "7",
    minor => "3"
  },
  selinux => {
    enabled => false
  }
}

 

Como podem ver, as duas ferramentas tem exatamente os mesmos facts relacionados ao sistema operacional. Assim tambem ocorre com facts de rede, hardware etc. E nas duas ferramentas é possível criar facts customizados que retornem o que você quiser levantar do sistema.

Linguagem

O Ansible é feito em Python e você utiliza YAML para criar suas regras.

O Puppet é feito em Ruby e utiliza uma linguagem Ruby-like para criar suas regras.

Instalar pacote

Vamos ver uma simples regra para instalação de um pacote.

Ansible:

- package:
    name: htop
    state: present

Puppet:

package { ‘htop’:
  ensure => present,
}

 

Serviço

Vamos subir um serviço e habilitá-lo no boot.

Ansible:

- service:
    name: crond
    state: started
    enabled: true

Puppet:

service { ‘crond’:
    ensure => running,
    enable => true,
}

 

Usuários

Até a criação de usuários é muito similar nas duas ferramentas.

Ansible:

- user:
    name: infra
    state: present
    shell: /bin/bash
    group: admin
    password: {{ infra_passwd_hash }}

Puppet:

user { ‘infra’:
  ensure   => present,
  shell    => ‘/bin/bash’,
  gid      => ‘admin’,
  password => $infra_passwd_hash,
}

Aqui vemos também que variáveis no Ansible são entre {{ }} e no Puppet com $.

Condicionais

Este exemplo diz: “Se a plataforma virtual for vmware E o sistema for um RedHat > 6 OU Debian > 7, instale o open-vm-tools”.

Ansible:

- package:
    name: open-vm-tools
    state: present
    when: 
      - facter_virtual == “vmware”
      - (ansible_os_family == “RedHat” and ansible_distribution_major_version >= 6) or (ansible_os_family == “Debian” and ansible_distribution_major_version >= 7)

Puppet:

if ( $::virtual == ‘vmware’ ) {
  if ( $::osfamily == ‘RedHat’ and $::lsbmajdistrelease >= 6)
  or ( $::osfamily == ‘Debian’ and $::lsbmajdistrelease >= 7) {
    package { ‘open-vm-tools’:
      ensure => present,
    }
  }
}

Aqui o YAML  mostra alguma limitação pois não é uma linguagem de programação em si. A DSL do Puppet neste exemplo se aproxima mais de uma linguagem normal de programação.

 

Loops

Loop para instalação de vários pacotes

Ansible:

- package: 
    name: "{{ item }}"
    state: present
  with_items:
    - htop
    - nload
    - strace

Puppet:

$packages = [ ‘htop’, ‘nload’, ‘strace’ ]
package { $packages:
  ensure => present,
}

Como no YAML não existe “for”, o Ansible faz o loop pelos valores em with_items colocando-os na variável {{ item }}.

O Puppet entende que, quando uma variável é um array, é pra fazer um loop.

Package / File / Service

A maioria das coisas consiste em instalar pacotes, gerenciar arquivos e subir serviços. Vamos ver como isso funciona em cada linguagem.

Ansible:

- package:
    name: squid
    state: present
- copy:
    src: squid.conf
    dest: /etc/squid/squid.conf
- service:
    name: squid
    state: started
    enabled: true

Puppet:

package { ‘squid’:
  ensure => present,
}
file { ‘/etc/squid/squid.conf’:
  source => ‘puppet://modules/<modulo>/squid.conf’
}
service { ‘squid’:
  ensure => running,
  enable => true,
}

Notem que as duas ferramentas precisam do mesmo número de linhas para fazer isso.

Porém, como o Puppet não executa as instruções necessariamente em ordem, seria necessário acrescentar algumas diretivas estabelecendo as devidas dependências. Como o Ansible executa sequencialmente as tasks, isso não é necessário.

Templates

Quando você precisa copiar arquivos para os servidores e esses arquivos podem variar dependendo de alguma lógica ou utilizar variáveis em seu conteúdo, você usa templates.

O Ansible usa templates Jinja2 e o Puppet ERB (ou EPP nas versões mais novas).

Ansible Jinja2:

# cat resolv.conf.j2

search {{ dns_domain }}
domain {{ dns_domain }}
{% for server in dns_servers %}
nameserver {{ server }}
{% endfor %}

Puppet ERB:

# cat resolv.conf.erb

search <%= dns_domain %>
domain <%= dns_domain %>
<% @dns_servers.each do |server| -%>
nameserver <%= server %>
<% end -%>

Instalação

Como o Ansible não precisa de agente já que é ele mesmo que vai nas máquinas, sua instalação é bem simples. Para instalar o Ansible em um CentOS por exemplo, basta digitar:

yum install ansible

E você está pronto para criar seu inventário e sair escrevendo playbooks.

Para instalar o Puppet você vai precisar de um servidor dedicado para essa função e, depois de instalar o servidor, ir em cada máquina e instalar e configurar o agente do Puppet apontando para o servidor Puppet.

Ou seja, a complexidade pra início de uso do Ansible é MUITO menor.

Fazem a mesma coisa ?

Com o que vimos até aqui, as duas ferramentas fazem as mesmas coisas ?

Resolvem os mesmos problemas ?

 

No próximo artigo farei algumas considerações sobre as principais diferenças entre elas.