ChurrOps on DevOps

Faaaala gurizada!!

Vamos falar hoje de Ansible, uma ferramenta conhecida como gestão de configuração, mas que não segue exatamente a cartilha da escola de GCONF do Sr. Mark Burgess, criador do CFEngine. Ansible é uma ferramenta de automação de TI, usada principalmente pela equipe de Infraestrutura para automatizar e garantir o estado desejado do seu ambiente.

Como funciona o Ansible?

Pense que tu tens um servidor com o Ansible instalado, tu cria uma Playbook informando no arquivo o que tu deseja que o Ansible faça e ele automaticamente se conecta nos servidores do seu cluster e executa o que foi solicitado. Ele trabalha em um modelo de idempotência, tu apenas descreve o estado do seu sistema ou serviço e não o que fazer para chegar até aquele estado, não importa em qual estado o serviço esteja o Ansible sabe como fazer as mudanças até chegar no estado desejado, isso é ótimo pois permite configurações confiáveis e seguras.

O Ansible se conecta nos servidores utilizando o protocolo SSH (ele depende disso para funcionar), por isso é preciso ter credenciais e/ou chaves de acesso para chegar em outros servidores, por este motivo é obrigatório estar rodando o serviço SSH. Ele não precisa de agents rodando nos servidores basta a configuração de SSH estar funcionando entre os servidores do seu cluster.

Características do Ansible

• Escrito em Python.
• Não precisa de agents instalados nos nodes.
• Arquitetura Master to Nodes.
• Utiliza uma linguagem de configuração em formato YAML (chave-valor).
• Grande quantidade de módulos e códigos no Github. Pelo comando ansible-galaxy é possível baixar e reutilizar playbooks escritos por outros usuários.
• Simples de realizar manutenção

Estrutura do Ansible

– Inventory: Arquivo de inventário no qual serão declarados quais os hosts que serão gerenciados pelo Ansible;

– Módulos: Controlam as atividades dos hosts remotos, são os responsáveis por executar as tarefas nas máquinas.     http://docs.ansible.com/ansible/latest/list_of_all_modules.html.

– Tasks: Tarefas que serão executadas no hosts;

– Playbooks: Conjunto de tarefas escritas em YAML que serão executadas nos servidores.

Mãos a obra!

Vamos lá, parar de enrolação e simbora.

>> Pré requisitos

Neste cenário iremos simular a criação de um usuário de aplicação e garantir a instalação do servidor web Nginx, para tal utilizaremos 2 servidores Linux “Centos7”. Sua única dependência é ter Python2 (acima) instalado nos nodes, que já é nativo na maioria das distribuições do Linux.

>> Preparação do ambiente

Gere o par de chaves SSH

~]# ssh-keygen
Generating public/private rsa key pair.
Enter file in which to save the key (/root/.ssh/id_rsa): <enter>
Enter passphrase (empty for no passphrase): <enter>
Enter same passphrase again: <enter>

Copie a chave pública para os servidores do seu cluster. Neste cenário só teremos 1 servidor no cluster.

~]# ssh-copy-id -i /root/.ssh/id_rsa.pub root@192.168.15.100

Realize o teste de acesso SSH.

~]# ssh -i /root/.ssh/id_rsa.pub root@192.168.15.100

 

>> Instalação do Ansible

~]# yum install ansible -y

~]# apt-get install ansible -y

Para mais detalhes da instalação do Ansible acesse: http://docs.ansible.com/ansible/latest/intro_installation.html#installation

>> Gerenciando os arquivos e diretórios

Após a instalação do Ansible é criado o diretório /etc/ansible/ com o seguinte conteúdo:

~]# ls -ltr /etc/ansible/
total 24
drwxr-xr-x. 4 root root 38    Jan 2  01:00 roles
-rw-r--r--. 1 root root 19183 Jan 10 21:18 ansible.cfg
-rw-r--r--. 1 root root 443   Jan 17 09:52 hosts

roles: É a forma automática de carregar arquivos de acordo com uma estrutura de diretórios definidas.

ansible.cfg: Arquivo de configuração padrão do Ansible

hosts: Arquivo de inventário que armazena a lista de servidores gerenciados e acessados por ele e suas variáveis para ser utilizados pela playbook. Por padrão, o arquivo de configuração é o /etc/ansible/hosts, esse arquivo pode ser alterado no arquivo de configuração “ansible.cfg”.

Dentro do arquivo de inventário podemos definir um host e também definir um grupo de hosts utilizando as seções nos arquivos de configurações

 

– Inventário do Ansible:

Configure os servidores do seu cluster no inventário do Ansible.

~]# vim /etc/ansible/hosts
#[production]

[docker]
192.168.15.1

[devops]
192.168.15.50

[churrops]
192.168.15.100

Neste cenário criamos um grupo de host que se chama [churrops]. A playbook será aplicada somente neste grupo.

 

Dentro de /etc/ansible/roles/ rode o comando ansible-galaxy init nginx para criar a estrutura de diretórios.

~]# ansible-galaxy init nginx
~]# ls -ltr
/etc/ansible/roles/
  /nginx/
    files/
    templates/
    tasks/
    handlers/
    vars/
    defaults/    
    Meta/
    tests/

