Ansible - Panduan Cepat

Ansible adalah mesin TI sumber terbuka sederhana yang mengotomatiskan penerapan aplikasi, orkestrasi layanan intra, penyediaan awan, dan banyak alat TI lainnya.

Ansible mudah diterapkan karena tidak menggunakan agen atau infrastruktur keamanan khusus.

Ansible menggunakan playbook untuk menjelaskan pekerjaan otomatisasi, dan playbook menggunakan bahasa yang sangat sederhana yaitu YAML(Ini adalah bahasa serialisasi data yang dapat dibaca manusia & biasanya digunakan untuk file konfigurasi, tetapi dapat digunakan di banyak aplikasi tempat data disimpan) yang sangat mudah bagi manusia untuk memahami, membaca, dan menulis. Oleh karena itu, keuntungannya adalah bahkan orang yang mendukung infrastruktur TI dapat membaca dan memahami playbook dan debug jika diperlukan (YAML - Ini dalam bentuk yang dapat dibaca manusia).

Ansible dirancang untuk penerapan multi-tingkat. Ansible tidak mengelola satu sistem pada satu waktu, ia memodelkan infrastruktur TI dengan menjelaskan semua sistem Anda yang saling terkait. Ansible sepenuhnya tanpa agen yang berarti Ansible bekerja dengan menghubungkan node Anda melalui ssh (secara default). Tetapi jika Anda menginginkan metode lain untuk koneksi seperti Kerberos, Ansible memberikan opsi itu kepada Anda.

Setelah terhubung ke node Anda, Ansible mendorong program kecil yang disebut "Ansible Modules". Mungkin menjalankan modul itu di node Anda dan menghapusnya setelah selesai. Ansible mengelola inventaris Anda dalam file teks sederhana (Ini adalah file host). Ansible menggunakan file host di mana seseorang dapat mengelompokkan host dan dapat mengontrol tindakan pada grup tertentu di buku pedoman.

Contoh File Host

Ini adalah isi dari file host -

#File name: hosts
#Description: Inventory file for your application. Defines machine type abc
node to deploy specific artifacts
# Defines machine type def node to upload
metadata.

[abc-node]
#server1 ansible_host = <target machine for DU deployment> ansible_user = <Ansible
user> ansible_connection = ssh
server1 ansible_host = <your host name> ansible_user = <your unix user>
ansible_connection = ssh

[def-node]
#server2 ansible_host = <target machine for artifact upload>
ansible_user = <Ansible user> ansible_connection = ssh
server2 ansible_host = <host> ansible_user = <user> ansible_connection = ssh

Apa itu Manajemen Konfigurasi

Manajemen konfigurasi dalam istilah Ansible berarti mempertahankan konfigurasi kinerja produk dengan menyimpan catatan dan memperbarui informasi terperinci yang menjelaskan perangkat keras dan perangkat lunak perusahaan.

Informasi tersebut biasanya mencakup versi dan pembaruan yang tepat yang telah diterapkan ke paket perangkat lunak yang diinstal dan lokasi serta alamat jaringan perangkat keras. Misalnya Jika Anda ingin menginstal versi baruWebLogic/WebSphere server di semua mesin yang ada di perusahaan Anda, tidak mungkin bagi Anda untuk pergi dan memperbarui setiap mesin secara manual.

Anda dapat menginstal WebLogic / WebSphere sekaligus di semua mesin Anda dengan buku pedoman dan inventaris Ansible yang ditulis dengan cara yang paling sederhana. Yang harus Anda lakukan adalah mencantumkan alamat IP node Anda di inventaris dan menulis pedoman untuk menginstal WebLogic / WebSphere. Jalankan playbook dari mesin kontrol Anda & itu akan diinstal di semua node Anda.

Bagaimana Ansible Works?

Gambar yang diberikan di bawah ini menunjukkan cara kerja Ansible.

Ansible works dengan menghubungkan ke node Anda dan menjalankan program kecil, yang disebut "Ansible modul "untuk mereka. Ansiblekemudian menjalankan modul ini (melalui SSH secara default), dan menghapusnya setelah selesai. Pustaka modul Anda dapat berada di mesin mana pun, dan tidak ada server, daemon, atau database yang diperlukan.

Node manajemen pada gambar di atas adalah node pengendali (node ​​pengelola) yang mengontrol seluruh eksekusi playbook. Ini adalah node tempat Anda menjalankan penginstalan. File inventaris menyediakan daftar host di mana modul Ansible perlu dijalankan dan node manajemen melakukan koneksi SSH dan mengeksekusi modul kecil di mesin host dan menginstal produk / perangkat lunak.

Beauty dari Ansible adalah menghapus modul setelah diinstal dengan sangat efektif sehingga terhubung ke mesin host, menjalankan instruksi dan jika berhasil diinstal menghapus kode yang telah disalin pada mesin host yang dijalankan.

Di bab ini, kita akan belajar tentang pengaturan lingkungan Ansible.

Proses Instalasi

Terutama, ada dua jenis mesin saat kita berbicara tentang penerapan -

• Control machine - Mesin dari mana kita dapat mengelola mesin lain.

• Remote machine - Mesin yang ditangani / dikendalikan oleh mesin kendali.

Mungkin ada beberapa mesin jarak jauh yang ditangani oleh satu mesin kontrol. Jadi, untuk mengelola mesin jarak jauh kita harus menginstal Ansible di mesin kontrol.

Persyaratan Mesin Kontrol

Ansible dapat dijalankan dari mesin apa pun dengan Python 2 (versi 2.6 atau 2.7) atau Python 3 (versi 3.5 dan lebih tinggi) diinstal.

Note - Windows tidak mendukung mesin kontrol.

Secara default, Ansible menggunakan ssh untuk mengelola mesin jarak jauh.

Ansible tidak menambahkan database apa pun. Tidak memerlukan daemon apa pun untuk memulai atau tetap menjalankannya. Saat mengelola mesin jarak jauh, Ansibledoes notbiarkan semua perangkat lunak terpasang atau berjalan di atasnya. Karenanya, tidak ada pertanyaan tentang cara memutakhirkannya saat pindah ke versi baru.

Ansible dapat dipasang pada mesin kontrol yang memiliki persyaratan yang disebutkan di atas dengan berbagai cara. Anda dapat menginstal rilis terbaru melalui Apt, yum, pkg, pip, OpenCSW, pacman, dll.

Instalasi melalui Apt di Mesin Ubuntu

Untuk menginstal Ansible Anda harus mengkonfigurasi PPA di komputer Anda. Untuk ini, Anda harus menjalankan baris kode berikut -

$ sudo apt-get update $ sudo apt-get install software-properties-common 
$ sudo apt-add-repository ppa:ansible/ansible $ sudo apt-get update 
$ sudo apt-get install ansible

Setelah menjalankan baris kode di atas, Anda siap untuk mengelola mesin jarak jauh melalui Ansible. Jalankan saja Ansible – version untuk memeriksa versi dan hanya untuk memeriksa apakah Ansible diinstal dengan benar atau tidak.

