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.
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
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
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:
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.
Übertragen Sie den Schlüssel vorübergehend und verwenden Sie das
ssh_optsGit-Moduloption zur Verwendung des öffentlichen Schlüssels des Bereitstellungsbenutzers.
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 }}"