Solução de Problemas: Senha Sudo Ausente no Ansible

Introdução

Ansible é uma ferramenta de automação poderosa que auxilia na gestão e configuração de servidores sem exigir intervenção manual. No entanto, muitas tarefas do Ansible requerem permissões elevadas para serem executadas corretamente. Ao executar comandos que necessitam de privilégios de administrador, o Ansible utiliza o mecanismo sudo, que pode solicitar uma senha.

Neste laboratório, você aprenderá como configurar corretamente as definições de senha sudo em playbooks do Ansible, entender problemas comuns relacionados ao sudo e implementar as melhores práticas para garantir que sua automação seja executada sem problemas com as permissões necessárias.

Instalando o Ansible e Criando um Playbook Básico

Nesta primeira etapa, instalaremos o Ansible e criaremos um playbook simples que requer privilégios sudo. Isso nos ajudará a entender os requisitos básicos para executar tarefas do Ansible com permissões elevadas.

Instalando o Ansible

Vamos começar instalando o Ansible em nosso sistema. Abra um terminal e execute os seguintes comandos:

sudo apt update
sudo apt install -y ansible

Após a conclusão da instalação, verifique se o Ansible foi instalado corretamente:

ansible --version

Você deve ver uma saída semelhante a esta, mostrando a versão do Ansible e informações de configuração:

ansible [core 2.12.x]
  config file = /etc/ansible/ansible.cfg
  configured module search path = ['/home/labex/.ansible/plugins/modules', '/usr/share/ansible/plugins/modules']
  ansible python module location = /usr/lib/python3/dist-packages/ansible
  ansible collection location = /home/labex/.ansible/collections:/usr/share/ansible/collections
  executable location = /usr/bin/ansible
  python version = 3.10.x (main, Ubuntu, linux/x86_64)
  jinja version = 3.0.3
  libyaml = True

Criar um Playbook Básico do Ansible

Agora, vamos criar um playbook Ansible simples que requer privilégios sudo. Este playbook instalará o pacote htop no sistema local.

Crie um novo diretório para seu projeto Ansible:

mkdir -p ~/project/ansible-sudo-lab
cd ~/project/ansible-sudo-lab

Em seguida, crie o arquivo de inventário que define os hosts que o Ansible irá gerenciar. Para este laboratório, usaremos o localhost:

echo "localhost ansible_connection=local" > inventory

Agora, crie um playbook básico que requer privilégios sudo. Abra o editor VSCode e crie um novo arquivo chamado basic_playbook.yml:

Clique em "File" no menu WebIDE
Selecione "New File"
Copie e cole o seguinte conteúdo:

---
- name: Basic sudo operation
  hosts: localhost
  become: true ## This enables sudo

  tasks:
    - name: Install htop
      apt:
        name: htop
        state: present
        update_cache: yes

Salve o arquivo como ~/project/ansible-sudo-lab/basic_playbook.yml

Este playbook tem a diretiva become: true, que diz ao Ansible para usar sudo para executar as tarefas. A própria tarefa tenta instalar o pacote htop usando o módulo apt.

Executar o Playbook

Agora, vamos executar nosso playbook e observar o que acontece:

cd ~/project/ansible-sudo-lab
ansible-playbook -i inventory basic_playbook.yml

Como o usuário labex tem acesso sudo sem senha, o playbook deve ser executado com sucesso sem solicitar uma senha. Você deve ver uma saída semelhante a esta:

PLAY [Basic sudo operation] ******************************************

TASK [Gathering Facts] **********************************************
ok: [localhost]

TASK [Install htop] ************************************************
ok: [localhost]

PLAY RECAP *********************************************************
localhost                  : ok=2    changed=0    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0

O playbook foi executado com sucesso porque nosso usuário atual (labex) já está configurado com acesso sudo sem senha. Nas próximas etapas, exploraremos como lidar com cenários em que uma senha sudo é necessária.

Entendendo a Configuração da Senha Sudo no Ansible

Na etapa anterior, criamos um playbook básico que usava privilégios sudo sem exigir uma senha. No entanto, em muitos cenários do mundo real, você precisará fornecer uma senha sudo para executar comandos privilegiados. Vamos explorar como lidar com senhas sudo no Ansible.

Como o Ansible Lida com Senhas Sudo

Quando o Ansible precisa executar um comando com privilégios elevados em um sistema remoto, ele usa a funcionalidade become. Por padrão, o Ansible usa o comando sudo para elevação de privilégios, mas você pode configurá-lo para usar outros métodos como su, pbrun ou pfexec.

