使用 RHEL 系统角色自动化系统管理

步骤

1. 创建一个名为 ansible 的用户，来管理并运行 playbook：

   [root@control-node]# useradd ansible

2. 切换到新创建的 ansible 用户：

   [root@control-node]# su - ansible

   以这个用户身份执行其余步骤。

3. 创建一个 SSH 公钥和私钥：

   [ansible@control-node]$ ssh-keygen
   Generating public/private rsa key pair.
   Enter file in which to save the key (/home/ansible/.ssh/id_rsa):
   Enter passphrase (empty for no passphrase): <password>
   Enter same passphrase again: <password>
   ...

   为密钥文件使用推荐的默认位置。

4. 可选： 要防止 Ansible 在每次建立连接时提示您输入 SSH 密钥密码，请配置一个 SSH 代理。

5. 使用以下内容创建 ~/.ansible.cfg 文件：

   [defaults]
   inventory = /home/ansible/inventory
   remote_user = ansible
   
   [privilege_escalation]
   become = True
   become_method = sudo
   become_user = root
   become_ask_pass = True

   注意

   ~/.ansible.cfg 文件中的设置具有更高的优先级，并覆盖全局 /etc/ansible/ansible.cfg 文件中的设置。

   使用这些设置，Ansible 执行以下操作：

   • 管理指定清单文件中的主机。
   • 当帐户建立到受管节点的 SSH 连接时，使用 remote_user 参数中设置的帐户。
   • 使用 sudo 工具，以 root 用户身份在受管节点上执行任务。
   • 每次应用 playbook 时，都会提示输入远程用户的 root 密码。出于安全考虑，建议这样做。

6. 创建一个列出受管主机主机名的 INI 或 YAML 格式的 ~/inventory 文件。您还可以在清单文件中定义主机组。例如，以下是 INI 格式的清单文件，它有三个主机，以及一个名为 US 的主机组：

   managed-node-01.example.com
   
   [US]
   managed-node-02.example.com ansible_host=192.0.2.100
   managed-node-03.example.com

   请注意，控制节点必须能够解析主机名。如果 DNS 服务器无法解析某些主机名，请在主机条目旁边添加 ansible_host 参数来指定其 IP 地址。

7. 安装 RHEL 系统角色：

   • 在没有 Ansible Automation Platform 的 RHEL 主机上，安装 rhel-system-roles 软件包：

     [root@control-node]# yum install rhel-system-roles

     此命令在 /usr/share/ansible/collections/ansible_collections/redhat/rhel_system_roles/ 目录中安装集合，ansible-core 软件包作为依赖项。

   • 在 Ansible Automation Platform 上，以 ansible 用户身份执行以下步骤：

     1. 在 ~/.ansible.cfg 文件中 将 Red Hat Automation hub 定义为内容的主要源。

     2. 从 Red Hat Automation Hub 安装 redhat.rhel_system_roles 集合：

        [ansible@control-node]$ ansible-galaxy collection install redhat.rhel_system_roles

        此命令在 ~/.ansible/collections/ansible_collections/redhat/rhel_system_roles/ 目录中安装集合。

流程

1. 创建一个名为 ansible 的用户：

   [root@managed-node-01]# useradd ansible

   控制节点稍后使用这个用户建立与这个主机的 SSH 连接。

2. 为 ansible 用户设置密码：

   [root@managed-node-01]# passwd ansible
   Changing password for user ansible.
   New password: <password>
   Retype new password: <password>
   passwd: all authentication tokens updated successfully.

   当 Ansible 使用 sudo 以 root 用户身份执行任务时，您必须输入此密码。

3. 在受管主机上安装 ansible 用户的 SSH 公钥：

   1. 以 ansible 用户身份登录到控制节点，并将 SSH 公钥复制到受管节点：

      [ansible@control-node]$ ssh-copy-id managed-node-01.example.com
      /usr/bin/ssh-copy-id: INFO: Source of key(s) to be installed: "/home/ansible/.ssh/id_rsa.pub"
      The authenticity of host 'managed-node-01.example.com (192.0.2.100)' can't be established.
      ECDSA key fingerprint is SHA256:9bZ33GJNODK3zbNhybokN/6Mq7hu3vpBXDrCxe7NAvo.

   2. 当提示时，输入 yes 进行连接：

      Are you sure you want to continue connecting (yes/no/[fingerprint])? yes
      /usr/bin/ssh-copy-id: INFO: attempting to log in with the new key(s), to filter out any that are already installed
      /usr/bin/ssh-copy-id: INFO: 1 key(s) remain to be installed -- if you are prompted now it is to install the new keys

   3. 当提示时，输入密码：

      ansible@managed-node-01.example.com's password: <password>
      
      Number of key(s) added: 1
      
      Now try logging into the machine, with:   "ssh 'managed-node-01.example.com'"
      and check to make sure that only the key(s) you wanted were added.

   4. 通过在控制节点上远程执行命令来验证 SSH 连接：

      [ansible@control-node]$ ssh managed-node-01.example.com whoami
      ansible

4. 为 ansible 用户创建一个 sudo 配置：

   1. 使用 visudo 命令创建并编辑 /etc/sudoers.d/ansible 文件：

      [root@managed-node-01]# visudo /etc/sudoers.d/ansible

      在普通编辑器中使用 visudo 的好处是该工具提供基本的检查，如在安装文件之前解析错误。

   2. 在 /etc/sudoers.d/ansible 文件中配置满足您要求的 sudoers 策略，例如：

      • 要为 ansible 用户授予权限，以便在输入 ansible 用户密码后以此主机上的任何用户和组身份运行所有命令，请使用：

        ansible   ALL=(ALL) ALL

      • 要向 ansible 用户授予权限，以便在不输入 ansible 用户密码的情况下以该主机上任何用户和组的身份运行所有命令，请使用：

        ansible   ALL=(ALL) NOPASSWD: ALL

   或者，配置匹配您安全要求的更精细的策略。有关 sudoers 策略的详情，请查看 sudoers (5) 手册页。

验证

1. 验证您可以在所有受管节点上执行来自控制节点的命令：

   [ansible@control-node]$ ansible all -m ping
   BECOME password: <password>
   managed-node-01.example.com | SUCCESS => {
           ...
       	"ping": "pong"
   }
   ...

   硬编码的所有组会动态包含清单文件中列出的所有主机。

2. 使用 Ansible command 模块，通过在所有受管节点上运行 whoami 工具来验证特权升级是否正常工作：

   [ansible@control-node]$ ansible all -m command -a whoami
   BECOME password: <password>
   managed-node-01.example.com | CHANGED | rc=0 >>
   root
   ...

   如果命令返回 root，则您在受管节点上正确地配置了 sudo。

流程

1. 将敏感变量存储在加密的文件中：

   1. 创建 vault ：

      $ ansible-vault create ~/vault.yml
      New Vault password: <vault_password>
      Confirm New Vault password: <vault_password>

   2. 在 ansible-vault create 命令打开编辑器后，以 <key>: <value> 格式输入敏感数据：

      usr: administrator
      pwd: <password>

   3. 保存更改，并关闭编辑器。Ansible 加密 vault 中的数据。

2. 创建一个包含以下内容的 playbook 文件，如 ~/playbook.yml ：

   ---
   - name: Active Directory integration
     hosts: managed-node-01.example.com
     vars_files:
       - ~/vault.yml
     tasks:
       - name: Join an Active Directory
         ansible.builtin.include_role:
           name: redhat.rhel_system_roles.ad_integration
         vars:
           ad_integration_user: "{{ usr }}"
           ad_integration_password: "{{ pwd }}"
           ad_integration_realm: "ad.example.com"
           ad_integration_allow_rc4_crypto: false
           ad_integration_timesync_source: "time_server.ad.example.com"

   示例 playbook 中指定的设置包括如下：

   ad_integration_allow_rc4_crypto: <true|false>

   配置角色是否在受管节点上激活 AD-SUPPORT 加密策略。默认情况下，RHEL 不支持弱 RC4 加密，但如果 AD 中的 Kerberos 仍然需要 RC4，则您可以通过设置 ad_integration_allow_rc4_crypto: true 来启用这个加密类型。

   如果 Kerberos 使用 AES 加密，则省略此变量或将其设置为 false。

   ad_integration_timesync_source: <time_server>

   指定用于时间同步的 NTP 服务器。Kerberos 需要在 AD 域控制器和域成员中同步时间，以防止重播攻击。如果省略此变量，ad_integration 角色不会使用 timesync RHEL 系统角色在受管节点上配置时间同步。

   有关 playbook 中使用的所有变量的详情，请查看控制节点上的 /usr/share/ansible/roles/rhel-system-roles.ad_integration/README.md 文件。

3. 验证 playbook 语法：

   $ ansible-playbook --ask-vault-pass --syntax-check ~/playbook.yml

   请注意，这个命令只验证语法，不能防止错误的、但有效的配置。

4. 运行 playbook：

   $ ansible-playbook --ask-vault-pass ~/playbook.yml

流程

1. 创建一个包含以下内容的 playbook 文件，如 ~/playbook.yml ：

   ---
   - name: Configuration and management of GRUB boot loader
     hosts: managed-node-01.example.com
     tasks:
       - name: Update existing boot loader entries
         ansible.builtin.include_role:
           name: redhat.rhel_system_roles.bootloader
         vars:
           bootloader_settings:
             - kernel:
                 path: /boot/vmlinuz-5.14.0-362.24.1.el9_3.aarch64
               options:
                 - name: quiet
                   state: present
           bootloader_reboot_ok: true

   示例 playbook 中指定的设置包括如下：

   kernel

   指定与您要更新的引导装载程序条目关联的内核。

   options

   指定要更新您所选的引导装载程序条目（内核）的内核命令行参数。

   bootloader_reboot_ok: true

   角色检测到需要重启才能使更改生效，并对受管节点执行重启。

   有关 playbook 中使用的所有变量的详情，请查看控制节点上的 /usr/share/ansible/roles/rhel-system-roles.bootloader/README.md 文件。

