web-dev-qa-db-fra.com

Copier la clé ssh d'un hôte à un autre

J'ai 2 serveurs d'applications avec un loadbalancer devant eux et 1 serveur de base de données dans mon système. Je les approvisionne en utilisant Ansible. Les serveurs d'applications ont Nginx + Passenger et fonctionnent pour une application Rails. Capistrano sera utilisé pour le déploiement, mais j’ai un problème avec les clés ssh. Mon repo git se trouve sur un autre serveur et je dois générer des clés publiques ssh sur des serveurs d'applications et les ajouter au serveur Git (fichier ToOH). Comment puis-je faire cela dans Ansible Playbook? 

PS: je peux avoir plus de 2 serveurs d'applications.

enter image description here

sshansiblecapistrano3ansible-playbook
40
beydogan

Jetez un coup d’œil au module registered_key_key pour obtenir des informations sur la gestion de vos clés publiques.

La solution la plus simple à laquelle je puisse penser serait de générer une nouvelle paire de clés pour votre application, à partager entre toutes vos instances d'application. Cela peut avoir des implications sur la sécurité (vous partagez en effet des clés entre toutes les instances!), Mais cela simplifiera beaucoup le processus de provisioning.

Vous aurez également besoin d'un utilisateur de déploiement sur chaque machine d'application, qui sera utilisé ultérieurement au cours du processus de déploiement. Vous aurez besoin de votre clé publique (ou de celle de Jenkins) sur le authorized_keys de chaque utilisateur déployé.

Un carnet de croquis:

---
- 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
28
el.atomo

Cela fait l'affaire pour moi, il collecte les clés publiques ssh sur les nœuds et les distribue sur tous les nœuds. De cette façon, ils peuvent communiquer entre eux.

- 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

Info: Ceci est pour l'utilisateur root

26
Jonas Libbrecht

Je créerais un utilisateur de déploiement qui est limité à l'accès à votre dépôt. Vous pouvez autoriser cela via http ou il existe quelques options pour le faire sur ssh . 

Si vous ne vous souciez pas de limiter l'utilisateur à un accès en lecture seule à votre référentiel, vous pouvez créer un utilisateur ssh normal. Une fois que l'utilisateur est créé, vous pouvez utiliser Ansible pour ajouter sa clé publique au fichier de clé autorisé sur le serveur git. Vous pouvez également utiliser le module clé autorisée .

Une fois que cela est installé, vous avez deux options:

  1. Si vous utilisez ssh, utilisez le transfert de clé ssh pour que l'utilisateur utilisé pour exécuter la tâche Ansible envoie sa clé publique au serveur dev.

  2. Transférez temporairement la clé et utilisez l'option ssh_optsgit pour utiliser la clé publique de l'utilisateur déployé.

1
jarv

J'ai créé un rôle paramétré pour m'assurer que la paire de clés ssh est générée dans un utilisateur source d'un hôte distant source et que sa clé publique est copiée sur un utilisateur cible d'un hôte distant cible.

Vous pouvez appeler ce rôle dans une boucle imbriquée de listes d'hôtes source et cible, comme indiqué en bas:

---
#****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 }}"

Invocation d'un rôle dans une boucle:

- 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 }}"
0
Nicholas Sushkin