Вы находитесь на странице: 1из 27

ANSIBLE

Ansible 1
1. Pré-Requisitos

Para que possamos ter o Ansible instalado e pronto para atuarmos com as configurações,
precisamos atender alguns pré-requisitos, são eles:

Servidores:

Servidor Ansible Debian 9 Minimal


Servidor Web CentOS 7 Minimal
Servidor DB CentOS 7 Minimal

Rede:

Ambos os servidores precisam estar na mesma rede, recomendamos usar o range


192.168.0.0/24.

Obs.: Todas as dependências serão instaladas no decorrer do curso!

Ansible 2
2. O que é ?

Ansible é uma ferramenta para automatizar/gerenciar múltiplas máquinas de


uma vez ainda é possível ultilizar playbooks para gerenciamento de configuração,
deploys de aplicações e orquestração de serviços.

2.1. Porque Ansible ?

O Ansible foi desenvolvido pensando na simplicidade e facilidade de uso. Este é


um dos fatores que está levando os administradores de sistema a escolher o
Ansible para gerenciar o parque de máquinas. Outro foco do Ansible é a segurança
e confiabilidade, utilizando o OpenSSH para transporte e comunicação dos nodes.
A simplicidade ajuda em ambientes de qualquer tamanho, sejam eles ambientes de
empresas pequenas ou ambientes de empresas multinacionais, se tornando fácil o
gerenciamento das máquinas e tornando possível a qualquer funcionário de TI ler
as tarefas do Ansible de forma simples. O Ansible gere as máquinas de uma forma
sem agente (agent-less) pelo openssh. O OpenSSH está presente em todas as
distribuições linux. O Ansible é descentralizado e depende somente das
credenciais OS existentes para controlar o ambiente. Também podemos utilizar
Kerberos ou LDAP para gerenciamento de autenticações centralizadas.

• Características Máster to nodes.

• Usa uma linguagem de configuração simples YAML

• Não necessita de agent instalado para a orquestração.

• Segurança já vem no protocolo SSH, ou sejá conexões criptografadas.

• Simples de usar.

Ansible 3
2.2 Como Ansible trabalha ?

O Ansible basicamente trabalha se conectando nos nodes especificados e envia


pequenos programas, que são chamados de módulos do Ansible, e quando finaliza
a tarefa esses módulos são finalizados. Todas as execuções são por SSH.

Uma das principais características que faz o Ansible ser atrativo para uso em
relação à automação de serviços é a sua linguagem bastante simples, não tem
necessidade de ter um notável conhecimento técnico para entender o que está
sendo feito. Outras características interessantes do Ansible são: Ele é simples de
começar a utiliza, pois apenas utiliza SSH para se conectar com os servidores e
executar as atividades, e o Ansible utiliza do princípio da idempotência, seus
modulos não executarão uma ação que não mudarão o estado do sistema.

2.3. Host Inventory

Ansible trabalha com múltiplos sistemas na sua infra-estrutura ao mesmo tempo,


para que isso aconteça você precisa antes adicionar os hosts no arquivo default
/etc/ansible/hosts ou utilizar o opção -i para especificar um arquivo diferente, no
arquivo você pode usar host ou ip.

Ansible 4
Exemplo:

/etc/ansible/hosts

[webservers]
a.exemplo.com
b.exemplo.com

[dbservers]
c.exemplo.com
d.exemplo.com

Os nomes que estão dentro dos colchetes são os nomes dos grupos, que é usado
para classificar os sistemas e para decidir em qual sistema você vai controlar.

Você pode selecionar uma conexão usando usuário e senha por hosts ou ssh key

[webservers]
a.exemplo.com ansible_connection=ssh ansible_ssh_root=root
ansible_ssh_pass=*

ou

[webservers]
a.exemplo.com
ansible_ssh_private_key_file=/etc/keys/acesso.pem

2.4. Playbooks

Playbooks são configurações, deploy e linguagem de orquestração, Elas podem


descrever as politicas que você quiser para seus sistemas remotos, e setar
procedimentos de configurações. Basicamente, Playbooks pode ser usado para
gerenciar configurações e desenvolver maquinas remotas. E em um nível mais
avançado o Ansible pode lançar diversos updates e pode delegar ações de outros
hosts, pode ser interativo com servidores de monitoramento e load balancers.
Playbooks são feitos para serem fácil de entender.

Exemplo de formato YAML

- name: Jardel Fernandes da Costa


