使用 RHEL 中的系统角色管理和配置任务

流程

1. 安装 rhel-system-roles 软件包：

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

   此命令将 Ansible Core 安装为依赖项。

2. 创建稍后用来管理和执行 playbook 的用户：

   [root@control-node]# useradd ansible

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

   [root@control-node]# su - ansible

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

4. 创建 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): password
   ...

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

5. 可选：配置 SSH 代理，以防止 Ansible 每次建立连接时提示您输入 SSH 密钥密码。

6. 使用以下内容创建 ~/.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 管理指定清单文件中的主机。
   • 当 Ansible 建立与受管节点的 SSH 连接时，Ansible 使用 remote_user 参数中设置的帐户。

   • Ansible 使用 sudo 实用程序以 root 用户身份对受管节点执行任务。

     为安全起见，请在受管节点上配置 sudo 以要求输入远程用户的密码，成为 root 用户。通过在 ~/.ansible.cfg 中指定 become_ask_pass=True 设置，Ansible 在执行 playbook 时提示输入此密码。

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

7. 创建 ~/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 地址。

验证

1. 准备受管节点。
2. 验证控制节点对受管节点的访问

流程

1. 创建用户：

   [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.
      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
      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.

   2. 在控制节点上远程执行命令以验证 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 ping 模块验证您可以在所有受管主机上执行命令：

   [ansible@control-node]$ ansible all -m ping
   BECOME password: password
   managed-node-01.example.com | SUCCESS => {
       "ansible_facts": {
           "discovered_interpreter_python": "/usr/bin/python3"
       },
       "changed": false,
       "ping": "pong"
   }
   ...

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

2. 使用 Ansible command 模块在受管主机上运行 whoami 工具：

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

   如果命令返回 root，您会在受管节点上正确配置 sudo，特权升级可以正常工作。

流程

1. 卸载 Ansible Engine：

   # yum remove ansible

2. 禁用 ansible-2-for-rhel-8-x86_64-rpms 存储库：

   # subscription-manager repos --disable ansible-2-for-rhel-8-x86_64-rpms

3. 安装 Ansible Core，它包括在 RHEL 8 AppStream 存储库中：

   # yum install ansible-core

1. �行以下命令：

   $ ansible-playbook -c local -i localhost, --check --become /usr/share/ansible/collections/ansible_collections/redhat/rhel_system_roles/tests/kernel_settings/tests_default.yml

流程

1. 定义 Red Hat Automation Hub 作为 ansible.cfg 配置文件中内容的默认源。请参阅 将 Red Hat Automation Hub 配置为内容的主源。

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

   # ansible-galaxy collection install redhat.rhel_system_roles

   安装完成后，角色作为 redhat.rhel_system_roles.<role_name> 提供。另外，您可以在 /usr/share/ansible/collections/ansible_collections/redhat/rhel_system_roles/roles/<role_name>/README.md 找到每个角色的文档。

1. �行以下命令：

   $ ansible-playbook -c local -i localhost, --check --become /usr/share/ansible/collections/ansible_collections/redhat/rhel_system_roles/tests/kernel_settings/tests_default.yml

流程

1. 创建定义所需角色的 playbook:

   1. 创建新 YAML 文件，并在文本编辑器中打开，例如：

      # vi logging-playbook.yml

   2. 将以下内容插入 YAML 文件中：

      ---
      - name: Deploying basics input and implicit files output
        hosts: all
        roles:
          - redhat.rhel_system_roles.logging
        vars:
          logging_inputs:
            - name: system_input
              type: basics
          logging_outputs:
            - name: files_output
              type: files
          logging_flows:
            - name: flow1
              inputs: [system_input]
              outputs: [files_output]

2. 在特定清单上执行 playbook:

   # ansible-playbook -i inventory-file logging-playbook.yml

   其中：

   • inventory-file 是清单文件的名称。
   • logging-playbook.yml 是您使用的 playbook。

验证步骤

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/messages 日志，例如：

      # cat /var/log/messages
      Aug  5 13:48:31 hostname root[6778]: test

      hostname 是客户端系统的主机名。日志显示输入 logger 命令的用户的用户名，在本例中是 root。

流程

1. 创建包含以下内容的 playbook.yml 文件：

   ---
   - name: Sets which boot device will be used on next boot
     hosts: localhost
       tasks:
       - redhat.rhel_mgmt.ipmi_boot:
          name: bmc.host.example.com
            user: admin_user
            password: basics
            bootdev: hd

2. 针对 localhost 执行 playbook：

   # ansible-playbook playbook.yml

流程

1. 创建包含以下内容的 playbook.yml 文件：

   ---
   - name: Turn the host on
     hosts: localhost
       tasks:
       - redhat.rhel_mgmt.ipmi_power:
          name: bmc.host.example.com
            user: admin_user
            password: basics
            state: on

2. 执行 playbook：

   # ansible-playbook playbook.yml

1. redfish_info:redfish_info 模块检索关于远程 Out-Of-Band (OOB) 控制器（如系统清单）的信息。
2. redfish_command:redfish_command 模块执行 Out-Of-Band (OOB) 控制器操作，如日志管理和用户管理，以及系统重启、打开和关闭电源操作等。
3. redfish_config:redfish_config 模块执行 OOB 控制器操作，如更改 OOB 配置或设置 BIOS 配置。

流程

1. 创建包含以下内容的 playbook.yml 文件：

   ---
   - name: Get CPU inventory
     hosts: localhost
     tasks:
       - redhat.rhel_mgmt.redfish_info:
           baseuri: "{{ baseuri }}"
           username: "{{ username }}"
           password: "{{ password }}"
           category: Systems
           command: GetCpuInventory
         register: result

2. 针对 localhost 执行 playbook：

   # ansible-playbook playbook.yml

流程

1. 创建包含以下内容的 playbook.yml 文件：

   ---
   - name: Power on system
     hosts: localhost
     tasks:
       - redhat.rhel_mgmt.redfish_command:
           baseuri: "{{ baseuri }}"
           username: "{{ username }}"
           password: "{{ password }}"
           category: Systems
           command: PowerOn

2. 针对 localhost 执行 playbook：

   # ansible-playbook playbook.yml

流程

1. 创建包含以下内容的 playbook.yml 文件：

   ---
   - name: "Set BootMode to UEFI"
     hosts: localhost
     tasks:
       - redhat.rhel_mgmt.redfish_config:
           baseuri: "{{ baseuri }}"
           username: "{{ username }}"
           password: "{{ password }}"
           category: Systems
           command: SetBiosAttributes
           bios_attributes:
             BootMode: Uefi

2. 针对 localhost 执行 playbook：

   # ansible-playbook playbook.yml

步骤

1. 另外，还可查看 清单（inventory）文件 ：

   #  cat /home/jdoe/<ansible_project_name>/inventory
   [testingservers]
   pdoe@192.168.122.98
   fdoe@192.168.122.226
   
   [db-servers]
   db1.example.com
   db2.example.com
   
   [webservers]
   web1.example.com
   web2.example.com
   192.0.2.42

   该文件定义 [testingservers] 组和其他组。它允许您对特定的系统集合更有效地运行 Ansible。

2. 创建配置文件来为 Ansible 操作设置默认值和特权升级。

   1. 创建新 YAML 文件，并在文本编辑器中打开，例如：

      #  vi /home/jdoe/<ansible_project_name>/ansible.cfg

   2. 将以下内容插入到文件中：

      [defaults]
      inventory = ./inventory
      
      [privilege_escalation]
      become = true
      become_method = sudo
      become_user = root
      become_ask_pass = true

      [defaults] 部分指定受管主机清单文件的路径。[privilege_escalation] 部分定义用户特权转移到指定受管主机上的 root。这对成功配置内核参数是必需的。运行 Ansible playbook 时，会提示您输入用户密码。用户在连接到受管主机后，通过 sudo 自动切换为 root。

3. 创建使用 kernel_settings 角色的 Ansible playbook。

   1. 创建新 YAML 文件，并在文本编辑器中打开，例如：

      #  vi /home/jdoe/<ansible_project_name>/kernel-roles.yml

      此文件代表一个 playbook，通常包含了一组有特定顺序的任务（也称为 play ）列表。这些任何会根据 inventory 文件中选择的特定管理主机进行。

   2. 将以下内容插入到文件中：

      ---
      -
        hosts: testingservers
        name: "Configure kernel settings"
        roles:
          - 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

      name 键是可选的。它将一个任意字符串作为标签与该 play 关联，并确定该 play 的用途。Play 中的 hosts 键指定对其运行 play 的主机。此键的值或值可以作为被管理的主机的单独名称提供，也可以作为 inventory 文件中定义的一组主机提供。

      vars 部分代表包含所选内核参数名称和值的变量列表。

      roles 键指定系统角色将配置 vars 部分中提到的参数和值。

      注意

      您可以修改 playbook 中的内核参数及其值以符合您的需要。

4. （可选）验证 play 中的语法是否正确。

   #  ansible-playbook --syntax-check kernel-roles.yml
   
   playbook: kernel-roles.yml

   本例演示了对 playbook 的成功验证。

5. 执行 playbook。

   #  ansible-playbook kernel-roles.yml
   
   ...
   
   BECOME password:
   
   PLAY [Configure kernel settings] **********************************************************************************
   
   
   
   PLAY RECAP ********************************************************************************************************
   fdoe@192.168.122.226       : ok=10   changed=4    unreachable=0    failed=0    skipped=6    rescued=0    ignored=0
   pdoe@192.168.122.98        : ok=10   changed=4    unreachable=0    failed=0    skipped=6    rescued=0    ignored=0

   在 Ansible 运行 playbook 之前，会提示您输入密码，以便受管主机上的用户可以切换到 root，这在配置内核参数时是必需的。

   recap 部分显示 play 成功完成所有受管主机 (failed=0)，并且已应用了 4 个内核参数 (changed=4)。

6. 重启您的受管主机并检查受影响的内核参数,以验证是否应用了更改并在重启后保留。

流程

1. 创建包含以下内容的 playbook 文件，如 ~/ethernet-static-IP.yml ：

   ---
   - name: Configure the network
     hosts: managed-node-01.example.com
     tasks:
     - name: Configure an Ethernet connection with static IP
       include_role:
         name: rhel-system-roles.network
   
       vars:
         network_connections:
           - name: enp7s0
             interface_name: enp7s0
             type: ethernet
             autoconnect: yes
             ip:
               address:
                 - 192.0.2.1/24
                 - 2001:db8:1::1/64
               gateway4: 192.0.2.254
               gateway6: 2001:db8:1::fffe
               dns:
                 - 192.0.2.200
                 - 2001:db8:1::ffbb
               dns_search:
                 - example.com
             state: up

2. 运行 playbook：

   # ansible-playbook ~/ethernet-static-IP.yml

流程

1. 创建包含以下内容的 playbook 文件，如 ~/ethernet-static-IP.yml ：

   ---
   - name: Configure the network
     hosts: managed-node-01.example.com
     tasks:
     - name: Configure an Ethernet connection with static IP
       include_role:
         name: rhel-system-roles.network
   
       vars:
         network_connections:
           - name: example
             match:
               path:
                 - pci-0000:00:0[1-3].0
                 - &!pci-0000:00:02.0
             type: ethernet
             autoconnect: yes
             ip:
               address:
                 - 192.0.2.1/24
                 - 2001:db8:1::1/64
               gateway4: 192.0.2.254
               gateway6: 2001:db8:1::fffe
               dns:
                 - 192.0.2.200
                 - 2001:db8:1::ffbb
               dns_search:
                 - example.com
             state: up

   本例中的 match 参数定义了 Ansible 将剧本应用到与 PCI ID 0000:00:0[1-3].0 匹配的设备，但没有 0000:00:02.0 设备。有关可以使用的特殊修饰符和通配符的详情，请查看 /usr/share/ansible/roles/rhel-system-roles.network/README.md 文件中的 match 参数描述。

2. 运行 playbook：

   # ansible-playbook ~/ethernet-static-IP.yml

流程

1. 创建包含以下内容的 playbook 文件，如 ~/ethernet-dynamic-IP.yml ：

   ---
   - name: Configure the network
     hosts: managed-node-01.example.com
     tasks:
     - name: Configure an Ethernet connection with dynamic IP
       include_role:
         name: rhel-system-roles.network
   
       vars:
         network_connections:
           - name: enp7s0
             interface_name: enp7s0
             type: ethernet
             autoconnect: yes
             ip:
               dhcp4: yes
               auto6: yes
             state: up

2. 运行 playbook：

   # ansible-playbook ~/ethernet-dynamic-IP.yml

流程

1. 创建包含以下内容的 playbook 文件，如 ~/ethernet-dynamic-IP.yml ：

   ---
   - name: Configure the network
     hosts: managed-node-01.example.com
     tasks:
     - name: Configure an Ethernet connection with dynamic IP
       include_role:
         name: rhel-system-roles.network
   
       vars:
         network_connections:
           - name: example
             match:
               path:
                 - pci-0000:00:0[1-3].0
                 - &!pci-0000:00:02.0
             type: ethernet
             autoconnect: yes
             ip:
               dhcp4: yes
               auto6: yes
             state: up

   本例中的 match 参数定义了 Ansible 将剧本应用到与 PCI ID 0000:00:0[1-3].0 匹配的设备，但没有 0000:00:02.0 设备。有关可以使用的特殊修饰符和通配符的详情，请查看 /usr/share/ansible/roles/rhel-system-roles.network/README.md 文件中的 match 参数描述。

2. 运行 playbook：

   # ansible-playbook ~/ethernet-dynamic-IP.yml

流程

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

   ---
   - name: Configure the network
     hosts: managed-node-01.example.com
     tasks:
     - name: Configure a VLAN that uses an Ethernet connection
       include_role:
         name: rhel-system-roles.network
   
       vars:
         network_connections:
           # Add an Ethernet profile for the underlying device of the VLAN
           - name: enp1s0
             type: ethernet
             interface_name: enp1s0
             autoconnect: yes
             state: up
             ip:
               dhcp4: no
               auto6: no
   
           # Define the VLAN profile
           - name: enp1s0.10
             type: vlan
             ip:
               address:
                 - "192.0.2.1/24"
                 - "2001:db8:1::1/64"
               gateway4: 192.0.2.254
               gateway6: 2001:db8:1::fffe
               dns:
                 - 192.0.2.200
                 - 2001:db8:1::ffbb
               dns_search:
                 - example.com
             vlan_id: 10
             parent: enp1s0
             state: up

   VLAN 配置文件中的 parent 属性将 VLAN 配置为在 enp1s0 设备之上运行。

2. 运行 playbook：

   # ansible-playbook ~/vlan-ethernet.yml

流程

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

   ---
   - name: Configure the network
     hosts: managed-node-01.example.com
     tasks:
     - name: Configure a network bridge that uses two Ethernet ports
       include_role:
         name: rhel-system-roles.network
   
       vars:
         network_connections:
           # Define the bridge profile
           - name: bridge0
             type: bridge
             interface_name: bridge0
             ip:
               address:
                 - "192.0.2.1/24"
                 - "2001:db8:1::1/64"
               gateway4: 192.0.2.254
               gateway6: 2001:db8:1::fffe
               dns:
                 - 192.0.2.200
                 - 2001:db8:1::ffbb
               dns_search:
                 - example.com
             state: up
   
           # Add an Ethernet profile to the bridge
           - name: bridge0-port1
             interface_name: enp7s0
             type: ethernet
             controller: bridge0
             port_type: bridge
             state: up
   
           # Add a second Ethernet profile to the bridge
           - name: bridge0-port2
             interface_name: enp8s0
             type: ethernet
             controller: bridge0
             port_type: bridge
             state: up

2. 运行 playbook：

   # ansible-playbook ~/bridge-ethernet.yml

流程

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

   ---
   - name: Configure the network
     hosts: managed-node-01.example.com
     tasks:
     - name: Configure a network bond that uses two Ethernet ports
       include_role:
         name: rhel-system-roles.network
   
       vars:
         network_connections:
           # Define the bond profile
           - name: bond0
             type: bond
             interface_name: bond0
             ip:
               address:
                 - "192.0.2.1/24"
                 - "2001:db8:1::1/64"
               gateway4: 192.0.2.254
               gateway6: 2001:db8:1::fffe
               dns:
                 - 192.0.2.200
                 - 2001:db8:1::ffbb
               dns_search:
                 - example.com
             bond:
               mode: active-backup
             state: up
   
           # Add an Ethernet profile to the bond
           - name: bond0-port1
             interface_name: enp7s0
             type: ethernet
             controller: bond0
             state: up
   
           # Add a second Ethernet profile to the bond
           - name: bond0-port2
             interface_name: enp8s0
             type: ethernet
             controller: bond0
             state: up

2. 运行 playbook：

   # ansible-playbook ~/bond-ethernet.yml

流程

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

   ---
   - name: Configure the network
     hosts: managed-node-01.example.com
     tasks:
     - name: Configure IPoIB
       include_role:
         name: rhel-system-roles.network
   
       vars:
         network_connections:
   
           # InfiniBand connection mlx4_ib0
           - name: mlx4_ib0
             interface_name: mlx4_ib0
             type: infiniband
   
           # IPoIB device mlx4_ib0.8002 on top of mlx4_ib0
           - name: mlx4_ib0.8002
             type: infiniband
             autoconnect: yes
             infiniband:
               p_key: 0x8002
               transport_mode: datagram
             parent: mlx4_ib0
             ip:
               address:
                 - 192.0.2.1/24
                 - 2001:db8:1::1/64
             state: up

   如果您像本例所示设置 p_key 参数，请不要在 IPoIB 设备中设置 interface_name 参数。

2. 运行 playbook：

   # ansible-playbook ~/IPoIB.yml

验证

1. 在 managed-node-01.example.com 主机上显示 mlx4_ib0.8002 设备的 IP 设置：

   # ip address show mlx4_ib0.8002
   ...
   inet 192.0.2.1/24 brd 192.0.2.255 scope global noprefixroute ib0.8002
      valid_lft forever preferred_lft forever
   inet6 2001:db8:1::1/64 scope link tentative noprefixroute
      valid_lft forever preferred_lft forever

2. 显示 mlx4_ib0.8002 设备的分区密钥(P_Key)：

   # cat /sys/class/net/mlx4_ib0.8002/pkey
   0x8002

3. 显示 mlx4_ib0.8002 设备的模式：

   # cat /sys/class/net/mlx4_ib0.8002/mode
   datagram

流程

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

   ---
   - name: Configuring policy-based routing
     hosts: managed-node-01.example.com
     tasks:
     - name: Routing traffic from a specific subnet to a different default gateway
       include_role:
         name: rhel-system-roles.network
   
       vars:
         network_connections:
           - name: Provider-A
             interface_name: enp7s0
             type: ethernet
             autoconnect: True
             ip:
               address:
                 - 198.51.100.1/30
               gateway4: 198.51.100.2
               dns:
                 - 198.51.100.200
             state: up
             zone: external
   
           - name: Provider-B
             interface_name: enp1s0
             type: ethernet
             autoconnect: True
             ip:
               address:
                 - 192.0.2.1/30
               route:
                 - network: 0.0.0.0
                   prefix: 0
                   gateway: 192.0.2.2
                   table: 5000
             state: up
             zone: external
   
           - name: Internal-Workstations
             interface_name: enp8s0
             type: ethernet
             autoconnect: True
             ip:
               address:
                 - 10.0.0.1/24
               route:
                 - network: 10.0.0.0
                   prefix: 24
                   table: 5000
               routing_rule:
                 - priority: 5
                   from: 10.0.0.0/24
                   table: 5000
             state: up
             zone: trusted
   
           - name: Servers
             interface_name: enp9s0
             type: ethernet
             autoconnect: True
             ip:
               address:
                 - 203.0.113.1/24
             state: up
             zone: trusted

2. 运行 playbook：

   # ansible-playbook ~/pbr.yml

验证

1. 在内部工作站子网的 RHEL 主机上：

   1. 安装 traceroute 软件包：

      # yum install traceroute

   2. 使用 traceroute 工具显示到互联网上主机的路由：

      # traceroute redhat.com
      traceroute to redhat.com (209.132.183.105), 30 hops max, 60 byte packets
       1  10.0.0.1 (10.0.0.1)     0.337 ms  0.260 ms  0.223 ms
       2  192.0.2.1 (192.0.2.1)   0.884 ms  1.066 ms  1.248 ms
       ...

      命令的输出显示路由器通过 192.0.2.1 ，即提供商 B 的网络来发送数据包。

2. 在服务器子网的 RHEL 主机上：

   1. 安装 traceroute 软件包：

      # yum install traceroute

   2. 使用 traceroute 工具显示到互联网上主机的路由：

      # traceroute redhat.com
      traceroute to redhat.com (209.132.183.105), 30 hops max, 60 byte packets
       1  203.0.113.1 (203.0.113.1)    2.179 ms  2.073 ms  1.944 ms
       2  198.51.100.2 (198.51.100.2)  1.868 ms  1.798 ms  1.549 ms
       ...

      命令的输出显示路由器通过 198.51.100.2 ，即供应商 A 的网络来发送数据包。

3. 在使用 RHEL 系统角色配置的 RHEL 路由器上：

   1. 显示规则列表：

      # ip rule list
      0:      from all lookup local
      5:    from 10.0.0.0/24 lookup 5000
      32766:  from all lookup main
      32767:  from all lookup default

      默认情况下，RHEL 包含表 local、main 和 default 的规则。

   2. 显示表 5000 中的路由：

      # ip route list table 5000
      0.0.0.0/0 via 192.0.2.2 dev enp1s0 proto static metric 100
      10.0.0.0/24 dev enp8s0 proto static scope link src 192.0.2.1 metric 102

   3. 显示接口和防火墙区：

      # firewall-cmd --get-active-zones
      external
        interfaces: enp1s0 enp7s0
      trusted
        interfaces: enp8s0 enp9s0

   4. 验证 external 区是否启用了伪装：

      # firewall-cmd --info-zone=external
      external (active)
        target: default
        icmp-block-inversion: no
        interfaces: enp1s0 enp7s0
        sources:
        services: ssh
        ports:
        protocols:
        masquerade: yes
        ...

流程

1. 创建包含以下内容的 playbook 文件，如 ~/enable-802.1x.yml ：

   ---
   - name: Configure an Ethernet connection with 802.1X authentication
     hosts: managed-node-01.example.com
     tasks:
       - name: Copy client key for 802.1X authentication
         copy:
           src: "/srv/data/client.key"
           dest: "/etc/pki/tls/private/client.key"
           mode: 0600
   
       - name: Copy client certificate for 802.1X authentication
         copy:
           src: "/srv/data/client.crt"
           dest: "/etc/pki/tls/certs/client.crt"
   
       - name: Copy CA certificate for 802.1X authentication
         copy:
           src: "/srv/data/ca.crt"
           dest: "/etc/pki/ca-trust/source/anchors/ca.crt"
   
       - include_role:
           name: rhel-system-roles.network
   
         vars:
           network_connections:
             - name: enp1s0
               type: ethernet
               autoconnect: yes
               ip:
                 address:
                   - 192.0.2.1/24
                   - 2001:db8:1::1/64
                 gateway4: 192.0.2.254
                 gateway6: 2001:db8:1::fffe
                 dns:
                   - 192.0.2.200
                   - 2001:db8:1::ffbb
                 dns_search:
                   - example.com
               ieee802_1x:
                 identity: user_name
                 eap: tls
                 private_key: "/etc/pki/tls/private/client.key"
                 private_key_password: "password"
                 client_cert: "/etc/pki/tls/certs/client.crt"
                 ca_cert: "/etc/pki/ca-trust/source/anchors/ca.crt"
                 domain_suffix_match: example.com
               state: up

2. 运行 playbook：

   # ansible-playbook ~/enable-802.1x.yml

流程

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

   ---
   - name: Configure the network
     hosts: managed-node-01.example.com
     tasks:
     - name: Configure an Ethernet connection with static IP and default gateway
       include_role:
         name: rhel-system-roles.network
   
       vars:
         network_connections:
           - name: enp1s0
             type: ethernet
             autoconnect: yes
             ip:
               address:
                 - 198.51.100.20/24
                 - 2001:db8:1::1/64
               gateway4: 198.51.100.254
               gateway6: 2001:db8:1::fffe
               dns:
                 - 198.51.100.200
                 - 2001:db8:1::ffbb
               dns_search:
                 - example.com
             state: up

2. 运行 playbook：

   # ansible-playbook ~/ethernet-connection.yml

流程

1. 创建包含以下内容的 playbook 文件，如 ~/add-static-routes.yml ：

   ---
   - name: Configure the network
     hosts: managed-node-01.example.com
     tasks:
     - name: Configure an Ethernet connection with static IP and additional routes
       include_role:
         name: rhel-system-roles.network
   
       vars:
         network_connections:
           - name: enp7s0
             type: ethernet
             autoconnect: yes
             ip:
               address:
                 - 192.0.2.1/24
                 - 2001:db8:1::1/64
               gateway4: 192.0.2.254
               gateway6: 2001:db8:1::fffe
               dns:
                 - 192.0.2.200
                 - 2001:db8:1::ffbb
               dns_search:
                 - example.com
               route:
                 - network: 198.51.100.0
                   prefix: 24
                   gateway: 192.0.2.10
                 - network: 2001:db8:2::
                   prefix: 64
                   gateway: 2001:db8:1::10
             state: up

2. 运行 playbook：

   # ansible-playbook ~/add-static-routes.yml

验证

1. 在受管节点上：

   1. 显示 IPv4 路由：

      # ip -4 route
      ...
      198.51.100.0/24 via 192.0.2.10 dev enp7s0

   2. 显示 IPv6 路由：

      # ip -6 route
      ...
      2001:db8:2::/64 via 2001:db8:1::10 dev enp7s0 metric 1024 pref medium

流程

1. 创建一个 playbook 文件，如 ~/configure-ethernet-device-with-ethtool-features.yml，其内容如下：

   ---
   - name: Configure the network
     hosts: managed-node-01.example.com
     tasks:
     - name: Configure an Ethernet connection with ethtool features
       include_role:
         name: rhel-system-roles.network
   
       vars:
         network_connections:
           - name: enp1s0
             type: ethernet
             autoconnect: yes
             ip:
               address:
                 - 198.51.100.20/24
                 - 2001:db8:1::1/64
               gateway4: 198.51.100.254
               gateway6: 2001:db8:1::fffe
               dns:
                 - 198.51.100.200
                 - 2001:db8:1::ffbb
               dns_search:
                 - example.com
             ethtool:
               features:
                 gro: "no"
                 gso: "yes"
                 tx_sctp_segmentation: "no"
             state: up

2. 运行 playbook：

   # ansible-playbook ~/configure-ethernet-device-with-ethtool-features.yml

流程

1. 创建一个 playbook 文件，如 ~/configure-ethernet-device-with-ethtoolcoalesce-settings.yml，其内容如下：

   ---
   - name: Configure the network
     hosts: managed-node-01.example.com
     tasks:
     - name: Configure an Ethernet connection with ethtool coalesce settings
       include_role:
         name: rhel-system-roles.network
   
       vars:
         network_connections:
           - name: enp1s0
             type: ethernet
             autoconnect: yes
             ip:
               address:
                 - 198.51.100.20/24
                 - 2001:db8:1::1/64
               gateway4: 198.51.100.254
               gateway6: 2001:db8:1::fffe
               dns:
                 - 198.51.100.200
                 - 2001:db8:1::ffbb
               dns_search:
                 - example.com
             ethtool:
               coalesce:
                 rx_frames: 128
                 tx_frames: 128
             state: up

2. 运行 playbook：

   # ansible-playbook ~/configure-ethernet-device-with-ethtoolcoalesce-settings.yml

流程

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

   ---
   - name: Reset firewalld example
     hosts: managed-node-01.example.com
     tasks:
     - name: Reset firewalld
       include_role:
         name: rhel-system-roles.firewall
   
       vars:
         firewall:
           - previous: replaced

2. 运行 playbook：

   # ansible-playbook ~/configuring-a-dmz.yml

流程

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

   ---
   - name: Configure firewalld
     hosts: managed-node-01.example.com
     tasks:
     - name: Forward incoming traffic on port 8080 to 443
       include_role:
         name: rhel-system-roles.firewall
   
       vars:
         firewall:
           - { forward_port: 8080/tcp;443;, state: enabled, runtime: true, permanent: true }

2. 运行 playbook：

   # ansible-playbook ~/port_forwarding.yml

流程

1. 创建包含以下内容的 playbook 文件，如 ~/opening-a-a-port.yml ：

   ---
   - name: Configure firewalld
     hosts: managed-node-01.example.com
     tasks:
     - name: Allow incoming HTTPS traffic to the local host
       include_role:
         name: rhel-system-roles.firewall
   
       vars:
         firewall:
           - port: 443/tcp
             service: http
             state: enabled
             runtime: true
             permanent: true

   permanent: true 选项可使新设置在重启后保持不变。

2. 运行 playbook：

   # ansible-playbook ~/opening-a-port.yml

流程

1. 创建包含以下内容的 playbook 文件，如 ~/configuring-a-dmz.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
       include_role:
         name: rhel-system-roles.firewall
   
       vars:
         firewall:
           - zone: dmz
             interface: enp1s0
             service: https
             state: enabled
             runtime: true
             permanent: true

2. 运行 playbook：

   # ansible-playbook ~/configuring-a-dmz.yml

流程

1. 准备您的 playbook。您可以从头开始，或修改作为 rhel-system-roles 软件包的一部分安装的示例 playbook：

   # cp /usr/share/doc/rhel-system-roles/selinux/example-selinux-playbook.yml my-selinux-playbook.yml
   # vi my-selinux-playbook.yml

2. 更改 playbook 的内容，使其适合您的场景。例如，以下部分确保系统安装并启用 selinux-local-1.pp SELinux 模块：

   selinux_modules:
   - { path: "selinux-local-1.pp", priority: "400" }

3. 保存更改，然后退出文本编辑器。

4. 在 host1、host2 和 host3 系统上运行您的 playbook：

   # ansible-playbook -i host1,host2,host3 my-selinux-playbook.yml

流程

1. 创建定义所需角色的 playbook:

   1. 创建新 YAML 文件，并在文本编辑器中打开，例如：

      # vi logging-playbook.yml

   2. 插入以下内容：

      ---
      - name: Deploying basics input and implicit files output
        hosts: all
        roles:
          - rhel-system-roles.logging
        vars:
          logging_inputs:
            - name: system_input
              type: basics
          logging_outputs:
            - name: files_output
              type: files
          logging_flows:
            - name: flow1
              inputs: [system_input]
              outputs: [files_output]

2. 对特定清单运行 playbook:

   # ansible-playbook -i inventory-file /path/to/file/logging-playbook.yml

   其中：

   • inventory-file 是清单文件。
   • logging-playbook.yml 是您使用的 playbook。

验证

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. 验证系统是否向日志发送信息：

   1. 发送测试信息：

      # logger test

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

      # cat /var/log/messages
      Aug  5 13:48:31 hostname root[6778]: test

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

流程

1. 使用以下内容创建一个新的 playbook.yml 文件：

   ---
   - name: Deploying files input and configured files output
     hosts: all
     roles:
       - linux-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]

   使用这个配置，包含 error 字符串的所有消息都会记录在 /var/log/errors.log 中，所有其他消息都记录在 /var/log/others.log 中。

   您可以将 error 属性值替换为您要过滤的字符串。

   您可以根据您的偏好修改变量。

