विभिन्न प्रकार के चर के साथ टेम्पलेट मॉड्यूल का उपयोग कैसे करें?

92

मेरा उपयोग मामला निम्नलिखित है:

मेरे पास एक टेम्प्लेट फ़ाइल है, और मैं उस टेम्प्लेट से 2 अलग-अलग फाइलें बनाना चाहूंगा, जिसमें वैरिएबल प्रत्येक फ़ाइल के लिए अलग-अलग वेरिएबल्स द्वारा भरा जाए।

उदाहरण के लिए, मैं यह कहना चाहता हूं कि मैं फ़ाइल को लाइन में रखना चाहता हूं: 

mkdir -p {{myTemplateVariable}}

मैं "File1" और "File2" द्वारा भरे गए इस वैरिएबल को प्राप्त करने का एक उचित तरीका खोजना चाहता हूं। कुछ इस तरह :

- name: template test 1
  template: 
        src=myTemplateFile
        dest=result1


- name: template test 2
  template: 
        src=myTemplateFile
        dest=result2

जहां मैं पहली टेम्प्लेटिंग के लिए निर्दिष्ट कर सकता हूं कि उपयोग करने वाला चर = "फाइल 1" है और दूसरे के लिए, बी = "पी 2" है।

ansible  ansible-template 
— Kestemont मैक्स
स्रोत
क्या यह ठीक है कि मैं अपने सभी व्यंजनों के साथ करता हूं, इस टिप्पणी को देखें stackoverflow.com/a/40189525/1571310 , आशा है कि यह मदद!
— टेकनोकैट

जवाबों:

51

2. अस्थिर के लिए 2.x:

- name: template test
  template: 
    src: myTemplateFile
    dest: result1
  vars:
    myTemplateVariable: File1

- name: template test
  template: 
    src: myTemplateFile
    dest: result2
  vars:
    myTemplateVariable: File2

के लिए Ansible 1.x:

दुर्भाग्य से templateमॉड्यूल इसे पास करने वाले चर का समर्थन नहीं करता है, जिसका उपयोग टेम्पलेट के अंदर किया जा सकता है। एक सुविधा अनुरोध था लेकिन इसे अस्वीकार कर दिया गया था।

मैं दो वर्कअराउंड के बारे में सोच सकता हूं:

1. शामिल करें

includeबयान का समर्थन करता है चर गुजर। तो आप templateएक अतिरिक्त फ़ाइल के अंदर अपना काम कर सकते हैं और इसे दो बार उचित मापदंडों के साथ शामिल कर सकते हैं:

my_include.yml:

- name: template test
  template: 
        src=myTemplateFile
        dest=destination

main.yml:

- include: my_include.yml destination=result1 myTemplateVariable=File1

- include: my_include.yml destination=result2 myTemplateVariable=File2

2. पुनः परिभाषित myTemplateVariable

एक और तरीका यह होगा कि हर templateकार्य से ठीक पहले myTemplateVariable को फिर से परिभाषित करें ।

- set_fact:
     myTemplateVariable: File1

- name: template test 1
  template: 
        src=myTemplateFile
        dest=result1

- set_fact:
     myTemplateVariable: File2

- name: template test 2
  template: 
        src=myTemplateFile
        dest=result2
— udondan
स्रोत
जवाब के लिए धन्यवाद। हालांकि, क्या वर्कअराउंड के बिना ऐसा करना वास्तव में असंभव है? मैं वर्तमान में कुछ करने की कोशिश कर रहा हूँ जैसे: stackoverflow.com/questions/26020465/… , लेकिन अभी भी कुछ त्रुटियाँ हो रही हैं (शायद सीधे संबंधित नहीं)।
— Kestemont Max
हां, आप इसे लूप के साथ भी कर सकते हैं - फिर भी यह एक वर्कअराउंड है। :)
— udondan
14
अब आवश्यकता नहीं है। "vars" अब समर्थित है। नीचे @ konstantin-suvorov उत्तर देखें।
— सोनज
123

Ansible 2.x के साथ आप vars:कार्यों के साथ उपयोग कर सकते हैं ।

साँचा test.j2:

mkdir -p {{myTemplateVariable}}

प्लेबुक:

- template: src=test.j2 dest=/tmp/File1
  vars:
    myTemplateVariable: myDirName

- template: src=test.j2 dest=/tmp/File2
  vars:
    myTemplateVariable: myOtherDir