2. 验证 playbook 语法：

   $ ansible-playbook --syntax-check ~/playbook.yml

   请注意，这个命令只验证语法，不能防止错误的、但有效的配置。

3. 运行 playbook：

   $ ansible-playbook ~/playbook.yml

流程

1. 将敏感变量存储在加密的文件中：

   1. 创建 vault ：

      $ ansible-vault create ~/vault.yml
      New Vault password: <vault_password>
      Confirm New Vault password: <vault_password>

   2. 在 ansible-vault create 命令打开编辑器后，以 <key>: <value> 格式输入敏感数据：

      pwd: <password>

   3. 保存更改，并关闭编辑器。Ansible 加密 vault 中的数据。

2. 创建一个包含以下内容的 playbook 文件，如 ~/playbook.yml ：

   ---
   - name: Configuration and management of GRUB boot loader
     hosts: managed-node-01.example.com
     vars_files:
       - ~/vault.yml
     tasks:
       - name: Set the bootloader password
         ansible.builtin.include_role:
           name: redhat.rhel_system_roles.bootloader
         vars:
           bootloader_password: "{{ pwd }}"
           bootloader_reboot_ok: true

   示例 playbook 中指定的设置包括如下：

   bootloader_password: "{{ pwd }}"

   变量确保使用密码保护引导参数。

   bootloader_reboot_ok: true

   角色检测到需要重启才能使更改生效，并对受管节点执行重启。

   重要

   更改引导装载程序密码不是幂等的事务。这意味着，如果您再次应用同样的 Ansible playbook，则结果将不一样，并且受管节点的状态将改变。

   有关 playbook 中使用的所有变量的详情，请查看控制节点上的 /usr/share/ansible/roles/rhel-system-roles.bootloader/README.md 文件。

3. 验证 playbook 语法：

   $ ansible-playbook --syntax-check --ask-vault-pass ~/playbook.yml

   请注意，这个命令只验证语法，不能防止错误的、但有效的配置。

4. 运行 playbook：

   $ ansible-playbook --ask-vault-pass ~/playbook.yml

验证

1. 在受管节点上的 GRUB 引导菜单屏幕中，按 e 键进行编辑。

   

2. 提示您输入用户名和密码：

   

   输入用户名: root

   引导装载程序用户名始终是 root，您不需要在 Ansible playbook 中指定它。

   输入 password: <password>

   引导装载程序密码对应于您在 vault.yml 文件中定义的 pwd 变量。

3. 您可以查看或编辑特定引导装载程序条目的配置：

   

流程

1. 创建一个包含以下内容的 playbook 文件，如 ~/playbook.yml ：

   ---
   - name: Configuration and management of the GRUB boot loader
     hosts: managed-node-01.example.com
     tasks:
       - name: Update the boot loader timeout
         ansible.builtin.include_role:
           name: redhat.rhel_system_roles.bootloader
         vars:
           bootloader_timeout: 10

   示例 playbook 中指定的设置包括如下：

   bootloader_timeout: 10

   输入一个整数，以控制在引导默认条目之前 GRUB 引导装载程序菜单显示多长时间。

   有关 playbook 中使用的所有变量的详情，请查看控制节点上的 /usr/share/ansible/roles/rhel-system-roles.bootloader/README.md 文件。

2. 验证 playbook 语法：

   $ ansible-playbook --syntax-check ~/playbook.yml

   请注意，这个命令只验证语法，不能防止错误的、但有效的配置。

3. 运行 playbook：

   $ ansible-playbook ~/playbook.yml

验证

1. 远程重启受管节点：

   # ansible managed-node-01.example.com -m ansible.builtin.reboot
   managed-node-01.example.com | CHANGED => {
       "changed": true,
       "elapsed": 21,
       "rebooted": true
   }

2. 在受管节点上，观察 GRUB 引导菜单屏幕。

   

   突出显示的条目将在 10s 后自动执行

   在 GRUB 自动使用默认条目之前，此引导菜单显示多长时间。

   • 替代方案：您可以远程查询受管节点的 /boot/grub2/grub.cfg 文件中的"timeout"设置：

     # ansible managed-node-01.example.com -m ansible.builtin.command -a "grep 'timeout' /boot/grub2/grub.cfg"
     managed-node-01.example.com | CHANGED | rc=0 >>
     if [ x$feature_timeout_style = xy ] ; then
       set timeout_style=menu
       set timeout=10
     # Fallback normal timeout code in case the timeout_style feature is
       set timeout=10
     if [ x$feature_timeout_style = xy ] ; then
         set timeout_style=menu
         set timeout=10
         set orig_timeout_style=${timeout_style}
         set orig_timeout=${timeout}
           # timeout_style=menu + timeout=0 avoids the countdown code keypress check
           set timeout_style=menu
           set timeout=10
           set timeout_style=hidden
           set timeout=10
     if [ x$feature_timeout_style = xy ]; then
       if [ "${menu_show_once_timeout}" ]; then
         set timeout_style=menu
         set timeout=10
         unset menu_show_once_timeout
         save_env menu_show_once_timeout

流程

1. 创建一个包含以下内容的 playbook 文件，如 ~/playbook.yml ：

   ---
   - name: Configuration and management of GRUB boot loader
     hosts: managed-node-01.example.com
     tasks:
       - name: Gather information about the boot loader configuration
         ansible.builtin.include_role:
           name: redhat.rhel_system_roles.bootloader
         vars:
           bootloader_gather_facts: true
   
       - name: Display the collected boot loader configuration information
         debug:
           var: bootloader_facts

   有关 playbook 中使用的所有变量的详情，请查看控制节点上的 /usr/share/ansible/roles/rhel-system-roles.bootloader/README.md 文件。

2. 验证 playbook 语法：

   $ ansible-playbook --syntax-check ~/playbook.yml

   请注意，这个命令只验证语法，不能防止错误的、但有效的配置。

3. 运行 playbook：

   $ ansible-playbook ~/playbook.yml

流程

1. 创建一个包含以下内容的 playbook 文件，如 ~/playbook.yml ：

   ---
   - name: Create certificates
     hosts: managed-node-01.example.com
     tasks:
       - name: Create a self-signed certificate
         ansible.builtin.include_role:
           name: redhat.rhel_system_roles.certificate
         vars:
           certificate_requests:
             - name: web-server
               ca: ipa
               dns: www.example.com
               principal: HTTP/www.example.com@EXAMPLE.COM
               run_before: systemctl stop httpd.service
               run_after: systemctl start httpd.service

   示例 playbook 中指定的设置包括如下：

   name: <path_or_file_name>

   定义生成的私钥和证书文件的名称或路径：

   • 如果将变量设置为 web-server，则角色会将私钥存储在 /etc/pki/tls/private/web-server.key 中，并将证书存储在 /etc/pki/tls/certs/web-server.crt 文件中。

   • 如果将变量设置为一个路径，如 /tmp/web-server，则角色会将私钥存储在 /tmp/web-server.key 中，并将证书存储在 /tmp/web-server.crt 文件中。

     请注意，您使用的目录必须设置了 cert_t SELinux 上下文。您可以使用 selinux RHEL 系统角色管理 SELinux 上下文。

   ca: ipa

   定义角色从 IdM CA 请求证书。

   dns: <hostname_or_list_of_hostnames>

   设置发布的证书中的 Subject Alternative Names (SAN)字段包含的主机名。您可以使用通配符(*)或以 YAML 列表格式指定多个名称。

   principal: <kerberos_principal>

   可选：设置应该在证书中包含的 Kerberos 主体。

   run_before: <command>

   可选：定义 certmonger 在从 CA 请求证书之前应执行的命令。

   run_after: <command>

   可选：定义 certmonger 在从 CA 收到发布的证书后应该执行的命令。

   有关 playbook 中使用的所有变量的详情，请查看控制节点上的 /usr/share/ansible/roles/rhel-system-roles.certificate/README.md 文件。

2. 验证 playbook 语法：

   $ ansible-playbook --syntax-check ~/playbook.yml

   请注意，这个命令只验证语法，不能防止错误的、但有效的配置。

3. 运行 playbook：

   $ ansible-playbook ~/playbook.yml

流程

1. 创建一个包含以下内容的 playbook 文件，如 ~/playbook.yml ：

   ---
   - name: Create certificates
     hosts: managed-node-01.example.com
     tasks:
       - name: Create a self-signed certificate
         ansible.builtin.include_role:
           name: redhat.rhel_system_roles.certificate
         vars:
           certificate_requests:
             - name: web-server
               ca: self-sign
               dns: test.example.com

   示例 playbook 中指定的设置包括如下：

   name: <path_or_file_name>

   定义生成的私钥和证书文件的名称或路径：

   • 如果将变量设置为 web-server，则角色会将私钥存储在 /etc/pki/tls/private/web-server.key 中，并将证书存储在 /etc/pki/tls/certs/web-server.crt 文件中。

   • 如果将变量设置为一个路径，如 /tmp/web-server，则角色会将私钥存储在 /tmp/web-server.key 中，并将证书存储在 /tmp/web-server.crt 文件中。

     请注意，您使用的目录必须设置了 cert_t SELinux 上下文。您可以使用 selinux RHEL 系统角色管理 SELinux 上下文。

   ca: self-sign

   定义角色创建了一个自签名证书。

   dns: <hostname_or_list_of_hostnames>

   设置发布的证书中的 Subject Alternative Names (SAN)字段包含的主机名。您可以使用通配符(*)或以 YAML 列表格式指定多个名称。

   有关 playbook 中使用的所有变量的详情，请查看控制节点上的 /usr/share/ansible/roles/rhel-system-roles.certificate/README.md 文件。

