Há muitas maneiras de automatizar tarefas comuns de sysadmin com o Ansible.

Neste artigo, mostrarei como fazer outras coisas com o Ansible, que facilitará a sua vida como sysadmin. Primeiro, porém quero compartilhar porque cheguei ao Ansible.

Comecei a usar o Ansible porque isso tornava os sistemas de patch mais fáceis. Eu poderia executar alguns comandos ad-hoc aqui e ali e alguns livros de exercícios que alguém escreveu. Eu não me aprofundei muito, porque o manual que eu estava usando usava muitos módulos e “lineinfile” e, para ser honesto, minhas regex técnicas eram inexistentes. Eu também estava limitado em minha capacidade devido à orientação e instruções da minha gerência: “Você pode rodar este manual e isso é tudo o que você pode fazer”

Depois de deixar o trabalho, comecei a trabalhar em uma equipe em que a maior parte da insfraestrutura estava na nuvem. Depois de me acostumar com a equipe e aprender como tudo funciona, comecei a tentar encontrar maneiras de automatizar mais coisas.

Estávamos gastando de dois a três meses implantando máquinas virtuais em grande número – fazendo todo o trabalho manualmente, incluindo o ciclo de vida de cada máquina virtual, desde o fornecimento até a desativação.

Nosso trabalho muitas vezes atrasou, já que passávamos muito tempo fazendo manutenção. Quando as pessoas saiam de férias, outras tinham que assumir com pouco conhecimento das tarefas que estavam fazendo.

Mergulhando mais fundo no Ansible

Compartilhar ideias sobre como resolver problemas é umas das melhoras coisas que podemos fazer no mundo de TI e open source, então eu fui à procura de ajuda enviando problemas no Ansible e fazendo perguntas em funções criadas por outros.

Ler a documentação (incluindo os tópicos a seguir) é a melhor maneira de começar a aprender sobre Ansible.

Começando
Melhoras práticas
Lâmpada Ansible
FAQ Ansible

Se você está tentando descobrir o que pode fazer com Ansible, pare um pouco e pense sobre as atividades que você faz, aquelas que levam muito tempo e que seriam mais bem aproveitadas em outras coisas, aqui estão alguns exemplos:

Gerenciando contas em sistemas: Criando usuários, adicionando-os aos grupos corretos e adicionando as chaves SSH ... essas são coisas que costumavam levar dias em que tínhamos um grande número de sistemas para construir. Mesmo usando um script de shell, esse processo consumia muito tempo.

Manter listas de pacotes necessários: isso pode fazer parte da sua postura de segurança e incluir os pacotes necessários para seus aplicativos.

Instalando aplicativos: Você pode usar sua documentação atual e converter instalações de aplicativos em tarefas localizando o módulo correto para o trabalho.

Configurando sistemas e aplicativos: Você pode querer mudar etc/ssh/sshd_config para diferentes ambientes (por exemplo, produção versus desenvolvimento) adicionando uma linha ou duas, ou talvez queira que um arquivo tenha uma aparência específica em cada sistema que você está gerenciando.

Provisionando uma VM na nuvem: Isso é ótimo quando você precisa iniciar algumas máquinas virtuais que são semelhantes para seus aplicativos e está cansado de usar a interface do usuário.

Agora vamos ver como usar o Ansible para automatizar algumas dessas tarefas repetitivas.

Gerenciando usuários:
Se você precisar criar uma lista grande de usuários e grupos com os usuários espalhados entre os diferentes grupos, você pode usar loops. Vamos começar criando os grupos:

- name: create user groups
group:
name: "{{ item }}"
loop:
- postgresql
- nginx-test
- admin
- dbadmin
- hadoop

Você pode criar usuários com parâmetros específicos como este:

- name: all users in the department
user:
name: "{{ item.name }}"
group: "{{ item.group }}"
groups: "{{ item.groups }}"
uid: "{{ item.uid }}"
state: "{{ item.state }}"
loop:
- { name: 'admin1', group: 'admin', groups: 'nginx', uid: '1234', state: 'present' }
- { name: 'dbadmin1', group: 'dbadmin', groups: 'postgres', uid: '4321', state: 'present' }
- { name: 'user1', group: 'hadoop', groups: 'wheel', uid: '1067', state: 'present' }
- { name: 'jose', group: 'admin', groups: 'wheel', uid: '9000', state: 'absent' }