Se o usuário que executa o Ansible precisar de uma senha para usar o sudo, o Ansible precisa saber essa senha. Existem várias maneiras de fornecer a senha sudo ao Ansible:

Opção de linha de comando: -K ou --ask-become-pass
Variável do playbook: become_password
Arquivo de configuração: ansible.cfg
Ansible Vault: Para armazenar senhas com segurança

Criando um Usuário de Teste com Requisito de Senha Sudo

Para demonstrar como lidar com senhas sudo, vamos criar um usuário de teste que exige uma senha para operações sudo:

sudo adduser ansible_test

Quando solicitado, insira a senha ansible123 e conclua o processo de criação do usuário.

Em seguida, vamos dar a este usuário privilégios sudo, mas exigir uma senha:

echo "ansible_test ALL=(ALL) ALL" | sudo tee /etc/sudoers.d/ansible_test

Esta configuração permite que o usuário ansible_test use sudo, mas exigirá a senha do usuário cada vez.

Criando um Playbook com Tratamento de Senha Sudo

Agora, vamos criar um playbook que demonstra como lidar com senhas sudo. Crie um novo arquivo chamado sudo_password_playbook.yml no WebIDE:

---
- name: Playbook with sudo password handling
  hosts: localhost
  become: true
  ## We'll provide the become_password when running the playbook

  tasks:
    - name: Get current user
      command: whoami
      register: current_user
      become: false ## This task doesn't need sudo

    - name: Print current user
      debug:
        msg: "Current user is {{ current_user.stdout }}"
      become: false ## This task doesn't need sudo

    - name: Run a command with sudo
      command: apt update
      register: sudo_output

    - name: Print sudo command result
      debug:
        msg: "Command ran with sudo: {{ sudo_output.rc == 0 }}"

Salve este arquivo como ~/project/ansible-sudo-lab/sudo_password_playbook.yml

Executando o Playbook com Entrada de Senha

Quando você deseja executar um playbook como um usuário que exige uma senha sudo, você pode usar a opção -K (ou --ask-become-pass) para solicitar a senha:

ansible-playbook -i inventory sudo_password_playbook.yml -K

Como estamos executando como o usuário labex, que tem sudo sem senha, você não será realmente solicitado a inserir uma senha. No entanto, em um ambiente de produção onde o sudo sem senha não está configurado, o Ansible solicitará que você insira a senha sudo.

Para simular este cenário com nosso usuário de teste, você pode executar o seguinte comando (embora não funcione totalmente neste ambiente de laboratório devido à falta de configuração SSH):

ansible-playbook -i inventory sudo_password_playbook.yml -u ansible_test -K

Quando solicitado a senha BECOME, você deve inserir ansible123.

Especificando a Senha Sudo em uma Variável Ansible

Em vez de inserir a senha interativamente, você pode fornecer a senha sudo como uma variável ao executar o playbook:

ansible-playbook -i inventory sudo_password_playbook.yml -e "ansible_become_password=ansible123"

Essa abordagem é útil para scripts automatizados onde a entrada interativa não é possível. No entanto, ela expõe a senha no histórico da linha de comando, o que é um risco de segurança. Em um ambiente de produção, você deve usar o Ansible Vault para armazenar informações confidenciais com segurança.

Usando o Ansible Vault para Gerenciamento Seguro de Senhas

Na etapa anterior, exploramos diferentes maneiras de fornecer senhas sudo aos playbooks do Ansible. No entanto, armazenar senhas em arquivos de texto simples ou passá-las na linha de comando não é seguro. Nesta etapa, aprenderemos como usar o Ansible Vault para gerenciar com segurança informações confidenciais, como senhas sudo.

O que é o Ansible Vault?

O Ansible Vault é um recurso que permite criptografar dados confidenciais, como senhas, chaves de API ou certificados. Os arquivos criptografados podem ser armazenados com segurança em sistemas de controle de versão sem expor as informações confidenciais. O Ansible pode descriptografar automaticamente esses arquivos durante a execução do playbook.

Criando um Arquivo Vault Criptografado

Vamos criar um arquivo criptografado para armazenar nossa senha sudo:

cd ~/project/ansible-sudo-lab
ansible-vault create vault.yml

Você será solicitado a criar uma nova senha do vault. Insira vaultpassword123 e confirme-a.

Após definir a senha do vault, um editor será aberto. Insira o seguinte conteúdo no editor:

---
vault_sudo_password: ansible123

Salve o arquivo e saia do editor.