यह अलग myTemplateVariableमानों को test.j2 में पास करेगा ।

— कोंस्टेंटिन सुवोरोव
स्रोत
9
शुरू में मैंने एक गलती की और उसके पास var थे: बाकी टेम्पलेट तर्कों की तरह इंडेंट किया गया (जैसे src :)। मुझे लगता है कि इंडेंट स्तर का अर्थ है var: कार्य का है, न कि टेम्पलेट का। तो आप कहीं भी कर सकते हैं, न केवल टेम्पलेट्स। अच्छा।
— ग्रेग
39

आप इसे बहुत आसान कर सकते हैं, देखिए मेरी सुपरवाइजर रेसिपी:

- name: Setup Supervisor jobs files
  template:
    src: job.conf.j2
    dest: "/etc/supervisor/conf.d/{{ item.job }}.conf"
    owner: root
    group: root
    force: yes
    mode: 0644
  with_items:
    - { job: bender, arguments: "-m 64", instances: 3 }
    - { job: mailer, arguments: "-m 1024", instances: 2 }
  notify: Ensure Supervisor is restarted

job.conf.j2:

[program:{{ item.job }}]
user=vagrant
command=/usr/share/nginx/vhosts/parclick.com/app/console rabbitmq:consumer {{ item.arguments }} {{ item.job }} -e prod
process_name=%(program_name)s_%(process_num)02d
numprocs={{ item.instances }}
autostart=true
autorestart=true
stderr_logfile=/var/log/supervisor/{{ item.job }}.stderr.log
stdout_logfile=/var/log/supervisor/{{ item.job }}.stdout.log

आउटपुट:

TASK [Supervisor : Setup Supervisor jobs files] ********************************
changed: [loc.parclick.com] => (item={u'instances': 3, u'job': u'bender', u'arguments': u'-m 64'})
changed: [loc.parclick.com] => (item={u'instances': 2, u'job': u'mailer', u'arguments': u'-m 1024'})

का आनंद लें!

— Tecnocat
स्रोत
इसे सही उत्तर के रूप में चिह्नित किया जाना चाहिए। चूँकि अब इसका समर्थन किया जा रहा है
— PoX
23

यह एक समाधान / हैक मैं उपयोग कर रहा हूँ:

कार्य / main.yml:

- name: parametrized template - a
  template:
    src: test.j2
    dest: /tmp/templateA
  with_items: var_a

- name: parametrized template - b
  template:
    src: test.j2
    dest: /tmp/templateB
  with_items: var_b

वार्स / main.yml

var_a:
  - 'this is var_a'
var_b:
  - 'this is var_b'

टेम्पलेट्स / test.j2:

{{ item }}

इसे चलाने के बाद, आप this is var_a/ tmp / templateA में और / tmp / templateB में मिलते हैं this is var_b।

मूल रूप से आप with_itemsएक आइटम सूची में प्रत्येक आइटम के साथ टेम्पलेट को प्रस्तुत करने के लिए दुरुपयोग करते हैं। यह काम करता है क्योंकि आप उपयोग करते समय सूची को नियंत्रित कर सकते हैं with_items।

इसका नकारात्मक पक्ष यह है कि आपको अपने itemटेम्पलेट में परिवर्तनशील नाम के रूप में उपयोग करना होगा ।

यदि आप इस तरह से एक से अधिक वेरिएबल पास करना चाहते हैं, तो आप इस तरह से अपनी सूची आइटम के रूप में प्राप्त कर सकते हैं:

var_a:
  -
    var_1: 'this is var_a1'
    var_2: 'this is var_a2'
var_b:
  -
    var_1: 'this is var_b1'
    var_2: 'this is var_b2'

और फिर उन्हें इस तरह से अपने टेम्पलेट में देखें:

{{ item.var_1 }}
{{ item.var_2 }}
— asmigala
स्रोत
1
स्वच्छ समाधान, लेकिन उपयोग करने के लिए टोपीwith_items: '{{ var_a }}'
— पीटर अज़ताई
8

मैंने इसे इस तरह से किया।

कार्यों में / main.yml

- name: template test
  template: 
        src=myTemplateFile.j2
        dest={{item}}
   with_dict: some_dict

और vars / main.yml में

some_dict:
  /path/to/dest1:
    var1: 1
    var2: 2
  /path/to/dest2:
    var1: 3
    var2: 4

