Ansible--經常使用模塊使用

時間 2019-11-13

標籤 ansible 經常使用模塊简体版

原文原文鏈接

ansible命令解釋

經過ansible命令執⾏的任務稱爲ad-hoc命令(任務)，其實它是相對playbook⽽⾔的。一般，命令⾏⽤來實現ansible的批量管理功能，playbook⽤來實現批量⾃動化功能。
執行：ansible --help 查看具體的使用幫助
幫助參數詳細說明: html

----------------------------------------------------------------------------------------------------------------
[普通選項]
-a MODULE_ARGS
--args=MODULE_ARGS
傳遞參數給模塊

--ask-vault-pass
詢問vault的密碼

-B SECONDS
--background=SECONDS
異步後臺⽅式執⾏任務，並在指定的秒數後超時，超時會殺掉任務的進程。默認是同步，即保持長鏈接，它會等待
全部執⾏完畢（即阻塞模式）。但有時候是不必這樣的，⽐如某些命令的執⾏時間⽐ssh的超時時間還長。若是
不指定超時秒數，將以同步⽅式運⾏任務

-P POLL_INTERVAL
--poll=POLL_INTERVAL
異步模式下輪詢任務的時間間隔，默認60秒

-C
--check
不對遠程主機作一些改變，而是預測某些可能發生的改變(檢查功能)

-e EXTRA_VARS
--extra-vars=EXTRA_VARS
配置額外的配置變量(key=value或者YAML/JSON格式)

-f FORKS
--forks=FORKS
指定並行處理的進程數量，默認5個

-h
--help
顯示幫助信息

-i INVENTORY
--inventory-file=INVENTORY
指定inventory⽂件，多個⽂件使⽤逗號分隔。默認爲/etc/ansible/hosts

-l SUBSET
--limit=SECONDS
使⽤額外的匹配模式來篩選⽬標主機列表。
此處的匹配模式是在已有匹配模式下進⾏的，因此是更嚴格的篩選。例如指定了主機組的狀況下，使⽤-l選項從中只選⼀臺主機進⾏控制

--list-hosts
不會執行任何操做，而是列出匹配到的主機列表

-m MODULE_NAME
--module-name=MODULE_NAME
指定要執行的模塊名，默認的模塊爲"command"

--new-vault-password-file=NEW_VAULT_PASSWORD_FILE
new vault password f ile f or rekey

-o
--one-line
簡化輸出(一行輸出模式)

--output-OUTPUT_FILE
output f ile name f or encrypt or decrypt; use - f or stdout

--syntax-check
檢查playbook的語法，不會執行

-t TREE
--tree=TREE
記錄輸出到此⽬錄中（測試時以每一個host名如IP地址爲⽂件名記錄，結果記錄到對應的⽂件中）。
此選項在ansible巨慢的時候(如瞬間應該返回的命令還須要10多秒才完成)有奇⽤，或者將ansible的結果重
定向到某個⽂件中也能解決，爲何如此，我也不明⽩(表⾯看來和輸出⽅式有關係)，屢次親測有效。

--vault-password-file=VAULT_PASSWORD_FILE
指定vault密碼文件

-v
--verbose
輸出詳細信息，-vvv和-vvvv輸出更詳細的信息

--version
顯示ansbile的版本

----------------------------------------------------------------------------------------------------------------
[如下是鏈接選項，⽤於控制誰以及如何鏈接主機]
-k
--ask-pass
詢問鏈接時的密碼

--private-key=KEY_FILE
--key-file=KEY_FILE
使用文件來認證SSH鏈接的過程

-u REMOTE_USER
--user=REMOTE_USER
使用指定的用戶名進行鏈接

-c CINNECTION
--connection=CINNECTION
鏈接類型，默認爲ssh。paramiko (SSH), ssh, winrm and local. local is mostly usef ul f or crontab or kickstarts.

-T TIMEOUT
--time=TIMEOUT
鏈接的超時時間，單位爲秒，默認10秒

--ssh-common-args=SSH_COMMON_ARGS
指定傳遞給sftp/scp/ssh等⼯具的通⽤額外參數

--sftp-extra-args=SFTP_EXTRA_ARGS
指定只傳遞給sftp的額外參數，如-f

--scp-extra-args=SCP_EXTRA_ARGS
指定只傳遞給scp的額外參數，如-l

--ssh-extra-args=SSH_EXTRA_ARGS
指定只傳遞給ssh的額外參數，如-R

----------------------------------------------------------------------------------------------------------------
[如下是權限控制選項：控制在⽬標主機上以什麼⾝份和權限運⾏任務]
-s
--sudo
爲運行ansible命令的用戶提高權限爲sudo_user的權限，此命令已經報廢，使用become代替

-u SUDO_USER
--sudo-user=SUDO_USER
指望的sudo_user,默認爲root，已報廢，使用become代替

-S
--su
使⽤su的⽅式執⾏操做，已廢棄，使⽤become替代

-R SU_USER
--su-user=SU_USER
使⽤此user的su執⾏操做，默認爲root，已廢棄，使⽤become替代

-b
--become
使用become的方式升級權限

--become-method=BECOME_METHOD
指定提高權限的方式,可選如下⼏種：sudo/su/pbrun/pf exec/doas/dzdo/ksu/runas值

--become-user=BECOME_USER
要提高爲哪一個user的權限，默認爲root

--ask-sudo-pass
詢問sudo密碼，已廢棄，使⽤become替代

--ask-su-pass
詢問su的密碼，已廢棄，使⽤become替代

-K
--ask-become-pass
詢問become提高權限時的密碼

----------------------------------------------------------------------------------------------------------------

經常使用模塊

ping 模塊

用途:嘗試鏈接被控制端主機，成功返回pong(ping--pong是一對的)
使用方法:node

[root@ansible ~]# ansible-doc -s ping
- name: Try to connect to host, verify a usable python and return `pong' on success
  ping:
      data:                  # Data to return for the `ping' return value. If this parameter is set to `crash', the module will cause an exception.

示例:python