2. 可选：验证 playbook 语法。

   # ansible-playbook --syntax-check playbook.yml

3. 在清单文件上运行 playbook:

   # ansible-playbook -i inventory_file /path/to/file/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:

   1. 创建新 YAML 文件，并在文本编辑器中打开，例如：

      # vi logging-playbook.yml

   2. 将以下内容插入到文件中：

      ---
      - name: Deploying remote input and remote_files output
        hosts: server
        roles:
          - 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: Deploying basics input and forwards output
        hosts: clients
        roles:
          - 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]
      
      [basic_input]
      [forward_output0, forward_output1]

      其中 host1.example.com 是日志服务器。

      注意

      您可以修改 playbook 中的参数以符合您的需要。

      警告

      日志解决方案只适用于在服务器或者客户端系统的 SELinux 策略中定义的端口并在防火墙中打开。默认 SELinux 策略包括端口 601、514、6514、10514 和 20514。要使用其他端口，请修改客户端和服务器系统上的 SELinux 策略。目前还不支持通过系统角色配置防火墙。

2. 创建列出您的服务器和客户端的清单文件：

   1. 创建新文件并在文本编辑器中打开该文件，例如：

      # vi inventory.ini

   2. 将以下内容插入到清单文件中：

      [servers]
      server ansible_host=host1.example.com
      [clients]
      client ansible_host=host2.example.com

      其中：

      • host1.example.com 是日志服务器。
      • host2.example.com 是日志客户端。

