Ansible copie de clé ssh à partir 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 suis en service à l'aide de Ansible. App serveurs Nginx + Passager et en cours d'exécution pour une application Rails. Utilisera capistrano pour le déploiement, mais j'ai une question à propos de clés ssh. Mon repo git est dans un autre serveur et j'ai pour générer des clés publiques ssh sur appservers et les ajouter à la Git serveur(fichier authorized_keys). Comment puis-je faire dans ansible playbook?

PS: j'ai peut être plus de 2 app serveurs.

Pourriez-vous élaborer sur la façon dont vous gérer les clés sur le serveur Git ? Est-ce un gitlab exemple ? Avez-vous seulement pour ajouter des clés dans un fichier authorized_keys ?
Je n'ai qu'à ajouter des touches fichier authorized_keys

InformationsquelleAutor beydogan | 2014-09-02

Prendre 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 je pense, serait de générer une nouvelle paire de clés pour votre application, pour être partagée sur l'ensemble de votre application instances. Cela peut avoir des répercussions sur la sécurité (vous êtes en effet le partage de clés entre toutes les instances!), mais ça va simplifier beaucoup le processus de configuration.

Vous aurez également besoin de déploiement de l'utilisateur sur chaque application de la machine, pour être utilisé plus tard au cours du processus de déploiement. Vous aurez besoin de votre clé publique (ou jenkins, un) sur chaque déployer de l'utilisateur 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

InformationsquelleAutor el.atomo

28

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
- J'ai adapté cette idée, mais avec local_action: ssh-agent -L et blogué à ce sujet: dannyman.toldme.com/2016/07/01/..., donc merci!!
- Bon, cela fonctionne, mais je ne comprends pas pourquoi vous avez mis shell: user=root key... au lieu de authorized_key: user=root key.... J'ai essayé de cet extrait, mais ne peut pas le faire fonctionne avec shell, avec authorized_key fonctionne comme un charme.
- problème une erreur par moi, beau spotting!
- Vous signifiait probablement ssh-add (au lieu ssh-agent) comme dans votre blog.
InformationsquelleAutor Jonas Libbrecht
1

Je voudrais créer un de déployer l'utilisateur est limité à tirer de l'accès à votre repos. Vous pouvez autoriser cette via http ou il ya quelques options pour le faire via ssh.

Si vous n'avez pas de soins sur la limitation de l'utilisateur pour un accès en lecture seule de votre pension vous pouvez alors créer une normal ssh de l'utilisateur. 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é module clé.

Une fois que c'est de la configuration, vous avez deux options:
1. Si vous utilisez ssh utiliser de clé ssh transfert, de sorte que l'utilisateur qui est utilisé pour exécuter l'Ansible tâche envoie sa clé publique sur le serveur de dev.
2. Transférer temporairement la touche et utilisez les ssh_opts git option de module utilisation de déployer la clé publique de l'utilisateur.
InformationsquelleAutor jarv

J'ai créé un paramétrée rôle de faire ssh paire de clés est générée dans une source d'utilisateur dans une source de l'hôte distant et sa clé publique copié à un utilisateur cible dans un objectif de l'hôte distant.

Vous pouvez appeler ce rôle dans une boucle imbriquée de la source et de la cible listes d'hôtes comme indiqué au 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 }}"

Invoquant 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 }}"

InformationsquelleAutor Nicholas Sushkin

Vous devez vous connecter pour publier un commentaire.