[root@ansible ~]# ansible all -m ping
192.168.192.131 | SUCCESS => {
    "changed": false, 
    "ping": "pong"
}
192.168.192.130 | SUCCESS => {
    "changed": false, 
    "ping": "pong"
}
192.168.192.129 | SUCCESS => {
    "changed": false, 
    "ping": "pong"
}
192.168.192.128 | SUCCESS => {
    "changed": false, 
    "ping": "pong"
}
參數all表明被控制端的全部主機

command 模塊

用途:默認ansible使⽤的模塊是command，便可以執⾏⼀些shell命令
使用方法:mysql

[root@ansible ~]# ansible-doc -s command
- name: Executes a command on a remote node
  command:
      argv:                  # 容許用戶以列表和字符串的形式提供命令，不能同時使用，也沒必要須提供其中一種
      chdir:                 # 在執行命令以前，先cd到指定的目錄下
      creates:               # 用於判斷命令是否要執行，若是指定的文件存在(可使用通配符)存在，則不執行
      free_form:             # 默認的選項，這裏只是顯示，其實是沒有的
      removes:               # 用於判斷命令是否要執行，若是指定的文件存在(可使用通配符)不存在，則不執行
      stdin:                 # 將命令的stdin直接設置爲指定值
      warn:                  # 設置command的警告信息(在/etc/ansible/ansible.cfg中有配置項)

示例:nginx

不加參數執行
[root@ansible ~]# ansible all -a "ls"
192.168.192.130 | CHANGED | rc=0 >>
anaconda-ks.cfg
haha.txt

192.168.192.129 | CHANGED | rc=0 >>
anaconda-ks.cfg
haha.txt
rc.local

chdir參數
[root@ansible ~]# ansible all -a "chdir=/etc/ssh ls"              
192.168.192.129 | CHANGED | rc=0 >>
moduli
ssh_config
sshd_config
ssh_host_ecdsa_key
ssh_host_ecdsa_key.pub
ssh_host_ed25519_key
ssh_host_ed25519_key.pub
ssh_host_rsa_key
ssh_host_rsa_key.pub

192.168.192.130 | CHANGED | rc=0 >>
moduli
ssh_config
sshd_config
ssh_host_ecdsa_key
ssh_host_ecdsa_key.pub
ssh_host_ed25519_key
ssh_host_ed25519_key.pub
ssh_host_rsa_key
ssh_host_rsa_key.pub

creates參數
[root@ansible ~]# ansible all -a "touch haha.txt creates=/root/haha.txt"         
192.168.192.129 | SUCCESS | rc=0 >>
skipped, since /root/haha.txt exists

192.168.192.130 | SUCCESS | rc=0 >>
skipped, since /root/haha.txt exists

removes參數
[root@ansible ~]# ansible all -a "touch haha1.txt removes=/root/haha1.txt"
192.168.192.130 | SUCCESS | rc=0 >>
skipped, since /root/haha1.txt does not exist

192.168.192.129 | SUCCESS | rc=0 >>
skipped, since /root/haha1.txt does not exist

舒適提示:
command不能解析變量(如$HOME)和某些操做符("<", ">", "|", ";"以及"&")，因此明確要使⽤這些不可解析的操做符時，使⽤shell模塊來代替commandsql

shell 模塊

用途:shell和command的⽤法基本⼀樣，實際上shell模塊執⾏命令的⽅式是在遠程使⽤/bin/sh來執⾏的，如/bin/sh ping
使用方法:shell

[root@ansible ~]# ansible-doc -s shell
- name: Execute commands in nodes.
  shell:
      chdir:                 # 在執行命令以前，先cd到指定的目錄下
      creates:               # 用於判斷命令是否要執行，若是指定的文件存在(可使用通配符)存在，則不執行
      executable:            # 再也不使⽤默認的/bin/sh解析並執⾏命令，⽽是使⽤此處指定的命令解析(例如使⽤expect解析expect腳本。必須爲絕對路徑)
      free_form:             # 默認的選項，這裏只是顯示，其實是沒有的
      removes:               # 用於判斷命令是否要執行，若是指定的文件存在(可使用通配符)不存在，則不執行
      stdin:                 # 將命令的stdin直接設置爲指定值
      warn:                  # 設置command的警告信息(在/etc/ansible/ansible.cfg中有配置項)

示例:數組

不加參數執行
[root@ansible ~]# ansible all -m shell -a "ls"
192.168.192.129 | CHANGED | rc=0 >>
anaconda-ks.cfg
haha.txt
rc.local

192.168.192.130 | CHANGED | rc=0 >>
anaconda-ks.cfg
haha.txt

chdir參數
[root@ansible ~]# ansible all -m shell -a "chdir=/etc/ ls | grep ssh" 
192.168.192.129 | CHANGED | rc=0 >>
ssh

192.168.192.130 | CHANGED | rc=0 >>
ssh

creates參數
[root@ansible ~]# ansible all -a "touch haha.txt creates=/root/haha.txt"         
192.168.192.129 | SUCCESS | rc=0 >>
skipped, since /root/haha.txt exists

192.168.192.130 | SUCCESS | rc=0 >>
skipped, since /root/haha.txt exists

removes參數
[root@ansible ~]# ansible all -a "touch haha1.txt removes=/root/haha1.txt"
192.168.192.130 | SUCCESS | rc=0 >>
skipped, since /root/haha1.txt does not exist

192.168.192.129 | SUCCESS | rc=0 >>
skipped, since /root/haha1.txt does not exist

使用在command下不能用的操做符
[root@ansible ~]# ansible all -m shell -a "echo '2131' > haha.txt && cat haha.txt"
192.168.192.130 | CHANGED | rc=0 >>
2131

192.168.192.129 | CHANGED | rc=0 >>
2131

注意:
在ansible中使⽤shell或command模塊⼀定要注意，它們默認不滿⾜冪等性，不少操做會重複執⾏，但有些操做是不容許重複執⾏的。
例如mysql的初始化命令mysql_install_db，它只能在第⼀次配置的過程當中初始化⼀次，其餘任什麼時候候如⾮須要則不容許執⾏。
解決方式:
這時候要實現冪等性，能夠經過模塊的creates和removes選項進⾏判斷，但⽆論如何，在執⾏這兩個模塊的時候都須要考慮要執⾏的命令是否應該實現冪等性緩存