job: Analista de Sistemas
Skills:
- Administração de Sistemas

Ansible 5
- Sistemas Windows
- Sistemas Linux
- Sistemas Redes

Exemplo de formato YAML (Mudando o resolv.conf das maquinas remotas e


instalando o pacote sl)

# Playbook de exemplo
- name: playbook para mudar o resolv.conf
hosts: all

tasks:
- name: Garantir pacote SL
apt: name=sl update_cache=yes state=present
- name: Atualizar o resolv.conf
copy: src=resolv.conf dest=/etc/resolv.conf

2.5. Módulos Ansible

Módulos, também conhecidos por “Plugins de Tarefas” são o que realmente


funcionam no Ansible, Eles são os responsáveis por executar as tarefas nas
máquinas. Os mesmos são chamados pelos Playbooks. Os módulos do Ansible
são onde a mágica acontece, eles são responsáveis por executar as tarefas
designadas a eles nos nodes gerenciados pelo ansible.

É possível desenvolver os nossos próprios módulos em qualquer linguagem de


programação, sendo que o Ansible utiliza o JSON para se comunicar com
módulos.

- apt: Gerencia instalação de pacotes utilizando o APT (debian/Ubuntu)


- yum: Gerencia instalação de pacotes utilizando o YUM (RedHat/CentOS/Fedora)
- command: Par executar um comando no host remoto.
- shell: Executa um shell script dentro da máquina, após realizar as tranferências
- service: Gerencia serviços em máquina remotas
- copy: copia arquivo na máquina local para o node remoto.
- git: gerencia repositório do git.
- unarchive: Descompactar arquivos na máquina remota.
- mount: Gerencia os dispositivos montados na máquina.
- template: Gerencia templates no ansible.
- ec2: Gerencia instancias ec2 ambiente cloud da Amazon

Ansible 6
2.6. Ansible gerenciando cloud AWS, Azure, Google

Com Ansible você pode gerenciar configurações na cloud AWS com simplicidade
e mantendo a arquitetura de “agent less”.

É possível verificar todos os módulos em


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

Ansible 7
3.0. Preparando o Ambiente

A Partir de agora vamos gerar o par de chaves para acesso do Ansible e


cadastrar a chave

Vamos criar o diretório para o par de chaves

# mkdir /opt/keys

Gerando 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):


/opt/keys/sshkey

Enter passphrase (empty for no passphrase): <enter>

Enter same passphrase again: <enter>

Copiando a chave para o node 1

# ssh-copy-id -i /etc/keys/sshkey.pub root@<ip do node 1>

Realizando o teste de acesso SSH

# ssh -i /opt/keys/sshkey root@<ip do node 1>

Ansible 8
3.1. Instalação do Ansible

O Ansible está disponível nos repositórios das principais distribuições do Linux,


mas é preciso ficar atento nas versãos do Ansible, devido a compatibilidade dos
módulos.

Instalando o Ansible via repositório

# yum install ansible

Acessando o Diretório e arquivo de configuração default

# cd /etc/ansible/

Abra o aqruivo de configuração e altera as seguintes configurações.

# vim ansible.cfg

roles_path = /etc/ ansible/roles

timeout = 30

log_path = /var/log/ansible.log

private_key_file = /opt/keys/sshkey

host_key_checking = False

Parâmetro roles_path:

Caminhos adicionais para a localização das roles do ansible, podemos passar


mais de um caminho separados por vingula (,).

Parâmetro timeout:

Tempo de esperar para conectar ao servidor em segundos. Por padrão em o valor


10 segundos, vamos aumentar para 30 segundos.

Ansible 9
Parâmetro log_path:

Por padrão os logs do ansible são desativados. Para habilitar o log precisamos
especificar o arquivo pela variável log_path. Por padrão o arquivo
/var/log/ansible.log.

Parâmetro private_key_file:

Quando definido sempre ira utilizar a chave privada do SSH para autenticar nos
nodes. Podemos também passar por parâmetro outra chave em alguns casos
utilizando o –private_key.

3.2. Inventário do Ansible e aprendendo alguns módulos

Ansible possui uma grande quantidade de módulos específicos para ambientes,


bancos de dados, ferramentas, sistemas operacionais, tecnologias e etc, mas
infelizmente seria impossível tratar de cada um deles então listarei alguns
módulos, específicos para tarefas de instalar pacotes, subir serviços ou mesmo
executar comandos de forma remota.

Vamos configurar os servidores na lista.