Ansible menggunakan sintaks YAML untuk mengekspresikan playbook Ansible. Bab ini memberikan ikhtisar tentang YAML. Ansible menggunakan YAML karena sangat mudah bagi manusia untuk memahami, membaca, dan menulis jika dibandingkan dengan format data lain seperti XML dan JSON.

Setiap YAML file secara opsional dimulai dengan "---" dan diakhiri dengan "...".

Memahami YAML

Di bagian ini, kita akan mempelajari berbagai cara merepresentasikan data YAML.

pasangan nilai kunci

YAML menggunakan pasangan nilai kunci sederhana untuk mewakili data. Kamus direpresentasikan dalam key: value pair.

Note - Harus ada spasi antara: dan nilai.

Contoh: Catatan siswa

--- #Optional YAML start syntax 
james: 
   name: james john 
   rollNo: 34 
   div: B 
   sex: male 
… #Optional YAML end syntax

Singkatan

Anda juga dapat menggunakan singkatan untuk mewakili kamus.

Contoh

James: {name: james john, rollNo: 34, div: B, sex: male}

Mewakili Daftar

Kami juga dapat mewakili Daftar di YAML. Setiap elemen (anggota) daftar harus ditulis dalam baris baru dengan lekukan yang sama dimulai dengan “-“ (- dan spasi).

Contoh

---
countries:  
   - America 
   - China 
   - Canada 
   - Iceland 
…

Singkatan

Anda juga dapat menggunakan singkatan untuk mewakili daftar.

Contoh

Countries: [‘America’, ‘China’, ‘Canada’, ‘Iceland’]

Daftar di dalam Kamus

Kita dapat menggunakan daftar di dalam kamus, yaitu nilai kunci adalah daftar.

Contoh

---  
james: 
   name: james john 
   rollNo: 34 
   div: B 
   sex: male 
   likes: 
      - maths 
      - physics 
      - english 
…

Daftar Kamus

Kami juga dapat membuat daftar kamus.

Contoh

---  
- james: 
   name: james john 
   rollNo: 34 
      div: B 
   sex: male 
   likes: 
      - maths 
      - physics 
      - english 

- robert: 
      name: robert richardson 
      rollNo: 53 
      div: B 
      sex: male 
   likes: 
      - biology 
      - chemistry 
…

YAML menggunakan “|” untuk menyertakan baris baru sambil menampilkan beberapa baris dan ">" untuk menyembunyikan baris baru sambil menampilkan beberapa baris. Karena ini kita dapat membaca dan mengedit baris besar. Dalam kedua kasus tersebut niat akan diabaikan.

Kami juga bisa mewakili Boolean(Benar / salah) di YAML. dimanaboolean nilai dapat peka huruf besar / kecil.

Contoh

---  
- james: 
   name: james john 
   rollNo: 34 
   div: B 
   sex: male 
   likes: 
      - maths 
      - physics 
      - english 
   
   result: 
      maths: 87 
      chemistry: 45 
      biology: 56 
      physics: 70 
      english: 80 
   
   passed: TRUE 
   
   messageIncludeNewLines: | 
      Congratulation!! 
      You passed with 79% 
   
   messageExcludeNewLines: > 
      Congratulation!! 
      You passed with 79%

Beberapa kata umum terkait dengan Ansible.

Service/Server - Proses pada mesin yang menyediakan layanan.

Machine - Server fisik, vm (mesin virtual) atau wadah.

Target machine - Mesin yang akan kita konfigurasikan dengan Ansible.

Task - Tindakan (jalankan ini, hapus itu) dll yang dikelola oleh Ansible.

Playbook - File yml tempat perintah yang memungkinkan ditulis dan yml dijalankan di mesin.

Perintah ad hoc adalah perintah yang dapat dijalankan secara individual untuk menjalankan fungsi cepat. Perintah ini tidak perlu dilakukan nanti.

Misalnya, Anda harus mereboot semua server perusahaan Anda. Untuk ini, Anda akan menjalankan perintah Adhoc dari '/usr/bin/ansible'.

Perintah ad-hoc ini tidak digunakan untuk manajemen konfigurasi dan penerapan, karena perintah ini digunakan satu kali.

ansible-playbook digunakan untuk manajemen konfigurasi dan penerapan.

Paralelisme dan Perintah Shell

Nyalakan ulang server perusahaan Anda dalam 12 garpu paralel sekaligus. Untuk ini, kita perlu menyiapkan SSHagent untuk koneksi.

$ ssh-agent bash 
$ ssh-add ~/.ssh/id_rsa

Untuk menjalankan reboot untuk semua server perusahaan Anda dalam satu grup, 'abc', dalam 12 garpu paralel -

$ Ansible abc -a "/sbin/reboot" -f 12

Secara default, Ansible akan menjalankan perintah Ad-hoc di atas dari akun pengguna saat ini. Jika Anda ingin mengubah perilaku ini, Anda harus memasukkan nama pengguna dalam perintah Ad-hoc sebagai berikut -

$ Ansible abc -a "/sbin/reboot" -f 12 -u username

Transfer File

Anda dapat menggunakan perintah Ad-hoc untuk melakukan SCP (Secure Copy Protocol) banyak file secara paralel di beberapa mesin.

Mentransfer file ke banyak server / mesin

$ Ansible abc -m copy -a "src = /etc/yum.conf dest = /tmp/yum.conf"

Membuat direktori baru

$ Ansible abc -m file -a "dest = /path/user1/new mode = 777 owner = user1 group = user1 state = directory"

Menghapus seluruh direktori dan file

$ Ansible abc -m file -a "dest = /path/user1/new state = absent"

Mengelola Paket

Perintah Ad-hoc tersedia untuk yum dan apt. Berikut adalah beberapa perintah Ad-hoc yang menggunakan yum.

Perintah berikut memeriksa apakah paket yum diinstal atau tidak, tetapi tidak memperbaruinya.

$ Ansible abc -m yum -a "name = demo-tomcat-1 state = present"

Perintah berikut memeriksa paket tidak diinstal.

$ Ansible abc -m yum -a "name = demo-tomcat-1 state = absent"

Perintah berikut memeriksa versi terbaru dari paket yang diinstal.

$ Ansible abc -m yum -a "name = demo-tomcat-1 state = latest"

Mengumpulkan Fakta

Fakta dapat digunakan untuk mengimplementasikan pernyataan bersyarat dalam pedoman. Anda dapat menemukan informasi adhoc dari semua fakta Anda melalui perintah Ad-hoc berikut -

$ Ansible all -m setup

Pada bab ini, kita akan belajar tentang PlayBooks in Ansible.

Playbook adalah file tempat kode yang memungkinkan ditulis. Playbook ditulis dalam format YAML. YAML adalah singkatan dari Yet Another Markup Language.Playbooksadalah salah satu fitur inti Ansible dan memberi tahu Ansible apa yang harus dijalankan. Mereka seperti daftar tugas untuk Ansible yang berisi daftar tugas.

Playbook berisi langkah-langkah yang ingin dijalankan pengguna pada mesin tertentu. Playbook dijalankan secara berurutan. Playbook adalah blok bangunan untuk semua kasus penggunaan Ansible.

