Como definir o usuário SSH padrão para conexões Ansible

Introdução

Ansible é uma ferramenta de automação poderosa que simplifica o gerenciamento de servidores remotos. Um aspecto crucial do Ansible é a capacidade de estabelecer conexões SSH seguras com esses servidores. Neste tutorial, exploraremos como definir o usuário SSH padrão para as conexões Ansible, garantindo um fluxo de trabalho suave e eficiente para suas tarefas de gerenciamento de servidores.

Instalando e Configurando o Ansible

Antes de configurar o usuário SSH para o Ansible, precisamos garantir que o Ansible esteja devidamente instalado e configurado em nosso sistema.

Instalando o Ansible

Vamos começar instalando o Ansible. 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, verificando sua versão:

ansible --version

Você deve ver uma saída semelhante à seguinte:

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, x86_64)
  jinja version = 3.0.3
  libyaml = True

Criando um Diretório de Trabalho do Ansible

Em seguida, vamos criar uma estrutura de diretórios para nosso projeto Ansible. Isso nos ajudará a manter nossos arquivos organizados:

mkdir -p ~/project/ansible/inventory
cd ~/project/ansible

Criando um Arquivo de Inventário Básico

O Ansible usa arquivos de inventário para definir os hosts que ele gerencia. Vamos criar um arquivo de inventário simples:

echo "[webservers]
localhost ansible_connection=local" > ~/project/ansible/inventory/hosts

Este arquivo de inventário define um grupo chamado webservers com apenas um host, localhost, e diz ao Ansible para usar uma conexão local em vez de SSH para este host.

Agora, vamos verificar nosso inventário:

ansible -i inventory/hosts --list-hosts all

Você deve ver uma saída como:

  hosts (1):
    localhost

Isso mostra que o Ansible reconhece nosso inventário e os hosts definidos nele.

Compreendendo as Conexões e Configurações SSH do Ansible

O Ansible usa principalmente SSH para se conectar a hosts remotos e executar comandos. Vamos explorar como o Ansible estabelece conexões SSH e como podemos configurar o usuário SSH padrão.

Como o Ansible Usa SSH

Por padrão, o Ansible tenta usar o usuário atual do seu sistema para estabelecer conexões SSH. Isso significa que, se você estiver logado como o usuário labex e executar um comando Ansible, o Ansible tentará se conectar aos hosts remotos como o usuário labex.

Este comportamento padrão pode nem sempre ser o que você deseja. Por exemplo:

• O servidor remoto pode exigir um usuário diferente para acesso
• Você pode querer usar um usuário dedicado para tarefas de automação
• Servidores diferentes podem exigir usuários diferentes

Hierarquia de Configuração do Ansible

O Ansible usa uma hierarquia de fontes de configuração para determinar qual usuário SSH usar:

1. Opções de linha de comando (prioridade mais alta)
2. Opções específicas da tarefa em playbooks
3. Variáveis de host e grupo no inventário
4. Arquivo de configuração do Ansible
5. Valores padrão (prioridade mais baixa)

Vamos criar um arquivo de configuração básico do Ansible para entender melhor isso:

cat > ~/project/ansible/ansible.cfg << 'EOF'
[defaults]
inventory = ./inventory/hosts
host_key_checking = False
EOF

Este arquivo de configuração diz ao Ansible para:

• Usar nosso arquivo de inventário por padrão
• Desativar a verificação da chave do host (útil para testes em ambientes de laboratório)

Vamos revisar o arquivo que acabamos de criar:

cat ~/project/ansible/ansible.cfg

Você deve ver o conteúdo que acabamos de adicionar ao arquivo.

Testando um Comando Ansible Básico

Agora, vamos executar um comando Ansible básico para ver o usuário atual:

cd ~/project/ansible
ansible localhost -m command -a "whoami"

A saída deve mostrar:

localhost | CHANGED | rc=0 >>
labex

Isso confirma que o Ansible está executando comandos como o usuário atual (labex).

Definindo o Usuário SSH Padrão para o Ansible

Agora que entendemos como o Ansible usa SSH, vamos explorar diferentes maneiras de definir o usuário SSH padrão para nossas conexões.

Método 1: Usando o Arquivo de Configuração do Ansible

A maneira mais simples de definir um usuário SSH padrão global é através do arquivo de configuração do Ansible. Vamos modificar nosso arquivo ansible.cfg:

cat > ~/project/ansible/ansible.cfg << 'EOF'
[defaults]
inventory = ./inventory/hosts
host_key_checking = False
remote_user = ansible_user
EOF

Nesta configuração, adicionamos o parâmetro remote_user, que diz ao Ansible para usar ansible_user como o usuário SSH padrão para todas as conexões.

Método 2: Definindo o Usuário no Arquivo de Inventário

Outra abordagem é definir o usuário SSH no arquivo de inventário. Este método permite que você defina usuários diferentes para hosts ou grupos diferentes.

Vamos modificar nosso arquivo de inventário:

