it-swarm.com.de

Ansible copy ssh key von einem Host zu einem anderen

Ich habe 2 App-Server mit einem Loadbalancer vor sich und 1 Datenbankserver in meinem System. Ich versorge sie mit Ansible. Für App-Server ist Nginx + Passenger und eine Rails-App verfügbar. Verwendet Capistrano für die Bereitstellung, aber ich habe ein Problem mit den SSH-Schlüsseln. Mein Git-Repo befindet sich auf einem anderen Server, und ich muss öffentliche SSH-Schlüssel auf Appservern generieren und sie dem Git-Server hinzufügen (To authorised_keys-Datei). Wie kann ich dies in einem Spielbuch tun? 

PS: Ich habe möglicherweise mehr als 2 App-Server.

enter image description here

40
beydogan

Schauen Sie sich das Modul authorised_key an , um Informationen zur Verwaltung Ihrer öffentlichen Schlüssel zu erhalten.

Die einfachste Lösung, die ich mir vorstellen kann, wäre, ein neues Schlüsselpaar für Ihre Anwendung zu generieren, das von allen Anwendungsinstanzen gemeinsam genutzt werden kann. Dies kann Auswirkungen auf die Sicherheit haben (Sie teilen tatsächlich Schlüssel zwischen allen Instanzen!), Aber es vereinfacht den Bereitstellungsprozess erheblich.

Sie benötigen außerdem einen Bereitstellungsbenutzer auf jeder App-Maschine, der später während des Bereitstellungsprozesses verwendet werden soll. Sie benötigen Ihren öffentlichen Schlüssel (oder den jenkins-Schlüssel) für jeden authorized_keys des Implementierungsbenutzers.

Ein Skizzen-Spielbuch:

---
- 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

Dies macht den Trick für mich, es sammelt die öffentlichen SSH-Schlüssel auf den Knoten und verteilt sie auf alle Knoten. Auf diese Weise können sie miteinander kommunizieren.

- 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: Dies ist für den Benutzer root

26
Jonas Libbrecht

Ich würde einen Bereitstellungsbenutzer erstellen, der nur Zugriff auf Ihre Repos hat. Sie können dies entweder über http zulassen oder es gibt einige Optionen, um dies über ssh durchzuführen.

Wenn Sie den Benutzer nicht auf den schreibgeschützten Zugriff auf Ihr Repo beschränken möchten, können Sie einen normalen SSH-Benutzer erstellen. Sobald der Benutzer erstellt ist, können Sie mit Ansible den öffentlichen Schlüssel des Benutzers zur Datei mit dem autorisierten Schlüssel auf dem Git-Server hinzufügen. Sie können das Modul für autorisierte Schlüssel verwenden .

Sobald dies eingerichtet ist, haben Sie zwei Möglichkeiten:

  1. Wenn Sie ssh verwenden, verwenden Sie die ssh-Schlüsselweiterleitung, damit der Benutzer, mit dem die Ansible-Aufgabe ausgeführt wird, seinen öffentlichen Schlüssel an den dev-Server sendet.

  2. Übertragen Sie den Schlüssel vorübergehend und verwenden Sie das ssh_optsGit-Moduloption zur Verwendung des öffentlichen Schlüssels des Bereitstellungsbenutzers.

1
jarv

Ich habe eine parametrisierte Rolle erstellt, um sicherzustellen, dass das ssh-Schlüsselpaar in einem Quellbenutzer in einem externen Quellhost generiert und dessen öffentlicher Schlüssel in einen Zielbenutzer in einem entfernten Zielhost kopiert wird.

Sie können diese Rolle in einer verschachtelten Schleife aus Quellen- und Zielhostlisten aufrufen, wie unten gezeigt:

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

Rolle in einer Schleife aufrufen:

- 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