2. 验证 playbook 语法：

   $ ansible-playbook --syntax-check ~/playbook.yml

   请注意，这个命令只验证语法，不能防止错误的、但有效的配置。

3. 运行 playbook：

   $ ansible-playbook ~/playbook.yml

流程

1. 创建一个包含以下内容的 playbook 文件，如 ~/playbook.yml ：

   ---
   - name: Manage the RHEL web console
     hosts: managed-node-01.example.com
     tasks:
       - name: Install RHEL web console
         ansible.builtin.include_role:
           name: redhat.rhel_system_roles.cockpit
         vars:
           cockpit_packages: default
           cockpit_manage_selinux: true
           cockpit_manage_firewall: true
           cockpit_certificates:
             - name: /etc/cockpit/ws-certs.d/01-certificate
               dns: ['localhost', 'www.example.com']
               ca: ipa

   示例 playbook 中指定的设置包括如下：

   cockpit_manage_selinux: true

   允许使用 selinux 系统角色配置 SELinux，以对 websm_port_t SELinux 类型设置正确的端口权限。

   cockpit_manage_firewall: true

   允许 cockpit 系统角色使用 firewalld 系统角色添加端口。

   cockpit_certificates: <YAML_dictionary>

   默认情况下，RHEL web 控制台使用自签名证书。或者，您可以将 cockpit_certificates 变量添加到 playbook 中，并将角色配置为从 IdM 证书颁发机构(CA)请求证书，或使用受管节点上的提供的现有的证书和私钥。

   有关 playbook 中使用的所有变量的详情，请查看控制节点上的 /usr/share/ansible/roles/rhel-system-roles.cockpit/README.md 文件。

2. 验证 playbook 语法：

   $ ansible-playbook --syntax-check ~/playbook.yml

   请注意，这个命令只验证语法，不能防止错误的、但有效的配置。

3. 运行 playbook：

   $ ansible-playbook ~/playbook.yml

流程

1. 创建一个包含以下内容的 playbook 文件，如 ~/playbook.yml ：

   ---
   - name: Configure cryptographic policies
     hosts: managed-node-01.example.com
     tasks:
       - name: Configure the FUTURE cryptographic security policy on the managed node
         ansible.builtin.include_role:
           name: redhat.rhel_system_roles.crypto_policies
         vars:
           - crypto_policies_policy: FUTURE
           - crypto_policies_reboot_ok: true

   示例 playbook 中指定的设置包括如下：

   crypto_policies_policy: FUTURE

   在受管节点上配置所需的加密策略(FUTURE)。它可以是基本策略，也可以是带有一些子策略的基本策略。指定的基本策略和子策略必须在受管节点上可用。默认值为 null。这意味着配置没有改变，crypto_policies RHEL 系统角色将只收集 Ansible 事实。

   crypto_policies_reboot_ok: true

   加密策略更改后导致系统重启，以确保所有服务和应用程序都将读取新的配置文件。默认值为 false。

   有关 playbook 中使用的所有变量的详情，请查看控制节点上的 /usr/share/ansible/roles/rhel-system-roles.crypto_policies/README.md 文件。

2. 验证 playbook 语法：

   $ ansible-playbook --syntax-check ~/playbook.yml

   请注意，这个命令只验证语法，不能防止错误的、但有效的配置。

3. 运行 playbook：

   $ ansible-playbook ~/playbook.yml

验证

1. 在控制节点上，创建另一个 playbook，例如 verify_playbook.yml ：

   ---
   - name: Verification
     hosts: managed-node-01.example.com
     tasks:
       - name: Verify active cryptographic policy
         ansible.builtin.include_role:
           name: redhat.rhel_system_roles.crypto_policies
       - name: Display the currently active cryptographic policy
         ansible.builtin.debug:
           var: crypto_policies_active

   示例 playbook 中指定的设置包括如下：

   crypto_policies_active

   导出的 Ansible 事实包含当前活动的 crypto_policies_policy 变量可接受的格式的策略名称。

2. 验证 playbook 语法：

   $ ansible-playbook --syntax-check ~/verify_playbook.yml

3. 运行 playbook：

   $ ansible-playbook ~/verify_playbook.yml
   TASK [debug] **************************
   ok: [host] => {
       "crypto_policies_active": "FUTURE"
   }

   crypto_policies_active 变量显示受管节点上活动的策略。

流程

1. 创建一个包含以下内容的 playbook 文件，如 ~/playbook.yml ：

   ---
   - name: Configuring fapolicyd
     hosts: managed-node-01.example.com
     tasks:
       - name: Allow only executables installed from RPM database and specific files
         ansible.builtin.include_role:
           name: redhat.rhel_system_roles.fapolicyd
         vars:
           fapolicyd_setup_permissive: false
           fapolicyd_setup_integrity: sha256
           fapolicyd_setup_trust: rpmdb,file
           fapolicyd_add_trusted_file:
             - <path_to_allowed_command>
             - <path_to_allowed_service>

   示例 playbook 中指定的设置包括如下：

   fapolicyd_setup_permissive: <true|false>

   启用或禁用向内核发送策略决策以强制执行。出于调试和测试目的，将此变量设置为 false。

   fapolicyd_setup_integrity: <type_type>

   定义完整性检查方法。您可以设置以下值之一：

   • none（默认）：禁用完整性检查。
   • size ：服务仅比较允许的应用程序的文件大小。
   • ima: 服务检查内核完整性测量架构(IMA)存储在文件的扩展属性中的 SHA-256 哈希。此外，服务也执行大小检查。请注意，该角色不会配置 IMA 内核子系统。要使用这个选项，您必须手动配置 IMA 子系统。
   • sha256 ：该服务比较允许的应用程序的 SHA-256 哈希。

   fapolicyd_setup_trust: <trust_backends>

   定义信任后端的列表。如果您包含了 file 后端，请在 fapolicyd_add_trusted_file 列表中指定允许的可执行文件。

   有关 playbook 中使用的所有变量的详情，请查看控制节点上的 /usr/share/ansible/roles/rhel-system-roles.fapolicyd.README.md 文件。

2. 验证 playbook 语法：

   $ ansible-playbook ~/playbook.yml --syntax-check

   请注意，这个命令只验证语法，不能防止错误的、但有效的配置。

3. 运行 playbook：

   $ ansible-playbook ~/playbook.yml

流程

1. 创建一个包含以下内容的 playbook 文件，如 ~/playbook.yml ：

   ---
   - name: Reset firewalld example
     hosts: managed-node-01.example.com
     tasks:
       - name: Reset firewalld
         ansible.builtin.include_role:
           name: redhat.rhel_system_roles.firewall
         vars:
           firewall:
             - previous: replaced

   示例 playbook 中指定的设置包括如下：

   previous: replaced

   删除所有现有的用户定义的设置，并将 firewalld 设置重置为默认值。如果将 previous:replaced 参数与其他设置相结合，则 firewall 角色会在应用新设置前删除所有现有设置。

   有关 playbook 中使用的所有变量的详情，请查看控制节点上的 /usr/share/ansible/roles/rhel-system-roles.firewall/README.md 文件。

2. 验证 playbook 语法：

   $ ansible-playbook --syntax-check ~/playbook.yml

   请注意，这个命令只验证语法，不能防止错误的、但有效的配置。

3. 运行 playbook：

   $ ansible-playbook ~/playbook.yml

流程

1. 创建一个包含以下内容的 playbook 文件，如 ~/playbook.yml ：

   ---
   - name: Configure firewalld
     hosts: managed-node-01.example.com
     tasks:
       - name: Forward incoming traffic on port 8080 to 443
         ansible.builtin.include_role:
           name: redhat.rhel_system_roles.firewall
         vars:
           firewall:
             - forward_port: 8080/tcp;443;
               state: enabled
               runtime: true
               permanent: true

   示例 playbook 中指定的设置包括如下：

   forward_port: 8080/tcp;443

   使用 TCP 协议进入到本地端口 8080 的流量被转发到端口 443。

   runtime: true

   启用运行时配置中的更改。默认值被设置为 true。

   有关 playbook 中使用的所有变量的详情，请查看控制节点上的 /usr/share/ansible/roles/rhel-system-roles.firewall/README.md 文件。

2. 验证 playbook 语法：

   $ ansible-playbook --syntax-check ~/playbook.yml

   请注意，这个命令只验证语法，不能防止错误的、但有效的配置。

3. 运行 playbook：

   $ ansible-playbook ~/playbook.yml

流程

1. 创建一个包含以下内容的 playbook 文件，如 ~/playbook.yml ：

   ---
   - name: Configure firewalld
     hosts: managed-node-01.example.com
     tasks:
       - name: Creating a DMZ with access to HTTPS port and masquerading for hosts in DMZ
         ansible.builtin.include_role:
           name: redhat.rhel_system_roles.firewall
         vars:
           firewall:
             - zone: dmz
               interface: enp1s0
               service: https
               state: enabled
               runtime: true
               permanent: true

   有关 playbook 中使用的所有变量的详情，请查看控制节点上的 /usr/share/ansible/roles/rhel-system-roles.firewall/README.md 文件。

2. 验证 playbook 语法：

   $ ansible-playbook --syntax-check ~/playbook.yml

   请注意，这个命令只验证语法，不能防止错误的、但有效的配置。

3. 运行 playbook：

   $ ansible-playbook ~/playbook.yml

流程