script 模塊

用途:script模塊用於控制遠程主機執行腳本，在執行腳本前，ansible會將本地腳本傳輸到遠程主機，而後在執行，在執行腳本的時候，其採用的是遠程主機上的shell環境
使用方法:安全

[root@ansible ~]# ansible-doc -s script
- name: Runs a local script on a remote node after transferring it
  script:
      chdir:                 # 在遠程執⾏腳本前先切換到此⽬錄下
      creates:               # 當此⽂件存在時，不執⾏腳本。可⽤於實現冪等性。
      decrypt:               # 此選項使用vault控制源文件的自動解密(對使用ansible-vault encrypt 文件名.yml 進行加密的文件解密)
      executable:            # 再也不使⽤默認的/bin/sh解析並執⾏命令，⽽是使⽤此處指定的命令解析(例如使⽤expect解析expect腳本。必須爲絕對路徑)
      free_form:             # 本地待執⾏的腳本路徑、選項、參數。之因此稱爲free_form，是由於它是腳本名+選項+參數。
      removes:               # 當此⽂件不存在時，不執⾏腳本。可⽤於實現冪等性。

示例:

新建一個腳本在ansible管理主機上
[root@ansible ~]# cat test.sh 
#!/bin/bash
echo "Test script module"

不加參數執行
[root@ansible ~]# ansible all -m script -a "test.sh"
192.168.192.130 | CHANGED => {
    "changed": true, 
    "rc": 0, 
    "stderr": "Shared connection to 192.168.192.130 closed.\r\n", 
    "stderr_lines": [
        "Shared connection to 192.168.192.130 closed."
    ], 
    "stdout": "Test script module\r\n", 
    "stdout_lines": [
        "Test script module"
    ]
}
192.168.192.129 | CHANGED => {
    "changed": true, 
    "rc": 0, 
    "stderr": "Shared connection to 192.168.192.129 closed.\r\n", 
    "stderr_lines": [
        "Shared connection to 192.168.192.129 closed."
    ], 
    "stdout": "Test script module\r\n", 
    "stdout_lines": [
        "Test script module"
    ]
}

chdir參數
[root@ansible ~]# ansible all -m script -a "chdir=/etc/ ./test.sh"
192.168.192.130 | CHANGED => {
    "changed": true, 
    "rc": 0, 
    "stderr": "Shared connection to 192.168.192.130 closed.\r\n", 
    "stderr_lines": [
        "Shared connection to 192.168.192.130 closed."
    ], 
    "stdout": "Test script module\r\n", 
    "stdout_lines": [
        "Test script module"
    ]
}
192.168.192.129 | CHANGED => {
    "changed": true, 
    "rc": 0, 
    "stderr": "Shared connection to 192.168.192.129 closed.\r\n", 
    "stderr_lines": [
        "Shared connection to 192.168.192.129 closed."
    ], 
    "stdout": "Test script module\r\n", 
    "stdout_lines": [
        "Test script module"
    ]
}

其餘的參數的使用方法都和shell的參數同樣，這裏就不列舉了！！！

copy 模塊

用途:copy模塊的做用就是拷貝文件,將 ansible 管理主機上的文件拷貝到遠程主機中
使用方法:

[root@ansible ~]# ansible-doc -s copy
- name: Copies files to remote locations
  copy:
      backup:                # 拷貝的同時也建立⼀個包含時間戳信息的備份⽂件，默認爲no,能夠指定爲backup=yes作文件備份
      content:               # 當用content代替src參數的時候，能夠把content指定的內容直接寫到一個文件
      decrypt:               # 此選項使用vault控制源文件的自動解密(對使用ansible-vault encrypt 文件名.yml 進行加密的文件解密)
      dest:                  # ⽬標路徑，只能是絕對路徑，若是拷貝的⽂件是⽬錄，則⽬標路徑必須也是⽬錄
      directory_mode:        # 當對⽬錄作遞歸拷貝時，設置了directory_mode將會使得只拷貝新建⽂件舊⽂件不會被拷貝。默認未設置.
      follow:                # 是否追蹤到連接的源⽂件(follow=yes|on)
      force:                 # 設置爲yes(默認)時，將覆蓋遠程同名⽂件。設置爲no時，忽略同名⽂件的拷貝。
      group:                 # 指定文件拷貝到遠程主機後的屬組，可是遠程主機上必須有對應的組，不然會報錯
      local_follow:          # 是否遵循本地機器中的文件系統連接(local_follow=yes|on)
      mode:                  # 設置遠程⽂件的權限。使⽤數值表⽰時不能省略第⼀位，如0644。也可使⽤'u+rwx'或'u=rw,g=r,o=r'等⽅式設置
      owner:                 # 設置遠程⽂件的全部者
      remote_src:            # 若是yes它會從目標機上搜索src文件(remote_src=yes|on)
      src:                   # 拷貝本地源⽂件到遠程，可以使⽤絕對路徑或相對路徑。若是路徑是⽬錄，且⽬錄後加了斜槓"/"，則只會拷貝⽬錄中的內容到遠程，若是⽬錄後不加斜槓，則拷貝⽬錄本⾝和⽬錄內的內容到遠程
      unsafe_writes:         # 是否以不安全的方式進行，可能致使數據損壞(unsafe_writes=yes|on)
      validate:              # 複製前是否檢驗須要複製目的地的路徑

示例:

這裏作一些經常使用選項的示例

1)不加參數執行(將本地主機上的/root/ansible/ansible-copy-module.sh拷貝到被控端主機/root/ansible/下)
[root@ansible ansible]# ansible all -m copy -a 'src=/root/ansible/ansible-copy-module.sh dest=/root/ansible'     
192.168.192.129 | CHANGED => {
    "changed": true, 
    "checksum": "9e4af9ed468fc3e4bcac3dc3022bb30a9cb85e01", 
    "dest": "/root/ansible", 
    "gid": 0, 
    "group": "root", 
    "md5sum": "10b9ac730043f12b56be19b32746abff", 
    "mode": "0644", 
    "owner": "root", 
    "size": 28, 
    "src": "/root/.ansible/tmp/ansible-tmp-1545791911.48-195372218323444/source", 
    "state": "file", 
    "uid": 0
}
在管理主機上對ansible-copy-module.sh進行修改，而後在執行下面的拷貝前備份