# vim /etc/ansible/hosts

[web]
192.168.10.2

[db]
192.168.10.3

Aqui estamos usando o módulo “ping” para verificar se os hosts estão vivos

# ansible web -m ping

192.168.10.2 | SUCCESS => {


"changed": false,
"ping": "pong"

# ansible db -m ping

192.168.10.3 | SUCCESS => {


"changed": false,
"ping": "pong"

Ansible 10
Vamos usar aquele que permite fazer qualquer operação dentro de um nó o
módulo “shell” que serve para executar remotamente um comando e retornar seu
resultado.

# ansible all -m shell -a "uptime"

192.168.10.2 | SUCCESS | rc=0 >>


12:46:57 up 4 days, 38 min, 19 users, load average: 0,50,
0,64, 0,61

192.168.10.3 | SUCCESS | rc=0 >>


12:50:09 up 5 days, 20:50, 0 users, load average: 0,55,
0,21, 0,22

É importante notar que tem um argumento obrigatório que é o comando a ser


executado, informado através do parâmetro “-a”

Obs: Você pode usar a opção “all” para executar em todos os grupos.

O módulo “get_url”, diferente dos primeiros, este tem a função bem mais
específica que é baixar arquivos através de FTP, HTTP ou HTTPs e colocá-los em
um local determinados no get_url.

# ansible all -m shell -a "mkdir /root/wordpress"

# ansible all -m get_url -a


"url=https://br.wordpress.org/wordpress-4.9-pt_BR.tar.gz
dest=/root/wordpress"

192.168.10.2 | SUCCESS => {


"changed": true,
"checksum_dest": null,
"checksum_src":
"940f260079113bc830cd9371947777ad47f52237",
"dest": "/root/wordpress/wordpress-4.9-pt_BR.tar.gz",

Ansible 11
"gid": 0,
"group": "root",
"md5sum": "c2fb94684095554f3f768cbbb424db63",
"mode": "0644",
"msg": "OK (10124112 bytes)",
"owner": "root",
"size": 10124112,
"src": "/tmp/tmpLuwIhW",
"state": "file",
"uid": 0,
"url": "https://br.wordpress.org/wordpress-4.9-
pt_BR.tar.gz"
}

192.168.10.3 | SUCCESS => {


"changed": true,
"checksum_dest": null,
"checksum_src":
"940f260079113bc830cd9371947777ad47f52237",
"dest": "/root/wordpress/wordpress-4.9-pt_BR.tar.gz",
"gid": 0,
"group": "root",
"md5sum": "c2fb94684095554f3f768cbbb424db63",
"mode": "0644",
"msg": "OK (10124112 bytes)",
"owner": "root",
"secontext": "unconfined_u:object_r:admin_hom RUA DAS
GOIABEIRAS, 400
e_t:s0",
"size": 10124112,
"src": "/tmp/tmpQjiU2w",
"state": "file",
"uid": 0,
"url": "https://br.wordpress.org/wordpress-4.9-
pt_BR.tar.gz"

Diferente do módulo “shell” este módulo tem dois argumentos obrigatórios. Um é


“url” que é justamente o que deverá ser baixado e o outro é “dest” informando o
local onde salvar o arquivo.

Aliás, diferente das demais execuções até agora, o resultado desta, apesar de bem
sucedida, foi impressa em uma cor diferente de verde ou vermelho habituais. Isso
é porque a execução resultou em uma alteração da situação anterior.

Ansible 12
O módulo “apt” gerencia a instalação de pacotes via APT No argumento “name”
você informa o nome do pacote a ser instalado. Um argumento opcional mais que
pode ser bastante útil é o “update_cache=true” para executar um apt-get update
antes.

Vamos instalar o pacote ntp.

# ansible web -m apt -a "name=ntp update_cache=true"

192.168.10.2 | SUCCESS => {


"cache_update_time": 1514984909,
"cache_updated": true,
"changed": true
}

O modúlo “service” permite inciar, reiniciar, parar, habilitar ou desabilitar serviços


de um determinado host, então vamos parar o serviço ntpd e depois iniciar.

# ansible web -m service --args="name=ntp state=stopped"

192.168.10.2 | SUCCESS => {


"changed": true,
"name": "ntp",
"state": "stopped",
"status": { …..
….
}

# ansible web -m service --args="name=ntp state=started"

192.168.10.2 | SUCCESS => {


"changed": true,
"name": "ntp",
"state": "started",
"status": { …..
….
}

Ansible 13
3.3. Overview do Formato YAML

- Arquivos do YAML possuem a extensão yml ou yaml

- Um dicionário é representado por Chave: Valor

- Arquivos YAML opcionalmente podem começar com --- e terminar com …

- Comentários são definidos pelo caracter #

- Uma lista é representada por uma linha que possui o mesmo nível de identação.
Começando por “- “ ( Traço e um espaço)

Vamos ao diretório de arquivos para o playbook que definimos ser no /opt.

Criando o diretório files

# mkdir /opt/files

Entre no diretório criado

# cd /opt/files

Vamos criar o arquivo resolv.conf

# vim resolv.conf

nameserver 8.8.8.8
nameserver 8.8.4.4

3.4. Criando nosso primeiro Playbook

Criando o diretório playbooks.

# mkdir /etc/ansible/playbooks

Entre no diretório criado.

Ansible 14
# cd /etc/ansible/playbooks

Vamos criar nosso primeiro playbook.

# vim playbook.yml

---

# Playbook de exemplo:
- name: Meu Primeiro de muitos Playbooks
hosts: all

tasks:
- name: Vamos garantir que todos os servidores tenham
o resolv.conf iguais
copy: src=/etc/ansible/playbooks/resolv.conf
dest=/etc/resolv.conf

No servidor executar o comando abaixo.

# ansible-playbook playbook.yml

PLAY [Meu primeiro de muitos Playbooks]


******************************

TASK [setup]
******************************************************
ok: [192.168.10.2]
ok: [192.168.10.3]

TASK [Vamos garantir que todos os servidores tenham o


resolv.conf iguais] ****
changed: [192.168.10.2]
changed: [192.168.10.3]

PLAY
RECAP*****************************************************
192.168.10.2 : ok=2 changed=1
unreachable=0 failed=0
192.168.10.3 : ok=2 changed=1

Ansible 15
unreachable=0 failed=0

Vamos verificar o resolv.conf de todos os hosts.

# ansible all -m command -a “cat /etc/resolv.conf”

192.168.10.2 | SUCCESS | rc=0 >>

nameserver 8.8.8.8
nameserver 8.8.4.4
192.168.10.3 | SUCCESS | rc=0 >>

nameserver 8.8.8.8
nameserver 8.8.4.4

Agora vamos instalar o pacote bb no Debian.

# vim playbook2.yml

---
# Playbook de exemplo:
- name: Meu Playbooks de instalação de pacote via APT
hosts: web

tasks:
- name: Vamos garantir que todos os servidores Debian
tenham o pacote bb instalado
apt: name=bb update_cache=yes state=present

Execute o comando abaixo.

# ansible-playbook playbook2.yml

Validando.

# ansible web -m command -a "find /usr/games -iname bb"

172.23.20.114 | SUCCESS | rc=0 >>


/usr/games/bb

Ansible 16
Agora vamos instalar o pacote sl no Centos.

# vim playbook3.yml

---
# Playbook de exemplo:
- name: Meu Playbooks de instalação de pacotes via YUM
hosts: db

tasks:
- name: Vamos garantir que todos os servidores Centos
tenham o pacote bb instalado
yum: name=sl state=present

Execute o seguinte comando.

# ansible-playbook playbook3.yml

Validando.

# ansible db -m command -a "find /usr/ -iname sl"


172.21.20.254 | SUCCESS | rc=0 >>
/usr/bin/sl
/usr/share/locale/sl

Agora imagine que você precisa instalar o mesmo pacote em distribuições


diferentes como por exemplo o “wget” (O pacote precisa existe na lista de
repositório)

# vim playbook4.yml

---
# Playbook de exemplo:
- name: Meu playbooks que instala o pacote wget
hosts: all

tasks:
- name: Vamos garantir que todos os servidores tenham
o pacote wget instalado
package: name=wget state=present

Ansible 17
Execute o comando abaixo.

# ansible-playbook playbook4.yml

Validando.

# ansible all -m command -a "wget -V"

Em alguns casos precisamos que nosso playbook possua variáveis.

As Variáveis podem ser passadas por inventário, Podemos definir as variáveis


dentro do playbook ou passar as mesmas pelo próprio comando de execução dos
playbooks.

# vim playbook5.yml

---
# Playbook 5 para criar usuario
- name: Criar um usuario no sistema
hosts: all
vars:
- username: aluno

tasks:
- name: Criando o usuário aluno
user: name={{ username }} shell=/bin/bash
createhome=yes

Execute o comando abaixo.

# ansible-playbook playbook5.yml

Validando.

# ansible web -m command -a "getent passwd aluno"

192.168.0.2 | SUCCESS | rc=0 >>


aluno:x:1006:1006::/home/aluno:/bin/bash

Ansible 18
Podemos criar usuário na linha de comando usando a variável criada
anteriormente.

# ansible-playbook -e username=developer playbook5.yml

Validando.

# ansible web -m command -a "getent passwd developer"

192.168.0.2 | SUCCESS | rc=0 >>


developer:x:1007:1007::/home/developer:/bin/bash

Usando Loops em Playbooks.

Em alguns casos precisamos executar várias atividades do mesmo módulo


inúmeras vezes como por exemplo, ao instalar vários pacotes em um servidor.
Para isso podemos usar o parâmetro with_items do Ansible para realizar um loop e
executar as mesmas atividades mais de uma vez.

# vim playbook6.yml

---
- name: Vamos garantir que os pacotes básicos do sistemas
sejam instalados
apt: name={{ item }} update_cache=yes state=present
with_items:
- vim
- htop
- mtr
- tcpdump
- dnsutils

Usando a condicional when.

As vezes precisamos que uma tarefa seja executar de acordo com uma condição,
para isso podemos usar o parâmetro WHEN do Ansible para definir quando ele
deve executar um módulo de acordo com alguma especificação.

# vim playbook7.yml

---

Ansible 19
# Plabook para usar o when
- name Exemplo usando um arquivo teste
hosts: all

tasks:
- name: testando um arquivo
command: test -f /root/teste
register: result
ignore_errors: yes
- name: Configurando uma variável dentro do arquivo teste
shell: echo “export ALUNO=/root/teste” > /root/teste
when: result.rc == 0

Validando.

# ansible-playbook playbook7.yml

PLAY [Exemplo usando um arquivo teste]


********************************

TASK [setup]
*******************************************************
ok: [192.168.10.2]
ok: [192.168.10.3]

TASK [testando um arquivo]


*******************************************
fatal: [192.168.10.2]: FAILED! => {"changed": true, "cmd":
["test", "-f", "/root/teste"], "delta": "0:00:00.060881",
"end": "2018-01-03 12:06:18.449298", "failed": true, "rc": 1,
"start": "2018-01-03 12:06:18.388417", "stderr": "",
"stdout": "", "stdout_lines": [], "warnings": []}
...ignoring
fatal: [192.168.10.3]: FAILED! => {"changed": true, "cmd":
["test", "-f", "/root/teste"], "delta": "0:00:00.027701",
"end": "2018-01-03 12:09:21.701630", "failed": true, "rc": 1,
"start": "2018-01-03 12:09:21.673929", "stderr": "",
"stdout": "", "stdout_lines": [], "warnings": []}
...ignoring

TASK [Configurando uma variável dentro do arquivo teste]


***********************
skipping: [192.168.10.2]
skipping: [192.168.10.3]

Ansible 20
PLAY RECAP
******************************************************
192.168.10.2 : ok=2 changed=0
unreachable=0 failed=0
192.168.10.3 : ok=2 changed=0
unreachable=0 failed=0

Como o arquivo “/root/teste” não existe é possível ver na saída que não houve
nenhuma alteração.

Vamos criar o arquivo.

# ansible all -m command -a "touch /root/teste"

Executa de novo.

# ansible-playbook playbook7.yml

Agora funcionou!

Validando.

# ansible all -m command -a "cat /root/teste"


192.168.10.2 | SUCCESS | rc=0 >>
“export ALUNO=/root/teste”

192.168.10.3 | SUCCESS | rc=0 >>


“export ALUNO=/root/teste”

Ansible 21
4.0. Roles

A melhor maneira de organizar as playbooks do Ansible é através das ROLES


roles é uma maneira de automaticamente carregar arquivos de acordo com uma
estrutura de diretórios definidas.

Exemplo:

/etc/ansible/roles/
wordpress/
files/
templates/
tasks/
handlers/
vars/
defaults/
meta

Comportamento:

- Caso exista o arquivo /roles/wordpress/tasks/main.yml, as tasks definidas


dentro do arquivo será inclusa na playbook.

- Caso exista o aquivo /roles/wordpress/handlers/main.yml. Os handlers


definidos dentro do arquivo será incluso no playbook.

- Caso exista o aquivo /roles/wordpress/vars/main.yml, as variáveis definida


dentro do arquivo será incluso no playbook

- Qualquer tarefa de copy, script, template ou include pode utilizar arquivos que
dentro dos diretórios files, templates, tasks.

Ansible 22
5.0 Vamos construir nosso ambiente web com wordpress usando roles.

Vamos criar a estrutura de diretórios para o ansible roles.

# mkdir /etc/ansible/roles ; cd /etc/ansible/roles

# mkdir wordpress

# cd wordpress/

# mkdir {files,templates,tasks,handlers,vars,defaults}

Criaremos uma playbook que vai instalar o apache2 e php5 e as dependências


para o wordpress.

# vim /etc/ansible/roles/wordpress/tasks/main.yml

#
# Configurando o apche para o grupo web
#
---

- name: Instala o apache


apt: name={{ item }} update_cache=yes state=present
with_items:
- apache2
- php5
- libapache2-mod-php5
- php5-mcrypt
- php5-gd
- libssh2-php

- name: Interrompe o Apache


service:
name: apache2
state: stopped

- name: Copia o diretorio /root/wordpress/* para dentro


do /var/www/html/
unarchive:
src: "/root/wordpress/wordpress-4.9-pt_BR.tar.gz"

Ansible 23
dest: "/var/www/html"
remote_src: yes

- name: Iniciando o Apache


service:
name: apache2
state: started

Vamos retornar para a raiz do Ansible.

# cd /etc/ansible/

Na raiz do Ansible vamos criar o yml que informa qual rule e em quais hosts serão
instalados.

# vim wordpress.yml

---
- hosts: web
roles:
- wordpress

Vamos instalar nosso servidor Web.

# ansible-playbook wordpress.yml

A partir de agora temos nosso servidor web instalado. Valide o Acesso! Vá no


servidor web e pegue o ip e coloque no seu navegador web.

http://<IP do servidor web>/wordpress

Ansible 24
5.1. Agora precisamos entregar um Banco de dados para o wordpress!

Vamos criar nossa estrutura de diretórios

# mkdir /etc/ansible/roles/mysql

# cd wordpress/

# mkdir {files,templates,tasks,handlers,vars,defaults}

Depois precisamos criar nossa task

# vim task/mail.yml

---

- name: Instalando o mariadb na maquina Centos/Redhat


yum: name={{ item }} state=present
with_items:
- python-devel
- python2-pip
- mariadb
- mariadb-server

- name: Inicializando o serviço mariadb


service: name=mariadb state=started enabled=true

- name: Check if root password is set


shell: mysqladmin -u root status
changed_when: false
failed_when: false
register: root_pwd_check

- name: Copiando as permissões do mysql


template: src=files/my.cnf dest=/root/.my.cnf owner=root
mode=0600

Ansible 25
- name: Criando o bando de dados mysql
mysql_db: name={{ wp_mysql_db }} state=present

- name: Criando o usuário


mysql_user:
name={{ wp_mysql_user }}
password={{ wp_mysql_password }}
priv=wordpress.*:ALL
host='%'

Como pode ver, estamos usando variaveis wp_mysql_user,


wp_mysql_password, wp_mysql_db, agora vamos declarar elas em defaults

# vim /etc/ansible/roles/mysql/defaults/main.yml

---
wp_mysql_db: wordpress
wp_mysql_user: wordpress
wp_mysql_password: wordpress123

Para conectar via mysql no ansible precisamos criar um .my.cnf no servidor db


para conseguir autenticar de forma segura, dentro de diretório templates vamos
criar um arquivo que vai ser copiado para o Servidor DB.

#vim /etc/ansible/roles/mysql/files/my.cnf

[client]
user=root
password=123456

Finalmente, vamos criar o arquivo que vai chamar a Role “mysql”

# vim /etc/ansible/mysql.yml

---
- hosts: db
roles:
- mysql

Ansible 26
Agora vamos instalar o mysql e em seguida vamos instalar o banco e configurar
uma base com usuário e senha.

# ansible-playbook /etc/ansible/mysql.yml

Se tudo funcionou corretamente você pode testar executando no servidor web:

# mysql -h <ip do servidor db> -uwordpress -pwordpress123


wordpress

Funcionando!

Agora você pode finalizar a configuração do wordpress via web!!!

Parabéns você agora tem um servidor web usando um framework para a


configuração do seu próprio site!

Ansible 27