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