2)backup參數:將本地主機上的/root/ansible/ansible-copy-module.sh拷貝到被控端主機/root/ansible/下(拷貝前備份,這裏的備份是在被控制端進行的)
[root@ansible ansible]# ansible all -m copy -a 'src=/root/ansible/ansible-copy-module.sh dest=/root/ansible backup=yes'
192.168.192.129 | CHANGED => {
    "backup_file": "/root/ansible.4061.2018-12-26@10:40:11~", 
    "changed": true, 
    "checksum": "ac0d55a766b74d8e24a4b028fe5b162a1f026522", 
    "dest": "/root/ansible", 
    "gid": 0, 
    "group": "root", 
    "md5sum": "f4cb7616d498638b01f81d164ebc64e4", 
    "mode": "0644", 
    "owner": "root", 
    "size": 42, 
    "src": "/root/.ansible/tmp/ansible-tmp-1545792010.33-171875446599908/source", 
    "state": "file", 
    "uid": 0
}
在上面能夠看到backup_file這個參數，後面就是備份的路徑(在被控制端主機上查看)

3)owner、group、mode參數
拷貝文件對文件權限和屬主屬組進行改變
[root@ansible ansible]# ansible all -m copy -a 'src=/root/ansible/ansible-copy-module.sh dest=/root/ansible/ owner=sshd group=sshd mode=0644'
192.168.192.129 | CHANGED => {
    "changed": true, 
    "checksum": "ac0d55a766b74d8e24a4b028fe5b162a1f026522", 
    "dest": "/root/ansible/ansible-copy-module.sh", 
    "gid": 74, 
    "group": "sshd", 
    "md5sum": "f4cb7616d498638b01f81d164ebc64e4", 
    "mode": "0644", 
    "owner": "sshd", 
    "size": 42, 
    "src": "/root/.ansible/tmp/ansible-tmp-1545792376.05-245560382140658/source", 
    "state": "file", 
    "uid": 74
}
查看權限
[root@ansible ansible]# ansible all -m shell -a "ls -l /root/ansible/ansible-copy-module.sh"
192.168.192.129 | CHANGED | rc=0 >>
-rw-r--r-- 1 sshd sshd 42 Dec 26 10:46 /root/ansible/ansible-copy-module.sh

4)content參數
將內容直接寫到被控端指定的文件中
[root@ansible ansible]# ansible all -m copy -a "content='my name is zhujingzhi' dest=/root/ansible/my.txt"
192.168.192.129 | CHANGED => {
    "changed": true, 
    "checksum": "4f138d7333fe41ecc4cd8bb08a55c92b9952a65f", 
    "dest": "/root/ansible/my.txt", 
    "gid": 0, 
    "group": "root", 
    "md5sum": "9a6e5e1b3273e1ba2dbec06cc4fd8a0c", 
    "mode": "0644", 
    "owner": "root", 
    "size": 21, 
    "src": "/root/.ansible/tmp/ansible-tmp-1545792591.83-125843029198237/source", 
    "state": "file", 
    "uid": 0
}
查看文件
[root@ansible ansible]# ansible all -m shell -a "cat /root/ansible/my.txt"
192.168.192.129 | CHANGED | rc=0 >>
my name is zhujingzhi!

5)force參數
是否忽略遠程同名文件(默認yes)
[root@ansible ansible]# ansible all -m copy -a "src=/root/ansible/my.txt dest=/root/ansible/my.txt force=no"        
192.168.192.129 | SUCCESS => {
    "changed": false, 
    "dest": "/root/ansible/my.txt", 
    "src": "/root/ansible/my.txt"
}

template 模塊

用途:template模塊⽤法和copy模塊⽤法基本⼀致，它主要⽤於複製配置⽂件
使用方法:

[root@ansible ~]# ansible-doc -s template
- name: Templates a file out to a remote server
  template:
      backup:                # 拷貝的同時也建立⼀個包含時間戳信息的備份⽂件，默認爲no
      block_end_string:      # 標記塊結束的字符串.
      block_start_string:    # 標記塊開頭的字符串.
      dest:                  # 遠程節點上的絕對路徑，用於放置template文件
      follow:                # 是否追蹤到連接的源⽂件(follow=yes|on)
      force:                 # 設置爲yes (默認)時，將覆蓋遠程同名⽂件。設置爲no時，忽略同名⽂件的拷貝
      group:                 # 設置遠程⽂件的所屬組
      lstrip_blocks:         # 若是將其設置爲真正的前導空格，那麼製表符將從行開始剝離到塊。將此選項設置爲True須要Jinja2版本>=2.7
      mode:                  # 設置遠程⽂件的權限。使⽤數值表⽰時不能省略第⼀位，如0644。也可使⽤'u+rwx' or 'u=rw,g=r,o=r'等⽅式設置
      newline_sequence:      # 指定用於模板文件的換行序列.
      output_encoding:       # 改變dest指定模板文件的編碼，默認爲utf8.
      owner:                 # 設置遠程⽂件的全部者
      src:                   # ansible控制器上Jinja2格式的模板所在位置，能夠是相對或絕對路徑.
      trim_blocks:           # 若是將此設置爲True，則刪除塊後的第一個換行(塊，而不是變量標記!).
      unsafe_writes:         # 是否以不安全的方式進行，可能致使數據損壞(unsafe_writes=yes|on)
      validate:              # 在複製到⽬標主機後但放到⽬標位置以前，執⾏此選項指定的命令，⼀般⽤於檢查配置⽂件語法，語法正確則保存到⽬標位置，若是要引⽤⽬標⽂件名，則使⽤%s
      variable_end_string:   # 打印語句結尾的字符串.
      variable_start_string: # 打印語句開頭的字符串