1. 将敏感变量存储在加密的文件中：

   1. 创建 vault ：

      $ ansible-vault create ~/vault.yml
      New Vault password: <vault_password>
      Confirm New Vault password: <vault_password>

   2. 在 ansible-vault create 命令打开编辑器后，以 <key>: <value> 格式输入敏感数据：

      cluster_password: <cluster_password>

   3. 保存更改，并关闭编辑器。Ansible 加密 vault 中的数据。

2. 创建一个包含以下内容的 playbook 文件，如 ~/playbook.yml ：

   ---
   - name: Create a high availability cluster
     hosts: node1 node2
     vars_files:
       - ~/vault.yml
     tasks:
       - name: Create TLS certificates and key files in a high availability cluster
         ansible.builtin.include_role:
           name: redhat.rhel_system_roles.ha_cluster
         vars:
           ha_cluster_cluster_name: my-new-cluster
           ha_cluster_hacluster_password: "{{ cluster_password }}"
           ha_cluster_manage_firewall: true
           ha_cluster_manage_selinux: true
           ha_cluster_pcsd_certificates:
             - name: FILENAME
               common_name: "{{ ansible_hostname }}"
               ca: self-sign

   示例 playbook 中指定的设置包括如下：

   ha_cluster_cluster_name: <cluster_name>

   您要创建的集群的名称。

   ha_cluster_hacluster_password: <password>

   hacluster 用户的密码。hacluster 用户对集群具有完全访问权限。

   ha_cluster_manage_firewall: true

   确定 ha_cluster RHEL 系统角色是否管理防火墙的变量。

   ha_cluster_manage_selinux: true

   确定 ha_cluster RHEL 系统角色是否使用 selinux RHEL 系统角色管理防火墙高可用性服务的端口的变量。

   ha_cluster_pcsd_certificates: <certificate_properties>

   在 /var/lib/pcsd 中创建自签名 pcsd 证书和私钥文件的变量。在本例中，pcsd 证书有文件名 FILENAME.crt，密钥文件名为 FILENAME.key。

   有关 playbook 中使用的所有变量的详情，请查看控制节点上的 /usr/share/ansible/roles/rhel-system-roles.ha_cluster/README.md 文件。

3. 验证 playbook 语法：

   $ ansible-playbook --syntax-check --ask-vault-pass ~/playbook.yml

   请注意，这个命令只验证语法，不能防止错误的、但有效的配置。

4. 运行 playbook：

   $ ansible-playbook --ask-vault-pass ~/playbook.yml

流程

1. 将敏感变量存储在加密的文件中：

   1. 创建 vault ：

      $ ansible-vault create ~/vault.yml
      New Vault password: <vault_password>
      Confirm New Vault password: <vault_password>

   2. 在 ansible-vault create 命令打开编辑器后，以 <key>: <value> 格式输入敏感数据：

      cluster_password: <cluster_password>

   3. 保存更改，并关闭编辑器。Ansible 加密 vault 中的数据。

2. 创建一个包含以下内容的 playbook 文件，如 ~/playbook.yml ：

   ---
   - name: Create a high availability cluster
     hosts: node1 node2
     vars_files:
       - ~/vault.yml
     tasks:
       - name: Create cluster with minimum required parameters and no fencing
         ansible.builtin.include_role:
           name: redhat.rhel_system_roles.ha_cluster
         vars:
           ha_cluster_cluster_name: my-new-cluster
           ha_cluster_hacluster_password: "{{ cluster_password }}"
           ha_cluster_manage_firewall: true
           ha_cluster_manage_selinux: true

   示例 playbook 中指定的设置包括如下：

   ha_cluster_cluster_name: <cluster_name>

   您要创建的集群的名称。

   ha_cluster_hacluster_password: <password>

   hacluster 用户的密码。hacluster 用户对集群具有完全访问权限。

   ha_cluster_manage_firewall: true

   确定 ha_cluster RHEL 系统角色是否管理防火墙的变量。

   ha_cluster_manage_selinux: true

   确定 ha_cluster RHEL 系统角色是否使用 selinux RHEL 系统角色管理防火墙高可用性服务的端口的变量。

   有关 playbook 中使用的所有变量的详情，请查看控制节点上的 /usr/share/ansible/roles/rhel-system-roles.ha_cluster/README.md 文件。

3. 验证 playbook 语法：

   $ ansible-playbook --syntax-check --ask-vault-pass ~/playbook.yml

   请注意，这个命令只验证语法，不能防止错误的、但有效的配置。

4. 运行 playbook：

   $ ansible-playbook --ask-vault-pass ~/playbook.yml

流程

1. 将敏感变量存储在加密的文件中：

   1. 创建 vault ：

      $ ansible-vault create ~/vault.yml
      New Vault password: <vault_password>
      Confirm New Vault password: <vault_password>

   2. 在 ansible-vault create 命令打开编辑器后，以 <key>: <value> 格式输入敏感数据：

      cluster_password: <cluster_password>

   3. 保存更改，并关闭编辑器。Ansible 加密 vault 中的数据。

2. 创建一个包含以下内容的 playbook 文件，如 ~/playbook.yml ：

   ---
   - name: Create a high availability cluster
     hosts: node1 node2
     vars_files:
       - ~/vault.yml
     tasks:
       - name: Create cluster with fencing and resources
         ansible.builtin.include_role:
           name: redhat.rhel_system_roles.ha_cluster
         vars:
           ha_cluster_cluster_name: my-new-cluster
           ha_cluster_hacluster_password: "{{ cluster_password }}"
           ha_cluster_manage_firewall: true
           ha_cluster_manage_selinux: true
           ha_cluster_resource_primitives:
             - id: xvm-fencing
               agent: 'stonith:fence_xvm'
               instance_attrs:
                 - attrs:
                     - name: pcmk_host_list
                       value: node1 node2
             - id: simple-resource
               agent: 'ocf:pacemaker:Dummy'
             - id: resource-with-options
               agent: 'ocf:pacemaker:Dummy'
               instance_attrs:
                 - attrs:
                     - name: fake
                       value: fake-value
                     - name: passwd
                       value: passwd-value
               meta_attrs:
                 - attrs:
                     - name: target-role
                       value: Started
                     - name: is-managed
                       value: 'true'
               operations:
                 - action: start
                   attrs:
                     - name: timeout
                       value: '30s'
                 - action: monitor
                   attrs:
                     - name: timeout
                       value: '5'
                     - name: interval
                       value: '1min'
             - id: dummy-1
               agent: 'ocf:pacemaker:Dummy'
             - id: dummy-2
               agent: 'ocf:pacemaker:Dummy'
             - id: dummy-3
               agent: 'ocf:pacemaker:Dummy'
             - id: simple-clone
               agent: 'ocf:pacemaker:Dummy'
             - id: clone-with-options
               agent: 'ocf:pacemaker:Dummy'
           ha_cluster_resource_groups:
             - id: simple-group
               resource_ids:
                 - dummy-1
                 - dummy-2
               meta_attrs:
                 - attrs:
                     - name: target-role
                       value: Started
                     - name: is-managed
                       value: 'true'
             - id: cloned-group
               resource_ids:
                 - dummy-3
           ha_cluster_resource_clones:
             - resource_id: simple-clone
             - resource_id: clone-with-options
               promotable: yes
               id: custom-clone-id
               meta_attrs:
                 - attrs:
                     - name: clone-max
                       value: '2'
                     - name: clone-node-max
                       value: '1'
             - resource_id: cloned-group
               promotable: yes

   示例 playbook 中指定的设置包括如下：

   ha_cluster_cluster_name: <cluster_name>

   您要创建的集群的名称。

   ha_cluster_hacluster_password: <password>

   hacluster 用户的密码。hacluster 用户对集群具有完全访问权限。

   ha_cluster_manage_firewall: true

   确定 ha_cluster RHEL 系统角色是否管理防火墙的变量。

   ha_cluster_manage_selinux: true

   确定 ha_cluster RHEL 系统角色是否使用 selinux RHEL 系统角色管理防火墙高可用性服务的端口的变量。

   ha_cluster_resource_primitives: <cluster_resources>

   由 ha_cluster RHEL 系统角色配置的 Pacemaker 资源的资源定义的列表，包括隔离

   ha_cluster_resource_groups: <resource_groups>

   由 ha_cluster RHEL 系统角色配置的资源组定义的列表。

   ha_cluster_resource_clones: <resource_clones>

   ha_cluster RHEL 系统角色配置的资源克隆定义的列表。

   有关 playbook 中使用的所有变量的详情，请查看控制节点上的 /usr/share/ansible/roles/rhel-system-roles.ha_cluster/README.md 文件。

3. 验证 playbook 语法：

   $ ansible-playbook --syntax-check --ask-vault-pass ~/playbook.yml

   请注意，这个命令只验证语法，不能防止错误的、但有效的配置。

4. 运行 playbook：

   $ ansible-playbook --ask-vault-pass ~/playbook.yml

流程

1. 将敏感变量存储在加密的文件中：

   1. 创建 vault ：

      $ ansible-vault create ~/vault.yml
      New Vault password: <vault_password>
      Confirm New Vault password: <vault_password>

   2. 在 ansible-vault create 命令打开编辑器后，以 <key>: <value> 格式输入敏感数据：

      cluster_password: <cluster_password>

   3. 保存更改，并关闭编辑器。Ansible 加密 vault 中的数据。

