Comment installer automatiquement les rôles Ansible Galaxy?


129

Tous mes playbooks / rôles Ansible sont archivés dans mon dépôt git.

Cependant, pour les rôles Ansible Galaxy, je dois toujours les télécharger explicitement un par un sur chaque machine à partir de laquelle je souhaite exécuter Ansible.

Il est même difficile de savoir à l'avance quels rôles Ansible Galaxy sont nécessaires jusqu'à ce qu'Ansible se plaint d'un rôle manquant au moment de l'exécution.

Comment est-il censé gérer les dépendances de rôle d'Ansible Galaxy? Je voudrais soit les avoir archivés dans mon dépôt git avec le reste de mon code ansible, soit les avoir automatiquement identifiés et téléchargés lorsque j'exécute Ansible sur une nouvelle machine.


galaxy.ansible.com/docs/using/index.html Voici tout ce dont vous avez besoin pour utiliser ansible-galaxy. C'est un doc bien fait! Même si vous êtes débutant :)
Ayra

@pdeva Pourriez-vous accepter l'une des réponses valides ci-dessous?
GG.

Réponses:


149

Vous devez utiliser un requirements.ymlfichier pour ce cas d'utilisation. Décrivez les rôles dont vous avez besoin à l'aide de l'une des nombreuses méthodes d'installation:

# Install a role from the Ansible Galaxy
- src: dfarrell07.opendaylight

# Install a role from GitHub
- name: opendaylight
  src: https://github.com/dfarrell07/ansible-opendaylight

# Install a role from a specific git branch
- name: opendaylight
  src: https://github.com/dfarrell07/ansible-opendaylight
  version: origin/master

# Install a role at a specific tag from GitHub
- name: opendaylight
  src: https://github.com/dfarrell07/ansible-opendaylight
  version: 1.0.0

# Install a role at a specific commit from GitHub
- name: opendaylight
  src: https://github.com/dfarrell07/ansible-opendaylight
  version: <commit hash>

Puis installez-les:

ansible-galaxy install -r requirements.yml