3. 对清单运行 playbook。

   # ansible-playbook -i /path/to/file/inventory.ini /path/to/file/_logging-playbook.yml

   其中：

   • inventory.ini 是清单文件。
   • logging-playbook.yml 是您创建的 playbook。

验证

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/messages 日志，例如：

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

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

流程

1. 复制 sshd 系统角色的示例 playbook：

   # cp /usr/share/doc/rhel-system-roles/sshd/example-root-login-playbook.yml path/custom-playbook.yml

2. 使用文本编辑器打开复制的 playbook，例如：

   # vim path/custom-playbook.yml
   
   ---
   - hosts: all
     tasks:
     - name: Configure sshd to prevent root and password login except from particular subnet
       include_role:
         name: rhel-system-roles.sshd
       vars:
         sshd:
           # root login and password login is enabled only from a particular subnet
           PermitRootLogin: no
           PasswordAuthentication: no
           Match:
           - Condition: "Address 192.0.2.0/24"
             PermitRootLogin: yes
             PasswordAuthentication: yes

   playbook 将受管节点配置为 SSH 服务器，以便：

   • 禁用密码和 root 用户登录
   • 只对子网 192.0.2.0/24 启用密码和 root 用户登录

   您可以根据您的偏好修改变量。如需了解更多详细信息，请参阅 SSH 服务器系统角色变量。