示例:

[root@ansible ~]# ansible all -m template -a "src=/etc/nginx/nginx.conf dest=/etc/nginx/nginx.conf mode=0770 owner=root group=root backup=yes validate='nginx -t -c %s'"
192.168.192.129 | CHANGED => {
    "backup_file": "/etc/nginx/nginx.conf.6179.2018-12-26@11:32:00~", 
    "changed": true, 
    "checksum": "ccc2942c816b4caae696e39dd0b079f97df6cd1a", 
    "dest": "/etc/nginx/nginx.conf", 
    "gid": 0, 
    "group": "root", 
    "md5sum": "96f714838028dea291bcd59b1447e46f", 
    "mode": "0770", 
    "owner": "root", 
    "size": 2468, 
    "src": "/root/.ansible/tmp/ansible-tmp-1545795118.58-264966235377818/source", 
    "state": "file", 
    "uid": 0
}
上的示例我測試的是nginx的配置文件，因此要提早安裝nginx
[root@ansible ~]# ansible all -m shell -a "yum -y install epel-release && yum -y install nginx"

fetch 模塊

用途:從被控遠端機器上拉取文件(和COPY模塊整好相反)
使用方法:

使用方法:
[root@ansible ~]# ansible-doc -s fetch
- name: Fetches a file from remote nodes
  fetch:
      dest:                  # 本地存儲拉取⽂件的⽬錄。例如dest=/data，src=/etc/fstab，遠程主機名host.exp.com，則保存的路徑爲/data/host.exp.com/etc/fstab。
      fail_on_missing:       # 當設置爲yes時，若是拉取的源⽂件不存在，則此任務失敗。默認爲no.
      flat:                  # 改變拉取後的路徑存儲⽅式。若是設置爲yes，且當dest以"/"結尾時，將直接把源⽂件的basename存儲在dest下。顯然，應該考慮多個主機拉取時的⽂件覆蓋狀況。
      src:                   # 遠程主機上的源⽂件。只能是⽂件，不⽀持⽬錄。在將來的版本中可能會⽀持⽬錄遞歸拉取.
      validate_checksum:     # fetch到⽂件後，檢查其md5和源⽂件是否相同

示例:

1) src、dest參數
拉取後的存儲路徑:/root/ansible/192.168.192.129/root/ansible/fetch.sh
[root@ansible ~]# ansible all -m fetch -a "src=/root/ansible/fetch.sh dest=/root/ansible/"     
192.168.192.129 | CHANGED => {
    "changed": true, 
    "checksum": "1d4eef5c77eacf079216ac851ebdde39c7c735ce", 
    "dest": "/root/ansible/192.168.192.129/root/ansible/fetch.sh", 
    "md5sum": "2442ddbfcb138987feedad26be9eccd8", 
    "remote_checksum": "1d4eef5c77eacf079216ac851ebdde39c7c735ce", 
    "remote_md5sum": null
}
2) flat參數
拉取後的存儲路徑：/root/ansible/fetch.sh
[root@ansible ~]# ansible all -m fetch -a "src=/root/ansible/fetch.sh dest=/root/ansible/ flat=yes"
192.168.192.129 | CHANGED => {
    "changed": true, 
    "checksum": "1d4eef5c77eacf079216ac851ebdde39c7c735ce", 
    "dest": "/root/ansible/fetch.sh", 
    "md5sum": "2442ddbfcb138987feedad26be9eccd8", 
    "remote_checksum": "1d4eef5c77eacf079216ac851ebdde39c7c735ce", 
    "remote_md5sum": null
}

3) 使用變量的方式按照變量值存儲
拉取後的存儲路徑:/root/ansible/192.168.192.129/fetch.sh
[root@ansible ~]# ansible all -m fetch -a "src=/root/ansible/fetch.sh dest=/root/ansible/{{inventory_hostname}}/ flat=yes"
192.168.192.129 | CHANGED => {
    "changed": true, 
    "checksum": "1d4eef5c77eacf079216ac851ebdde39c7c735ce", 
    "dest": "/root/ansible/192.168.192.129/fetch.sh", 
    "md5sum": "2442ddbfcb138987feedad26be9eccd8", 
    "remote_checksum": "1d4eef5c77eacf079216ac851ebdde39c7c735ce", 
    "remote_md5sum": null
}
{{inventory_hostname}}表示:192.168.192.129

file 模塊

用途:管理文件、目錄的屬性，也能夠建立文件或者目錄
使用方法:

在file模塊中state參數是十分重要的

[root@ansible ~]# ansible-doc -s file
- name: Sets attributes of files
  file:
      follow:                       # 是否遵循目的機器中的文件系統連接(可選值爲:yes|on)
      force:                        # 當state=link的時候，可配合此參數強制建立連接文件，當force=yes時，表示強制建立連接文件
                                    # 不過強制建立連接文件分爲三種狀況。狀況一：當要建立的連接文件指向的源文件並不存在時，使用此參數，能夠先強制建立出連接文件。
                                    # 狀況二：當要建立連接文件的目錄中已經存在與連接文件同名的文件時，將force設置爲yes，會將同名文件覆蓋爲連接文件，至關於刪除同名文件，建立連接文件。
                                    # 狀況三：當要建立連接文件的目錄中已經存在與連接文件同名的文件，而且連接文件指向的源文件也不存在，這時會強制替換同名文件爲連接文件
      group:                        # 設置遠程⽂件的所屬組
      mode:                         # 設置遠程⽂件的權限。使⽤數值表⽰時不能省略第⼀位，如0644。也可使⽤
      owner:                        # 設置遠程⽂件的全部者
      path:                         # 必須的參數，用於指定要操做的文件或者目錄
      recurse:                      # 當要操做的文件爲目錄，將recurse設置爲yes，能夠遞歸的修改目錄中的文件屬性
      src:                          # 當state設置爲link或者hard時，表示咱們想要建立一個軟連接或者硬連接，因此，咱們必須指明軟連接或硬鏈連接的哪一個文件，經過src參數便可指定連接源
      state:                        # 此參數很是靈活，其對應的值須要根據狀況設定。好比，咱們想要在遠程主機上建立/testdir/a/b目錄，那麼則須要設置path=/testdir/a/b，
                                    # 可是，咱們沒法從」/testdir/a/b「這個路徑看出b是一個文件仍是一個目錄，ansible也一樣沒法單單從一個字符串就知道你要建立文件仍是目錄，因此，咱們須要經過state參數進行說明
                                    # state=directory:表示建立目錄，若是path指定的不存在則被建立
                                    # state=touch:建立文件
                                    # state=link:建立軟連接文件
                                    # state=hard:建立硬連接文件
                                    # state=absent:刪除文件(刪除時不用區分目標是文件、目錄、仍是連接)
      unsafe_writes:                # 是否以不安全的方式進行，可能致使數據損壞(unsafe_writes=yes|on)