2. 创建一个包含以下内容的 playbook 文件，如 ~/playbook.yml ：

   ---
   - name: Create a high availability cluster
     hosts: node1 node2
     vars_files:
       - ~/vault.yml
     tasks:
       - name: Create cluster with fencing and resource operation defaults
         ansible.builtin.include_role:
           name: redhat.rhel_system_roles.ha_cluster
         vars:
           ha_cluster_cluster_name: my-new-cluster
           ha_cluster_hacluster_password: "{{ cluster_password }}"
           ha_cluster_manage_firewall: true
           ha_cluster_manage_selinux: true
           # Set a different resource-stickiness value during
           # and outside work hours. This allows resources to
           # automatically move back to their most
           # preferred hosts, but at a time that
           # does not interfere with business activities.
           ha_cluster_resource_defaults:
             meta_attrs:
               - id: core-hours
                 rule: date-spec hours=9-16 weekdays=1-5
                 score: 2
                 attrs:
                   - name: resource-stickiness
                     value: INFINITY
               - id: after-hours
                 score: 1
                 attrs:
                   - name: resource-stickiness
                     value: 0
           # Default the timeout on all 10-second-interval
           # monitor actions on IPaddr2 resources to 8 seconds.
           ha_cluster_resource_operation_defaults:
             meta_attrs:
               - rule: resource ::IPaddr2 and op monitor interval=10s
                 score: INFINITY
                 attrs:
                   - name: timeout
                     value: 8s

   示例 playbook 中指定的设置包括如下：

   ha_cluster_cluster_name: <cluster_name>

   您要创建的集群的名称。

   ha_cluster_hacluster_password: <password>

   hacluster 用户的密码。hacluster 用户对集群具有完全访问权限。

   ha_cluster_manage_firewall: true

   确定 ha_cluster RHEL 系统角色是否管理防火墙的变量。

   ha_cluster_manage_selinux: true

   确定 ha_cluster RHEL 系统角色是否使用 selinux RHEL 系统角色管理防火墙高可用性服务的端口的变量。

   ha_cluster_resource_defaults: <resource_defaults>

   定义资源默认值集合的变量。

   ha_cluster_resource_operation_defaults: <resource_operation_defaults>

   定义资源操作默认值集合的变量。

   有关 playbook 中使用的所有变量的详情，请查看控制节点上的 /usr/share/ansible/roles/rhel-system-roles.ha_cluster/README.md 文件。

3. 验证 playbook 语法：

   $ ansible-playbook --syntax-check --ask-vault-pass ~/playbook.yml

   请注意，这个命令只验证语法，不能防止错误的、但有效的配置。

4. 运行 playbook：

   $ ansible-playbook --ask-vault-pass ~/playbook.yml

流程

1. 将敏感变量存储在加密的文件中：

   1. 创建 vault ：

      $ ansible-vault create ~/vault.yml
      New Vault password: <vault_password>
      Confirm New Vault password: <vault_password>

   2. 在 ansible-vault create 命令打开编辑器后，以 <key>: <value> 格式输入敏感数据：

      cluster_password: <cluster_password>
      fence1_password: <fence1_password>
      fence2_password: <fence2_password>

   3. 保存更改，并关闭编辑器。Ansible 加密 vault 中的数据。

2. 创建一个 playbook 文件，如 ~/playbook.yml。这个 playbook 示例文件配置一个运行 firewalld 和 selinux 服务的集群。

   ---
   - name: Create a high availability cluster
     hosts: node1 node2
     vars_files:
       - ~/vault.yml
     tasks:
       - name: Configure a cluster that defines fencing levels
         ansible.builtin.include_role:
           name: redhat.rhel_system_roles.ha_cluster
         vars:
           ha_cluster_cluster_name: my-new-cluster
           ha_cluster_hacluster_password: "{{ cluster_password }}"
           ha_cluster_manage_firewall: true
           ha_cluster_manage_selinux: true
           ha_cluster_resource_primitives:
             - id: apc1
               agent: 'stonith:fence_apc_snmp'
               instance_attrs:
                 - attrs:
                     - name: ip
                       value: apc1.example.com
                     - name: username
                       value: user
                     - name: password
                       value: "{{ fence1_password }}"
                     - name: pcmk_host_map
                       value: node1:1;node2:2
             - id: apc2
               agent: 'stonith:fence_apc_snmp'
               instance_attrs:
                 - attrs:
                     - name: ip
                       value: apc2.example.com
                     - name: username
                       value: user
                     - name: password
                       value: "{{ fence2_password }}"
                     - name: pcmk_host_map
                       value: node1:1;node2:2
           # Nodes have redundant power supplies, apc1 and apc2. Cluster must
           # ensure that when attempting to reboot a node, both power
           # supplies # are turned off before either power supply is turned
           # back on.
           ha_cluster_stonith_levels:
             - level: 1
               target: node1
               resource_ids:
                 - apc1
                 - apc2
             - level: 1
               target: node2
               resource_ids:
                 - apc1
                 - apc2

   示例 playbook 中指定的设置包括如下：

   ha_cluster_cluster_name: <cluster_name>

   您要创建的集群的名称。

   ha_cluster_hacluster_password: <password>

   hacluster 用户的密码。hacluster 用户对集群具有完全访问权限。

   ha_cluster_manage_firewall: true

   确定 ha_cluster RHEL 系统角色是否管理防火墙的变量。

   ha_cluster_manage_selinux: true

   确定 ha_cluster RHEL 系统角色是否使用 selinux RHEL 系统角色管理防火墙高可用性服务的端口的变量。

   ha_cluster_resource_primitives: <cluster_resources>

   由 ha_cluster RHEL 系统角色配置的 Pacemaker 资源的资源定义的列表，包括隔离

   ha_cluster_stonith_levels: <stonith_levels>

   定义 STONITH 级别的变量，也称为隔离拓扑，它将集群配置为使用多个设备来隔离节点。

   有关 playbook 中使用的所有变量的详情，请查看控制节点上的 /usr/share/ansible/roles/rhel-system-roles.ha_cluster/README.md 文件。

3. 验证 playbook 语法：

   $ ansible-playbook --syntax-check --ask-vault-pass ~/playbook.yml

   请注意，这个命令只验证语法，不能防止错误的、但有效的配置。

4. 运行 playbook：

   $ ansible-playbook --ask-vault-pass ~/playbook.yml

流程

1. 将敏感变量存储在加密的文件中：

   1. 创建 vault ：

      $ ansible-vault create ~/vault.yml
      New Vault password: <vault_password>
      Confirm New Vault password: <vault_password>

   2. 在 ansible-vault create 命令打开编辑器后，以 <key>: <value> 格式输入敏感数据：

      cluster_password: <cluster_password>

   3. 保存更改，并关闭编辑器。Ansible 加密 vault 中的数据。

2. 创建一个包含以下内容的 playbook 文件，如 ~/playbook.yml ：

   ---
   - name: Create a high availability cluster
     hosts: node1 node2
     vars_files:
       - ~/vault.yml
     tasks:
       - name: Create cluster with resource constraints
         ansible.builtin.include_role:
           name: redhat.rhel_system_roles.ha_cluster
         vars:
           ha_cluster_cluster_name: my-new-cluster
           ha_cluster_hacluster_password: "{{ cluster_password }}"
           ha_cluster_manage_firewall: true
           ha_cluster_manage_selinux: true
           # In order to use constraints, we need resources
           # the constraints will apply to.
           ha_cluster_resource_primitives:
             - id: xvm-fencing
               agent: 'stonith:fence_xvm'
               instance_attrs:
                 - attrs:
                     - name: pcmk_host_list
                       value: node1 node2
             - id: dummy-1
               agent: 'ocf:pacemaker:Dummy'
             - id: dummy-2
               agent: 'ocf:pacemaker:Dummy'
             - id: dummy-3
               agent: 'ocf:pacemaker:Dummy'
             - id: dummy-4
               agent: 'ocf:pacemaker:Dummy'
             - id: dummy-5
               agent: 'ocf:pacemaker:Dummy'
             - id: dummy-6
               agent: 'ocf:pacemaker:Dummy'
           # location constraints
           ha_cluster_constraints_location:
             # resource ID and node name
             - resource:
                 id: dummy-1
               node: node1
               options:
                 - name: score
                   value: 20
             # resource pattern and node name
             - resource:
                 pattern: dummy-\d+
               node: node1
               options:
                 - name: score
                   value: 10
             # resource ID and rule
             - resource:
                 id: dummy-2
               rule: '#uname eq node2 and date in_range 2022-01-01 to 2022-02-28'
             # resource pattern and rule
             - resource:
                 pattern: dummy-\d+
               rule: node-type eq weekend and date-spec weekdays=6-7
           # colocation constraints
           ha_cluster_constraints_colocation:
             # simple constraint
             - resource_leader:
                 id: dummy-3
               resource_follower:
                 id: dummy-4
               options:
                 - name: score
                   value: -5
             # set constraint
             - resource_sets:
                 - resource_ids:
                     - dummy-1
                     - dummy-2
                 - resource_ids:
                     - dummy-5
                     - dummy-6
                   options:
                     - name: sequential
                       value: "false"
               options:
                 - name: score
                   value: 20
           # order constraints
           ha_cluster_constraints_order:
             # simple constraint
             - resource_first:
                 id: dummy-1
               resource_then:
                 id: dummy-6
               options:
                 - name: symmetrical
                   value: "false"
             # set constraint
             - resource_sets:
                 - resource_ids:
                     - dummy-1
                     - dummy-2
                   options:
                     - name: require-all
                       value: "false"
                     - name: sequential
                       value: "false"
                 - resource_ids:
                     - dummy-3
                 - resource_ids:
                     - dummy-4
                     - dummy-5
                   options:
                     - name: sequential
                       value: "false"
           # ticket constraints
           ha_cluster_constraints_ticket:
             # simple constraint
             - resource:
                 id: dummy-1
               ticket: ticket1
               options:
                 - name: loss-policy
                   value: stop
             # set constraint
             - resource_sets:
                 - resource_ids:
                     - dummy-3
                     - dummy-4
                     - dummy-5
               ticket: ticket2
               options:
                 - name: loss-policy
                   value: fence

   示例 playbook 中指定的设置包括如下：

   ha_cluster_cluster_name: <cluster_name>

   您要创建的集群的名称。

   ha_cluster_hacluster_password: <password>

   hacluster 用户的密码。hacluster 用户对集群具有完全访问权限。

   ha_cluster_manage_firewall: true

   确定 ha_cluster RHEL 系统角色是否管理防火墙的变量。

   ha_cluster_manage_selinux: true

   确定 ha_cluster RHEL 系统角色是否使用 selinux RHEL 系统角色管理防火墙高可用性服务的端口的变量。

   ha_cluster_resource_primitives: <cluster_resources>

   由 ha_cluster RHEL 系统角色配置的 Pacemaker 资源的资源定义的列表，包括隔离

   ha_cluster_constraints_location: <location_constraints>

   定义资源位置约束的变量。

   ha_cluster_constraints_colocation: <colocation_constraints>

   定义资源托管约束的变量。

   ha_cluster_constraints_order: <order_constraints>

   定义资源顺序约束的变量。

   ha_cluster_constraints_ticket: <ticket_constraints>

   定义 Booth 票据约束的变量。