3. 可选：验证 playbook 语法。

   # ansible-playbook --syntax-check path/custom-playbook.yml

4. 在清单文件上运行 playbook:

   # ansible-playbook -i inventory_file path/custom-playbook.yml
   
   ...
   
   PLAY RECAP
   **************************************************
   
   localhost : ok=12 changed=2 unreachable=0 failed=0
   skipped=10 rescued=0 ignored=0

验证

1. 登录到 SSH 服务器：

   $ ssh user1@10.1.1.1

   其中：

   • user1 是 SSH 服务器上的用户。
   • 10.1.1.1 是 SSH 服务器的 IP 地址。

2. 检查 SSH 服务器上的 sshd_config 文件的内容：

   $ vim /etc/ssh/sshd_config
   
   # Ansible managed
   HostKey /etc/ssh/ssh_host_rsa_key
   HostKey /etc/ssh/ssh_host_ecdsa_key
   HostKey /etc/ssh/ssh_host_ed25519_key
   AcceptEnv LANG LC_CTYPE LC_NUMERIC LC_TIME LC_COLLATE LC_MONETARY LC_MESSAGES
   AcceptEnv LC_PAPER LC_NAME LC_ADDRESS LC_TELEPHONE LC_MEASUREMENT
   AcceptEnv LC_IDENTIFICATION LC_ALL LANGUAGE
   AcceptEnv XMODIFIERS
   AuthorizedKeysFile .ssh/authorized_keys
   ChallengeResponseAuthentication no
   GSSAPIAuthentication yes
   GSSAPICleanupCredentials no
   PasswordAuthentication no
   PermitRootLogin no
   PrintMotd no
   Subsystem sftp /usr/libexec/openssh/sftp-server
   SyslogFacility AUTHPRIV
   UsePAM yes
   X11Forwarding yes
   Match Address 192.0.2.0/24
     PasswordAuthentication yes
     PermitRootLogin yes