示例:

1)state=directory參數(建立目錄)
[root@ansible ~]# ansible all -m file -a "path=/root/file state=directory owner=root group=root mode=0777"   
192.168.192.129 | CHANGED => {
    "changed": true, 
    "gid": 0, 
    "group": "root", 
    "mode": "0777", 
    "owner": "root", 
    "path": "/root/file", 
    "size": 6, 
    "state": "directory", 
    "uid": 0
}
查看結果(很明顯建立了一個file的目錄)
[root@ansible ~]# ansible all -m shell -a "ls -l /root/ | grep file"
192.168.192.129 | CHANGED | rc=0 >>
drwxrwxrwx  2 root root    6 Dec 26 14:33 file

2)state=touch參數(建立文件)
[root@ansible ~]# ansible all -m file -a "path=/root/file/file.txt state=touch owner=root group=root mode=0655"
192.168.192.129 | CHANGED => {
    "changed": true, 
    "dest": "/root/file/file.txt", 
    "gid": 0, 
    "group": "root", 
    "mode": "0655", 
    "owner": "root", 
    "size": 0, 
    "state": "file", 
    "uid": 0
}
查看結果(很明顯建立了一個file的文件)
[root@ansible ~]# ansible all -m shell -a "ls -l /root/file/file.txt"
192.168.192.129 | CHANGED | rc=0 >>
-rw-r-xr-x 1 root root 0 Dec 26 14:36 /root/file/file.txt

3)state=link(建立軟連接文件)
[root@ansible ~]# ansible all -m file -a "path=/root/file/file.txt src=/root/ansible/my.txt state=link owner=root group=root mode=0655" 
192.168.192.129 | CHANGED => {
    "changed": true, 
    "dest": "/root/file/file.txt", 
    "gid": 0, 
    "group": "root", 
    "mode": "0777", 
    "owner": "root", 
    "size": 20, 
    "src": "/root/ansible/my.txt", 
    "state": "link", 
    "uid": 0
}
查看結果(已經發現/root/file/file.txt已經連接到/root/ansible/my.txt)
[root@ansible ~]# ansible all -m shell -a "ls -l /root/file/"    
192.168.192.129 | CHANGED | rc=0 >>
total 0
lrwxrwxrwx 1 root root 20 Dec 26 14:46 file.txt -> /root/ansible/my.txt

舒適提示:這裏須要注意的是src指定的連接文件要存在，若是不存在也想先建立的話要加上force=yes參數

4)state=hard(建立硬連接文件)
[root@ansible ~]# ansible all -m file -a "path=/root/file/file1.txt src=/root/haha.txt state=hard owner=root group=root mode=0655" 
192.168.192.129 | CHANGED => {
    "changed": true, 
    "dest": "/root/file/file1.txt", 
    "gid": 0, 
    "group": "root", 
    "mode": "0655", 
    "owner": "root", 
    "size": 5, 
    "src": "/root/haha.txt", 
    "state": "hard", 
    "uid": 0
}
查看結果(查看兩個文件的內容是否同樣)
[root@ansible ~]# ansible all -m shell -a "cat /root/file/file1.txt && cat /root/haha.txt"
192.168.192.129 | CHANGED | rc=0 >>
2131
2131

5)state=absent(刪除文件)
[root@ansible ~]# ansible all -m file -a "path=/root/file/file1.txt state=absent"
192.168.192.129 | CHANGED => {
    "changed": true, 
    "path": "/root/file/file1.txt", 
    "state": "absent"
}
查看結果(/root/file/file1.txt已經被刪除)
[root@ansible ~]# ansible all -m shell -a "ls -l /root/file"
192.168.192.129 | CHANGED | rc=0 >>
total 0
lrwxrwxrwx 1 root root 20 Dec 26 14:46 file.txt -> /root/ansible/my.txt

6)force參數
在建立軟連接時src指定的文件不存在,能夠添加force=yes參數，先建立軟連接
/root/ansible/file.txt 不存在
[root@ansible ~]# ansible all -m file -a "path=/root/file/file1.txt src=/root/ansible/file.txt state=link owner=root group=root mode=0655 force=yes"
 [WARNING]: Cannot set fs attributes on a non-existent symlink target. follow should be set to False to avoid this.
 # 這個警告可使用follow=no參數取消掉

192.168.192.129 | CHANGED => {
    "changed": true, 
    "dest": "/root/file/file1.txt", 
    "src": "/root/ansible/file.txt", 
    "state": "absent"
}
查看結果(雖然/root/ansible/file.txt文件不存在，可是軟連接也是建立成功的)
[root@ansible ~]# ansible all -m shell -a "ls -l /root/file/"         
192.168.192.129 | CHANGED | rc=0 >>
total 0
lrwxrwxrwx 1 root root 22 Dec 26 14:59 file1.txt -> /root/ansible/file.txt

rsync 模塊

在ansible中rsync模塊的名字叫synchronize

用途:synchronize模塊⽤於實現rsync的簡單版常⽤功能，它⽆法實現完整版的rsync，畢竟rsync功能太多太細緻。若是要使⽤rsync，仍是應該使⽤command或shell模塊來調⽤rsync命令
使用方法:

