(IaC) Parte 2: Criando um playbook para provisionamento de 3 instâncias EC2 na AWS usando Ansible

Primeiramente vamos entender o que é Ansible e porque ele é uma das ferramentas de DevOps mais usadas hoje. Aqui a documentação do Ansible para que você possa estudar, é super objetiva e tem muitos exemplos 😉

Ansible é uma simples e poderosa ferramenta de automatização criada para gerenciar múltiplas máquinas de uma vez. Além disso, é uma engine que permite executar Ansible Playbooks.

Veja alguns pontos que são importantes do Ansible:
- escrito em Python;
- utiliza o protocolo SSH para conexão com os hosts;
- não precisa de agentes nos hosts remotos;
- grande quantidade de códigos no GitHub;
- fácil instalação (simples, rápido e poderoso);
- all-in-one: Tudo Em Um (possui mais de 1200 módulos disponíveis).

  • O que você precisa ter para esse artigo?
    - Uma conta na AWS (free tier) 🚀
    - Muita vontade de aprender Ansible e gostar de DevOps (haha 😜)
  • Instalação do Ansible no Linux Ubuntu

Aqui vou mostrar o case usando o Ubuntu, você pode seguir os comandos abaixo para a instalação do Ansible em seu sistema Ubuntu:

$ sudo apt update$ sudo apt install software-properties-common$ sudo apt-add-repository --yes --update ppa:ansible/ansible$ sudo apt install ansible

Agora vamos checar a versão do Ansible que foi instalada:

ansible — version

Para a instalação do Ansible em outros sistemas/distros clique aqui.

  • Entendendo os principais arquivos do Ansible

Arquivo hosts: esse arquivo é onde vão ser cadastrados todos os hosts que serão gerenciados pelo Ansible (O IP das instâncias EC2 ficam aqui).
Arquivo ansible.cfg: arquivo de configuração do Ansible.
Diretório playbooks: é um conjunto de tarefas escritas em YAML que serão executadas nos servidores.

  • Criando a estrutura do projeto

Vamos criar nosso arquivo de playbook antes na diretório do projeto /etc/ansible. Esse é um arquivo de nome main.yml que vamos chamar no momento da execução do nosso playbook.

---
- hosts: local
roles:
- create
...

Agora criando a nossa estrutura usando o comando abaixo:

# ansible-galaxy init create

Feito isso, vamos verificar como ficou toda a estrutura:

# tree 
.
└── create
├── defaults
│ └── main.yml
├── files
├── handlers
│ └── main.yml
├── meta
│ └── main.yml
├── README.md
├── tasks
│ ├── main.yml
├── templates
├── tests
│ ├── inventory
│ └── test.yml
└── vars
└── main.yml
9 directories, 9 files

Primeiramente, devemos começar criando nossa task, que será usada para provisionar as instâncias EC2. Vamos navegar até o diretório tasks:

# cd /etc/ansible/roles/create/tasks

Vamos utilizar o código abaixo, basta você copiar e colar aí na sua maquineta, vamos criar o arquivo provisioning.yml:

# vim provisioning.yml- name: Criando o Security Group
local_action:
module: ec2_group
name: "{{ security_group }}"
description: Security Group Giropops
region: "{{ region }}"
rules:
- proto: tcp
from_port: 22
to_port: 22
cidr_ip: 0.0.0.0/0
rules_egress:
- proto: all
cidr_ip: 0.0.0.0/0
register: basic_firewall
- name: Criando a instancia EC2
local_action: ec2
group={{ security_group }}
instance_type={{ instance_type }}
image={{ image }}
wait=true
region={{ region }}
keypair={{ keypair }}
count={{ count }}
register: ec2
- name: Adicionando a instancia ao inventario temp
add_host: name={{ item.public_ip }} groups=giropops-new
with_items: "{{ ec2.instances }}"
- name: Adicionando a instancia criada no arquivo hosts
local_action: lineinfile
dest="./hosts"
regexp={{ item.public_ip }}
insertafter="[semanadevops]" line={{ item.public_ip }}
with_items: "{{ ec2.instances }}"
- name: Esperando o ssh
local_action: wait_for
host={{ item.public_ip }}
port=22
state=started
with_items: "{{ ec2.instances }}"
- name: Adicionando um nome tag na instancia
local_action: ec2_tag resource={{ item.id }} region={{ region }} state=present
with_items: "{{ ec2.instances }}"
args:
tags:
Name: SemanaDevOps
- name: Adicionando a maquina criada no known_hosts
shell: ssh-keyscan -H {{ item.public_ip }} >> ~/.ssh/known_hosts
with_items: "{{ ec2.instances }}"