Olhando para o usuário jose, você pode reconhecer que state: ‘absent’ exclui essa conta de usuário e talvez esteja se perguntando por que precisa incluir todos os outros parâmetros quando estiver apenas removendo-o. É porque este é um bom lugar para manter a documentação de alterações importantes para auditorias ou conformidade de segurança. Ao armazenar os papeis no Git como sua fonte de verdade, você pode voltar e olhar as versões antigas do Git, se posteriormente precisar responder perguntas porque as alterações foram feitas.

Para implantar chaves SSH para alguns usuários, você pode usar o mesmo tipo de loop que no último exemplo.

*- name: copy admin1 and dbadmin ssh keys
authorizedkey:
user: "{{ item.user }}"
key: "{{ item.key }}"
state: "{{ item.state }}"
comment: "{{ item.comment }}"
loop:
- { user: 'admin1', key: "{{ lookup('file', '/data/testtempkey.pub'), state: 'present', comment: 'admin1 key' }
- { user: 'dbadmin', key: "{{ lookup('file', '/data/vmtempkey.pub'), state: 'absent', comment: 'dbadmin key' } *

Aqui especificamos o user como encontrar a chave, usando lookup, a state e comment descrevendo o propósito da chave.

A instalação do pacote pode variar dependendo do sistema de packaging que você está usando. Você pode usar Ansible Facts para determinar qual módulo usar. O Ansible oferece um módulo genérico chamado package que usa ansiblepkgmgr e chama o gerenciador de pacotes apropriado para o sistema. Por exemplo, se você estiver usando o Fedora, o módulo de pacote irá chamar o gerenciador de pacotes DNF.

O módulo de pacote funcionará se você estiver fazendo uma instalação simples de pacotes. Se você está fazendo um trabalho mais complexo, você terá que usar o módulo correto para o seu sistema. Por exemplo, se você quiser ignorar GPG Keys e instalar todos os pacotes de segurança em um sistema baseado em RHEL, será necessário usar o módulo yum. Você terá diferentes opções dependendo do seu packaging module, mas elas geralmente oferecem mais parâmetros do que o módulo de pacote genérico da Ansible.

Aqui está um exemplo usando o módulo de pacote:

- name: install a package
package:
name: nginx
state: installed

O seguinte usa o módulo yum para instalar o NGINX, desabilitar gpgcheck o repo, ignorar os certificados do repositório e pular todos os pacotes quebrados que possam aparecer.

- name: install a package
yum:
name: nginx
state: installed
disablegpgcheck: yes
validatecerts: no
skipbroken: yes

Aqui está um exemplo usando o Apt. O módulo Apt informa ao Ansible para desinstalar o NGINX e não atualizar o cache:

- name: install a package
apt:
name: nginx
state: absent
updatecache: no

Você pode usar loop ao instalar pacotes, mas eles são processados individualmente se você passar uma lista:

- name:
- nginx
- postgresql-server
- ansible
- httpd

NOTA: Verifique se você sabe o nome correto do pacote que deseja no gerenciador de pacotes que está usando. Alguns nomes mudam dependendo do gerenciador de pacotes.

Iniciando Serviços:

Muito parecido com pacotes, o Ansible possui diferentes módulos para iniciar serviços. Como em nosso exemplo anterior, em que usamos módulo de pacote para fazer uma instalação geral de pacotes, o módulo de serviço faz um trabalho semelhante com os serviços, incluindo o systemd e o Upstart. (Verifique a documentação do módulo para obter uma lista completa). Aqui está um exemplo:

    • name: start nginx
      service:
      name: nginx
      state: started*

Você pode usar o módulo de serviço da Ansible se estiver apenas iniciando e interrompendo aplicativos e não precisar de nada mais sofisticado. Mas, como no módulo yum, se você precisar de mais opções, precisará usar o módulo systemd. Por exemplo, se você modificar os arquivos systemd, você precisará fazer um daemon-reload, o módulo de serviço não funcionará para isso; você terá que usar o módulo systemd.

- name: reload postgresql for new configuration and reload daemon
systemd:
name: postgresql
state: reload
daemon-reload: yes

Este é um ótimo ponto de partida, mas pode se tornar incômodo porque o serviço sempre será recarregado / reiniciado. Este é um bom lugar para usar um handler.

Se você usou as práticas recomendadas e criou sua função usando ansible-galaxy init “role name”, você deve ter a estrutura de diretório completa. Você pode incluir o código acima handlers/main.yml e chamá-lo quando fizer uma alteração com o aplicativo. Por exemplo:

handlers / main.yml

  • name: recarrega o postgresql para nova configuração e recarrega o daemon
    systemd:
    nome: postgresql
    state: reload
    daemon-reload: yes
    Esta é a tarefa que chama o handler
  • name: configure postgresql
    template:
    src: postgresql.service.j2
    dest: /usr/lib/systemd/system/postgresql.service
    notify: reload postgresql for new configuration and reload daemon

Ele configura o PostgreSQL alterando o arquivo systemd, mas em vez de definir a reinicialização nas tarefas (como antes), ele chama o handler para fazer o reinicio no final da execução. Essa é uma boa maneira de configurar seu aplicativo e mantê-lo, pois o handler só é executado quando** uma tarefa é alterada** – não no meio de sua configuração.

O exemplo anterior usa o módulo de modelo e um arquivo Jinja2. Uma das coisas mais maravilhosas sobre como configurar aplicativos com o Ansible é usar modelos. Você pode configurar um arquivo inteiro como postgresql.service na configuração completa que você precisa. Mas, em vez de alterar todas as linhas, você pode usar variáveis e definir as opções em outro lugar. Isso permitirá que você altere qualquer variável a qualquer momento e seja mais versátil. Por exemplo:

[database]
DBTYPE = "{{ giteadb }}"
HOST = "{{ ansiblefqdn}}:3306"
NAME = gitea
USER = gitea
PASSWD = "{{ giteadbpasswd }}"
SSLMODE = disable
PATH = "{{ giteadbdir }}/gitea.db

Isso configura as opções do banco de dados no arquivo app.ini para o Gitea. Isso é semelhante a escrever tarefas Ansible, mesmo que seja um arquivo de configuração, e facilita definir variáveis e fazer alterações. Isso pode ser expandido ainda mais se você estiver usando groupvars, o que permite definir variáveis para todos os sistemas e grupos específicos (por exemplo, produção versus desenvolvimento). Isso facilita o gerenciamento de variáveis e você não precisa especificar as mesmas em todas as funções.

Provisionando um sistema

Analisamos várias coisas que você pode fazer com o Ansible em seu sistema, mas ainda não discutimos como provisionar um sistema. Aqui está um exemplo de provisionamento de uma máquina virtual (VM) com a solução de nuvem OpenStack.

- name: create a VM in openstack
ospserver:
name: cloudera-namenode
state: present
cloud: openstack
regionname: andromeda
image: 923569a-c777-4g52-t3y9-cxvhl86zx345
flavorram: 20146
flavor: big
autoip: yes
volumes: cloudera-namenode

Todos os módulos do OpenStack começam com os, o que facilita encontrá-los. A configuração acima usa o módulo osp-server, que permite adicionar ou remover uma instância. Inclui o nome da VM, seu estado, suas opções de nuvem e como ela se autentica na API.

Mais informações sobre cloud.yml estão disponíveis nos documentos do OpenStack, mas se você não quiser usar o cloud.yml, poderá usar um dicionário que lista suas credenciais usando a authopção. Se você quiser excluir a VM, basta mudar state: para absent.

Digamos que você tenha uma lista de servidores que você desligou porque não conseguiu descobrir como fazer os aplicativos funcionarem e deseja iniciá-los novamente. Você pode usar osserveraction para reiniciá-los (ou reconstruí-los se quiser começar do zero).
Aqui está um exemplo que inicia o servidor e informa aos módulos o nome da instância:

- name: restart some servers
osserveraction:
action: start
cloud: openstack
regionname: andromeda
server: cloudera-namenode

A maioria dos módulos do OpenStack usa opções semelhantes. Portanto, para reconstruir o servidor, podemos usar as mesmas opções, mas alterar o action para rebuild adicionar o image que queremos que ele use:

osserveraction:
action: rebuild
image: 923569a-c777-4g52-t3y9-cxvhl86zx345

Fazendo outras coisas

Existem módulos para muitas tarefas de administração do sistema, mas o que você deve fazer se não houver uma para o que você está tentando fazer? Use o shell e os módulos de comando, que permitem que você execute qualquer comando como na linha de comando. Aqui está um exemplo usando o OpenStack CLI:

- name: execute um comando de
comando opencli : "openstack hypervisor list"

São muitas as maneiras pelas quais você pode realizar tarefas diárias com o Ansible. O uso dessa ferramenta de automação pode transformar uma tarefa difícil em uma solução simples, economizar tempo e tornar os dias de trabalho mais curtos e relaxados.

Gostou do conteúdo? Compartilhe com seus amigos que se interessam pelo assunto e inscreva-se aqui para receber outros conteúdos como este no seu e-mail.

Artigo escrito por Jonathan Lozada De La Matta (Red Hat)
Fonte: opensource.com