使用方法:
[root@ansible ~]# ansible-doc -s synchronize
- name: A wrapper around rsync to make common tasks in your playbooks quick and easy.
  synchronize:
      archive:               # 等價於rsync的"-a"選項，即便⽤歸檔模式。它等價於rsync的"-rtopgDl"選項。值爲yes/no.
      checksum:              # 是否對文件進行校驗(在archive(歸檔)開啓的時候checksum也是開啓的).
      compress:              # 是否開啓壓縮，默認是開啓的.
      copy_links:            # 同步的時候是否複製符號連接.
      delete:                # 刪除源中沒有可是目標存在的文件，使兩邊的數據內容一致，已推送爲主須要設置參數recursive=yes結合使用.
      dest:                  # 目標文件及目錄
      dest_port:             # 目標主機上的ssh的端口
      dirs:                  # 不使用遞歸的方式傳送目錄
      existing_only:         # receiver(接收端)沒有的文件不一樣步，但仍會傳輸，只是臨時文件重組後不重命名而已.
      group:                 # 保留所屬組屬性
      link_dest:             # 在rsync期間向硬連接添加目標
      links:                 # 拷貝連接文件自身
      mode:                  # 指定推(push)仍是拉(pull)的傳輸模式
      owner:                 # 保留全部者屬性
      partial:               # 等價於'--partial'選項，默認rsync在傳輸中斷時會刪除傳輸了一半的文件，指定該選項將保留這個部分不完整的文件，使得下次傳輸時能夠直接從未完成的數據塊開始傳輸.
      perms:                 # 保留權限屬性.
      private_key:           # 指定基於ssh的rsync鏈接的私鑰 (例如 `~/.ssh/id_rsa')
      recursive:             # 遞歸到目錄中的文件.
      rsync_opts:            # 指定額外的rsync選項，使用數組的方式傳遞這些選項.
      rsync_path:            # 等價於'--rsync-path'選項，目的是啓動遠程rsync，例如能夠指定[--rsync-path=rsync],甚至[--rsync-path=cd /tmp/c && rsync],當不指定rsync的路徑時，默認是/usr/bin/rsync.
      rsync_timeout:         # 指定rsync在多久時間內沒有數據傳輸就超時退出.
      set_remote_user:       # 主要用於/etc/ansible/hosts中定義或默認使用的用戶與rsync使用的用戶不一樣的狀況.
      src:                   # (必選)指定待傳輸的源⽂件。能夠是相對路徑，也能夠是絕對路徑.
      times:                 # 保留mtime屬性
      use_ssh_args:          # 使用ansible.cfg中配置的ssh_args
      verify_host:           # 對目標主機進行ssh的host key驗證

示例:

舒適提示:在使用synchronize模塊的時候須要在管理機和被控制端的遠程服務器上安裝rsync，保證在管理機和被控制端的遠程服務器上有rsync的命令
安裝rsync：yum -y install rsync
1) 簡簡單單(指定src和dest)
[root@ansible ~]# ansible all -m synchronize -a "src=/root/rsyncfile/ dest=/root/rsyncfile/"
192.168.192.129 | CHANGED => {
    "changed": true, 
    "cmd": "/usr/bin/rsync --delay-updates -F --compress --archive --rsh=/usr/bin/ssh -S none -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null --out-format=<<CHANGED>>%i %n%L /root/rsyncfile/ 192.168.192.129:/root/rsyncfile/", 
    "msg": "cd+++++++++ ./\n<f+++++++++ 123\n<f+++++++++ 313\n<f+++++++++ 31323\n", 
    "rc": 0, 
    "stdout_lines": [
        "cd+++++++++ ./", 
        "<f+++++++++ 123", 
        "<f+++++++++ 313", 
        "<f+++++++++ 31323"
    ]
}
查看結果
[root@ansible ~]# ansible all -m shell -a "ls -l /root/rsyncfile"   
192.168.192.129 | CHANGED | rc=0 >>
total 0
-rw-r--r-- 1 root root 0 Dec 26 15:55 123
-rw-r--r-- 1 root root 0 Dec 26 15:55 313
-rw-r--r-- 1 root root 0 Dec 26 15:55 31323

2) 把本地的/root/rsyncfile目錄以及裏面除了.txt結尾的文件同步到遠程服務器的/root目錄裏面，而且同步/root/rsyncfile目錄以及文件的屬性，還要刪除本地沒有但遠程主機有的文件
/root/rsyncfile目錄下的內容
[root@ansible ~]# ll rsyncfile/
total 0
-rw-r--r-- 1 sshd sshd 0 Dec 26 15:55 123
-rw-r--r-- 1 sshd sshd 0 Dec 26 16:02 1.txt
-rw-r--r-- 1 sshd sshd 0 Dec 26 16:02 2.txx
-rw-r--r-- 1 sshd sshd 0 Dec 26 15:55 313
-rw-r--r-- 1 sshd sshd 0 Dec 26 15:55 31323
-rw-r--r-- 1 sshd sshd 0 Dec 26 16:02 3.txt
-rw-r--r-- 1 sshd sshd 0 Dec 26 16:02 4.py

[root@ansible ~]# ansible all -m synchronize -a "src=/root/rsyncfile dest=/root compress=yes delete=yes archive=yes rsync_opts=--exclude=*.txt"  
192.168.192.129 | CHANGED => {
    "changed": true, 
    "cmd": "/usr/bin/rsync --delay-updates -F --compress --delete-after --archive --rsh=/usr/bin/ssh -S none -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null --exclude=*.txt --out-format=<<CHANGED>>%i %n%L /root/rsyncfile 192.168.192.129:/root", 
    "msg": "cd+++++++++ rsyncfile/\n<f+++++++++ rsyncfile/123\n<f+++++++++ rsyncfile/2.txx\n<f+++++++++ rsyncfile/313\n<f+++++++++ rsyncfile/31323\n<f+++++++++ rsyncfile/4.py\n", 
    "rc": 0, 
    "stdout_lines": [
        "cd+++++++++ rsyncfile/", 
        "<f+++++++++ rsyncfile/123", 
        "<f+++++++++ rsyncfile/2.txx", 
        "<f+++++++++ rsyncfile/313", 
        "<f+++++++++ rsyncfile/31323", 
        "<f+++++++++ rsyncfile/4.py"
    ]
}

