view | history | commit | commitdiff
sborenst
2018-09-06 febf59bde588523e1a1bf7f654116eb6e1b301ec
commit | author | age
e2d605 1 - name: Step 002 Post Infrastructure
S 2   hosts: localhost
3   connection: local
4   become: false
5   vars_files:
6     - "{{ ANSIBLE_REPO_PATH }}/configs/{{ env_type }}/env_vars.yml"
7     - "{{ ANSIBLE_REPO_PATH }}/configs/{{ env_type }}/env_secret_vars.yml"
8   tags:
9     - step002
10     - post_infrastructure
11   tasks:
c73d82 12     - environment:
GC 13         AWS_ACCESS_KEY_ID: "{{aws_access_key_id}}"
14         AWS_SECRET_ACCESS_KEY: "{{aws_secret_access_key}}"
15         AWS_DEFAULT_REGION: "{{aws_region_final|d(aws_region)}}"
087c6c 16       when:
GC 17         - "'clientvms' in groups"
18         - groups['clientvms'] | length > 0
c30ebe 19         - cloudformation_out_final.stack_outputs.AutoScalingGroupClientVM is defined
c73d82 20       block:
a55590 21       - name: test cloudformation_out_final
S 22         debug:
23           var: cloudformation_out_final
24           verbosity: 2
c30ebe 25
c73d82 26       - name: Deactivate autoscaling
GC 27         command: >-
28           aws autoscaling suspend-processes --auto-scaling-group-name
a55590 29           {{cloudformation_out_final.stack_outputs.AutoScalingGroupClientVM}}
c30ebe 30
c73d82 31       - name: Write down autoscaling name
GC 32         copy:
33           dest: "{{ANSIBLE_REPO_PATH}}/workdir/{{ env_type }}.{{ guid }}.AutoScalingGroupClientVM"
34           content: "{{cloudformation_out_final.stack_outputs.AutoScalingGroupClientVM}}"
35
36       - name: Allocate and associate an EIP to the clientVMs
37         ec2_eip:
38           device_id: "{{hostvars[item].instance_id}}"
c30ebe 39           release_on_disassociation: yes
c73d82 40         with_items: "{{groups['clientvms']}}"
GC 41         register: eips
42
42f0d0 43       # reimport roles to update inventory, since publicIP changed 
c73d82 44       - name: Run infra-ec2-create-inventory Role
GC 45         import_role:
46           name: "{{ ANSIBLE_REPO_PATH }}/roles/infra-ec2-create-inventory"
47       - name: Run Common SSH Config Generator Role
48         import_role:
49           name: "{{ANSIBLE_REPO_PATH}}/roles/infra-common-ssh-config-generate"
50
51       - name: Create DNS record for each clientVM
52         route53:
53           hosted_zone_id: "{{HostedZoneId}}"
54           zone: "{{subdomain_base}}"
3c83ad 55           record: "clientvm{{idx + 1}}.{{subdomain_base}}"
c73d82 56           state: present
GC 57           type: A
58           ttl: 90
59           value: "{{hostvars[item].public_ip_address}}"
60         with_items: "{{groups['clientvms']}}"
61         loop_control:
62           index_var: idx
7b8683 63           pause: 2
c73d82 64
GC 65       - name: Rename instance
66         ec2_tag:
67           state: present
68           resource: "{{hostvars[item].instance_id}}"
69           tags:
3c83ad 70             Name: "clientvm{{idx + 1}}"
c73d82 71         with_items: "{{groups['clientvms']}}"
GC 72         loop_control:
73           index_var: idx
e2d605 74
e3ddad 75       - name: Set hostname
GC 76         become: yes
77         hostname:
78           name: "clientvm{{idx + 1}}"
79         delegate_to: "{{item}}"
80         with_items: "{{groups['clientvms']}}"
81         loop_control:
82           index_var: idx
83
e2d605 84     - name: Job Template to launch a Job Template with update on launch inventory set
S 85       uri:
86         url: "https://{{ ansible_tower_ip }}/api/v1/job_templates/{{ job_template_id }}/launch/"
87         method: POST
88         user: "{{tower_admin}}"
89         password: "{{tower_admin_password}}"
90         body:
91           extra_vars:
92             guid: "{{guid}}"
93             ipa_host_password: "{{ipa_host_password}}"
94
95         body_format: json
96         validate_certs: False
97         HEADER_Content-Type: "application/json"
98         status_code: 200, 201
99       when: tower_run == 'true'
100
101     - name: get S3User credentials from stack outputs
102       set_fact:
103         s3user: "{{ cloudformation_out_final.stack_outputs.S3User }}"
104         s3user_access_key: "{{ cloudformation_out_final.stack_outputs.S3UserAccessKey }}"
105         s3user_secret_access_key: "{{ cloudformation_out_final.stack_outputs.S3UserSecretAccessKey }}"
106       when:
107         - cloudformation_out_final is defined
108         - cloudformation_out_final.stack_outputs.S3UserAccessKey is defined
109         - cloudformation_out_final.stack_outputs.S3UserSecretAccessKey is defined
110       tags:
111         - provision_cf_template
112
113     - name: write down s3user credentials
114       copy:
115         dest: "{{ANSIBLE_REPO_PATH}}/workdir/{{ env_type }}.{{ guid }}.s3user.credentials"
116         content: |
117           * S3 Bucket for registry: {{s3user}}
118           ** S3User access key: {{s3user_access_key}}
119           ** S3User secret key: {{s3user_secret_access_key}}
120       when: s3user_access_key is defined
121
122     - name: get Route53User credentials from stack outputs
123       set_fact:
124         route53user: "{{ cloudformation_out_final.stack_outputs.Route53User }}"
125         route53user_access_key: "{{ cloudformation_out_final.stack_outputs.Route53UserAccessKey }}"
126         route53user_secret_access_key: "{{ cloudformation_out_final.stack_outputs.Route53UserSecretAccessKey }}"
127       when:
128         - cloudformation_out_final is defined
129         - cloudformation_out_final.stack_outputs.Route53UserAccessKey is defined
130         - cloudformation_out_final.stack_outputs.Route53UserSecretAccessKey is defined
131       tags:
132         - provision_cf_template
133
134     - name: write down Route53User credentials
135       copy:
136         dest: "{{ANSIBLE_REPO_PATH}}/workdir/{{ env_type }}.{{ guid }}.route53user.credentials"
137         content: |
138           * Route53 User for Let's Encrypt: {{ route53user }}
139           ** Route53User access key: {{ route53user_access_key }}
140           ** Route53User secret key: {{ route53user_secret_access_key }}
141       when: route53user_access_key is defined
142
a55590 143
e2d605 144 - name: Detect and map data disks (support) for Azure
S 145   hosts: support
146   become: true
147   gather_facts: false
148   vars_files:
149     - "{{ ANSIBLE_REPO_PATH }}/configs/{{ env_type }}/env_vars.yml"
150     - "{{ ANSIBLE_REPO_PATH }}/configs/{{ env_type }}/env_secret_vars.yml"
151   tasks:
152     - name: test if docker_device file is present (previous run)
153       stat:
154         path: /var/preserve/docker_device
155       register: rfile
156
157     - name: Get docker device
158       changed_when: false
159       vars:
160         query: "[?name == 'support']|[].volumes[?purpose=='docker'].lun|[0][0]"
161       shell: >
162         parted -m /dev/sda print all 2>/dev/null
163         | grep unknown
164         | grep /dev/sd
165         | cut -d':' -f1
166         | sed -n '{{ (instances|json_query(query)|int) + 1}}p'
167       register: result
168       when:
169         - cloud_provider == 'azure'
170         - instances is defined
171         # docker_device will be present on support nodes only when glusterfs is installed
172         - install_glusterfs | bool
173         - not rfile.stat.exists
174
175     - name: set fact for docker_device
176       set_fact:
177         docker_device: "{{ result.stdout }}"
178       when:
179         - cloud_provider == 'azure'
180         - result | succeeded
181         - install_glusterfs | bool
182         - not rfile.stat.exists
183
184     - name: Write down docker_device for idempotency
185       copy:
186         dest: /var/preserve/docker_device
187         content: "{{ docker_device }}"
188         force: no
189       when:
190         - cloud_provider == 'azure'
191         - result | succeeded
192         - install_glusterfs | bool
193         - not rfile.stat.exists
194
195     # idempotency
196
197     - name: get device_name from file (from previous run)
198       slurp:
199         src: /var/preserve/docker_device
200       register: slurp_result
201       when:
202         - cloud_provider == 'azure'
203         - install_glusterfs | bool
204         - rfile.stat.exists
205
206     - name: set fact for docker_device (from previous run)
207       set_fact:
208         docker_device: "{{ slurp_result.content|b64decode }}"
209       when:
210         - cloud_provider == 'azure'
211         - result | succeeded
212         - install_glusterfs | bool
213         - rfile.stat.exists
214
215     # glusterfs device
216
217     - name: test if glusterfs_device_name file is present (previous run)
218       stat:
219         path: /var/preserve/glusterfs_device_name
220       register: rfile
221
222     - name: Get glusterfs device
223       changed_when: false
224       vars:
225         query: "[?name == 'support']|[].volumes[?purpose=='glusterfs'].lun|[0][0]"
226       shell: >
227         parted -m /dev/sda print all 2>/dev/null
228         | grep unknown
229         | grep /dev/sd
230         | cut -d':' -f1
231         | sed -n '{{ (instances|json_query(query)|int) + 1}}p'
232       register: result
233       when:
234         - install_glusterfs | bool
235         - cloud_provider == 'azure'
236         - instances is defined
237         - not rfile.stat.exists
238
239     - name: set fact for glusterfs_device_name
240       set_fact:
241         glusterfs_device_name: "{{ result.stdout }}"
242       when:
243         - install_glusterfs | bool
244         - cloud_provider == 'azure'
245         - result | succeeded
246         - not rfile.stat.exists
247
248     - name: Write down glusterfs_device_name for idempotency
249       copy:
250         dest: /var/preserve/glusterfs_device_name
251         content: "{{ glusterfs_device_name }}"
252         force: no
253       when:
254         - install_glusterfs | bool
255         - cloud_provider == 'azure'
256         - result | succeeded
257         - not rfile.stat.exists
258
259     # idempotency
260
261     - name: get device_name from file (from previous run)
262       slurp:
263         src: /var/preserve/glusterfs_device_name
264       register: slurp_result
265       when:
266         - cloud_provider == 'azure'
267         - install_glusterfs | bool
268         - rfile.stat.exists
269
270     - name: set fact for glusterfs_device_name (from previous run)
271       set_fact:
272         glusterfs_device_name: "{{ slurp_result.content|b64decode }}"
273       when:
274         - cloud_provider == 'azure'
275         - result | succeeded
276         - install_glusterfs | bool
277         - rfile.stat.exists
278
279     # nfs_pvs
280
281     - name: test if nfs_pvs file is present (previous run)
282       stat:
283         path: /var/preserve/nfs_pvs
284       register: rfile
285
286     - name: Get NFS device
287       changed_when: false
288       vars:
289         query: "[?name == 'support']|[].volumes[?purpose=='nfs'].lun|[0][0]"
290       shell: >
291         parted -m /dev/sda print all 2>/dev/null
292         | grep unknown
293         | grep /dev/sd
294         | cut -d':' -f1
295         | sed -n '{{ (instances|json_query(query)|int) + 1}}p'
296       register: result
297       when:
298         - install_nfs | bool
299         - cloud_provider == 'azure'
300         - instances is defined
301         - not rfile.stat.exists
302
303     - name: set fact for nfs_pvs
304       set_fact:
305         nfs_pvs: "{{ result.stdout }}"
306       when:
307         - install_nfs | bool
308         - cloud_provider == 'azure'
309         - result | succeeded
310         - not rfile.stat.exists
311
312     - name: Write down nfs_pvs for idempotency
313       copy:
314         dest: /var/preserve/nfs_pvs
315         content: "{{ nfs_pvs }}"
316         force: no
317       when:
318         - install_nfs | bool
319         - cloud_provider == 'azure'
320         - result | succeeded
321         - not rfile.stat.exists
322
323     # idempotency
324
325     - name: get nfs_pvs from file (from previous run)
326       slurp:
327         src: /var/preserve/nfs_pvs
328       register: slurp_result
329       when:
330         - cloud_provider == 'azure'
331         - install_nfs | bool
332         - rfile.stat.exists
333
334     - name: set fact for nfs_pvs (from previous run)
335       set_fact:
336         nfs_pvs: "{{ slurp_result.content|b64decode }}"
337       when:
338         - cloud_provider == 'azure'
339         - result | succeeded
340         - install_nfs | bool
341         - rfile.stat.exists
342
343 - name: Detect and map data disks (nodes) for Azure
344   hosts: nodes
345   become: true
346   gather_facts: false
347   vars_files:
348     - "{{ ANSIBLE_REPO_PATH }}/configs/{{ env_type }}/env_vars.yml"
349     - "{{ ANSIBLE_REPO_PATH }}/configs/{{ env_type }}/env_secret_vars.yml"
350   tasks:
351     - name: test if docker_device file is present (previous run)
352       stat:
353         path: /var/preserve/docker_device
354       register: rfile
355
356     - name: Get docker device
357       changed_when: false
358       vars:
359         query: "[?name == 'node']|[].volumes[?purpose=='docker'].lun|[0][0]"
360       shell: >
361         parted -m /dev/sda print all 2>/dev/null
362         | grep unknown
363         | grep /dev/sd
364         | cut -d':' -f1
365         | sed -n '{{ (instances|json_query(query)|int) + 1}}p'
366       register: result
367       when:
368         - cloud_provider == 'azure'
369         - instances is defined
370         - not rfile.stat.exists
371
372     - name: set fact for docker_device
373       set_fact:
374         docker_device: "{{ result.stdout }}"
375       when:
376         - cloud_provider == 'azure'
377         - result | succeeded
378         - not rfile.stat.exists
379
380     - name: Write down docker_device for idempotency
381       copy:
382         dest: /var/preserve/docker_device
383         content: "{{ docker_device }}"
384         force: no
385       when:
386         - cloud_provider == 'azure'
387         - result | succeeded
388         - not rfile.stat.exists
389
390     # idempotency
391
392     - name: get device_name from file (from previous run)
393       slurp:
394         src: /var/preserve/docker_device
395       register: slurp_result
396       when:
397         - cloud_provider == 'azure'
398         - rfile.stat.exists
399
400     - name: set fact for docker_device (from previous run)
401       set_fact:
402         docker_device: "{{ slurp_result.content|b64decode }}"
403       when:
404         - cloud_provider == 'azure'
405         - result | succeeded
406         - rfile.stat.exists
407
408 - name: Detect and map data disks (infranodes) for Azure
409   hosts: infranodes
410   become: true
411   gather_facts: false
412   vars_files:
413     - "{{ ANSIBLE_REPO_PATH }}/configs/{{ env_type }}/env_vars.yml"
414     - "{{ ANSIBLE_REPO_PATH }}/configs/{{ env_type }}/env_secret_vars.yml"
415   tasks:
416     - name: test if docker_device file is present (previous run)
417       stat:
418         path: /var/preserve/docker_device
419       register: rfile
420
421     - name: Get docker device
422       changed_when: false
423       vars:
424         query: "[?name == 'infranode']|[].volumes[?purpose=='docker'].lun|[0][0]"
425       shell: >
426         parted -m /dev/sda print all 2>/dev/null
427         | grep unknown
428         | grep /dev/sd
429         | cut -d':' -f1
430         | sed -n '{{ (instances|json_query(query)|int) + 1}}p'
431       register: result
432       when:
433         - cloud_provider == 'azure'
434         - instances is defined
435         - not rfile.stat.exists
436
437     - name: set fact for docker_device
438       set_fact:
439         docker_device: "{{ result.stdout }}"
440       when:
441         - cloud_provider == 'azure'
442         - result | succeeded
443         - not rfile.stat.exists
444
445     - name: Write down docker_device for idempotency
446       copy:
447         dest: /var/preserve/docker_device
448         content: "{{ docker_device }}"
449         force: no
450       when:
451         - cloud_provider == 'azure'
452         - result | succeeded
453         - not rfile.stat.exists
454
455     # idempotency
456
457     - name: get device_name from file (from previous run)
458       slurp:
459         src: /var/preserve/docker_device
460       register: slurp_result
461       when:
462         - cloud_provider == 'azure'
463         - rfile.stat.exists
464
465     - name: set fact for docker_device (from previous run)
466       set_fact:
467         docker_device: "{{ slurp_result.content|b64decode }}"
468       when:
469         - cloud_provider == 'azure'
470         - result | succeeded
471         - rfile.stat.exists
472
473 - name: Map data disks (masters) for Azure
474   hosts: masters
475   become: true
476   gather_facts: false
477   vars_files:
478     - "{{ ANSIBLE_REPO_PATH }}/configs/{{ env_type }}/env_vars.yml"
479     - "{{ ANSIBLE_REPO_PATH }}/configs/{{ env_type }}/env_secret_vars.yml"
480   tasks:
481     - name: test if docker_device file is present (previous run)
482       stat:
483         path: /var/preserve/docker_device
484       register: rfile
485
486     - name: Get docker device
487       changed_when: false
488       vars:
489         query: "[?name == 'master']|[].volumes[?purpose=='docker'].lun|[0][0]"
490       shell: >
491         parted -m /dev/sda print all 2>/dev/null
492         | grep unknown
493         | grep /dev/sd
494         | cut -d':' -f1
495         | sed -n '{{ (instances|json_query(query)|int) + 1}}p'
496       register: result
497       when:
498         - cloud_provider == 'azure'
499         - instances is defined
500         - not rfile.stat.exists
501
502     - name: set fact for docker_device
503       set_fact:
504         docker_device: "{{ result.stdout }}"
505       when:
506         - cloud_provider == 'azure'
507         - result | succeeded
508         - not rfile.stat.exists
509
510     - name: Write down docker_device for idempotency
511       copy:
512         dest: /var/preserve/docker_device
513         content: "{{ docker_device }}"
514         force: no
515       when:
516         - cloud_provider == 'azure'
517         - result | succeeded
518         - not rfile.stat.exists
519
520     # idempotency
521
522     - name: get device_name from file (from previous run)
523       slurp:
524         src: /var/preserve/docker_device
525       register: slurp_result
526       when:
527         - cloud_provider == 'azure'
528         - rfile.stat.exists
529
530     - name: set fact for docker_device (from previous run)
531       set_fact:
532         docker_device: "{{ slurp_result.content|b64decode }}"
533       when:
534         - cloud_provider == 'azure'
535         - result | succeeded
536         - rfile.stat.exists