Agora, se você tentar visualizar o conteúdo do arquivo vault, verá que ele está criptografado:

cat vault.yml

Você deve ver uma saída semelhante a:

$ANSIBLE_VAULT;1.1;AES256
32623438613466396238613731623338376461653866353031313632316237613561393639613131
3562626166616332386265373761653835356134613561380a363761333362323238663136633439
32343032333832313562353261333530666639643239303436643363393630643639316232303564
3962356162356361370a313038333432353162333462323035323262396233333039326535356662
31363539613432656362326565613232336535393232653939323466323131393362

Usando Variáveis Vault em um Playbook

Agora, vamos criar um playbook que usa a senha sudo criptografada. Crie um novo arquivo chamado secure_sudo_playbook.yml:

---
- name: Playbook with secure sudo password
  hosts: localhost
  become: true
  become_password: "{{ vault_sudo_password }}"
  vars_files:
    - vault.yml

  tasks:
    - name: Get sudo user
      command: whoami
      register: sudo_user

    - name: Print sudo user
      debug:
        msg: "Running as {{ sudo_user.stdout }}"

    - name: Check sudo access
      command: apt update
      register: apt_result
      failed_when: false

    - name: Print result
      debug:
        msg: "Sudo access successful: {{ apt_result.rc == 0 }}"

Salve este arquivo como ~/project/ansible-sudo-lab/secure_sudo_playbook.yml

Executando um Playbook com Vault

Ao executar um playbook que inclui um arquivo vault criptografado, você precisa fornecer a senha do vault. Existem várias maneiras de fazer isso:

Usando a opção --ask-vault-pass:

ansible-playbook -i inventory secure_sudo_playbook.yml --ask-vault-pass

Quando solicitado, insira a senha do vault: vaultpassword123

Usando um arquivo de senha do vault:

Primeiro, crie um arquivo contendo a senha do vault:

echo "vaultpassword123" > vault_password_file
chmod 600 vault_password_file

Em seguida, execute o playbook com o arquivo de senha:

ansible-playbook -i inventory secure_sudo_playbook.yml --vault-password-file vault_password_file

Você deve ver uma saída semelhante a:

PLAY [Playbook with secure sudo password] ***************************

TASK [Gathering Facts] **********************************************
ok: [localhost]

TASK [Get sudo user] ***********************************************
changed: [localhost]

TASK [Print sudo user] *********************************************
ok: [localhost] => {
    "msg": "Running as root"
}

TASK [Check sudo access] *******************************************
changed: [localhost]

TASK [Print result] ************************************************
ok: [localhost] => {
    "msg": "Sudo access successful: True"
}

PLAY RECAP *********************************************************
localhost                  : ok=5    changed=2    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0

Melhores Práticas para Gerenciamento de Senhas Sudo

Aqui estão algumas práticas recomendadas a serem seguidas ao gerenciar senhas sudo no Ansible:

Sempre use o Ansible Vault para criptografar informações confidenciais
Nunca armazene senhas do vault no controle de versão
Use um método seguro para distribuir senhas do vault (por exemplo, gerenciador de senhas)
Considere usar um ID do vault para diferentes ambientes (dev, staging, produção)
Altere as senhas do vault regularmente

Em um ambiente de produção, você também pode considerar o uso de uma ferramenta como o HashiCorp Vault ou o AWS Secrets Manager para um gerenciamento de segredos ainda mais seguro.

Solucionando Problemas Comuns de Senhas Sudo

Mesmo com a configuração adequada, você pode encontrar problemas com senhas sudo no Ansible. Nesta etapa, exploraremos problemas comuns e suas soluções.

Problemas Comuns de Senhas Sudo

Aqui estão alguns problemas comuns que você pode encontrar ao usar sudo com Ansible:

Senha sudo ausente: O Ansible não consegue encontrar a senha sudo para executar comandos privilegiados.
Senha sudo incorreta: A senha sudo fornecida está incorreta.
Problemas de configuração do sudo: O usuário de destino não tem as permissões sudo corretas.
Sudo requer um TTY: Alguns sistemas exigem que um TTY seja alocado para comandos sudo.

Vamos explorar cada um desses problemas e suas soluções.

Criando um Ambiente Problemático para Teste

Para entender melhor esses problemas, vamos criar um cenário em que o sudo requer um TTY. Edite o arquivo sudoers para nosso usuário de teste:

sudo cp /etc/sudoers.d/ansible_test /etc/sudoers.d/ansible_test.bak
echo 'Defaults:ansible_test requiretty' | sudo tee -a /etc/sudoers.d/ansible_test