查看結果(能夠看到同步過去的文件屬性都和源文件相同，而且沒有同步源文件裏面以.txt結尾的兩個文件)
[root@ansible ~]# ansible all -m shell -a "ls -l /root/rsyncfile"
192.168.192.129 | CHANGED | rc=0 >>
total 0
-rw-r--r-- 1 sshd sshd 0 Dec 26 15:55 123
-rw-r--r-- 1 sshd sshd 0 Dec 26 16:02 2.txx
-rw-r--r-- 1 sshd sshd 0 Dec 26 15:55 313
-rw-r--r-- 1 sshd sshd 0 Dec 26 15:55 31323
-rw-r--r-- 1 sshd sshd 0 Dec 26 16:02 4.py

hostname 模塊

用途:管理配置主機名
使用方法:

[root@ansible ~]# ansible-doc -s hostname
- name: Manage hostname
  hostname:
      name:                  # 必選，主機名稱

示例:

舒適提示:使用這個模塊存在一個問題就是一改主機名緊跟着應該是在這個清單裏面的機器都會被改掉致使主機名徹底相同
是有解決方法的，使用變量的方式進行更改

先針對一臺主機進行修改主機名，瞭解其用法
[root@ansible ~]# ansible 192.168.192.129 -m hostname -a "name=ansible_node1"          
192.168.192.129 | CHANGED => {
    "ansible_facts": {
        "ansible_domain": "", 
        "ansible_fqdn": "ansible_node1", 
        "ansible_hostname": "ansible_node1", 
        "ansible_nodename": "ansible_node1"
    }, 
    "changed": true, 
    "name": "ansible_node1"
}
查看結果(發現主機名已經修改)
[root@ansible ~]# ansible 192.168.192.129 -m shell -a "hostname"
192.168.192.129 | CHANGED | rc=0 >>
ansible_node1

使用hostname模塊修改主機名是直接生效的而且是永久生效

yum 模塊

用途:使用yum包管理器管理包
使用方法:

[root@ansible ~]# ansible-doc -s yum
- name: Manages packages with the `yum' package manager
  yum:
      allow_downgrade:       # 是否容許給現有包的版本進行降級
      autoremove:            # 卸載包而且刪除其全部的依賴包,若是這個依賴包被其餘包所依賴則不會刪除(authorremove=yes)
      bugfix:                # 若是bugfix=yes和state=latest則僅安裝已標記爲與bug修復相關的更新
      conf_file:             # 指定yum.repo配置文件.
      disable_excludes:      # 禁用YUM配置文件中定義的排除(yum.repo文件中的某個塊). 
                             # disable_excludes=all 禁用全部排除
                             # disable_excludes=main 禁用yum.conf中的[main]中定義的排除
                             # disable_excludes=repoid 禁用未給定repo id定義的排除
      disable_gpg_check:     # 安裝包時禁止gpgcheck，僅在state=present或者latest時生效.
      disable_plugin:        # 禁用yum的Loaded plugins(使用yum repolist all | less 查看全部插件)
      disablerepo:           # 禁止指定的repo源，多個repo源使用逗號分隔
      download_only:         # 只下載指定的安裝包，不進行安裝.
      enable_plugin:         # 開啓yum的Loaded plugins(使用yum repolist all | less 查看全部插件).
      enablerepo:            # 明確使用那個repo源
      exclude:               # 排除那些包不安裝，僅在state=present或者latest時生效
      installroot:           # 指定yum安裝包的用戶，用此用戶安裝的只容許root和指定用戶使用
      list:                  # 相似於yum list.
      name:                  # (必選參數)指定包名，能夠指定版本號，多個包可使用逗號分隔
      releasever:            # Specifies an alternative release from which all packages will be installed.
      security:              # 若是設置爲yes和state=latest，則只安裝標記爲與安全相關的更新
      skip_broken:           # 跳過具備損壞的依賴包
      state:                 # 用於指定軟件包的狀態 ，默認值爲present，表示確保軟件包已經安裝
                             # state=present安裝狀態(默認值)
                             # state=installed安裝狀態
                             # state=latest安裝狀態(安裝最新的版本)
                             # state=absent卸載狀態
                             # state=removed卸載狀態
      update_cache:          # 強制yum檢查緩存是否過時，並在須要時從新下載.僅在state=present或者latest時生效.
      update_only:           # 使用最新軟件包時，只更新已安裝的軟件包。不要安裝軟件包.僅在state=present或者latest時生效
      validate_certs:        # 這僅適用於使用https url做爲rpm的源的狀況。例如，用於localinstall。若是設置爲no，則不會驗證SSL證書

示例:

使用nginx和telnet爲例(對應 yum 源未開啓 gpg 驗證，因此須要設置 disable_gpg_check=yes)
這裏輸出的東西太多告終果就不放到博客了(結果綠色和黃色都是執行成功了，紅色爲錯誤)
1) state=present(安裝包)
[root@ansible ~]# ansible all -m yum -a "name=nginx disable_gpg_check=yes state=present"

2) state=installed(安裝包)
[root@ansible ~]# ansible all -m yum -a "name=nginx disable_gpg_check=yes state=installed"

3) state=latest(安裝最新的版本)
[root@ansible ~]# ansible all -m yum -a "name=nginx disable_gpg_check=yes state=latest"

4) state=absent(卸載包)
[root@ansible ~]# ansible all -m yum -a "name=nginx disable_gpg_check=yes state=absent"

5) state=removed(卸載包)
[root@ansible ~]# ansible all -m yum -a "name=nginx disable_gpg_check=yes state=removed"

6) enablerepo(明確使用那個repo源)
[root@ansible ~]# ansible all -m yum -a "name=telnet disable_gpg_check=yes enablerepo=local"

7) disablerepo(禁止指定的repo源，多個repo源使用逗號分隔)
[root@ansible ~]# ansible all -m yum -a "name=telnet disable_gpg_check=yes disablerepo=local"