3. 验证 playbook 语法：

   $ ansible-playbook --syntax-check --ask-vault-pass ~/playbook.yml

   请注意，这个命令只验证语法，不能防止错误的、但有效的配置。

4. 运行 playbook：

   $ ansible-playbook --ask-vault-pass ~/playbook.yml

流程

1. 将敏感变量存储在加密的文件中：

   1. 创建 vault ：

      $ ansible-vault create ~/vault.yml
      New Vault password: <vault_password>
      Confirm New Vault password: <vault_password>

   2. 在 ansible-vault create 命令打开编辑器后，以 <key>: <value> 格式输入敏感数据：

      cluster_password: <cluster_password>

   3. 保存更改，并关闭编辑器。Ansible 加密 vault 中的数据。

2. 创建一个包含以下内容的 playbook 文件，如 ~/playbook.yml ：

   ---
   - name: Create a high availability cluster
     hosts: node1 node2
     vars_files:
       - ~/vault.yml
     tasks:
       - name: Create cluster that configures Corosync values
         ansible.builtin.include_role:
           name: redhat.rhel_system_roles.ha_cluster
         vars:
           ha_cluster_cluster_name: my-new-cluster
           ha_cluster_hacluster_password: "{{ cluster_password }}"
           ha_cluster_manage_firewall: true
           ha_cluster_manage_selinux: true
           ha_cluster_transport:
             type: knet
             options:
               - name: ip_version
                 value: ipv4-6
             links:
               -
                 - name: linknumber
                   value: 1
                 - name: link_priority
                   value: 5
               -
                 - name: linknumber
                   value: 0
                 - name: link_priority
                   value: 10
             compression:
               - name: level
                 value: 5
               - name: model
                 value: zlib
             crypto:
               - name: cipher
                 value: none
               - name: hash
                 value: none
           ha_cluster_totem:
             options:
               - name: block_unlisted_ips
                 value: 'yes'
               - name: send_join
                 value: 0
           ha_cluster_quorum:
             options:
               - name: auto_tie_breaker
                 value: 1
               - name: wait_for_all
                 value: 1

   示例 playbook 中指定的设置包括如下：

   ha_cluster_cluster_name: <cluster_name>

   您要创建的集群的名称。

   ha_cluster_hacluster_password: <password>

   hacluster 用户的密码。hacluster 用户对集群具有完全访问权限。

   ha_cluster_manage_firewall: true

   确定 ha_cluster RHEL 系统角色是否管理防火墙的变量。

   ha_cluster_manage_selinux: true

   确定 ha_cluster RHEL 系统角色是否使用 selinux RHEL 系统角色管理防火墙高可用性服务的端口的变量。

   ha_cluster_transport: <transport_method>

   设置集群传输方法的变量。

   ha_cluster_totem: <totem_options>

   配置 Corosync totem 选项的变量。

   ha_cluster_quorum: <quorum_options>

   配置集群仲裁选项的变量。

   有关 playbook 中使用的所有变量的详情，请查看控制节点上的 /usr/share/ansible/roles/rhel-system-roles.ha_cluster/README.md 文件。

3. 验证 playbook 语法：

   $ ansible-playbook --ask-vault-pass --syntax-check ~/playbook.yml

   请注意，这个命令只验证语法，不能防止错误的、但有效的配置。

4. 运行 playbook：

   $ ansible-playbook --ask-vault-pass ~/playbook.yml

流程

1. 创建一个包含以下内容的 playbook 文件，如 ~/playbook.yml ：

   ---
   - name: Create a high availability cluster that uses SBD node fencing
     hosts: node1 node2
     roles:
       - rhel-system-roles.ha_cluster
     vars:
       ha_cluster_cluster_name: my-new-cluster
       ha_cluster_hacluster_password: <password>
       ha_cluster_manage_firewall: true
       ha_cluster_manage_selinux: true
       ha_cluster_sbd_enabled: yes
       ha_cluster_sbd_options:
         - name: delay-start
           value: 'no'
         - name: startmode
           value: always
         - name: timeout-action
           value: 'flush,reboot'
         - name: watchdog-timeout
           value: 30
       # Suggested optimal values for SBD timeouts:
       # watchdog-timeout * 2 = msgwait-timeout (set automatically)
       # msgwait-timeout * 1.2 = stonith-timeout
       ha_cluster_cluster_properties:
         - attrs:
             - name: stonith-timeout
               value: 72
       ha_cluster_resource_primitives:
         - id: fence_sbd
           agent: 'stonith:fence_sbd'
           instance_attrs:
             - attrs:
                 # taken from host_vars
                 - name: devices
                   value: "{{ ha_cluster.sbd_devices | join(',') }}"
                 - name: pcmk_delay_base
                   value: 30

   这个 playbook 示例文件配置一个运行 firewalld 和 selinux 服务的集群，其使用 SBD 隔离并创建 SBD Stonith 资源。

   为生产环境创建 playbook 文件时，vault 会加密密码，如在 使用 Ansible Vault 加密内容 中所述。

2. 验证 playbook 语法：

   $ ansible-playbook --syntax-check ~/playbook.yml

   请注意，这个命令只验证语法，不能防止错误的、但有效的配置。

3. 运行 playbook：

   $ ansible-playbook ~/playbook.yml

流程

1. 将敏感变量存储在加密的文件中：

   1. 创建 vault ：

      $ ansible-vault create ~/vault.yml
      New Vault password: <vault_password>
      Confirm New Vault password: <vault_password>

   2. 在 ansible-vault create 命令打开编辑器后，以 <key>: <value> 格式输入敏感数据：

      cluster_password: <cluster_password>

   3. 保存更改，并关闭编辑器。Ansible 加密 vault 中的数据。

2. 创建一个包含以下内容的 playbook 文件，如 ~/playbook.yml ：

   ---
   - name: Create a high availability cluster
     hosts: node1 node2
     vars_files:
       - ~/vault.yml
     tasks:
       - name: Create a cluster that defines node attributes
         ansible.builtin.include_role:
           name: redhat.rhel_system_roles.ha_cluster
         vars:
           ha_cluster_cluster_name: my-new-cluster
           ha_cluster_hacluster_password: "{{ cluster_password }}"
           ha_cluster_manage_firewall: true
           ha_cluster_manage_selinux: true
           ha_cluster_node_options:
             - node_name: node1
               attributes:
                 - attrs:
                     - name: attribute1
                       value: value1A
                     - name: attribute2
                       value: value2A
             - node_name: node2
               attributes:
                 - attrs:
                     - name: attribute1
                       value: value1B
                     - name: attribute2
                       value: value2B

   ha_cluster_cluster_name: <cluster_name>

   您要创建的集群的名称。

   ha_cluster_hacluster_password: <password>

   hacluster 用户的密码。hacluster 用户对集群具有完全访问权限。

   ha_cluster_manage_firewall: true

   确定 ha_cluster RHEL 系统角色是否管理防火墙的变量。

   ha_cluster_manage_selinux: true

   确定 ha_cluster RHEL 系统角色是否使用 selinux RHEL 系统角色管理防火墙高可用性服务的端口的变量。

   ha_cluster_node_options: <node_settings>

   定义因集群节点而异的各种设置的变量。

   有关 playbook 中使用的所有变量的详情，请查看控制节点上的 /usr/share/ansible/roles/rhel-system-roles.ha_cluster/README.md 文件。

3. 验证 playbook 语法：

   $ ansible-playbook --syntax-check --ask-vault-pass ~/playbook.yml

   请注意，这个命令只验证语法，不能防止错误的、但有效的配置。

4. 运行 playbook：

   $ ansible-playbook --ask-vault-pass ~/playbook.yml

   其他资源

   • Pacemaker 规则

流程

1. 将敏感变量存储在加密的文件中：

   1. 创建 vault ：

      $ ansible-vault create ~/vault.yml
      New Vault password: <vault_password>
      Confirm New Vault password: <vault_password>

   2. 在 ansible-vault create 命令打开编辑器后，以 <key>: <value> 格式输入敏感数据：

      cluster_password: <cluster_password>

   3. 保存更改，并关闭编辑器。Ansible 加密 vault 中的数据。