Esta configuração faz com que o sudo exija um TTY quando o usuário ansible_test executa comandos sudo, o que pode causar problemas com o Ansible.

Criando um Playbook de Solução de Problemas

Crie um novo playbook chamado troubleshoot_sudo.yml que inclui algumas técnicas comuns de solução de problemas de sudo:

---
- name: Troubleshoot sudo issues
  hosts: localhost
  become: true
  become_method: sudo
  ## We'll provide the become_password when running the playbook

  tasks:
    - name: Check sudo version
      command: sudo --version
      register: sudo_version
      become: false

    - name: Print sudo version
      debug:
        msg: "{{ sudo_version.stdout_lines[0] }}"
      become: false

    - name: Check sudo configuration
      command: sudo -l
      register: sudo_config
      become: false
      failed_when: false

    - name: Print sudo configuration
      debug:
        msg: "{{ sudo_config.stdout_lines }}"
      become: false
      when: sudo_config.rc == 0

    - name: Test sudo command with pty
      command: apt update
      register: sudo_test
      failed_when: false
      vars:
        ansible_become_flags: "-H"

    - name: Print sudo test result
      debug:
        msg: "Sudo command {{ 'succeeded' if sudo_test.rc == 0 else 'failed' }}"

Salve este arquivo como ~/project/ansible-sudo-lab/troubleshoot_sudo.yml

Executando o Playbook de Solução de Problemas

Execute o playbook de solução de problemas:

ansible-playbook -i inventory troubleshoot_sudo.yml -K

Como estamos executando como o usuário labex, que tem sudo sem senha, o playbook deve ser executado com sucesso.

Soluções Comuns para Problemas de Senha Sudo

Aqui estão soluções para problemas comuns de senha sudo:

1. Senha sudo ausente

Se o Ansible falhar com uma mensagem como "Missing sudo password", você pode:

Usar a opção -K para solicitar a senha sudo
Definir a variável ansible_become_password em seu inventário ou playbook
Usar o Ansible Vault para armazenar e fornecer com segurança a senha sudo

2. Senha sudo incorreta

Se a senha sudo estiver incorreta:

Verifique novamente a senha que você está fornecendo
Verifique se a senha do usuário não expirou ou foi alterada
Verifique se a configuração do sudo foi alterada no sistema de destino

3. Problemas de configuração do sudo

Se o usuário não tiver as permissões sudo corretas:

Verifique o arquivo sudoers no sistema de destino
Verifique se o usuário está nos grupos corretos
Use sudo -l para verificar os privilégios sudo do usuário

4. Sudo requer um TTY

Se o sudo exigir um TTY:

Adicione ansible_become_flags: "-H" ao seu playbook ou inventário
Modifique o arquivo sudoers para remover a opção requiretty
Use a opção pty: true em suas tarefas

Restaurar a Configuração Original do Sudo

Vamos restaurar a configuração original do sudo para nosso usuário de teste:

sudo cp /etc/sudoers.d/ansible_test.bak /etc/sudoers.d/ansible_test
sudo rm /etc/sudoers.d/ansible_test.bak

Isso remove a opção requiretty que adicionamos anteriormente.

Resumo

Neste laboratório, você aprendeu a lidar com senhas sudo em playbooks do Ansible, um desafio comum para muitos administradores e engenheiros de DevOps. Aqui está um resumo do que você realizou:

Você instalou o Ansible e criou um playbook básico que usa privilégios sudo
Você aprendeu diferentes métodos para fornecer senhas sudo aos playbooks do Ansible
Você usou o Ansible Vault para armazenar e gerenciar com segurança informações confidenciais
Você explorou problemas comuns de senha sudo e aprendeu a solucioná-los

Essas habilidades o ajudarão a criar playbooks do Ansible mais seguros e confiáveis, capazes de lidar com várias configurações sudo em diferentes ambientes.

Principais conclusões deste laboratório:

Sempre use métodos seguros como o Ansible Vault para armazenar informações confidenciais
Compreenda as diferentes maneiras de fornecer senhas sudo ao Ansible
Saiba como solucionar problemas comuns de senha sudo
Siga as melhores práticas para o gerenciamento de senhas sudo no Ansible

Com essas habilidades, você pode agora usar o Ansible com confiança para tarefas que exigem privilégios elevados, garantindo que sua automação seja executada de forma suave e segura.

Resolvendo Problemas de Senha Sudo Ausente no Ansible