3. 检查您是否可以以 root 用户身份从 192.0.2.0/24 子网连接到服务器：

   1. 确定您的 IP 地址：

      $ hostname -I
      192.0.2.1

      如果 IP 地址在 192.0.2.1 - 192.0.2.254 范围内，您可以连接到服务器。

   2. 以 root 用户身份连接到服务器：

      $ ssh root@10.1.1.1

流程

1. 使用以下内容创建一个新的 playbook.yml 文件：

   ---
   - hosts: all
     tasks:
     - name: "Configure ssh clients"
       include_role:
         name: rhel-system-roles.ssh
       vars:
         ssh_user: root
         ssh:
           Compression: true
           GSSAPIAuthentication: no
           ControlMaster: auto
           ControlPath: ~/.ssh/.cm%C
           Host:
             - Condition: example
               Hostname: example.com
               User: user1
         ssh_ForwardX11: no

   此 playbook 使用以下配置在受管节点上配置 root 用户的 SSH 客户端首选项：

   • 压缩已启用。
   • ControlMaster 多路复用设置为 auto。
   • 连接到 example.com 主机的example 别名是 user1。
   • example 主机别名已创建，它表示使用 user1 用户名连接到 example.com 主机。
   • X11 转发被禁用。

   另外，您还可以根据您的偏好修改这些变量。如需了解更多详细信息，请参阅 ssh 系统角色变量。