Struktur Playbook

Setiap buku pedoman adalah agregasi dari satu atau lebih permainan di dalamnya. Playbook disusun menggunakan Drama. Bisa ada lebih dari satu permainan di dalam pedoman.

Fungsi permainan adalah untuk memetakan serangkaian instruksi yang ditentukan terhadap tuan rumah tertentu.

YAML adalah bahasa yang diketik dengan ketat; jadi, perhatian ekstra harus diberikan saat menulis file YAML. Ada beberapa editor YAML tetapi kami lebih suka menggunakan editor sederhana seperti notepad ++. Buka saja notepad ++ dan salin dan tempel yaml di bawah ini dan ubah bahasanya menjadi YAML (Bahasa → YAML).

YAML dimulai dengan --- (3 tanda hubung)

Buat Playbook

Mari kita mulai dengan menulis contoh file YAML. Kami akan menelusuri setiap bagian yang ditulis dalam file yaml.

--- 
   name: install and configure DB
   hosts: testServer
   become: yes

   vars: 
      oracle_db_port_value : 1521
   
   tasks:
   -name: Install the Oracle DB
      yum: <code to install the DB>
    
   -name: Ensure the installed service is enabled and running
   service:
      name: <your service name>

Di atas adalah contoh PlayBook di mana kami mencoba untuk membahas sintaks dasar dari sebuah playbook. Simpan konten di atas dalam file sebagaitest.yml. Sintaks YAML harus mengikuti indentasi yang benar dan perlu sedikit berhati-hati saat menulis sintaks.

Tag YAML yang Berbeda

Sekarang mari kita membahas tag YAML yang berbeda. Tag yang berbeda dijelaskan di bawah -

nama

Tag ini menentukan nama dari buku pedoman yang mungkin. Seperti apa yang akan dilakukan oleh pedoman ini. Nama logis apa pun dapat diberikan ke pedoman.

tuan rumah

Tag ini menentukan daftar host atau grup host yang tugasnya ingin kita jalankan. Bidang / tag host adalah wajib. Ini memberi tahu Ansible di mana host untuk menjalankan tugas yang terdaftar. Tugas dapat dijalankan di mesin yang sama atau di mesin jarak jauh. Seseorang dapat menjalankan tugas pada beberapa mesin dan karenanya tag host dapat memiliki grup entri host juga.

vars

Vars tag memungkinkan Anda menentukan variabel yang dapat Anda gunakan di playbook Anda. Penggunaannya mirip dengan variabel dalam bahasa pemrograman apa pun.

tugas

Semua pedoman harus berisi tugas atau daftar tugas yang akan dijalankan. Tugas adalah daftar tindakan yang perlu dilakukan. Bidang tugas berisi nama tugas. Ini berfungsi sebagai teks bantuan untuk pengguna. Ini tidak wajib tetapi terbukti berguna dalam men-debug pedoman. Setiap tugas secara internal terhubung ke sepotong kode yang disebut modul. Modul yang harus dijalankan, dan argumen yang diperlukan untuk modul yang ingin Anda jalankan.

Peran menyediakan kerangka kerja untuk kumpulan variabel, tugas, file, templat, dan modul yang sepenuhnya independen atau saling bergantung.

Di Ansible, peran adalah mekanisme utama untuk memecah buku pedoman menjadi beberapa file. Ini menyederhanakan penulisancomplex playbooks, dan membuatnya lebih mudah untuk digunakan kembali. Pemutusan pedoman memungkinkan Anda untuk secara logis memecah pedoman menjadi komponen yang dapat digunakan kembali.

Setiap peran pada dasarnya terbatas pada fungsionalitas tertentu atau keluaran yang diinginkan, dengan semua langkah yang diperlukan untuk memberikan hasil tersebut baik dalam peran itu sendiri atau dalam peran lain yang dicantumkan sebagai dependensi.

Peran bukanlah pedoman. Peran adalah fungsi kecil yang dapat digunakan secara mandiri tetapi harus digunakan dalam pedoman. Tidak ada cara untuk menjalankan peran secara langsung. Peran tidak memiliki pengaturan eksplisit untuk host mana peran tersebut akan diterapkan.

Buku pedoman tingkat atas adalah jembatan yang menahan tuan rumah dari file inventaris Anda ke peran yang harus diterapkan ke tuan rumah tersebut.

Membuat Peran Baru

Struktur direktori untuk peran sangat penting untuk membuat peran baru.

Struktur Peran

Peran memiliki tata letak terstruktur pada sistem file. Struktur default dapat diubah tetapi untuk saat ini mari kita tetap menggunakan default.

Setiap peran adalah pohon direktori itu sendiri. Nama peran adalah nama direktori di dalam direktori / peran.

$ ansible-galaxy -h

Pemakaian

ansible-galaxy [delete|import|info|init|install|list|login|remove|search|setup] [--help] [options] ...

Pilihan

• -h, --help - Tunjukkan pesan bantuan ini dan keluar.

• -v, --verbose - Mode verbose (-vvv untuk lebih banyak, -vvvv untuk mengaktifkan debugging koneksi)

• --version - Tampilkan nomor versi program dan keluar.

Membuat Direktori Peran

Perintah di atas telah membuat direktori peran.