cat > ~/project/ansible/inventory/hosts << 'EOF'
[webservers]
localhost ansible_connection=local

[dbservers]
db.example.com ansible_user=db_admin

[all:vars]
ansible_user=default_user
EOF

Neste exemplo:

• Adicionamos um novo grupo chamado dbservers com um host db.example.com e especificamos que o Ansible deve usar o usuário db_admin ao se conectar a este host.
• Também adicionamos uma variável de grupo ansible_user=default_user que se aplica a todos os hosts, a menos que seja substituída.

Método 3: Usando Opções de Linha de Comando

Você também pode especificar o usuário SSH diretamente na linha de comando ao executar comandos Ansible:

ansible localhost -m command -a "whoami" -u specific_user

A opção -u diz ao Ansible para usar specific_user para este comando específico, substituindo qualquer usuário definido em arquivos de configuração ou inventário.

Método 4: Definindo o Usuário em Playbooks

Ao usar playbooks do Ansible, você pode especificar o usuário SSH no nível do play:

Vamos criar um playbook simples para demonstrar isso:

cat > ~/project/ansible/user_demo.yml << 'EOF'
---
- name: Demonstrate user configuration
  hosts: localhost
  remote_user: playbook_user
  
  tasks:
    - name: Show current user
      command: whoami
      register: current_user
      
    - name: Display current user
      debug:
        msg: "Current user is {{ current_user.stdout }}"
EOF

Neste playbook, o parâmetro remote_user define o usuário SSH como playbook_user para todas as tarefas neste play.

Precedência do Usuário no Ansible

Compreender a precedência desses diferentes métodos é importante:

1. Opções de linha de comando (flag -u) têm a prioridade mais alta
2. Configurações no nível da tarefa em playbooks
3. Configurações no nível do play em playbooks
4. Variáveis de host no inventário
5. Variáveis de grupo no inventário
6. Configurações do arquivo de configuração (remote_user em ansible.cfg)
7. Usuário padrão do sistema (prioridade mais baixa)

Isso significa que configurações de usuário mais específicas substituem as mais gerais.

Testando e Verificando a Configuração do Usuário SSH

Agora que configuramos o usuário SSH padrão de diferentes maneiras, vamos testar e verificar nossa configuração.

Testando a Configuração do Arquivo de Configuração

Primeiro, vamos executar um comando Ansible simples para ver se as configurações do nosso arquivo de configuração são aplicadas:

cd ~/project/ansible
ansible localhost -m command -a "whoami"

Como estamos nos conectando ao localhost com ansible_connection=local, o Ansible ainda executará comandos como o usuário atual, independentemente da configuração remote_user. No entanto, se esta fosse uma conexão remota, o Ansible tentaria usar o usuário ansible_user que especificamos na configuração.

Usando ansible-inventory para Verificar as Configurações do Usuário

O Ansible fornece um comando chamado ansible-inventory que nos permite ver como o Ansible interpreta nosso inventário, incluindo as configurações do usuário SSH:

ansible-inventory --list

Este comando gera uma representação JSON do inventário, mostrando todas as variáveis associadas a cada host, incluindo as configurações do usuário SSH.

Testando as Configurações do Usuário com um Playbook

Vamos executar o playbook que criamos na etapa anterior:

ansible-playbook user_demo.yml

A saída mostrará algo como:

PLAY [Demonstrate user configuration] ******************************************

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

TASK [Show current user] *******************************************************
changed: [localhost]

TASK [Display current user] ****************************************************
ok: [localhost] => {
    "msg": "Current user is labex"
}

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

A saída mostra que o comando ainda é executado como o usuário labex, o que é esperado porque estamos nos conectando ao localhost com ansible_connection=local.

Criando um Exemplo de Configuração de Usuário SSH Real

Vamos criar um exemplo mais realista que demonstra como configurar a configuração do usuário SSH para hosts remotos. Criaremos um novo playbook:

cat > ~/project/ansible/remote_user_example.yml << 'EOF'
---
- name: Example of remote user configuration
  hosts: all
  remote_user: admin_user
  
  tasks:
    - name: This task uses the play-level user (admin_user)
      debug:
        msg: "This would run as admin_user"
      
    - name: This task uses a specific user
      debug:
        msg: "This would run as operator_user"
      remote_user: operator_user
      
    - name: This task uses become to elevate privileges
      debug:
        msg: "This would run as the root user"
      become: true
      become_user: root
EOF

Neste playbook:

• Definimos remote_user: admin_user no nível do play, que se aplica a todas as tarefas por padrão
• A segunda tarefa substitui isso com remote_user: operator_user
• A terceira tarefa usa become: true para elevar os privilégios ao usuário root

Este exemplo mostra os diferentes níveis em que você pode configurar o usuário SSH no Ansible.

Configuração Avançada do Usuário SSH e Solução de Problemas

Agora que abordamos os conceitos básicos de como definir o usuário SSH padrão para o Ansible, vamos explorar algumas técnicas avançadas e etapas de solução de problemas.

