60

Is there an easy way to deploy a folder full of template .j2 folder to a linux box, using the same name as the template, but without the .j2 extension, rather than using the template module for each file?

Right now i have a long list of:

- name: create x template
  template:
    src=files/x.conf.j2
    dest=/tmp/x.conf
    owner=root
    group=root
    mode=0755
  notify:
    - restart myService

7 Answers 7

94

You could use with_fileglob to get the list of files from your template directory and use filters to strip the j2 extension like this:

- name: create x template
  template:
    src: "{{ item }}"
    dest: /tmp/{{ item | basename | regex_replace('\.j2$', '') }}
  with_fileglob:
    - ../templates/*.j2
4
  • 14
    note with_fileglob always operates from files/, you can get to templates with ../templates/mytemplate/*. stackoverflow.com/a/27407566/1695680 May 13, 2015 at 20:10
  • 5
    Thanks, this is super helpful. I found that I had to use two backslashes to escape the literal period in the regex_replace function. Maybe because I had the entire dest template portion within double quotes so I could use YAML format for the task definition (which I prefer over the one-liner format). Mar 31, 2016 at 23:03
  • 1
    this assumes only files live within the templates folder, if you need to support both directories and files within the templates folder then you need with_filetree - see stackoverflow.com/questions/41667864/…
    – danday74
    Jan 16, 2017 at 2:02
  • 5
    Remember to escape \ if you are wrapping the whole value in double quote. dest: "/tmp/{{ item | basename | regex_replace('\\.j2$', '') }}"
    – tom10271
    Nov 12, 2020 at 7:43
21

Michael DeHaan(creator of Ansible) made a post on CoderWall that talks about very similar issue. You can adjust and expand it according to your needs(such as permissions and ownership). Relevant part of the post is here:


This can be simplified by using "with_items" and a single notify statement. If any of the tasks change, the service will be notified in exactly the same way that it needs to restart at the end of the playbook run.

 - name:  template everything for fooserv
   template: src={{item.src}} dest={{item.dest}}
   with_items:
      - { src: 'templates/foo.j2', dest: '/etc/splat/foo.conf' }
      - { src: 'templates/bar.j2', dest: '/etc/splat/bar.conf' }
   notify: 
      - restart fooserv

Note that since we have tasks that take more than one unique argument, we don't just say "item" in the 'template:' line, but use with_items with a hash (dictionary) variable. You can also keep it a little shorter by using lists, if you like. This is a stylistic preference:

 - name:  template everything for fooserv
   template: src={{item.0}} dest={{item.1}}
   with_items:
      - [ 'templates/foo.j2', '/etc/splat/foo.conf' ]
      - [ 'templates/bar.j2', '/etc/splat/bar.conf' ]
   notify: 
      - restart fooserv

Of course we could also define the list you were walking over in another file, like a "groupvars/webservers" file to define all the variables needed for the webservers group, or a YAML file loaded from the "varsfiles" directive inside the playbook. Look how this can clean up if we do.

- name: template everything for fooserv
  template: src={{item.src}} dest={{item.dest}}
  with_items: {{fooserv_template_files}}
  notify: 
      - restart fooserv
4
  • 6
    A simpler method might be to write template: src=templates/{{item}}.j2 dest=/etc/splat/{{item}}.conf, and then use a plain list of items: with_items: - foo - bar
    – Ethan
    Jan 6, 2015 at 3:47
  • This actually looks wrong now. The correct template line would be template: src={{item.src}} dest={{item.dest}} (i.e. not ${var} but rather {{var}}) Nov 13, 2015 at 13:45
  • @FabianoFrancesconi updated.
    – Mxx
    Nov 13, 2015 at 15:01
  • item.0 actually just gets f from - [ 'foo.bar' , 'foo.baz' ] instead of foo.bar. Which ansible version are you using? github.com/ansible/ansible/issues/5913 Apr 23, 2020 at 18:23
14

I wrote a filetree lookup plugin that can help with actions on file trees.

You can recurse over files in a file tree and based on file properties perform actions (e.g. template or copy). Since the relative path is returned, you can recreate the filetree on the target system(s) with ease.

- name: Template complete tree
  template:
    src: '{{ item.src }}'
    dest: /web/{{ item.path }}
    force: yes
  with_filetree: some/path/
  when: item.state == 'file'

It makes for more readable playbooks.

13
  • It's not been merged yet :-( May 24, 2016 at 11:32
  • 2
    It has been merged.
    – Dag Wieers
    Sep 26, 2016 at 18:32
  • Is there a way to filter say only *.conf files?
    – Andrey
    May 12, 2017 at 7:20
  • Sure, in the "when:" part you can write an expression that fits your need.
    – Dag Wieers
    May 13, 2017 at 12:36
  • 1
    The plugin is not slow, it's the process of templating and copying each file individually that makes it slow. But that has hardly anything to do with the plugin, the plugin could is useful for other things than templating or copying.
    – Dag Wieers
    Jun 24, 2017 at 18:59
9

The answer by Russel does work but it needs improvement

- name: create x template
- template: src={{ item }} dest=/tmp/{{ item | basename | regex_replace('.j2','') }}
- with_fileglob:
   - files/*.j2

Firs of all the $ needs to go as it was wrong regex in the regex_replace . Secondly all the files should be in the files directory rather than templates directory

1
  • 5
    Welcome to Server Fault! Your answer suggests a workable solution to the question is available through a previous answer, thus would be more appropriate as an edit of that answer. Please consider deleting your current answer and suggesting an edit to Russell's answer.
    – Paul
    Jan 16, 2015 at 17:31
4

The below command worked for me to do a recursive lookup for j2 files in templates and move it to the destination. Hope it helps someone looking for recursive copy of templates to destination.

     - name: Copying the templated jinja2 files
       template: src={{item}} dest={{RUN_TIME}}/{{ item | regex_replace(role_path+'/templates','') | regex_replace('\.j2', '') }}
       with_items: "{{ lookup('pipe','find {{role_path}}/templates -type f').split('\n') }}"
2

There is a possibility to grab the list of actual files from the directory automatically and iterate them afterwards..

- name:         get the list of templates to transfer
  local_action: "shell ls templates/* | sed 's~.*/~~g'"
  register:     template_files

- name:         iterate and send templates
  template:     src=templates/{{ item }} dest=/mydestination/{{ item }}
  with_items:
  - "{{ template_files.stdout.splitlines() }}"
1
  • Note the standard caveat about splitting on newline - filenames may contain newlines. A safer solution is to use a shell utility that supports print0, such as find, and then split on \u0000. Aug 14, 2017 at 2:44
0

I did it and it worked. \o/

- name: "Create file template"
  template:
    src: "{{ item.src }}"
    dest: "{{ your_dir_remoto }}/{{ item.dest }}"
  loop:
    - { src: '../templates/file1.yaml.j2', dest: 'file1.yaml' }
    - { src: '../templates/file2.yaml.j2', dest: 'file2.yaml' }

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.