2. 可选：验证 playbook 语法。

   # ansible-playbook --syntax-check path/custom-playbook.yml

3. 在清单文件上运行 playbook:

   # ansible-playbook -i inventory_file path/custom-playbook.yml

流程

1. 在 playbook 中添加带有 sshd_config_namespace 变量的配置片断：

   ---
   - hosts: all
     tasks:
     - name: <Configure SSHD to accept some useful environment variables>
       include_role:
         name: rhel-system-roles.sshd
       vars:
         sshd_config_namespace: <my-application>
         sshd:
           # Environment variables to accept
           AcceptEnv:
             LANG
             LS_COLORS
             EDITOR

   当您将 playbook 应用到清单时，角色会在 /etc/ssh/sshd_config 文件中添加下列代码片段（如果没有的话）。

   # BEGIN sshd system role managed block: namespace <my-application>
   Match all
     AcceptEnv LANG LS_COLORS EDITOR
   # END sshd system role managed block: namespace <my-application>

流程

1. 使用以下内容创建一个新的 playbook.yml 文件：

   - name: Host to host VPN
     hosts: managed_node1, managed_node2
     roles:
       - rhel-system-roles.vpn
     vars:
       vpn_connections:
         - hosts:
             managed_node1:
             managed_node2:

   此 playbook 使用系统角色自动生成的密钥进行预共享密钥身份验证，来配置 managed_node1-to-managed_node2 的连接。

2. 可选：通过将以下部分添加到主机的 vpn_connections 列表中，配置从受管主机到清单文件中未列出的外部主机的连接：

       vpn_connections:
         - hosts:
             managed_node1:
             managed_node2:
             external_node:
               hostname: 192.0.2.2

   这将配置另外两个连接：managed_node1-to-external_node 和 managed_node2-to-external_node。

1. 可选：您可以使用 vpn_connections 中的额外部分为受管节点指定多个 VPN 连接，如控制平面和数据平面：

   - name: Multiple VPN
     hosts: managed_node1, managed_node2
     roles:
       - rhel-system-roles.vpn
     vars:
       vpn_connections:
         - name: control_plane_vpn
           hosts:
             managed_node1:
               hostname: 192.0.2.0 # IP for the control plane
             managed_node2:
               hostname: 192.0.2.1
         - name: data_plane_vpn
           hosts:
             managed_node1:
               hostname: 10.0.0.1 # IP for the data plane
             managed_node2:
               hostname: 10.0.0.2

2. 可选：您可以根据您的偏好修改变量。详情请查看 /usr/share/doc/rhel-system-roles/vpn/README.md 文件。

3. 可选：验证 playbook 语法。

   # ansible-playbook --syntax-check /path/to/file/playbook.yml -i /path/to/file/inventory_file

4. 在清单文件上运行 playbook:

   # ansible-playbook -i /path/to/file/inventory_file /path/to/file/playbook.yml

验证

1. 在受管节点上，确认连接已成功载入：

   # ipsec status | grep connection.name

   将 connection.name 替换为来自此节点的连接的名称，如 managed_node1-to-managed_node2。

1. 在受管节点上，确认连接是否成功启动：

   # ipsec trafficstatus | grep connection.name

2. 可选：如果连接没有成功加载，请输入以下命令来手动添加连接。这将提供更具体的信息，说明连接未能建立的原因：

   # ipsec auto --add connection.name

   注意

   加载和启动连接过程中可能出现的任何错误都会在日志中报告，这些错误可以在 /var/log/pluto.log 中找到。由于这些日志难以解析，因此请尝试手动添加连接来获得日志消息，而不是从标准输出中获得。

流程

1. 使用以下内容创建一个新的 playbook.yml 文件：

   - name: Mesh VPN
     hosts: managed_node1, managed_node2, managed_node3
     roles:
       - rhel-system-roles.vpn
     vars:
       vpn_connections:
         - opportunistic: true
           auth_method: cert
           policies:
             - policy: private
               cidr: default
             - policy: private-or-clear
               cidr: 198.51.100.0/24
             - policy: private
               cidr: 192.0.2.0/24
             - policy: clear
               cidr: 192.0.2.7/32

2. 可选：您可以根据您的偏好修改变量。详情请查看 /usr/share/doc/rhel-system-roles/vpn/README.md 文件。

3. 可选：验证 playbook 语法。

   # ansible-playbook --syntax-check playbook.yml

4. 在清单文件上运行 playbook:

   # ansible-playbook -i inventory_file /path/to/file/playbook.yml

流程

1. 使用以下内容创建一个新的 playbook.yml 文件：

   ---
   - hosts: all
     tasks:
     - name: Configure crypto policies
       include_role:
         name: rhel-system-roles.crypto_policies
       vars:
         - crypto_policies_policy: FUTURE
         - crypto_policies_reboot_ok: true

   您可以将 FUTURE 值替换为您首选的加密策略，例如：DEFAULT、LEGACY 和 FIPS:OSPP.

   crypto_policies_reboot_ok: true 变量会导致系统在系统角色更改加密策略后重启系统。

   如需了解更多详细信息，请参阅 crypto_policies 系统角色变量和事实。

2. 可选：验证 playbook 语法。

   # ansible-playbook --syntax-check playbook.yml

3. 在清单文件上运行 playbook:

   # ansible-playbook -i inventory_file playbook.yml

验证

1. 在控制节点上，创建另一个 playbook，例如,名为 verify_playbook.yml:

   - hosts: all
     tasks:
    - name: Verify active crypto policy
      include_role:
        name: rhel-system-roles.crypto_policies
   
    - debug:
        var: crypto_policies_active

   此 playbook 不更改系统上的任何配置，只报告受管节点上的活动策略。

2. 运行同一个清单文件上的 playbook:

   # ansible-playbook -i inventory_file verify_playbook.yml
   
   TASK [debug] **************************
   ok: [host] => {
       "crypto_policies_active": "FUTURE"
   }

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

步骤

1. 准备包含 Tang 服务器设置的 playbook。您可以从头开始，或使用 /usr/share/ansible/roles/rhel-system-roles.nbde_server/examples/ 目录中的一个 playbook 示例。

   # cp /usr/share/ansible/roles/rhel-system-roles.nbde_server/examples/simple_deploy.yml ./my-tang-playbook.yml

2. 在您选择的文本编辑器中编辑 playbook，例如：

   # vi my-tang-playbook.yml

3. 添加所需参数。以下 playbook 示例确保部署 Tang 服务器和密钥轮转：

   ---
   - hosts: all
   
     vars:
       nbde_server_rotate_keys: yes
   
     roles:
       - rhel-system-roles.nbde_server

4. 应用完成的 playbook:

   # ansible-playbook -i inventory-file my-tang-playbook.yml

   其中： * inventory-file 是清单文件。* logging-playbook.yml 是您使用的 playbook。

流程

1. 准备包含 Clevis 客户端设置的 playbook。您可以从头开始，或使用 /usr/share/ansible/roles/rhel-system-roles.nbde_client/examples/ 目录中的一个 playbook 示例。

   # cp /usr/share/ansible/roles/rhel-system-roles.nbde_client/examples/high_availability.yml ./my-clevis-playbook.yml