2. 创建一个包含以下内容的 playbook 文件，如 ~/playbook.yml ：

   ---
   - name: Create a high availability cluster
     hosts: z1.example.com z2.example.com
     vars_files:
       - ~/vault.yml
     tasks:
       - name: Configure active/passive Apache server in a high availability cluster
         ansible.builtin.include_role:
           name: redhat.rhel_system_roles.ha_cluster
         vars:
           ha_cluster_hacluster_password: "{{ cluster_password }}"
           ha_cluster_cluster_name: my_cluster
           ha_cluster_manage_firewall: true
           ha_cluster_manage_selinux: true
           ha_cluster_fence_agent_packages:
             - fence-agents-apc-snmp
           ha_cluster_resource_primitives:
             - id: myapc
               agent: stonith:fence_apc_snmp
               instance_attrs:
                 - attrs:
                     - name: ipaddr
                       value: zapc.example.com
                     - name: pcmk_host_map
                       value: z1.example.com:1;z2.example.com:2
                     - name: login
                       value: apc
                     - name: passwd
                       value: apc
             - id: my_lvm
               agent: ocf:heartbeat:LVM-activate
               instance_attrs:
                 - attrs:
                     - name: vgname
                       value: my_vg
                     - name: vg_access_mode
                       value: system_id
             - id: my_fs
               agent: Filesystem
               instance_attrs:
                 - attrs:
                     - name: device
                       value: /dev/my_vg/my_lv
                     - name: directory
                       value: /var/www
                     - name: fstype
                       value: xfs
             - id: VirtualIP
               agent: IPaddr2
               instance_attrs:
                 - attrs:
                     - name: ip
                       value: 198.51.100.3
                     - name: cidr_netmask
                       value: 24
             - id: Website
               agent: apache
               instance_attrs:
                 - attrs:
                     - name: configfile
                       value: /etc/httpd/conf/httpd.conf
                     - name: statusurl
                       value: http://127.0.0.1/server-status
           ha_cluster_resource_groups:
             - id: apachegroup
               resource_ids:
                 - my_lvm
                 - my_fs
                 - VirtualIP
                 - Website

   示例 playbook 中指定的设置包括如下：

   ha_cluster_cluster_name: <cluster_name>

   您要创建的集群的名称。

   ha_cluster_hacluster_password: <password>

   hacluster 用户的密码。hacluster 用户对集群具有完全访问权限。

   ha_cluster_manage_firewall: true

   确定 ha_cluster RHEL 系统角色是否管理防火墙的变量。

   ha_cluster_manage_selinux: true

   确定 ha_cluster RHEL 系统角色是否使用 selinux RHEL 系统角色管理防火墙高可用性服务的端口的变量。

   ha_cluster_fence_agent_packages: <fence_agent_packages>

   要安装的隔离代理软件包的列表。

   ha_cluster_resource_primitives: <cluster_resources>

   由 ha_cluster RHEL 系统角色配置的 Pacemaker 资源的资源定义的列表，包括隔离

   ha_cluster_resource_groups: <resource_groups>

   ha_cluster RHEL 系统角色配置的资源组定义的列表。

   有关 playbook 中使用的所有变量的详情，请查看控制节点上的 /usr/share/ansible/roles/rhel-system-roles.ha_cluster/README.md 文件。

3. 验证 playbook 语法：

   $ ansible-playbook --syntax-check --ask-vault-pass ~/playbook.yml

   请注意，这个命令只验证语法，不能防止错误的、但有效的配置。

4. 运行 playbook：

   $ ansible-playbook --ask-vault-pass ~/playbook.yml

5. 当您使用 apache 资源代理来管理 Apache 时，它不会使用 systemd。因此，您必须编辑 Apache 提供的 logrotate 脚本，使其不使用 systemctl 重新加载 Apache。

   在集群中的每个节点上删除 /etc/logrotate.d/httpd 文件中的以下行：

   # /bin/systemctl reload httpd.service > /dev/null 2>/dev/null || true

   • 对于 RHEL 8.6 及之后的版本，将您删除的行替换为以下三行，将 /var/run/httpd-website.pid 指定为 PID 文件路径，其中 website 是 Apache 资源的名称。在本例中，Apache 资源名称是 Website。

     /usr/bin/test -f /var/run/httpd-Website.pid >/dev/null 2>/dev/null &&
     /usr/bin/ps -q $(/usr/bin/cat /var/run/httpd-Website.pid) >/dev/null 2>/dev/null &&
     /usr/sbin/httpd -f /etc/httpd/conf/httpd.conf -c "PidFile /var/run/httpd-Website.pid" -k graceful > /dev/null 2>/dev/null || true

   • 对于 RHEL 8.5 及更早版本，将您删除的行替换为以下三行：

     /usr/bin/test -f /run/httpd.pid >/dev/null 2>/dev/null &&
     /usr/bin/ps -q $(/usr/bin/cat /run/httpd.pid) >/dev/null 2>/dev/null &&
     /usr/sbin/httpd -f /etc/httpd/conf/httpd.conf -c "PidFile /run/httpd.pid" -k graceful > /dev/null 2>/dev/null || true

验证

1. 从集群中的一个节点检查集群的状态。请注意，所有四个资源都运行在同一个节点上，z1.example.com。

   如果发现配置的资源没有运行，则您可以运行 pcs resource debug-start resource 命令来测试资源配置。

   [root@z1 ~]# pcs status
   Cluster name: my_cluster
   Last updated: Wed Jul 31 16:38:51 2013
   Last change: Wed Jul 31 16:42:14 2013 via crm_attribute on z1.example.com
   Stack: corosync
   Current DC: z2.example.com (2) - partition with quorum
   Version: 1.1.10-5.el7-9abe687
   2 Nodes configured
   6 Resources configured
   
   Online: [ z1.example.com z2.example.com ]
   
   Full list of resources:
    myapc  (stonith:fence_apc_snmp):       Started z1.example.com
    Resource Group: apachegroup
        my_lvm     (ocf::heartbeat:LVM-activate):   Started z1.example.com
        my_fs      (ocf::heartbeat:Filesystem):    Started z1.example.com
        VirtualIP  (ocf::heartbeat:IPaddr2):       Started z1.example.com
        Website    (ocf::heartbeat:apache):        Started z1.example.com

2. 集群启动并运行后，您可以将浏览器指向定义为 IPaddr2 资源的 IP 地址，来查看示例显示，包含简单的单词"Hello"。

   Hello

3. 要测试运行在 z1.example.com 上的资源组是否可以切换到节点 z2.example.com，请将节点 z1.example.com 置于 待机 模式，之后该节点将不能再托管资源。

   [root@z1 ~]# pcs node standby z1.example.com

4. 将节点 z1 置于 待机 模式后，从集群中的某个节点检查集群状态。请注意，资源现在都应运行在 z2 上。

   [root@z1 ~]# pcs status
   Cluster name: my_cluster
   Last updated: Wed Jul 31 17:16:17 2013
   Last change: Wed Jul 31 17:18:34 2013 via crm_attribute on z1.example.com
   Stack: corosync
   Current DC: z2.example.com (2) - partition with quorum
   Version: 1.1.10-5.el7-9abe687
   2 Nodes configured
   6 Resources configured
   
   Node z1.example.com (1): standby
   Online: [ z2.example.com ]
   
   Full list of resources:
   
    myapc  (stonith:fence_apc_snmp):       Started z1.example.com
    Resource Group: apachegroup
        my_lvm     (ocf::heartbeat:LVM-activate):  Started z2.example.com
        my_fs      (ocf::heartbeat:Filesystem):    Started z2.example.com
        VirtualIP  (ocf::heartbeat:IPaddr2):       Started z2.example.com
        Website    (ocf::heartbeat:apache):        Started z2.example.com

   定义的 IP 地址的网页仍会显示，而不中断。

5. 要从 待机 模式中删除 z1，请输入以下命令。

   [root@z1 ~]# pcs node unstandby z1.example.com

   注意

   从 待机 模式中删除节点本身不会导致资源切换到该节点。这将依赖于资源的 resource-stickiness 值。有关 resource-stickiness 元属性的详情，请参考 配置资源以首选其当前节点。

流程

1. 创建一个包含以下内容的 playbook 文件，如 ~/playbook.yml ：

   ---
   - name: Configure journald
     hosts: managed-node-01.example.com
     tasks:
       - name: Configure persistent logging
         ansible.builtin.include_role:
           name: redhat.rhel_system_roles.journald
         vars:
           journald_persistent: true
           journald_max_disk_size: <size>
           journald_per_user: true
           journald_sync_interval: <interval>

   示例 playbook 中指定的设置包括如下：

   journald_persistent: true

   启用持久性日志记录。

   journald_max_disk_size: <size>

   指定日志文件的最大磁盘空间大小（以 MB 为单位），例如 2048。

   journald_per_user: true

   配置 journald 来为每个用户单独保留日志数据。

   journald_sync_interval: <interval>

   设置同步间隔（以分钟为单位），例如 1。

   有关 playbook 中使用的所有变量的详情，请查看控制节点上的 /usr/share/ansible/roles/rhel-system-roles.journald/README.md 文件。

2. 验证 playbook 语法：

   $ ansible-playbook --syntax-check ~/playbook.yml

   请注意，这个命令只验证语法，不能防止错误的、但有效的配置。

3. 运行 playbook：

   $ ansible-playbook ~/playbook.yml

流程

1. 创建一个包含以下内容的 playbook 文件，如 ~/playbook.yml ：

   ---
   - name: Configuring kernel crash dumping
     hosts: managed-node-01.example.com
     tasks:
       - name: Setting the kdump directory.
         ansible.builtin.include_role:
           name: redhat.rhel_system_roles.kdump
         vars:
           kdump_target:
             type: raw
             location: /dev/sda1
           kdump_path: /var/crash/vmcore
           kernel_settings_reboot_ok: true

   示例 playbook 中指定的设置包括如下：

   kdump_target: <type_and_location>

   将 vmcore 写到 root 文件系统以外的地方。当 type 是 raw 或文件系统时，location 指向一个分区（按名称、标签或 UUID）。

   kernel_settings_reboot_ok: <true|false>

   默认值为 false。如果设置为 true，则系统角色将确定是否需要重启受管主机，以使请求的更改生效，并重启。如果设置为 false，则角色将返回值为 true 的变量 kernel_settings_reboot_required ，表示需要重启。在这种情况下，用户必须手动重启受管节点。

   有关 playbook 中使用的所有变量的详情，请查看控制节点上的 /usr/share/ansible/roles/rhel-system-roles.kdump/README.md 文件。