Voici un exemple de travail (installation d'OpenDaylight en utilisant Ansible comme approvisionneur Vagrant). Consultez les documents Ansible pertinents pour plus d'informations.


Voir également la réponse de @Kieran Andrews ci-dessous. Il élargit celui-ci.
Marco Ferrari

1
Il ne s'agit pas vraiment d'installer automatiquement les dépendances de rôle d'un playbook, mais d'installer explicitement une liste de dépendances qui ont été manuellement répertoriées par l'homme qui a créé le playbook.
Neil le

53

Comme suggéré, vous pouvez utiliser la galaxie ansible pour ce besoin.

Ansible a une fonctionnalité où vous pouvez créer un requirements.ymlfichier qui répertorie tous vos rôles. Vous pouvez en savoir plus ici: http://docs.ansible.com/ansible/latest/galaxy.html#installing-multiple-roles-from-a-file

Par exemple (requirements.yml):

- src: yatesr.timezone

Vous exécutez ensuite ansible-galaxy install -r requirements.ymlsur ce fichier pour télécharger tous les rôles qui y sont répertoriés.

Si vous souhaitez l'automatiser davantage, vous pouvez créer un script shell simple qui exécutera les deux commandes.

Par exemple (ansible.sh):

./ansible.sh

ansible-galaxy install -r requirements.yml
ansible-playbook playbook.yml -i inventory 

1
Juste testé, il affiche un message indiquant que les rôles sont déjà téléchargés, aucune erreur. Version2.2.1
Igonato

Si le livre de jeu utilise les rôles de galaxie que vous installez, ils ne s'exécuteront pas la première fois que le livre de jeu est appelé car leur présence est vérifiée avant d'être téléchargé. Appeler le playbook une deuxième fois ramassera alors les rôles nouvellement installés.
Ben

J'ai mis à jour comment je le fais maintenant, avec un script wrapper pour réduire les commandes.
Kieran Andrews

19

Je me retrouve souvent à installer un JDK Java. L'utilisation d'un rôle facilite ce contact. J'ai essayé plusieurs façons différentes (y compris beaucoup de .gitmodules et de sous-modules ... Je dois utiliser plusieurs systèmes git pour travailler et tout cela devient moche). Ma plus grande exigence est que je ne vérifie pas le code de rôle dans mon projet de playbook, principalement pour que je puisse tout garder au même endroit.

Le contenu de mon fichier 'requirements.yml':

- src: https://github.com/staylorx/ansible-role-wls-prep.git
  version: master
  name: staylorx.wls-prep

- src: https://my-work-git-extravaganza.com
  version: 2.x
  name: coolplace.niftyrole

#From Ansible Galaxy
- src: staylorx.oracle-jdk

Je lance un playbook séparé, install-roles.yml:

---

- hosts: localhost

  tasks:
    - file:
        path:  roles
        state: absent

    - local_action:
        command ansible-galaxy install -r requirements.yml --roles-path roles

    - lineinfile:
        dest:   .gitignore
        regexp: '^\/roles$'
        line:   '/roles'
        state:  present

Je lance ce premier playbook, puis j'exécute mes rôles dans n'importe quel playbook normalement. Pour moi, le secret est de m'assurer qu'il est ignoré par git afin que je ne vérifie pas les rôles par erreur. De plus, comme j'efface le dossier à chaque fois, je m'assure que je n'ai pas besoin de forcer ou d'ignorer les erreurs.


Il échouera avec «rôle introuvable» avant même d'exécuter la commande locale.
Daniel Andrei Mincă

1
@ Mincă Daniel Andrei vous devez utiliser une manière dynamique, ex include_role. vérifier ceci
user1686407

4

Une autre solution consiste à utiliser des sous-modules git. Après tout, Ansible Galaxy n'est qu'un répertoire de référentiels github ...

J'utilise cette commande pour ajouter automatiquement n'importe quel rôle Galaxy en tant que sous-module:

ansible-galaxy info <package> | grep -A 1 github_repo | tr '\n' ' ' | sed -e "s/.*github_repo: \([^[:space:]]*\)[^\w]*github_user: \([^[:space:]]*\)[[:space:]]*/git submodule add git:\/\/github.com\/\2\/\1.git roles\/\2.\1/g" | sh

Validez ensuite les modifications dans votre dépôt git. Lorsque vous clonerez votre repo à l'avenir, assurez-vous de le cloner avec des sous-modules, par exemplegit clone ... --recursive

Un avantage de ceci est qu'un sous-module git fait toujours référence à une version spécifique (git commit-hash). Cela vous empêchera d'exécuter des mises à jour non testées dans votre environnement de production. Une nouvelle version d'un rôle Galaxy pourrait avoir des bugs ou fonctionner complètement différemment qu'auparavant. Avec un sous-module git, vous décidez si et quand vous mettez à jour un rôle vers la nouvelle version.

En outre, vous n'aurez pas à vous occuper de la liste noire des rôles de galaxie dans votre .gitignorepour éviter de valider leur code dans votre référentiel.


5
C'est une mauvaise pratique à mon avis. Il est généralement plus simple d'utiliser des outils de gestion des dépendances que de coller les dépôts SCM ensemble, en particulier lorsque nous parlons de sous-modules git pour SCM.
David Resnick le

1
D'accord. En fait, je ne l'utilise plus. Pourtant, c'est une approche valable car ansible-galaxy est loin d'être parfaite. Galaxy ne vérifiera pas les mises à jour, même si une version est modifiée dans votre fichier d'exigences, si vous le forcez à télécharger à nouveau tous les rôles avec l' --forceindicateur non documenté , il ne vous montrera pas si ou ce qui a réellement changé. C'est une boîte noire que vous ne pouvez contrôler que si vous conservez les rôles de galaxie téléchargés dans SCM. Pour d'autres raisons, c'est quand même une bonne idée. Lorsque vous tirez des sous-modules, vous voyez au moins quels rôles ont changé.
udondan le

BTW, tous les problèmes que rencontrent les sous-modules, AFAIK sont négligeables dans cette situation car ils sont liés à la modification de leur contenu. Tirant est parfaitement bien par mon expérience ..
udondan

4

Vous pouvez utiliser un rôle Ansible pour installer les rôles nécessaires à l'aide du module de commande .

Voici un exemple très basique qui s'exécute ansible-galaxy install:

- name: Install roles from Ansible Galaxy
  command: ansible-galaxy install {{ item.item }}
  with_items:
    - "{{ ansible_roles_list }}"

Le ansible_roles_listpeut être fourni sous forme de variable ou de paramètre de rôle.

Si vous faites cela dans un rôle, il doit être appliqué avant tout autre rôle que vous souhaitez installer en l'utilisant, dans un playbook distinct. En effet, Ansible vérifie si tous les rôles sont disponibles avant d'exécuter le playbook où vous les référencez.


egg and chicken :)
bazeusz

2

À ce stade, pour autant que je sache, il n'y a pas de moyen automatique de télécharger des rôles au moment de l'exécution. Votre meilleur pari est de les engager dans votre propre dépôt ou d'avoir une documentation appropriée répertoriant toutes les exigences. Vous pouvez même créer un livre de jeu pré-vol qui installe vos rôles. :)


3
Vous pouvez utiliser un fichier requirements.txt pour cela. Voir: docs.ansible.com
toast38coza

0

Ici, mes exigences sont sur le rôle et utilisées dans install.yml

main.yml

 # tasks file for MY_ROLE
- name: Install requirements
  local_action: command ansible-galaxy install -r {{ role_path }}/requirements.yml -p /etc/ansible/roles

- include_tasks: install.yml 
.  
├── playbook.yml  
├── inventory  
├── roles  
│    └── My_Role   
│        ├── tasks  
│        │   └── main.yml  
│        │   └── install.yml  
│        └── requirements.yml

0

Si requirements.yml réside dans le répertoire des rôles de votre projet, Tower / AWX installe les rôles automatiquement.

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.