2. 在您选择的文本编辑器中编辑 playbook，例如：

   # vi my-clevis-playbook.yml

3. 添加所需参数。以下 playbook 示例配置 Clevis 客户端，以便在两个 Tang 服务器中至少有一个可用时自动解锁两个 LUKS 加密卷：

   ---
   - hosts: all
   
     vars:
       nbde_client_bindings:
         - device: /dev/rhel/root
           encryption_key_src: /etc/luks/keyfile
           servers:
             - http://server1.example.com
             - http://server2.example.com
         - device: /dev/rhel/swap
           encryption_key_src: /etc/luks/keyfile
           servers:
             - http://server1.example.com
             - http://server2.example.com
   
     roles:
       - rhel-system-roles.nbde_client

4. 应用完成的 playbook:

   # ansible-playbook -i host1,host2,host3 my-clevis-playbook.yml

流程

1. 可选：创建一个清单文件，如 inventory.file ：

   $ *touch inventory.file*

2. 打开清单文件并定义要请求证书的主机，例如：

   [webserver]
   server.idm.example.com

3. 创建 playbook 文件，如 request-certificate.yml:

   • 将 hosts 设置为包含您要对其请求证书的主机，如 webserver。

   • 将 certificate_requests 变量设置为包含以下内容：

     • 将 name 参数设为所需证书的名称，如 mycert。
     • 将 dns 参数设为要在证书中包含的域，如 *.example.com。
     • 将 ca 参数设为 self-sign。

   • 在 roles 下设置 rhel-system-roles.certificate 角色。

     这是本例的 playbook 文件：

     ---
     - hosts: webserver
     
       vars:
         certificate_requests:
           - name: mycert
             dns: "*.example.com"
             ca: self-sign
     
       roles:
         - rhel-system-roles.certificate

4. 保存该文件。

5. 运行 playbook:

   $ *ansible-playbook -i inventory.file request-certificate.yml*

流程

1. 可选：创建一个清单文件，如 inventory.file ：

   $ *touch inventory.file*

2. 打开清单文件并定义要请求证书的主机，例如：

   [webserver]
   server.idm.example.com

3. 创建 playbook 文件，如 request-certificate.yml:

   • 将 hosts 设置为包含您要对其请求证书的主机，如 webserver。

   • 将 certificate_requests 变量设置为包含以下内容：

     • 将 name 参数设为所需证书的名称，如 mycert。
     • 将 dns 参数设要在证书中包含的域，如 www.example.com。
     • 将 principal 参数设为指定 Kerberos 主体，如 HTTP/www.example.com@EXAMPLE.COM。
     • 将 ca 参数设为 ipa。

   • 在 roles 下设置 rhel-system-roles.certificate 角色。

     这是本例的 playbook 文件：

     ---
     - hosts: webserver
       vars:
         certificate_requests:
           - name: mycert
             dns: www.example.com
             principal: HTTP/www.example.com@EXAMPLE.COM
             ca: ipa
     
       roles:
         - rhel-system-roles.certificate

4. 保存该文件。

5. 运行 playbook:

   $ *ansible-playbook -i inventory.file request-certificate.yml*

流程

1. 可选：创建一个清单文件，如 inventory.file ：

   $ *touch inventory.file*

2. 打开清单文件并定义要请求证书的主机，例如：

   [webserver]
   server.idm.example.com

3. 创建 playbook 文件，如 request-certificate.yml:

   • 将 hosts 设置为包含您要对其请求证书的主机，如 webserver。

   • 将 certificate_requests 变量设置为包含以下内容：

     • 将 name 参数设为所需证书的名称，如 mycert。
     • 将 dns 参数设要在证书中包含的域，如 www.example.com。
     • 将 ca 参数设为您要用来发布证书的 CA，如 self-sign 。
     • 将 run_before 参数设为在签发或续订证书之前要执行的命令，如 systemctl stop httpd.service。
     • 将 run_after 参数设为在签发或续订此证书后要执行的命令，如 systemctl start httpd.service。

   • 在 roles 下设置 rhel-system-roles.certificate 角色。

     这是本例的 playbook 文件：

     ---
     - hosts: webserver
       vars:
         certificate_requests:
           - name: mycert
             dns: www.example.com
             ca: self-sign
             run_before: systemctl stop httpd.service
             run_after: systemctl start httpd.service
     
       roles:
         - rhel-system-roles.certificate

4. 保存该文件。

5. 运行 playbook:

   $ *ansible-playbook -i inventory.file request-certificate.yml*

流程

1. 使用以下内容创建一个新的 playbook.yml 文件：

   ---
   - hosts: kdump-test
     vars:
       kdump_path: /var/crash
     roles:
       - rhel-system-roles.kdump

2. 可选：验证 playbook 语法。

   # ansible-playbook --syntax-check playbook.yml

3. 在清单文件上运行 playbook:

   # ansible-playbook -i inventory_file /path/to/file/playbook.yml

流程

1. 创建包含以下内容的 playbook.yml 文件：

   ---
   - name: Configure the storage
     hosts: managed-node-01.example.com
     tasks:
     - name: Create a RAID on sdd, sde, sdf, and sdg
       include_role:
         name: rhel-system-roles.storage
       vars:
       storage_safe_mode: false
       storage_volumes:
         - name: data
           type: raid
           disks: [sdd, sde, sdf, sdg]
           raid_level: raid0
           raid_chunk_size: 32 KiB
           mount_point: /mnt/data
           state: present

   警告

   设备名称在某些情况下可能会改变，例如：当您在系统中添加新磁盘时。因此，为了避免数据丢失，请不要在 playbook 中使用特定的磁盘名称。

2. 可选：验证 playbook 语法：

   # ansible-playbook --syntax-check playbook.yml

3. 运行 playbook:

   # ansible-playbook -i inventory.file /path/to/file/playbook.yml

流程

1. 使用以下内容创建一个新的 playbook.yml 文件：

   - hosts: all
     vars:
       storage_safe_mode: false
       storage_pools:
         - name: my_pool
           type: lvm
           disks: [sdh, sdi]
           raid_level: raid1
           volumes:
             - name: my_pool
               size: "1 GiB"
               mount_point: "/mnt/app/shared"
               fs_type: xfs
               state: present
     roles:
       - name: rhel-system-roles.storage

   注意

   要使用 RAID 创建 LVM 池，您必须使用 raid_level 参数来指定 RAID 类型。

2. 可选。验证 playbook 语法。

   # ansible-playbook --syntax-check playbook.yml

3. 在清单文件上运行 playbook:

   # ansible-playbook -i inventory.file /path/to/file/playbook.yml

流程

1. 使用以下内容创建一个新的 playbook.yml 文件：

   - hosts: all
     vars:
       storage_volumes:
         - name: barefs
           type: disk
           disks:
            - sdb
           fs_type: xfs
           fs_label: label-name
           mount_point: /mnt/data
           encryption: true
           encryption_password: your-password
     roles:
      - rhel-system-roles.storage

2. 可选：验证 playbook 语法：

   # ansible-playbook --syntax-check playbook.yml

3. 在清单文件上运行 playbook:

   # ansible-playbook -i inventory.file /path/to/file/playbook.yml

流程

1. 使用以下内容创建一个新的 playbook.yml 文件：

   ---
   - hosts: timesync-test
     vars:
       timesync_ntp_servers:
         - hostname: 2.rhel.pool.ntp.org
           pool: yes
           iburst: yes
     roles:
       - rhel-system-roles.timesync

2. 可选：验证 playbook 语法。

   # ansible-playbook --syntax-check playbook.yml