$ ansible-galaxy init vivekrole 
ERROR! The API server (https://galaxy.ansible.com/api/) is not responding, please try again later. 

$ ansible-galaxy init --force --offline vivekrole - vivekrole was created successfully $ tree vivekrole/ 
vivekrole/ 
├── defaults 
│   └── main.yml 
├── files ├── handlers 
│   └── main.yml 
├── meta 
│   └── main.yml 
├── README.md ├── tasks 
│   └── main.yml 
├── templates ├── tests │   ├── inventory 
│   └── test.yml 
└── vars 
    └── main.yml 
 
8 directories, 8 files

Tidak semua direktori akan digunakan dalam contoh dan kami akan menunjukkan penggunaan beberapa di antaranya dalam contoh.

Memanfaatkan Peran dalam Playbook

Ini adalah kode dari pedoman yang kami tulis untuk tujuan demo. Kode ini dari pedoman vivek_orchestrate.yml. Kami telah menentukan host:tomcat-node dan menyebut dua peran - install-tomcat dan start-tomcat.

Pernyataan masalahnya adalah bahwa kami memiliki perang yang perlu kami terapkan pada mesin melalui Ansible.

--- 
- hosts: tomcat-node 
roles: 
   - {role: install-tomcat} 
   - {role: start-tomcat}

Isi dari struktur direktori tempat kami menjalankan pedoman.

$ ls 
ansible.cfg  hosts  roles  vivek_orchestrate.retry vivek_orchestrate.yml

Ada direktori tugas di bawah setiap direktori dan berisi main.yml. Isi main.yml dari install-tomcat adalah -

--- 
#Install vivek artifacts 
-  
   block: 
      - name: Install Tomcat artifacts
         action: > 
            yum name = "demo-tomcat-1" state = present 
         register: Output 
          
   always: 
      - debug: 
         msg: 
            - "Install Tomcat artifacts task ended with message: {{Output}}" 
            - "Installed Tomcat artifacts - {{Output.changed}}"

Isi main.yml dari start tomcat adalah -

#Start Tomcat          
-  
   block: 
      - name: Start Tomcat 
      command: <path of tomcat>/bin/startup.sh" 
      register: output 
      become: true 
   
   always: 
      - debug: 
         msg: 
            - "Start Tomcat task ended with message: {{output}}" 
            - "Tomcat started - {{output.changed}}"

Keuntungan memecah playbook menjadi peran adalah siapa pun yang ingin menggunakan fitur Instal tomcat dapat memanggil peran Instal Tomcat.

Memecah Pedoman menjadi Peran

Jika bukan karena role tersebut, konten main.yml dari role masing-masing dapat disalin di playbook ymlmengajukan. Tetapi untuk memiliki modularitas, peran dibuat.

Entitas logis apa pun yang dapat digunakan kembali sebagai fungsi yang dapat digunakan kembali, entitas itu dapat dipindahkan ke peran. Contoh untuk ini ditunjukkan di atas

Jalankan perintah untuk menjalankan pedoman.

-vvv option for verbose output – verbose output 
$ cd vivek-playbook/

Ini adalah perintah untuk menjalankan pedoman

$ sudo ansible-playbook -i hosts vivek_orchestrate.yml –vvv 
-----------------------------------------------------------------
-----------------------------------------------------------------------

Keluaran

Output yang dihasilkan seperti yang terlihat di layar -

Menggunakan /users/demo/vivek-playbook/ansible.cfg sebagai file konfigurasi.

PLAYBOOK: vivek_orchestrate.yml *********************************************************
*********************************************************** 
1 plays in vivek_orchestrate.yml 

PLAY [tomcat-node] **********************************************************************
******** ************************************************* 
 
TASK [Gathering Facts] *************************************************
****************************** ********************************************* 
Tuesday 21 November 2017  13:02:05 +0530 (0:00:00.056) 0:00:00.056 ****** 
Using module file /usr/lib/python2.7/sitepackages/ansible/modules/system/setup.py 
<localhost> ESTABLISH LOCAL CONNECTION FOR USER: root 
<localhost> EXEC /bin/sh -c 'echo ~ && sleep 0' 
<localhost> EXEC /bin/sh -c '( umask 77 && mkdir -p "` echo 
   /root/.ansible/tmp/ansible-tmp-1511249525.88-259535494116870 `" && 
   echo ansible-tmp-1511249525.88-259535494116870="` 
   echo /root/.ansible/tmp/ansibletmp-1511249525.88-259535494116870 `" ) && sleep 0' 
<localhost> PUT /tmp/tmpPEPrkd TO 
   /root/.ansible/tmp/ansible-tmp-1511249525.88259535494116870/setup.py 
<localhost> EXEC /bin/sh -c 'chmod u+x 
   /root/.ansible/tmp/ansible-tmp1511249525.88-259535494116870/ 
   /root/.ansible/tmp/ansible-tmp-1511249525.88259535494116870/setup.py && sleep 0' 
<localhost> EXEC /bin/sh -c '/usr/bin/python 
   /root/.ansible/tmp/ansible-tmp1511249525.88-259535494116870/setup.py; rm -rf 
   "/root/.ansible/tmp/ansible-tmp1511249525.88-259535494116870/" > /dev/null 2>&1 && sleep 0' 
ok: [server1] 
META: ran handlers 
 
TASK [install-tomcat : Install Tomcat artifacts] ***********************************
*************************************************************** 
task path: /users/demo/vivek-playbook/roles/install-tomcat/tasks/main.yml:5 
Tuesday 21 November 2017  13:02:07 +0530 (0:00:01.515)       0:00:01.572 ****** 
Using module file /usr/lib/python2.7/sitepackages/ansible/modules/packaging/os/yum.py 
<localhost> ESTABLISH LOCAL CONNECTION FOR USER: root 
<localhost> EXEC /bin/sh -c 'echo ~ && sleep 0' 
<localhost> EXEC /bin/sh -c '( umask 77 && mkdir -p "` echo 
   /root/.ansible/tmp/ansible-tmp-1511249527.34-40247177825302 `" && echo 
   ansibletmp-1511249527.34-40247177825302="` echo 
   /root/.ansible/tmp/ansible-tmp1511249527.34-40247177825302 `" ) && sleep 0' 
<localhost> PUT /tmp/tmpu83chg TO 
   /root/.ansible/tmp/ansible-tmp-1511249527.3440247177825302/yum.py 
<localhost> EXEC /bin/sh -c 'chmod u+x 
   /root/.ansible/tmp/ansible-tmp1511249527.34-40247177825302/ 
   /root/.ansible/tmp/ansible-tmp-1511249527.3440247177825302/yum.py && sleep 0' 
<localhost> EXEC /bin/sh -c '/usr/bin/python 
   /root/.ansible/tmp/ansible-tmp1511249527.34-40247177825302/yum.py; rm -rf 
   "/root/.ansible/tmp/ansible-tmp1511249527.34-40247177825302/" > /dev/null 2>
   &1 && sleep 0' 
changed: [server1] => { 
   "changed": true, 
   "invocation": { 
      "module_args": { 
         "conf_file": null, 
         "disable_gpg_check": false, 
         "disablerepo": null, 
         "enablerepo": null, 
         "exclude": null, 
         "install_repoquery": true, 
         "installroot": "/", 
         "list": null, 
         "name": ["demo-tomcat-1"], 
         "skip_broken": false, 
         "state": "present", 
         "update_cache": false, 
         "validate_certs": true 
      } 
   }, 
   "msg": "", 
   "rc": 0, 
   "results": [ 
      "Loaded plugins: product-id, 
      search-disabled-repos, 
      subscriptionmanager\nThis system is not registered to Red Hat Subscription Management. 
      You can use subscription-manager to register.\nResolving Dependencies\n--> 
      Running transaction check\n---> 
      Package demo-tomcat-1.noarch 0:SNAPSHOT-1 will be installed\n--> Finished Dependency 
      Resolution\n\nDependencies Resolved\n
      \n================================================================================\n 
      Package Arch Version Repository         
      Size\n==================================================================\nInstalling:\n 
      demo-tomcat-1 noarch SNAPSHOT-1 demo-repo1 7.1 M\n\nTransaction 
      Summary\n==================================================================\nInstall  1 
      Package\n\nTotal download size: 7.1 M\nInstalled size: 7.9 M\nDownloading 
         packages:\nRunning transaction 
      check\nRunning transaction test\nTransaction test succeeded\nRunning transaction\n  Installing : 
      demotomcat-1-SNAPSHOT-1.noarch 1/1 \n  Verifying  : 
      demo-tomcat-1-SNAPSHOT-1.noarch 1/1 \n\nInstalled:\n  
      demo-tomcat-1.noarch 0:SNAPSHOT-1 \n\nComplete!\n" 
   ] 
} 
 
TASK [install-tomcat : debug] **********************************************************
*************************************************************************** 
task path: /users/demo/vivek-playbook/roles/install-tomcat/tasks/main.yml:11 
Tuesday 21 November 2017  13:02:13 +0530 (0:00:06.757) 0:00:08.329 ****** 
ok: [server1] => { 
   "changed": false, 
   "msg": [ 
      "Install Tomcat artifacts task ended with message: {
         u'msg': u'', u'changed': True, u'results': 
         [u'Loaded plugins: product-id, 
         search-disabledrepos, 
         subscription-manager\\nThis system is not registered to Red Hat Subscription Management. 
         You can use subscription-manager to register.\\nResolving Dependencies\\n--> 
         Running transaction check\\n---> 
         Package demo-tomcat-1.noarch 0:SNAPSHOT-1 will be installed\\n--> 
         Finished Dependency Resolution\\n
         \\nDependencies 
         Resolved\\n\\n==================================================================\\n 
         Package Arch Version Repository         
         Size\\n======================================================================== 
         =====\\nInstalling:\\n demo-tomcat-1 noarch SNAPSHOT-1 demo-repo1 7.1 M\\n\\nTransaction 
         Summary\\n=========================================================\\nInstall  1 
         Package\\n\\nTotal download size: 7.1 M\\nInstalled size: 7.9 M\\nDownloading 
            packages:\\nRunning 
         transaction check\\nRunning transaction test\\nTransaction test succeeded\\nRunning 
            transaction\\n  
         Installing : demo-tomcat-1-SNAPSHOT-1.noarch 1/1 \\n  Verifying  : 
         demo-tomcat-1-SNAPSHOT-1.noarch
         1/1 \\n\\nInstalled:\\n  demo-tomcat-1.noarch 0:SNAPSHOT-1  \\n\\nComplete!\\n'], u'rc': 0
      }", 
      "Installed Tomcat artifacts - True" 
   ] 
} 
 
TASK [install-tomcat : Clean DEMO environment] ****************************************
************************************************************ 
task path: /users/demo/vivek-playbook/roles/install-tomcat/tasks/main.yml:19 
Tuesday 21 November 2017  13:02:13 +0530 (0:00:00.057) 0:00:08.387 ****** 
[WARNING]: when statements should not include jinja2 templating delimiters such as {{ }} or 
   {% %}. Found: {{installationOutput.changed}} 
 
Using module file /usr/lib/python2.7/sitepackages/ansible/modules/files/file.py 
<localhost> ESTABLISH LOCAL CONNECTION FOR USER: root 
<localhost> EXEC /bin/sh -c 'echo ~ && sleep 0' 
<localhost> EXEC /bin/sh -c '( umask 77 && mkdir -p "` echo 
   /root/.ansible/tmp/ansible-tmp-1511249534.13-128345805983963 `" && echo 
   ansible-tmp-1511249534.13-128345805983963="` echo 
   /root/.ansible/tmp/ansibletmp-1511249534.13-128345805983963 `" ) && sleep 0' 
<localhost> PUT /tmp/tmp0aXel7 TO 
   /root/.ansible/tmp/ansible-tmp-1511249534.13128345805983963/file.py 
<localhost> EXEC /bin/sh -c 'chmod u+x 
   /root/.ansible/tmp/ansible-tmp1511249534.13-128345805983963/ 
   /root/.ansible/tmp/ansible-tmp-1511249534.13128345805983963/file.py && sleep 0' 
<localhost> EXEC /bin/sh -c '/usr/bin/python 
   /root/.ansible/tmp/ansible-tmp1511249534.13-128345805983963/file.py; rm -rf 
   "/root/.ansible/tmp/ansible-tmp1511249534.13-128345805983963/" > /dev/null 2>&1 
   && sleep 0' 
changed: [server1] => { 
   "changed": true, 
      "diff": { 
         "after": { 
            "path": "/users/demo/DEMO", 
            "state": "absent" 
      }, 
      "before": { 
         "path": "/users/demo/DEMO", 
         "state": "directory" 
      } 
   },

   "invocation": { 
      "module_args": { 
         "attributes": null, 
         "backup": null, 
         "content": null, 
         "delimiter": null, 
         "diff_peek": null, 
         "directory_mode": null, 
         "follow": false, 
         "force": false, 
         "group": null, 
         "mode": null, 
         "original_basename": null, 
         "owner": null, 
         "path": "/users/demo/DEMO", 
         "recurse": false, 
         "regexp": null, 
         "remote_src": null, 
         "selevel": null, 
         "serole": null, 
         "setype": null, 
         "seuser": null, 
         "src": null, 
         "state": "absent", 
         "unsafe_writes": null, 
         "validate": null 
      } 
   }, 
   "path": "/users/demo/DEMO", 
   "state": "absent" 
} 
 
TASK [install-tomcat : debug] ********************************************************
************************************************************* 
task path: /users/demo/vivek-playbook/roles/install-tomcat/tasks/main.yml:29 
Tuesday 21 November 2017  13:02:14 +0530 (0:00:00.257)       0:00:08.645 ****** 
ok: [server1] => {
   "changed": false, 
   "msg": [ 
      "Clean DEMO environment task ended with message:{u'diff': {u'after': {u'path': 
         u'/users/demo/DEMO', u'state': u'absent'}, 
      u'before': {u'path': u'/users/demo/DEMO', u'state': u'directory'}}, u'state': u'absent', 
         u'changed': True, u'path': u'/users/demo/DEMO'}", 
      "check value  :True" 
   ] 
} 
 
TASK [install-tomcat : Copy Tomcat to user home] *************************************
******************************************************** 
task path: /users/demo/vivek-playbook/roles/install-tomcat/tasks/main.yml:37 
Tuesday 21 November 2017  13:02:14 +0530 (0:00:00.055)       0:00:08.701 ****** 
[WARNING]: when statements should not include jinja2 templating delimiters such as {{ }} or 
   {% %}. Found: {{installationOutput.changed}} 
 
Using module file /usr/lib/python2.7/sitepackages/ansible/modules/commands/command.py 
<localhost> ESTABLISH LOCAL CONNECTION FOR USER: root 
<localhost> EXEC /bin/sh -c 'echo ~ && sleep 0' 
<localhost> EXEC /bin/sh -c '( umask 77 && mkdir -p "` echo 
   /root/.ansible/tmp/ansible-tmp-1511249534.43-41077200718443 `" && echo 
   ansibletmp-1511249534.43-41077200718443="` echo 
   /root/.ansible/tmp/ansible-tmp1511249534.43-41077200718443 `" ) && sleep 0' 
<localhost> PUT /tmp/tmp25deWs TO 
   /root/.ansible/tmp/ansible-tmp-1511249534.4341077200718443/command.py 
<localhost> EXEC /bin/sh -c 'chmod u+x 
   /root/.ansible/tmp/ansible-tmp1511249534.43-41077200718443/ 
   /root/.ansible/tmp/ansible-tmp-1511249534.4341077200718443/command.py && sleep 0' 
<localhost> EXEC /bin/sh -c '/usr/bin/python 
   /root/.ansible/tmp/ansible-tmp1511249534.43-41077200718443/command.py; rm -rf 
   "/root/.ansible/tmp/ansibletmp-1511249534.43-41077200718443/" > /dev/null 2>&1 
   && sleep 0' 
changed: [server1] => { 
   "changed": true, 
   "cmd": [ 
      "cp", 
      "-r", 
      "/opt/ansible/tomcat/demo", 
      "/users/demo/DEMO/" 
   ],
   "delta": "0:00:00.017923", 
   "end": "2017-11-21 13:02:14.547633", 
   "invocation": { 
      "module_args": { 
         "_raw_params": "cp -r /opt/ansible/tomcat/demo /users/demo/DEMO/", 
         "_uses_shell": false, 
         "chdir": null, 
         "creates": null, 
         "executable": null, 
         "removes": null, 
         "warn": true 
      } 
   }, 
   "rc": 0, 
   "start": "2017-11-21 13:02:14.529710", 
   "stderr": "", 
   "stderr_lines": [], 
   "stdout": "", 
   "stdout_lines": [] 
} 
 
TASK [install-tomcat : debug] ********************************************************
********************************************************** 
task path: /users/demo/vivek-playbook/roles/install-tomcat/tasks/main.yml:47 
Tuesday 21 November 2017  13:02:14 +0530 (0:00:00.260)       0:00:08.961 ****** 
ok: [server1] => { 
   "changed": false, 
   "msg": "Copy Tomcat to user home task ended with message {
      'stderr_lines': [], u'changed': True, u'end': u'2017-11-21 13:02:14.547633', u'stdout': 
      u'', u'cmd': [u'cp', u'-r', u'/opt/ansible/tomcat/demo', u'/users/demo/DEMO/'], u'rc': 0, 
      u'start': u'2017-11-21 13:02:14.529710', u'stderr': u'', u'delta': u'0:00:00.017923', 
      'stdout_lines': []}" 
} 
 
TASK [start-tomcat : Start Tomcat] **************************************************
********************************************************** 
task path: /users/demo/vivek-playbook/roles/start-tomcat/tasks/main.yml:5 
Tuesday 21 November 2017  13:02:14 +0530 (0:00:00.044)       0:00:09.006 ****** 
Using module file /usr/lib/python2.7/sitepackages/ansible/modules/commands/command.py 
<localhost> ESTABLISH LOCAL CONNECTION FOR USER: root 
<localhost> EXEC /bin/sh -c 'echo ~ && sleep 0' 
<localhost> EXEC /bin/sh -c '( umask 77 && mkdir -p "` echo 
   /root/.ansible/tmp/ansible-tmp-1511249534.63-46501211251197 `" && echo 
   ansibletmp-1511249534.63-46501211251197="` echo 
   /root/.ansible/tmp/ansible-tmp1511249534.63-46501211251197 `" ) && sleep 0' 
<localhost> PUT /tmp/tmp9f06MQ TO 
   /root/.ansible/tmp/ansible-tmp-1511249534.6346501211251197/command.py 
<localhost> EXEC /bin/sh -c 'chmod u+x 
   /root/.ansible/tmp/ansible-tmp1511249534.63-46501211251197/ 
   /root/.ansible/tmp/ansible-tmp-1511249534.6346501211251197/command.py && sleep 0' 
<localhost> EXEC /bin/sh -c '/usr/bin/python 
   /root/.ansible/tmp/ansible-tmp1511249534.63-46501211251197/command.py; rm -rf 
   "/root/.ansible/tmp/ansibletmp-1511249534.63-46501211251197/" > /dev/null 2>&1 
   && sleep 0' 
changed: [server1] => { 
   "changed": true, 
   "cmd": [ "/users/demo/DEMO/bin/startup.sh" ], 
   "delta": "0:00:00.020024", 
   "end": "2017-11-21 13:02:14.741649", 
   "invocation": { 
      "module_args": { 
         "_raw_params": "/users/demo/DEMO/bin/startup.sh", 
         "_uses_shell": false, 
         "chdir": null, 
         "creates": null, 
         "executable": null, 
         "removes": null, 
         "warn": true 
      } 
   }, 
   "rc": 0, 
   "start": "2017-11-21 13:02:14.721625", 
   "stderr": "", 
   "stderr_lines": [], 
   "stdout": "Tomcat started.", 
   "stdout_lines": [ "Tomcat started." ] 
} 
 
TASK [start-tomcat : debug] *************************************************
********************************************************************** 
task path: /users/demo/vivek-playbook/roles/start-tomcat/tasks/main.yml:10 
Tuesday 21 November 2017  13:02:14 +0530 (0:00:00.150)       0:00:09.156 ****** 
ok: [server1] => { 
   "changed": false, 
   "msg": [ 
      "Start Tomcat task ended with message: {'
         stderr_lines': [], u'changed': True, u'end': u'2017-11-21 13:02:14.741649', u'stdout': 
         u'Tomcat started.', u'cmd': [u'/users/demo/DEMO/bin/startup.sh'], u'rc': 0, u'start': 
         u'2017-11-21 13:02:14.721625', u'stderr': u'', u'delta': u'0:00:00.020024', 
         'stdout_lines': [u'Tomcat started.']}", 
      "Tomcat started - True" 
   ] 
} 
META: ran handlers 
META: ran handlers 
 
PLAY RECAP ******************************************************************************* 
********************************************************* 
server1  : ok = 9    changed = 4    unreachable = 0    failed = 0 
 
Tuesday 21 November 2017  13:02:14 +0530 (0:00:00.042)       0:00:09.198 ****** 
=============================================================================== 
install-tomcat : Install Tomcat artifacts ------------------------------- 6.76s 
/users/demo/vivek-playbook/roles/install-tomcat/tasks/main.yml:5 -------------- 
Gathering Facts --------------------------------------------------------- 1.52s 
 ------------------------------------------------------------------------------ 
install-tomcat : Copy Tomcat to user home ------------------------------- 0.26s 
/users/demo/vivek-playbook/roles/install-tomcat/tasks/main.yml:37 ------------- 

install-tomcat : Clean DEMO environment --------------------------------- 0.26s 
/users/demo/vivek-playbook/roles/install-tomcat/tasks/main.yml:19 ------------- 

start-tomcat : Start Tomcat --------------------------------------------- 0.15s 
/users/demo/vivek-playbook/roles/start-tomcat/tasks/main.yml:5 ----------------

install-tomcat : debug -------------------------------------------------- 0.06s 
/users/demo/vivek-playbook/roles/install-tomcat/tasks/main.yml:11 ------------- 

install-tomcat : debug -------------------------------------------------- 0.06s 
/users/demo/vivek-playbook/roles/install-tomcat/tasks/main.yml:29 ------------- 

install-tomcat : debug -------------------------------------------------- 0.04s 
/users/demo/vivek-playbook/roles/install-tomcat/tasks/main.yml:47 ------------- 

start-tomcat : debug ---------------------------------------------------- 0.04s 
/users/demo/vivek-playbook/roles/start-tomcat/tasks/main.yml:10 ---------------

Tekan URL berikut dan Anda akan diarahkan ke halaman seperti yang ditunjukkan di bawah ini - http://10.76.0.134:11677/HelloWorld/HelloWorld

Perang yang dikerahkan hanya memiliki servlet yang menampilkan "Hello World". Output rinci menunjukkan waktu yang dibutuhkan oleh setiap tugas karena entri ditambahkan dalam file ansible.cfg -

[defaults] 
callback_whitelist = profile_tasks

Variabel dalam pedoman adalah very similaruntuk menggunakan variabel dalam bahasa pemrograman apa pun. Ini membantu Anda menggunakan dan menetapkan nilai ke variabel dan menggunakannya di mana pun di buku pedoman. Seseorang dapat menempatkan kondisi di sekitar nilai variabel dan menggunakannya dalam pedoman.

Contoh

- hosts : <your hosts> 
vars:
tomcat_port : 8080

Dalam contoh di atas, kami telah menetapkan nama variabel tomcat_port dan menetapkan nilai 8080 ke variabel itu dan dapat menggunakannya di buku pedoman Anda kapan pun diperlukan.

Sekarang mengambil referensi dari contoh yang dibagikan. Kode berikut berasal dari salah satu peran (install-tomcat) -

block: 
   - name: Install Tomcat artifacts 
      action: > 
      yum name = "demo-tomcat-1" state = present 
      register: Output 
          
   always: 
      - debug: 
         msg: 
            - "Install Tomcat artifacts task ended with message: {{Output}}" 
            - "Installed Tomcat artifacts - {{Output.changed}}"

Di sini, outputnya adalah variabel yang digunakan.

Mari kita telusuri semua kata kunci yang digunakan dalam kode di atas -

• block - Sintaks yang memungkinkan untuk mengeksekusi blok tertentu.

• name - Nama blok yang relevan - ini digunakan untuk logging dan membantu debugging yang mana semua blok berhasil dieksekusi.

• action- Kode di sebelah tag aksi adalah tugas yang akan dijalankan. Tindakan lagi adalah kata kunci yang mungkin digunakan di yaml.

• register - Output dari aksi didaftarkan menggunakan kata kunci register dan Output adalah nama variabel yang menampung output aksi.

• always - Sekali lagi kata kunci Ansible, menyatakan bahwa di bawah ini akan selalu dijalankan.

• msg - Menampilkan pesan.

Penggunaan variabel - {{Output}} ->

Ini akan membaca nilai dari variabel Output. Juga seperti yang digunakan di tab msg, ini akan mencetak nilai variabel output.

Selain itu, Anda juga dapat menggunakan sub properti variabel. Seperti dalam kasus memeriksa {{Output.changed}} apakah output berubah dan karenanya menggunakannya.

Penanganan Pengecualian di PlayBooks

Penanganan pengecualian di Ansible mirip dengan penanganan pengecualian dalam bahasa pemrograman apa pun. Contoh penanganan pengecualian dalam playbook ditunjukkan di bawah ini.

tasks: 
   - name: Name of the task to be executed 
      block: 
         - debug: msg = 'Just a debug message , relevant for logging' 
         - command: <the command to execute> 
      
      rescue: 
         - debug: msg = 'There was an exception.. ' 
         - command: <Rescue mechanism for the above exception occurred) 
      
      always: 
         - debug: msg = "this will execute in all scenarios. Always will get logged"

Berikut ini adalah sintaks untuk penanganan pengecualian.

• rescue dan always adalah kata kunci khusus untuk penanganan pengecualian.

• Block adalah tempat kode ditulis (apa pun yang akan dijalankan di mesin Unix).

• Jika perintah yang ditulis di dalam fitur blok gagal, maka eksekusi mencapai blok penyelamatan dan dijalankan. Jika tidak ada kesalahan dalam perintah di bawah fitur blokir, maka penyelamatan tidak akan dijalankan.

• Always dieksekusi dalam semua kasus.

• Jadi jika kita bandingkan sama dengan java, maka mirip dengan try, catch dan akhirnya block.

• Sini, Block mirip dengan try block tempat Anda menulis kode yang akan dieksekusi dan rescue mirip dengan catch block dan always mirip dengan finally.

Loop

Di bawah ini adalah contoh untuk mendemonstrasikan penggunaan Loops in Ansible.

Tugasnya adalah untuk menyalin kumpulan semua file perang dari satu direktori ke folder webapps tomcat.

Sebagian besar perintah yang digunakan dalam contoh di bawah ini sudah dibahas sebelumnya. Di sini, kami akan berkonsentrasi pada penggunaan loop.

Awalnya dalam perintah 'shell' kami telah melakukan ls * .war. Jadi, itu akan mencantumkan semua file perang di direktori.

Output dari perintah itu diambil dalam variabel bernama output.

Untuk mengulang, sintaks 'with_items' digunakan.

with_items: "{{output.stdout_lines}}" -> output.stdout_lines memberi kita output baris demi baris dan kemudian kita mengulang output dengan perintah with_items dari Ansible.

Melampirkan contoh keluaran hanya untuk membuat orang mengerti bagaimana kita menggunakan stdout_lines dalam perintah with_items.

--- 
#Tsting 
- hosts: tomcat-node 
   tasks: 
      - name: Install Apache 
      shell: "ls *.war" 
      register: output 
      args: 
         chdir: /opt/ansible/tomcat/demo/webapps 
      
      - file: 
         src: '/opt/ansible/tomcat/demo/webapps/{{ item }}' 
         dest: '/users/demo/vivek/{{ item }}' 
         state: link 
      with_items: "{{output.stdout_lines}}"

                

                    
                
            

Blok

Buku pedoman secara keseluruhan dipecah menjadi balok-balok. Bagian terkecil dari langkah-langkah untuk dieksekusi ditulis dalam blok. Menulis instruksi khusus dalam blok membantu memisahkan fungsionalitas dan menanganinya dengan penanganan pengecualian jika diperlukan.

Contoh blok tercakup dalam penggunaan variabel, penanganan pengecualian, dan loop di atas.

Persyaratan

Kondisional digunakan ketika seseorang perlu menjalankan langkah tertentu berdasarkan suatu kondisi.

--- 
#Tsting 
- hosts: all 
   vars: 
      test1: "Hello Vivek" 
   tasks: 
      - name: Testing Ansible variable 
      debug: 
         msg: "Equals" 
         when: test1 == "Hello Vivek"

Dalam kasus ini, Sama akan dicetak karena variabel test1 sama dengan yang disebutkan dalam kondisi when. when dapat digunakan dengan kondisi logika OR dan logika AND seperti pada semua bahasa pemrograman.

Ubah saja nilai variabel test1 dari Hello Vivek menjadi Hello World dan lihat hasilnya.

Di bab ini, kita akan mempelajari apa itu eksekusi lanjutan dengan Ansible.

Bagaimana Membatasi Eksekusi berdasarkan Tugas

Ini adalah strategi eksekusi yang sangat penting di mana seseorang hanya perlu mengeksekusi satu eksekusi dan bukan seluruh pedoman. For example, misalkan Anda hanya ingin menghentikan server (jika masalah produksi datang) dan kemudian memposting penerapan tambalan Anda hanya ingin memulai server.

Di sini, di playbook asli, stop and start adalah bagian dari peran yang berbeda dalam playbook yang sama tetapi ini dapat ditangani dengan penggunaan tag. Kami dapat memberikan tag yang berbeda ke peran yang berbeda (yang pada gilirannya akan memiliki tugas) dan karenanya berdasarkan tag yang disediakan oleh pelaksana hanya peran / tugas tertentu yang dijalankan. Jadi untuk contoh yang diberikan di atas, kita dapat menambahkan tag seperti berikut -

- {role: start-tomcat, tags: ['install']}}

Perintah berikut membantu dalam menggunakan tag -

ansible-playbook -i hosts <your yaml> --tags "install" -vvv

Dengan perintah di atas, hanya peran start-tomcat yang akan dipanggil. Tag yang diberikan peka huruf besar / kecil. Pastikan kecocokan tepat diteruskan ke perintah.

Bagaimana Membatasi Eksekusi oleh Host

Ada dua cara untuk mencapai pelaksanaan langkah-langkah khusus pada host tertentu. Untuk peran tertentu, seseorang mendefinisikan host - host spesifik mana yang peran tertentu harus dijalankan.

Contoh

- hosts: <A> 
   environment: "{{your env}}" 
   pre_tasks: 
      - debug: msg = "Started deployment. 
      Current time is {{ansible_date_time.date}} {{ansible_date_time.time}} " 
     
   roles: 
      - {role: <your role>, tags: ['<respective tag>']} 
   post_tasks: 
      - debug: msg = "Completed deployment. 
      Current time is {{ansible_date_time.date}} {{ansible_date_time.time}}" 
 
- hosts: <B> 
   pre_tasks: 
      - debug: msg = "started.... 
      Current time is {{ansible_date_time.date}} {{ansible_date_time.time}} " 
        
   roles: 
      - {role: <your role>, tags: ['<respective tag>']} 
   post_tasks: 
      - debug: msg = "Completed the task.. 
      Current time is {{ansible_date_time.date}} {{ansible_date_time.time}}"

Sesuai contoh di atas, bergantung pada host yang disediakan, peran masing-masing hanya akan dipanggil. Sekarang host A dan B saya ditentukan di host (file inventaris).

Solusi Alternatif

Solusi yang berbeda mungkin dengan menentukan host playbook menggunakan variabel, lalu meneruskan alamat host tertentu melalui --extra-vars -

# file: user.yml  (playbook) 
--- 
- hosts: '{{ target }}' 
   user: ... 
playbook contd….

Menjalankan Playbook

ansible-playbook user.yml --extra-vars "target = "<your host variable>"

Jika {{target}} tidak ditentukan, pedoman tidak melakukan apa pun. Grup dari file host juga dapat dilewati jika perlu. Ini tidak membahayakan jika vars ekstra tidak disediakan.

Playbook menargetkan satu host

$ ansible-playbook user.yml --extra-vars "target = <your hosts variable>" --listhosts

Strategi paling umum untuk men-debug Playbook yang mungkin menggunakan modul yang diberikan di bawah ini -

Debug dan Daftar

Keduanya adalah modul yang tersedia di Ansible. Untuk tujuan debugging, kita perlu menggunakan dua modul dengan bijaksana. Contohnya ditunjukkan di bawah ini.

Gunakan Verbositas

Dengan perintah Ansible, seseorang dapat memberikan tingkat verbositas. Anda dapat menjalankan perintah dengan tingkat verbositas satu (-v) atau dua (-vv).

Poin Penting

Pada bagian ini, kita akan membahas beberapa contoh untuk memahami beberapa konsep.

Jika Anda tidak mengutip argumen yang dimulai dengan variabel. Sebagai contoh,

vars: 
   age_path: {{vivek.name}}/demo/ 
   
{{vivek.name}}

Ini akan membuat kesalahan.

Larutan

vars: 
   age_path: "{{vivek.name}}/demo/" – marked in yellow is the fix. 
 
How to use register -> Copy this code into a yml file say test.yml and run it  
--- 
#Tsting 
- hosts: tomcat-node 
   tasks: 
 
   - shell: /usr/bin/uptime 
      register: myvar 
      - name: Just debugging usage 
         debug: var = myvar

Ketika saya menjalankan kode ini melalui perintah Ansible-playbook -i hosts test.yml, saya mendapatkan output seperti yang ditunjukkan di bawah ini.

Jika Anda melihat yaml, kami telah mendaftarkan output dari perintah ke dalam variabel - myvar dan baru saja mencetak hasilnya.

Teks bertanda kuning, memberitahu kita tentang properti dari variabel –myvar yang dapat digunakan untuk kontrol aliran lebih lanjut. Dengan cara ini kita dapat mengetahui tentang properti yang diekspos dari variabel tertentu. Perintah debug berikut membantu dalam hal ini.

$ ansible-playbook -i hosts test.yml 

PLAY [tomcat-node] ***************************************************************
**************** ****************************************************************
*************** ****************************** 
 
TASK [Gathering Facts] *****************************************************************
************** *****************************************************************
************** ************************** 
Monday 05 February 2018  17:33:14 +0530 (0:00:00.051) 0:00:00.051 ******* 
ok: [server1] 
 
TASK [command] ******************************************************************
************* ******************************************************************
************* ********************************** 
Monday 05 February 2018  17:33:16 +0530 (0:00:01.697) 0:00:01.748 ******* 
changed: [server1] 
 
TASK [Just debugging usage] ******************************************************************
************* ******************************************************************
************* ********************* 
Monday 05 February 2018  17:33:16 +0530 (0:00:00.226) 0:00:01.974 ******* 
ok: [server1] => { 
   "myvar": { 
      "changed": true, 
      "cmd": "/usr/bin/uptime", 
      "delta": "0:00:00.011306", 
      "end": "2018-02-05 17:33:16.424647", 
      "rc": 0, 
      "start": "2018-02-05 17:33:16.413341", 
      "stderr": "", 
      "stderr_lines": [], 
      "stdout": " 17:33:16 up 7 days, 35 min,  1 user,  load average: 0.18, 0.15, 0.14", 
      "stdout_lines": [ 
         " 17:33:16 up 7 days, 35 min,  1 user,  load average: 0.18, 0.15, 0.14" 
      ] 
   } 
} 
 
PLAY RECAP ****************************************************************************
**********************************************************************************
 ************************************** 
server1 : ok = 3    changed = 1    unreachable = 0    failed = 0

Masalah Umum Playbook

Di bagian ini, kita akan belajar tentang beberapa masalah pedoman umum. Masalahnya adalah -

• Quoting
• Indentation

Playbook ditulis dalam format yaml dan dua di atas adalah masalah paling umum di yaml / playbook.

Yaml tidak mendukung indentasi berbasis tab dan mendukung indentasi berbasis spasi, jadi orang harus berhati-hati dalam hal yang sama.

Note - setelah Anda selesai menulis yaml, buka situs ini (https://editor.swagger.io/) dan salin tempel yaml Anda di sisi kiri untuk memastikan bahwa yaml terkompilasi dengan benar. Ini hanya tip.

Kesombongan memenuhi syarat kesalahan dalam peringatan dan juga kesalahan.