Feito isso, vamos inserir no arquivo main.yml do diretório tasks o nosso provisioning.yml que acabamos de criar:

---
# tasks file for create
- include: provisioning.yml
...

Agora temos que criar nossas variáveis que declaramos, para isso vamos navegar até o /etc/ansible/roles/create/vars/main.yml.
Nesse arquivo main.yml vamos inserir o seguinte código que são nossas variáveis:

---
# vars file for create
instance_type: t2.micro
security_group: giropops
image: ami-064a0193585662d74
keypair: semanadevops-ansible
region: us-east-1
count: 3
  • Criação de usuário na AWS IAM

Precisaremos criar também um usuário e grupo no IAM. Peço que siga o link abaixo para criação de usuário na AWS.
Eu poderia mostrar passo a passo como criar o usuário e grupo na AWS, mas irei postar somente a documentação da AWS, pois é bem didática e simples de se entender, assim você vai treinando também em como pesquisar as coisas sozinho, isso ajuda no dia a dia no trabalho, pode ter certeza.

Crie seu usuário e grupo usando esse link aqui.

Feito a criação do usuário, anote o AWS_ACCESS_KEY e o AWS_SECRET_ACCESS, pois vamos usar essas chaves mais adiante.

Você verá uma imagem semelhante à essa abaixo:

IAM AWS

Depois de ter anotado as chaves de acesso, o AWS_ACCESS_KEY_ID (ID da chave de acesso) e AWS AWS_SECRET_ACCESS_KEY (Chave de acesso secreta) e execute o seguinte comando:

export AWS_ACCESS_KEY_ID=<your_aws_access_key_id>export AWS_SECRET_ACCESS_KEY=<your_aws_secret_access_key>
  • Criação de key pairs na AWS

Acessando o painel do EC2 na AWS, no menu do lado esquerdo, Network and Security, clique em Key Pairs e crie uma chave. Use o nome dessa chave de semanadevops-ansible. E faça o download desta chave. Não se esqueça de copiar a chave para o diretório do projeto /etc/ansible

No console da AWS só precisaremos fazer esses dois passos, criar usuário e grupo e a key-pair para nosso projeto.

Para fechar essa etapa, precisamos dar permissão 0400 na key-pair criada e adicionar a key-pair com ssh:

# chmod 0400 semanadevops-ansible.pem# ssh-add semanadevops-ansible.pem
  • Execução do nosso playbook

Bom, nessa etapa podemos executar nosso playbook para verificar se está tudo ok e sem erros no código.

ansible-playbook -i hosts main.yml

Antes de executar o playbook, você pode testar o código usando o recurso --syntax-check do Ansible, ele verifica se existe erros no código do playbook.

Outro recurso foda é o --check que faz a execução do playbook mas sem aplicar as mudanças de fato. Fica a dica, usem bastante essas opções. 😉

Início da saída do comando “ansible-playbook -i hosts main.yml”
Final da saída do comando “ansible-playbook -i hosts main.yml”

A saída do comando foi um sucesso, veja como ficou acima.
Vamos acessar o console na AWS e verificar as instâncias EC2:

EC2 AWS

Top, você automatizou o processo de provisionamento de 3 instâncias EC2 com a Ansible.

Eu inseri o IP de uma instância no arquivo de inventory para testar o ping:

# ansible semanadevops -m ping 
54.84.238.150 | SUCCESS => {
"ansible_facts": {
"discovered_interpreter_python": "/usr/bin/python3"
},
"changed": false,
"ping": "pong"
}
  • Conclusão

Esse artigo foi breve, uma rápida visão de como provisionar as instâncias com Ansible, em próximos artigos irei falar mais sobre a estrutura de roles do Ansible, o modo ad-hoc e dicas de uso da sintaxe yml.

Gostaria de citar a semana DevOps da LinuxTips que ocorreu esse ano, eu aprendi muito com o pessoal, o conteúdo foi prático e na faixa. Aproveito também para divulgar a semana de IAAS que vai ocorrer agora em Dezembro, não deixem de participar. Link aqui. #VAIIII

Obrigado pela leitura! Perguntas, comentários e sugestões são bem-vindos! 😃

Senior Linux Administrator @IBM

Get the Medium app

A button that says 'Download on the App Store', and if clicked it will lead you to the iOS App store
A button that says 'Get it on, Google Play', and if clicked it will lead you to the Google Play store