और टेम्प्लेट / myTemplateFile.j2 में

some_var = {{ item.value.var1 }}
some_other_var = {{ item.value.var2 }}

आशा है इससे तुम्हारी समस्या का समाधान हो गया होगा।

— नबरुन चटर्जी
स्रोत
with_dictबेहतर उपाय है।
— zx1986
1 
- name: copy vhosts
  template: src=site-vhost.conf dest=/etc/apache2/sites-enabled/{{ item }}.conf
  with_items:
    - somehost.local
    - otherhost.local
  notify: restart apache

महत्वपूर्ण: ध्यान दें कि एक आइटम के लिए सिर्फ एक स्ट्रिंग होना जरूरी नहीं है, यह एक वस्तु हो सकती है जिसमें आप जितनी चाहें उतनी संपत्ति रख सकते हैं, ताकि आप किसी भी संख्या में चर पास कर सकें।

मेरे पास टेम्पलेट में:

<VirtualHost *:80>
    ServerAdmin me@example.org
    ServerName {{ item }}
    DocumentRoot /vagrant/public


    ErrorLog ${APACHE_LOG_DIR}/error-{{ item }}.log
    CustomLog ${APACHE_LOG_DIR}/access.log combined

</VirtualHost>
— बार्ट मैकलोड
स्रोत
1
मैं इसे एक वस्तु कैसे बना सकता हूं?
— कैमडिक्सन
1

मुझे हल करने के लिए इसी तरह की समस्या थी, यहां टेम्प्लेट फ़ाइलों में वेरिएबल्स पास करने का एक सरल समाधान है, ट्रिक वैरिएबल का लाभ लेते हुए टेम्प्लेट फ़ाइल लिखना है। आपको एक शब्दकोश (सूची भी संभव है) बनाने की आवश्यकता है, जो प्रत्येक फ़ाइल के अनुरूप चर का सेट रखता है। फिर टेम्पलेट फ़ाइल के भीतर उन्हें एक्सेस करें।

निचे देखो:

the template file: test_file.j2
# {{ ansible_managed }} created by xbalaji@gmail.com

{% set dkey  = (item | splitext)[0]  %}
{% set fname = test_vars[dkey].name  %}
{% set fip   = test_vars[dkey].ip    %}
{% set fport = test_vars[dkey].port  %}
filename: {{ fname }}
ip address: {{ fip }}
port: {{ fport }}

प्लेबुक

---
#
# file: template_test.yml
# author: xbalaji@gmail.com
#
# description: playbook to demonstrate passing variables to template files
#
# this playbook will create 3 files from a single template, with different
# variables passed for each of the invocation
#
# usage:
# ansible-playbook -i "localhost," template_test.yml

- name: template variables testing
  hosts: all
  gather_facts: false

  vars:
    ansible_connection: local
    dest_dir: "/tmp/ansible_template_test/"
    test_files:
      - file_01.txt
      - file_02.txt
      - file_03.txt
    test_vars:
      file_01:
        name: file_01.txt
        ip: 10.0.0.1
        port: 8001
      file_02:
        name: file_02.txt
        ip: 10.0.0.2
        port: 8002
      file_03:
        name: file_03.txt
        ip: 10.0.0.3
        port: 8003

  tasks:
    - name: copy the files
      template:
        src: test_file.j2
        dest: "{{ dest_dir }}/{{ item }}"
      with_items:
        - "{{ test_files }}"
— xbalaji
स्रोत
0

एक सूची का उपयोग करके एक और वास्तविक दुनिया उदाहरण

php.ini के लिए एक टेम्पलेट के लिए एक उद्धरण

{% if 'cli/php.ini' in item.d %}
max_execution_time = 0
memory_limit = 1024M
{% else %}
max_execution_time = 300
memory_limit = 512M
{% endif %}

यह var है

php_templates:
  - { s: 'php.ini.j2', d: "/etc/php/{{php_version}}/apache2/php.ini" }
  - { s: 'php.ini.j2', d: "/etc/php/{{php_version}}/cli/php.ini" }

फिर मैंने इसके साथ तैनाती की

- name: push templated files
  template:
    src: "{{item.s}}"
    dest: "{{item.d}}"
    mode: "{{item.m | default(0644) }}"
    owner: "{{item.o | default('root') }}"
    group: "{{item.g | default('root') }}"
    backup: yes
  with_items: "{{php_templates}}"
— Krad
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.