specify - Ansible copy ssh key de un host a otro

ssh-copy-id ubuntu

Question

Tengo 2 servidores de aplicaciones con un loadbalancer frente a ellos y 1 servidor de base de datos en mi sistema. Los estoy aprovisionando usando Ansible. Los servidores de aplicaciones tienen Nginx + Passenger y se están ejecutando para una aplicación de Rails. Utilizaré capistrano para la implementación pero tengo un problema con las claves ssh. Mi git repo está en otro servidor y tengo que generar ssh public keys en los servidores de aplicaciones y agregarlos al servidor de Git (a archivo authorized_keys). ¿Cómo puedo hacer esto en el libro de jugadas ansible?

PD: puedo tener más de 2 servidores de aplicaciones.

Answer 1

Creé una función parametrizada para asegurarme de que el par de claves ssh se genera en un usuario fuente en un host remoto fuente y su clave pública copiada a un usuario objetivo en un host remoto objetivo.

Puede invocar ese rol en un bucle anidado de listas de host de origen y destino como se muestra en la parte inferior:

---
#****h* ansible/ansible_roles_ssh_authorize_user
# NAME
#   ansible_roles_ssh_authorize_user - Authorizes user via ssh keys
#
# FUNCTION
#
#   Copies user''s SSH public key from a source user in a source host
#   to a target user in a target host
#
# INPUTS
#
#   * ssh_authorize_user_source_user
#   * ssh_authorize_user_source_host
#   * ssh_authorize_user_target_user
#   * ssh_authorize_user_target_host
#****
#****h* ansible_roles_ssh_authorize_user/main.yml
# NAME
#   main.yml - Main playbook for role ssh_authorize_user
# HISTORY
#   $Id: $
#****

- assert:
    that:
      - ssh_authorize_user_source_user != ''''
      - ssh_authorize_user_source_host != ''''
      - ssh_authorize_user_target_user != ''''
      - ssh_authorize_user_target_host != ''''
  tags:
    - check_vars
- name: Generate SSH Keypair in Source
  user:
    name: "{{ ssh_authorize_user_source_user }}"
    state: present
    ssh_key_comment: "ansible-generated for {{ ssh_authorize_user_source_user }}@{{ ssh_authorize_user_source_host }}"
    generate_ssh_key: yes
  delegate_to: "{{ ssh_authorize_user_source_host }}"
  register: source_user
- name: Install SSH Public Key in Target
  authorized_key:
    user: "{{ ssh_authorize_user_target_user }}"
    key: "{{ source_user.ssh_public_key }}"
  delegate_to: "{{ ssh_authorize_user_target_host }}"
- debug:
    msg: "{{ ssh_authorize_user_source_user }}@{{ ssh_authorize_user_source_host }} authorized to log in to {{ ssh_authorize_user_target_user }}@{{ ssh_authorize_user_target_host }}"

Invocando rol en un bucle:

- name: Authorize User
  include_role:
    name: ssh_authorize_user
  vars:
    ssh_authorize_user_source_user: "{{ git_user }}"
    ssh_authorize_user_source_host: "{{ item[0] }}"
    ssh_authorize_user_target_user: "{{ git_user }}"
    ssh_authorize_user_target_host: "{{ item[1] }}"
  with_nested:
    - "{{ app_server_list }}"
    - "{{ git_server_list }}"

Answer 2

Crearía un usuario de implementación que está restringido para obtener acceso a sus repositorios. Puede permitir esto a través de http o hay algunas opciones para hacerlo a través de ssh .

Si no le importa limitar al usuario al acceso de solo lectura a su repositorio, puede crear un usuario ssh normal. Una vez que se crea el usuario, puede usar Ansible para agregar la clave pública del usuario al archivo de clave autorizado en el servidor de git. Puede usar el módulo de clave autorizado .

Una vez que está configurado, tienes dos opciones:

1. Si usa ssh use el reenvío de la clave ssh para que el usuario que se utiliza para ejecutar la tarea Ansible envíe su clave pública al servidor de desarrollo.

2. Transfiera temporalmente la clave y use la opción del módulo ssh_opts git para usar la clave pública de despliegue del usuario.

Answer 3

Eche un vistazo al módulo authorized_key para obtener información sobre cómo administrar sus claves públicas.

La solución más directa que puedo pensar sería generar un nuevo par de claves para su aplicación, que se compartirá entre todas las instancias de su aplicación. Esto puede tener implicaciones de seguridad (de hecho, ¡está compartiendo claves entre todas las instancias!), Pero simplificará mucho el proceso de aprovisionamiento.

También necesitará un usuario de implementación en cada máquina de aplicaciones, que se utilizará más adelante durante el proceso de implementación. Necesitará su clave pública (o jenkins one) en cada implementación de las authorized_keys del usuario.

Un cuaderno de bosquejos:

---
- name: ensure app/deploy public key is present on git server
  hosts: gitserver
  tasks:
    - name: ensure app public key
      authorized_key: 
        user: "{{ git_user }}" 
        key: app_keys/id_dsa.pub 
        state: present

- name: provision app servers
  hosts: appservers
  tasks:
    - name: ensure app/deploy user is present
      user: 
        name: "{{ deploy_user }}"
        state: present

    - name: ensure you''ll be able to deploy later on
      authorized_key:
        user: "{{ deploy_user }}" 
        key: "{{ path_to_your_public_key }}" 
        state: present

    - name: ensure private key and public one are present
      copy: 
        src: keys/myapp.private 
        dest: "/home/{{ deploy_user }}/.ssh/{{ item }}" 
        mode: 0600
      with_items:
        - app_keys/id_dsa.pub
        - app_keys/id_dsa

Answer 4

Esto me funciona, recoge las claves públicas ssh en los nodos y las distribuye en todos los nodos. De esta forma, pueden comunicarse entre ellos.

- hosts: controllers
  gather_facts: false
  remote_user: root
  tasks:
    - name: fetch all public ssh keys
      shell: cat ~/.ssh/id_rsa.pub
      register: ssh_keys
      tags:
        - ssh

    - name: check keys
      debug: msg="{{ ssh_keys.stdout }}"
      tags:
        - ssh

    - name: deploy keys on all servers
      authorized_key: user=root key="{{ item[0] }}"
      delegate_to: "{{ item[1] }}"
      with_nested:
        - "{{ ssh_keys.stdout }}"
        - "{{groups[''controllers'']}}"
      tags:
        - ssh

Información: esto es para la root usuario