3. 在清单文件上运行 playbook:

   # ansible-playbook -i inventory_file /path/to/file/playbook.yml

流程

1. 使用以下内容创建一个 playbook.yml 文件：

   ---
   - hosts: timesync-test
     vars:
       timesync_ntp_servers:
         - hostname: ptbtime1.ptb.de
           iburst: yes
           nts: yes
     roles:
       - rhel-system-roles.timesync

   ptbtime1.ptb.de 是一个公共服务器的示例。您可能想要使用不同的公共服务器或您自己的服务器。

2. 可选：验证 playbook 语法。

   # ansible-playbook --syntax-check playbook.yml

3. 在清单文件上运行 playbook:

   # ansible-playbook -i inventory_file /path/to/file/playbook.yml

验证

1. 在客户端机器上执行测试：

   # chronyc -N authdata
   
   Name/IP address         Mode KeyID Type KLen Last Atmp  NAK Cook CLen
   =====================================================================
   ptbtime1.ptb.de         NTS     1   15  256  157    0    0    8  100

2. 检查是否报告的 cookies 数量大于零。

流程

1. 通过在清单中添加以下内容，在 /etc/ansible/hosts Ansible 清单中配置 localhost ：

   localhost ansible_connection=local

2. 使用以下内容创建一个 Ansible playbook:

   ---
   - hosts: localhost
     vars:
       metrics_graph_service: yes
     roles:
       - rhel-system-roles.metrics

3. 运行 Ansible playbook:

   # ansible-playbook name_of_your_playbook.yml

   注意

   由于 metrics_graph_service 布尔值被设置为 value="yes"，因此会使用 pcp 自动安装并提供 Grafana ，并添加为数据源。

4. 要查看机器上收集的指标的视图，请访问 grafanaweb 界面 ，如 访问 Grafana web UI 中所述。

步骤

1. 将您要通过 playbook 监控的机器的名称或 IP 添加到 /etc/ansible/hosts Ansible 清单文件中括号内的标识组名称下：

   [remotes]
   webserver.example.com
   database.example.com

2. 使用以下内容创建一个 Ansible playbook:

   ---
   - hosts: remotes
     vars:
       metrics_retention_days: 0
     roles:
       - rhel-system-roles.metrics

3. 运行 Ansible playbook:

   # ansible-playbook name_of_your_playbook.yml -k

步骤

1. 使用以下内容创建一个 Ansible playbook:

   ---
   - hosts: localhost
     vars:
       metrics_graph_service: yes
       metrics_query_service: yes
       metrics_retention_days: 10
       metrics_monitored_hosts: ["database.example.com", "webserver.example.com"]
     roles:
       - rhel-system-roles.metrics

2. 运行 Ansible playbook:

   # ansible-playbook name_of_your_playbook.yml

   注意

   由于 metrics_graph_service 和 metrics_query_service 布尔值被设置为 value="yes"，因此会使用pcp 来自动安装并提供 grafana ，并添加为带有 pcp 数据记录索引到 redis 的数据源，允许 pcp 查询语言用于复杂的数据查询。

3. 要查看机器集中收集的指标的图形表示，并查询数据，请访问 grafana web 界面，如 访问 Grafana Web UI 中所述。

步骤

1. 在您要为其设置身份验证的 Ansible playbook 中包含以下变量：

   ---
     vars:
       metrics_username: your_username
       metrics_password: your_password

2. 运行 Ansible playbook:

   # ansible-playbook name_of_your_playbook.yml

流程

1. 通过在清单中添加以下内容，在 /etc/ansible/hosts Ansible 清单中配置 localhost ：

   localhost ansible_connection=local

2. 创建一个包含以下内容的 Ansible playbook：

   ---
   - hosts: localhost
     roles:
       - role: rhel-system-roles.metrics
         vars:
           metrics_from_mssql: yes

3. 运行 Ansible playbook:

   # ansible-playbook name_of_your_playbook.yml

流程

1. 安装 Ansible Core，它包括在 RHEL 8 AppStream 存储库中：

   # *yum install ansible-core*

2. 安装 microsoft.sql.server Ansible 角色：

   # *yum install ansible-collection-microsoft-sql*

流程

1. 创建一个扩展名为 .yml 的文件。例如，mssql-server.yml。

2. 在 .yml 文件中添加以下内容：

   ---
   - hosts: all
     vars:
       mssql_accept_microsoft_odbc_driver_17_for_sql_server_eula: true
       mssql_accept_microsoft_cli_utilities_for_sql_server_eula: true
       mssql_accept_microsoft_sql_server_standard_eula: true
       mssql_password: <password>
       mssql_edition: Developer
       mssql_tcp_port: 1443
     roles:
       - microsoft.sql.server

   将 <password> 替换为您的 SQL Server 密码。

3. 运行 mssql-server.yml ansible playbook:

   # *ansible-playbook mssql-server.yml*

流程

1. 使用以下内容创建一个新的 playbook.yml 文件：

   ---
   - name: Deploy session recording
     hosts: all
     vars:
       tlog_scope_sssd: some
       tlog_users_sssd:
         - recorded-user
   
     roles:
       - rhel-system-roles.tlog

   其中,

   • tlog_scope_sssd:

     • some 指定您只记录某些用户和组，而不是 all 或 none。

   • tlog_users_sssd:

     • recorded-user 指定您要记录会话的用户。请注意，这不会为您添加用户。您必须自行设置该用户。

2. 另外，还可以验证 playbook 语法。

   # ansible-playbook --syntax-check playbook.yml

3. 在清单文件上运行 playbook:

   # ansible-playbook -i IP_Address /path/to/file/playbook.yml -v

1. 进入创建 SSSD 配置丢弃文件的文件夹：

   # cd /etc/sssd/conf.d

2. 检查文件内容：

   # cat /etc/sssd/conf.d/sssd-session-recording.conf

流程

1. 使用以下内容创建一个新的 playbook.yml 文件：

   ---
   - name: Deploy session recording excluding users and groups
     hosts: all
     vars:
       tlog_scope_sssd: all
       tlog_exclude_users_sssd:
         - jeff
         - james
       tlog_exclude_groups_sssd:
         - admins
   
     roles:
       - rhel-system-roles.tlog

   其中,

   • tlog_scope_sssd:

     • all ：指定您要记录所有用户和组。

   • tlog_exclude_users_sssd:

     • user names：指定您要从会话记录中排除的用户的用户名。

   • tlog_exclude_groups_sssd:

     • admins 指定要从会话记录中排除的组。

2. （可选）验证 playbook 语法；

   # ansible-playbook --syntax-check playbook.yml

3. 在清单文件上运行 playbook:

   # ansible-playbook -i IP_Address /path/to/file/playbook.yml -v

1. 进入创建 SSSD 配置丢弃文件的文件夹：

   # cd /etc/sssd/conf.d

2. 检查文件内容：

   # cat sssd-session-recording.conf

流程

1. 创建一个用户并为这个用户分配密码：

   # useradd recorded-user
   # passwd recorded-user

2. 以您刚刚创建的用户身份登录到该系统：

   # ssh recorded-user@localhost

3. 当系统提示您输入 yes 或 no 进行身份验证时请输入 "yes"。

4. 插入 record-user 的密码。

   系统显示有关记录会话的信息。

   ATTENTION! Your session is being recorded!

5. 记录完会话后，键入：

   # exit

   系统从用户注销并关闭与本地主机的连接。

1. 运行以下命令：

   # journalctl -o verbose -r

2. 搜索 tlog-rec 记录的日志条目的 MESSAGE 字段。

   # journalctl -xel _EXE=/usr/bin/tlog-rec-session