2. 验证 playbook 语法：

   $ ansible-playbook --syntax-check ~/playbook.yml

   请注意，这个命令只验证语法，不能防止错误的、但有效的配置。

3. 运行 playbook：

   $ ansible-playbook ~/playbook.yml

流程

1. 创建一个包含以下内容的 playbook 文件，如 ~/playbook.yml ：

   ---
   - name: Configuring kernel settings
     hosts: managed-node-01.example.com
     tasks:
       - name: Configure hugepages, packet size for loopback device, and limits on simultaneously open files.
         ansible.builtin.include_role:
           name: redhat.rhel_system_roles.kernel_settings
         vars:
           kernel_settings_sysctl:
             - name: fs.file-max
               value: 400000
             - name: kernel.threads-max
               value: 65536
           kernel_settings_sysfs:
             - name: /sys/class/net/lo/mtu
               value: 65000
           kernel_settings_transparent_hugepages: madvise
           kernel_settings_reboot_ok: true

   示例 playbook 中指定的设置包括如下：

   kernel_settings_sysfs: <list_of_sysctl_settings>

   sysctl 设置的 YAML 列表以及您要分配给这些设置的值。

   kernel_settings_transparent_hugepages: <value>

   控制内存子系统透明巨页(THP)设置。您可以禁用 THP 支持(never)、在系统范围(always )或在 MAD_HUGEPAGE 区域内(madvise)启用它。

   kernel_settings_reboot_ok: <true|false>

   默认值为 false。如果设置为 true，则系统角色将确定是否需要重启受管主机，以使请求的更改生效，并重启。如果设置为 false，则角色将返回值为 true 的变量 kernel_settings_reboot_required ，表示需要重启。在这种情况下，用户必须手动重启受管节点。

1. 验证 playbook 语法：

   $ ansible-playbook --syntax-check ~/playbook.yml

   请注意，这个命令只验证语法，不能防止错误的、但有效的配置。

2. 运行 playbook：

   $ ansible-playbook ~/playbook.yml

流程

1. 创建一个包含以下内容的 playbook 文件，如 ~/playbook.yml ：

   ---
   - name: Deploy the logging solution
     hosts: managed-node-01.example.com
     tasks:
       - name: Filter logs based on a specific value they contain
         ansible.builtin.include_role:
           name: redhat.rhel_system_roles.logging
         vars:
           logging_inputs:
             - name: files_input
               type: basics
           logging_outputs:
             - name: files_output0
               type: files
               property: msg
               property_op: contains
               property_value: error
               path: /var/log/errors.log
             - name: files_output1
               type: files
               property: msg
               property_op: "!contains"
               property_value: error
               path: /var/log/others.log
           logging_flows:
             - name: flow0
               inputs: [files_input]
               outputs: [files_output0, files_output1]

   示例 playbook 中指定的设置包括如下：

   logging_inputs

   定义一个记录输入字典的列表。type: basics 选项涵盖了来自 systemd 日志或 Unix 套接字的输入。

   logging_outputs

   定义一个记录输出字典的列表。type: files 选项支持将日志存储在本地文件中，通常存储在 /var/log/ 目录中。property: msg; property: contains 和 property_value: error 选项指定所有包含 error 字符串的日志都存储在 /var/log/errors.log 文件中。property: msg; property: !contains; 和 property_value: error 选项指定所有其他日志都放在 /var/log/others.log 文件中。您可以将 error 值替换为您要过滤的字符串。

   logging_flows

   定义一个记录流字典的列表，以指定 logging_inputs 和 logging_outputs 之间的关系。inputs: [files_input] 选项指定一个从其开始处理日志的输入的列表。outputs: [files_output0, files_output1] 选项指定一个日志发送到的输出的列表。

   有关 playbook 中使用的所有变量的详情，请查看控制节点上的 /usr/share/ansible/roles/rhel-system-roles.logging/README.md 文件。

2. 验证 playbook 语法：

   $ ansible-playbook --syntax-check ~/playbook.yml

   请注意，这个命令只验证语法，不能防止错误的、但有效的配置。

3. 运行 playbook：

   $ ansible-playbook ~/playbook.yml

验证

1. 在受管节点上，测试 /etc/rsyslog.conf 文件的语法：

   # rsyslogd -N 1
   rsyslogd: version 8.1911.0-6.el8, config validation run...
   rsyslogd: End of config validation run. Bye.

2. 在受管节点上，验证系统是否向日志发送包含 error 字符串的消息：

   1. 发送测试信息：

      # logger error

   2. 查看 /var/log/errors.log 日志，例如：

      # cat /var/log/errors.log
      Aug  5 13:48:31 hostname root[6778]: error

      其中 hostname 是客户端系统的主机名。请注意，该日志包含输入 logger 命令的用户的用户名，本例中为 root。

流程

1. 创建一个包含以下内容的 playbook 文件，如 ~/playbook.yml ：

   ---
   - name: Deploy the logging solution
     hosts: managed-node-01.example.com
     tasks:
       - name: Configure the server to receive remote input
         ansible.builtin.include_role:
           name: redhat.rhel_system_roles.logging
         vars:
           logging_inputs:
             - name: remote_udp_input
               type: remote
               udp_ports: [ 601 ]
             - name: remote_tcp_input
               type: remote
               tcp_ports: [ 601 ]
           logging_outputs:
             - name: remote_files_output
               type: remote_files
           logging_flows:
             - name: flow_0
               inputs: [remote_udp_input, remote_tcp_input]
               outputs: [remote_files_output]
   
   - name: Deploy the logging solution
     hosts: managed-node-02.example.com
     tasks:
       - name: Configure the server to output the logs to local files in directories named by remote host names
         ansible.builtin.include_role:
           name: redhat.rhel_system_roles.logging
         vars:
           logging_inputs:
             - name: basic_input
               type: basics
           logging_outputs:
             - name: forward_output0
               type: forwards
               severity: info
               target: <host1.example.com>
               udp_port: 601
             - name: forward_output1
               type: forwards
               facility: mail
               target: <host1.example.com>
               tcp_port: 601
           logging_flows:
             - name: flows0
               inputs: [basic_input]
               outputs: [forward_output0, forward_output1]

   示例 playbook 的第一个 play 中指定的设置包括以下：

   logging_inputs

   定义一个记录输入字典的列表。type: remote 选项涵盖通过网络来自其他日志记录系统的远程输入。udp_ports: [ 601 ] 选项定义要监控的 UDP 端口号的列表。tcp_ports: [ 601 ] 选项定义要监控的 TCP 端口号的列表。如果 udp_ports 和 tcp_ports 都设置了，则 udp_ports 被使用，tcp_ports 被丢弃。

   logging_outputs

   定义一个记录输出字典的列表。type: remote_files 选项使输出将日志存储到每个远程主机的本地文件和程序名称产生的日志中。

   logging_flows

   定义一个记录流字典的列表，以指定 logging_inputs 和 logging_outputs 之间的关系。inputs: [remote_udp_input, remote_tcp_input] 选项指定输入的列表，日志的处理从该列表开始。outputs: [remote_files_output] 选项指定输出的列表，日志被发送到此输出中。

   示例 playbook 的第二个 play 中指定的设置包括以下：

   logging_inputs

   定义一个记录输入字典的列表。type: basics 选项涵盖了来自 systemd 日志或 Unix 套接字的输入。

   logging_outputs

   定义一个记录输出字典的列表。type: forwards 选项支持通过网络将日志发送到远程日志服务器。severity: info 选项是指具有信息重要性的日志消息。facility: mail 选项是指正在生成日志消息的系统程序的类型。target: <host1.example.com> 选项指定远程日志记录服务器的主机名。udp_port: 601/tcp_port: 601 选项定义远程日志记录服务器侦听的 UDP/TCP 端口。

   logging_flows

   定义一个记录流字典的列表，以指定 logging_inputs 和 logging_outputs 之间的关系。inputs: [basic_input] 选项指定输入的列表，日志的处理从该列表开始。outputs: [forward_output0, forward_output1] 选项指定输出的列表，日志被发送到此输出中。

   有关 playbook 中使用的所有变量的详情，请查看控制节点上的 /usr/share/ansible/roles/rhel-system-roles.logging/README.md 文件。

2. 验证 playbook 语法：

   $ ansible-playbook --syntax-check ~/playbook.yml

   请注意，这个命令只验证语法，不能防止错误的、但有效的配置。

3. 运行 playbook：

   $ ansible-playbook ~/playbook.yml

验证

1. 在客户端和服务器系统上测试 /etc/rsyslog.conf 文件的语法：

   # rsyslogd -N 1
   rsyslogd: version 8.1911.0-6.el8, config validation run (level 1), master config /etc/rsyslog.conf
   rsyslogd: End of config validation run. Bye.

2. 验证客户端系统向服务器发送信息：

   1. 在客户端系统中发送测试信息：

      # logger test

   2. 在服务器系统上，查看 /var/log/<host2.example.com>/messages 日志，例如：

      # cat /var/log/<host2.example.com>/messages
      Aug  5 13:48:31 <host2.example.com> root[6778]: test

      其中 <host2.example.com> 是客户端系统的主机名。请注意，该日志包含输入 logger 命令的用户的用户名，本例中为 root。