Possibilité de copier la clé ssh d'un hôte à un autre
j'ai 2 serveurs d'application avec un loadbalancer en face d'eux et 1 serveur de base de données dans mon système. Je les alimente en utilisant Ansible. Les serveurs App ont Nginx + Passenger et fonctionnent pour une application Rails. Je vais utiliser capistrano pour le déploiement, mais j'ai un problème avec les clés SSH. Mon git repo se trouve dans un autre serveur et je dois générer des clés publiques ssh sur les serveurs appservers et les ajouter au serveur Git(au fichier authorized_keys). Comment puis-je faire cela dans un manuel accessible?
PS: j'en ai peut-être plus que 2 serveurs app.
4 réponses
jetez un coup d'oeil à la authorized_key module pour obtenir des informations sur la façon de gérer 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 dans toutes vos instances app. cela peut avoir des implications en matière de sécurité (vous partagez en effet des clés entre toutes les instances!), mais cela simplifiera beaucoup le processus de provisionnement.
vous aurez également besoin d'un utilisateur deploy sur chaque machine app, à utiliser ultérieurement pendant le processus de déploiement. Vous aurez besoin de votre clé publique (ou celle de jenkins) sur chaque utilisateur de deploy authorized_keys.
Une esquisse playbook:
---
- 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
Cela fait l'affaire pour moi, il recueille les clés publiques ssh sur les nœuds et la distribue sur tous les nœuds. De cette façon, ils peuvent communiquer les uns avec les autres.
- 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: C'est pour l'utilisateur root
je créerais un utilisateur deploy qui est restreint pour tirer l'accès à vos repos. Vous pouvez autoriser cela par http ou .
si vous ne vous souciez pas de limiter l'utilisateur à l'accès en lecture seule à votre repo, alors vous pouvez créer un utilisateur SSH normal. Une fois l'utilisateur créé, vous pouvez utiliser Ansible pour ajouter la clé publique de l'utilisateur autorisé fichier de clé sur le serveur git, vous pouvez utiliser le autorisé clé module.
Une fois que c'est fait, vous avez deux options:
si vous utilisez ssh utilisez SSH key forwarding de sorte que l'utilisateur qui est utilisé pour exécuter la tâche possible envoie sa clé publique au serveur dev.
transférer Temporairement la touche
ssh_optsoption du module git utiliser le déployer la clé publique de l'utilisateur.
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 dans un hôte distant source et que sa clé publique est copiée à un utilisateur cible dans un hôte distant cible.
vous pouvez invoquer 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 de 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 }}"