Obs. Dentro do diretório tasks é onde são criadas as tarefas, onde podem ser executadas uma a uma ou em grupo.

AGORA SIMM!! rsrs

>> Criando o usuário

Dentro do diretório /tasks vamos criar o arquivo user.yml que será nossa tarefa para criação do usuário do nginx.

 ~]# vim user.yml
---
#Playbook para criacao do usuario do nginx
- name: Criacao do usuario para start do nginx
  hosts: churrops
  vars:
    - username: nginusr
  tasks:
    - name: Criando usuario nos servidores.
      user: name={{ username }} shell=/bin/bash createhome=yes state=present
      tags: usuario_nginx

O parâmetro “tags” é opcional e serve para dar um apelido a tarefa podendo assim chamarmos a tarefa pelo apelido direto na linha de comando utilizando o parâmetro –tags. Caso contrário podemos utilizar o parâmetro –skip-tags “usuario_nginx” para não rodar a tarefa usuário-nginx.

>> Instalando o serviço do Nginx

No diretório /tasks criaremos o arquivo com o seguinte conteúdo.

~]# vim packages_nginx.yml
---
- name: Instalando o pacote epel-release e mais alguns pacotes básicos do sitema para a instalacao do nginx.
  hosts: churrops
  tasks:
    - name: 
      yum: name={{ item }} update_cache=yes state=present
      with_items:
        - epel-release
        - vim
        - git
        - wget
        - curl
   tags: packages-nginx

 

Dentro do mesmo diretório /tasks iremos criar o arquivo install_nginx.yml com o seguinte conteúdo.

~]# vim install_nginx.yml
---
#################################
#Playbook de instalacao do nginx#
#################################
- name: Instalacao do nginx
  hosts: churrops
  remote_user: {{ username }}
  tasks:
    - name: Instalando o nginx e garantindo que o nginx esteja na versão mais recente!
      yum: name=nginx sate=latest
      notify:
        - start nginx
  #Garantindo que o nginx esteja rodando e ative durante o boot do sistema!
  handlers:
     - name: start nginx
       service: name=nginx state=started enabled=yes
    tags: install-nginx

Neste exemplo utilizei a variável “remote_user: {{ username }} ” mas não especifiquei nenhum valor para esta variável pois eu informei no arquivo main.yml no diretório /vars. Neste caso informamos as variáveis somente no arquivo main.yml na role do nginx, com isso não precisamos especificar o valor à cada tarefa, conforme abaixo.

~]# cat /etc/ansible/roles/nginx/vars/main.yml
---
# vars file for nginx

# Variáveis que poderão ser utilizadas por qualquer tarefa do nginx
username: nginusr

>> Criando a Playbook

Após a criação das tarefas acima iremos criar a playbook. Dentro de /task crie o arquivo primeira-playbook.yml  e inclua as tarefas que criamos nos passos anteriores.

~]# vim primeira-playbook.yml
---
# tasks file for nginx
- include: user.yml
- include: packages_nginx.yml
- include: install_nginx.yml

Após incluir as tarefas enfim executaremos a nossa playbook 😀

~]# ansible-playbook -i /etc/ansible/hosts primeira-playbook.yml -v

-i = Especificando o arquivo de inventário.

-v = Parâmetro que define a quantidade de informação que será mostrada na tela enquanto a playbook roda, podendo ir até -vvvv (1-4v).

 

Após executar a playbook verifique se o usuário foi criado com sucesso, se os pacotes foram instalados e se o serviço do nginx já está no ar.

Para isso utilizaremos a linha de comando do Ansible.

~]# ansible churrops -m command -a "getent passwd nginusr"

O resultado será algo parecido com este:

~]# ansible churrops -m command -a "rpm -qa epel-release git vim wget curl"

O resultado será algo como este:

~]# ansible churrops -m command -a "systemctl status nginx"

O resultado será parecido com este:

 

Então é isso galera… este foi um breve resumo da utilização do Ansible, mas podemos realizar o provisionamento, gerenciamento e deploys de aplicações de toda nossa infraestrutura com o Ansible.

 

Lista com alguns Módulos do Ansible:

– apt: Gerencia a instalação de pacotes utilizando o APT (debian/ubuntu).

– yum: Gerencia a instalação de pacotes utilizando o YUM (RedHat/CentOS/Fedora).

– command: Executa um comando em node remoto.

– shell: Executa um shell script dentro da máquina, após realizar as transferências.

– service: Gerencia serviços em máquinas remotas.

– copy: Copia arquivos na máquina local para o node remoto.

– git: Gerencia repositório do git.

– unarchive: Descompacta arquivos na máquina remota.

– mount: Gerencia os dispositivos montados na máquina.

– template: Gerencia templates no Ansible.

– ec2: Gerencia instâncias ec2 no ambiente cloud da Amazon.

Link: http://docs.ansible.com/ansible/list_of_cloud_modules.html

Para mais informações sobre o Ansible e seus módulos , acesse a documentação pelo site oficial:

  Link: http://docs.ansible.com/

---