Usando Chaves SSH com Ansible

Ao se conectar a hosts remotos, é uma boa prática usar a autenticação por chave SSH em vez de senhas. Vamos ver como configurar a autenticação por chave SSH no Ansible:

cat > ~/project/ansible/ssh_key_example.yml << 'EOF'
---
- name: Example using SSH key authentication
  hosts: all
  remote_user: secure_user
  vars:
    ansible_ssh_private_key_file: ~/.ssh/id_rsa
  
  tasks:
    - name: Show SSH connection details
      debug:
        msg: "Connecting as {{ ansible_user }} using key {{ ansible_ssh_private_key_file }}"
EOF

Neste exemplo:

• Definimos remote_user: secure_user como o usuário SSH padrão
• Especificamos o arquivo de chave privada SSH a ser usado com ansible_ssh_private_key_file

Definindo Usuários Diferentes para Diferentes Ambientes

Em cenários do mundo real, você pode querer usar usuários SSH diferentes para diferentes ambientes (desenvolvimento, staging, produção). Vamos ver como conseguir isso:

mkdir -p ~/project/ansible/group_vars

Agora, vamos criar arquivos de variáveis de grupo para diferentes ambientes:

cat > ~/project/ansible/group_vars/development << 'EOF'
---
ansible_user: dev_user
EOF

cat > ~/project/ansible/group_vars/production << 'EOF'
---
ansible_user: prod_user
ansible_ssh_private_key_file: ~/.ssh/prod_key
EOF

Atualize o arquivo de inventário para incluir esses grupos de ambiente:

cat > ~/project/ansible/inventory/hosts << 'EOF'
[webservers]
localhost ansible_connection=local

[development]
dev.example.com

[production]
prod1.example.com
prod2.example.com

[all:vars]
ansible_user=default_user
EOF

Com esta configuração:

• Hosts no grupo development usarão o usuário SSH dev_user
• Hosts no grupo production usarão o usuário SSH prod_user e uma chave SSH específica
• Todos os outros hosts usarão o usuário SSH default_user

Solução de Problemas de Configuração do Usuário SSH

Se você encontrar problemas com a configuração do usuário SSH no Ansible, aqui estão algumas etapas de solução de problemas:

1. Verifique o inventário interpretado pelo Ansible

Para ver como o Ansible interpreta seu inventário, incluindo todos os valores das variáveis:

ansible-inventory --list

2. Execute o Ansible com verbosidade

Executar o Ansible com verbosidade aumentada pode ajudar a identificar problemas de conexão:

ansible localhost -m ping -vvv

A flag -vvv aumenta o nível de verbosidade, mostrando informações detalhadas sobre o processo de conexão SSH.

3. Teste a conexão SSH manualmente

Você pode testar a conexão SSH manualmente para verificar se o usuário e a chave estão funcionando:

ssh -i ~/.ssh/id_rsa username@hostname

4. Verifique se há erros de conexão SSH

Erros comuns de conexão SSH incluem:

• Permissão negada (chave pública) (Permission denied (publickey)): Isso indica um problema com a autenticação por chave SSH
• Falha na verificação da chave do host (Host key verification failed): Isso ocorre quando a chave do host foi alterada
• Conexão recusada (Connection refused): Isso indica que o serviço SSH não está em execução ou está bloqueado por um firewall

5. Crie um playbook de teste de configuração do Ansible

Vamos criar um playbook simples para testar nossa configuração do usuário SSH:

cat > ~/project/ansible/test_ssh_config.yml << 'EOF'
---
- name: Test SSH user configuration
  hosts: all
  gather_facts: no
  
  tasks:
    - name: Display connection information
      debug:
        msg: |
          Connected to: {{ inventory_hostname }}
          User: {{ ansible_user | default('not set') }}
          SSH Key: {{ ansible_ssh_private_key_file | default('not set') }}
EOF

Execute este playbook para ver as informações de conexão para cada host:

ansible-playbook -i inventory/hosts test_ssh_config.yml

Este playbook mostrará o usuário SSH e a chave que o Ansible está usando para cada host, o que pode ajudar a identificar problemas de configuração.

Resumo

Neste laboratório, você aprendeu como configurar o usuário SSH padrão para conexões Ansible usando vários métodos. Agora você entende como:

1. Instalar e configurar o Ansible com uma configuração básica
2. Configurar o usuário SSH padrão através do arquivo de configuração do Ansible
3. Definir usuários SSH em diferentes níveis: inventário, playbook e linha de comando
4. Verificar e testar sua configuração de usuário SSH
5. Solucionar problemas comuns de conexão SSH

Essas habilidades permitirão que você gerencie sua infraestrutura de forma mais eficaz com o Ansible, garantindo conexões seguras e confiáveis ​​aos seus servidores remotos. Ao configurar corretamente o usuário SSH para suas conexões Ansible, você pode implementar fluxos de trabalho de automação consistentes em diferentes ambientes, mantendo as práticas de segurança apropriadas.