使用 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. 将 Red Hat Automation hub 定义为 ~/.ansible.cfg 文件中内容的主要源。

     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 => {
       	"ansible_facts": {
       	    "discovered_interpreter_python": "/usr/bin/python3"
       	},
       	"changed": false,
       	"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. 创建包含以下内容的 playbook 文件，如 ~/playbook.yml ：

   ---
   - name: Set boot device to be used on next boot
     hosts: managed-node-01.example.com
     tasks:
       - name: Ensure boot device is HD
         redhat.rhel_mgmt.ipmi_boot:
           user: <admin_user>
           password: <password>
           bootdev: hd

2. 验证 playbook 语法：

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

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

3. 运行 playbook：

   $ ansible-playbook ~/playbook.yml

步骤

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

   ---
   - name: Power management
     hosts: managed-node-01.example.com
     tasks:
       - name: Ensure machine is powered on
         redhat.rhel_mgmt.ipmi_power:
           user: <admin_user>
           password: <password>
           state: on

2. 验证 playbook 语法：

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

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

3. 运行 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 文件，如 ~/playbook.yml ：

   ---
   - name: Manage out-of-band controllers using Redfish APIs
     hosts: managed-node-01.example.com
     tasks:
       - name: Get CPU inventory
         redhat.rhel_mgmt.redfish_info:
           baseuri: "<URI>"
           username: "<username>"
           password: "<password>"
           category: Systems
           command: GetCpuInventory
         register: result

2. 验证 playbook 语法：

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

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

3. 运行 playbook：

   $ ansible-playbook ~/playbook.yml

步骤

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

   ---
   - name: Manage out-of-band controllers using Redfish APIs
     hosts: managed-node-01.example.com
     tasks:
       - name: Power on system
         redhat.rhel_mgmt.redfish_command:
           baseuri: "<URI>"
           username: "<username>"
           password: "<password>"
           category: Systems
           command: PowerOn

2. 验证 playbook 语法：

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

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

3. 运行 playbook：

   $ ansible-playbook ~/playbook.yml

步骤

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

   ---
   - name: Manages out-of-band controllers using Redfish APIs
     hosts: managed-node-01.example.com
     tasks:
       - name: Set BootMode to UEFI
         redhat.rhel_mgmt.redfish_config:
           baseuri: "<URI>"
           username: "<username>"
           password: "<password>"
   	category: Systems
           command: SetBiosAttributes
           bios_attributes:
             BootMode: Uefi

2. 验证 playbook 语法：

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

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

3. 运行 playbook：

   $ ansible-playbook ~/playbook.yml

步骤

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

   ---
   - name: Configure a direct integration between a RHEL system and an AD domain
     hosts: managed-node-01.example.com
     roles:
       - rhel-system-roles.ad_integration
     vars:
       ad_integration_realm: "domain.example.com"
       ad_integration_password: !vault | vault encrypted password
       ad_integration_manage_crypto_policies: true
       ad_integration_allow_rc4_crypto: true
       ad_integration_timesync_source: "adserver.domain.example.com"

2. 验证 playbook 语法：

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

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

3. 运行 playbook：

   $ ansible-playbook ~/playbook.yml

步骤

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

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

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

   默认情况下，certmonger 会在证书过期前自动尝试续订证书。您可以通过将 Ansible playbook 中的 auto_renew 参数设置为 no 来禁用此功能。

2. 验证 playbook 语法：

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

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

3. 运行 playbook：

   $ ansible-playbook ~/playbook.yml

步骤

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

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

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

   默认情况下，certmonger 会在证书过期前自动尝试续订证书。您可以通过将 Ansible playbook 中的 auto_renew 参数设置为 no 来禁用此功能。

2. 验证 playbook 语法：

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

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

3. 运行 playbook：

   $ ansible-playbook ~/playbook.yml

步骤

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

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

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

   默认情况下，certmonger 会在证书过期前自动尝试续订证书。您可以通过将 Ansible playbook 中的 auto_renew 参数设置为 no 来禁用此功能。

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: rhel-system-roles.cockpit
         vars:
           cockpit_packages: default
           cockpit_port: 9050
           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 crypto policies
     hosts: managed-node-01.example.com
     tasks:
       - name: Configure crypto policies
         ansible.builtin.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 设置会导致系统在系统角色更改加密策略后重启。

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 crypto policy
         ansible.builtin.include_role:
           name: rhel-system-roles.crypto_policies
       - debug:
           var: crypto_policies_active

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: Reset firewalld example
     hosts: managed-node-01.example.com
     tasks:
       - name: Reset firewalld
         ansible.builtin.include_role:
           name: rhel-system-roles.firewall
         vars:
           firewall:
             - previous: replaced

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: rhel-system-roles.firewall
         vars:
           firewall:
             - { forward_port: 8080/tcp;443;, state: enabled, runtime: true, permanent: true }

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: Allow incoming HTTPS traffic to the local host
         ansible.builtin.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 --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: rhel-system-roles.firewall
         vars:
           firewall:
             - zone: dmz
               interface: enp1s0
               service: https
               state: enabled
               runtime: true
               permanent: true

2. 验证 playbook 语法：

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

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

3. 运行 playbook：

   $ ansible-playbook ~/playbook.yml

步骤

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

   ---
   - name: Create TLS certificates and key files in a high availability cluster
     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_pcsd_certificates:
         - name: FILENAME
           common_name: "{{ ansible_hostname }}"
           ca: self-sign

   此 playbook 配置运行 firewalld 和 selinux 服务的集群，并在 /var/lib/ pcsd 中创建自签名 pcsd 证书和私钥文件。pcsd 证书具有文件名 FILENAME.crt，密钥文件名为 FILENAME.key。

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

2. 验证 playbook 语法：

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

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

3. 运行 playbook：

   $ ansible-playbook ~/playbook.yml

步骤

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

   ---
   - name: Create a high availability cluster with no fencing and which runs no resources
     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

   这个示例 playbook 文件配置一个运行 firewalld 和 selinux 服务的集群，没有配置隔离，且没有运行任何资源。

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

2. 验证 playbook 语法：

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

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

3. 运行 playbook：

   $ ansible-playbook ~/playbook.yml

步骤

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

   ---
   - name: Create a high availability cluster that includes a fencing device and resources
     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_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 文件配置一个运行 firewalld 和 selinux 服务的集群。集群包括隔离、多个资源和资源组。它还包含资源组的资源克隆。

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

2. 验证 playbook 语法：

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

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

3. 运行 playbook：

   $ ansible-playbook ~/playbook.yml

步骤

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

   ---
   - name: Create a high availability cluster that defines resource and resource operation defaults
     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
       # 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 文件配置一个运行 firewalld 和 selinux 服务的集群。集群包括资源和资源操作默认值。

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

2. 验证 playbook 语法：

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

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

3. 运行 playbook：

   $ ansible-playbook ~/playbook.yml

步骤

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

   1. 创建密码库：

      $ 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: 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

3. 验证 playbook 语法：

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

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

4. 运行 playbook：

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

步骤

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

   ---
   - name: Create a high availability cluster with resource constraints
     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
       # 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 文件配置一个运行 firewalld 和 selinux 服务的集群。集群包括资源位置约束、资源托管约束、资源顺序约束和资源票据约束。

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

2. 验证 playbook 语法：

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

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

3. 运行 playbook：

   $ ansible-playbook ~/playbook.yml

步骤

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

   ---
   - name: Create a high availability cluster that configures Corosync values
     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_transport:
         type: knet
         options:
           - name: ip_version
             value: ipv4-6
           - name: link_mode
             value: active
         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 文件配置一个运行 firewalld 和 selinux 服务配置 Corosync 属性的集群。

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

2. 验证 playbook 语法：

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

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

3. 运行 playbook：

   $ ansible-playbook ~/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. 创建一个指定集群中的节点的清单文件，如 为 ha_cluster 系统角色指定清单 中所述。

2. 创建一个 playbook 文件，如 new-cluster.yml。

   注意

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

   以下示例 playbook 文件配置一个运行 firewalld 和 selinux 服务的集群，它带有为集群中的节点配置的节点属性。

   - hosts: node1 node2
     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_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
   
     roles:
       - linux-system-roles.ha_cluster

3. 保存该文件。

4. 运行 playbook，指定在第 1 步中创建的清单文件清单的路径。

   # ansible-playbook -i inventory new-cluster.yml

步骤

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

   ---
   - name: Configure active/passive Apache server in a high availability cluster
     hosts: z1.example.com z2.example.com
     roles:
       - rhel-system-roles.ha_cluster
     vars:
       ha_cluster_hacluster_password: <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 文件在运行 firewalld 和 selinux 服务的主动/被动双节点 HA 集群中配置之前创建的 Apache HTTP 服务器。

   这个示例使用主机名为 zapc.example.com 的 APC 电源开关。如果集群不使用任何其他隔离代理，则您可以选择在定义 ha_cluster_fence_agent_packages 变量时只列出集群所需的隔离代理。

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

2. 验证 playbook 语法：

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

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

3. 运行 playbook：

   $ ansible-playbook ~/playbook.yml

4. 当您使用 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: 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 ：

   ---
   - hosts: managed-node-01.example.com
     roles:
       - rhel-system-roles.kdump
     vars:
       kdump_path: /var/crash

2. 验证 playbook 语法：

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

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

3. 运行 playbook：

   $ ansible-playbook ~/playbook.yml

步骤

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

   ---
   - name: Configure kernel settings
     hosts: managed-node-01.example.com
     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

   • 名称 ：将任意字符串与 play 关联为标签的可选键，并确定该 play 的用途。
   • 在 play 中 主机: 键，用于指定运行该 play 的主机。此键的值或值可以作为被管理的主机的单独名称提供，也可以作为 inventory 文件中定义的一组主机提供。
   • playbook 的 vars: 部分，它表示包含所选内核参数名称和值的变量列表。

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

     注意

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

2. 验证 playbook 语法：

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

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

3. 运行 playbook：

   $ ansible-playbook ~/playbook.yml

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

步骤

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

   ---
   - name: Deploying basics input and implicit files output
     hosts: managed-node-01.example.com
     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 --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. 验证系统是否向日志发送信息：

   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 文件，如 ~/playbook.yml ：

   ---
   - name: Deploying files input and configured files output
     hosts: managed-node-01.example.com
     roles:
       - 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]

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

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

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

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: Deploying remote input and remote_files output
     hosts: managed-node-01.example.com
     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: managed-node-02.example.com
     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. 验证 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。

步骤

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

   ---
   - name: Manage metrics
     hosts: localhost
     roles:
       - rhel-system-roles.metrics
     vars:
       metrics_graph_service: yes
       metrics_manage_firewall: true
       metrics_manage_selinux: true

   因为 metrics_graph_service 布尔值被设置为 value="yes"，所以 Grafana 被自动安装和置备，并使用 pcp 添加为一个数据源。因为 metrics_manage_firewall 和 metrics_manage_selinux 都被设为 true，所以 metrics 角色使用 firewall 和 selinux 系统角色来管理 metrics 角色使用的端口。

2. 验证 playbook 语法：

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

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

3. 运行 playbook：

   $ ansible-playbook ~/playbook.yml

步骤

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

   ---
   - name: Configure a fleet of machines to monitor themselves
     hosts: managed-node-01.example.com
     roles:
       - rhel-system-roles.metrics
     vars:
       metrics_retention_days: 0
       metrics_manage_firewall: true
       metrics_manage_selinux: true

   因为 metrics_manage_firewall 和 metrics_manage_selinux 都被设为 true，所以 metrics 角色使用 firewall 和 selinux 角色来管理 metrics 角色使用的端口。

2. 验证 playbook 语法：

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

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

3. 运行 playbook：

   $ ansible-playbook ~/playbook.yml

步骤

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

   - name: Set up your local machine to centrally monitor a fleet of machines
     hosts: localhost
     roles:
       - rhel-system-roles.metrics
     vars:
       metrics_graph_service: yes
       metrics_query_service: yes
       metrics_retention_days: 10
       metrics_monitored_hosts: ["database.example.com", "webserver.example.com"]
       metrics_manage_firewall: yes
       metrics_manage_selinux: yes

   因为 metrics_graph_service 和 metrics_query_service 布尔值都被设置为 value="yes"，所以 grafana 被自动安装和置备，并使用 pcp 添加为一个数据源，使用 pcp 将数据记录索引到 redis 中，允许 pcp 查询语言用于复杂的数据查询。因为 metrics_manage_firewall 和 metrics_manage_selinux 都被设为 true，所以 metrics 角色使用 firewall 和 selinux 角色来管理 metrics 角色使用的端口。

2. 验证 playbook 语法：

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

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

3. 运行 playbook：

   $ ansible-playbook ~/playbook.yml

步骤

1. 编辑现有的 playbook 文件，如 ~/playbook.yml，并添加与身份验证相关的变量：

   ---
   - name: Set up authentication by using the scram-sha-256 authentication mechanism
     hosts: managed-node-01.example.com
     roles:
       - rhel-system-roles.metrics
     vars:
       metrics_retention_days: 0
       metrics_manage_firewall: true
       metrics_manage_selinux: true
       metrics_username: <username>
       metrics_password: <password>

2. 验证 playbook 语法：

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

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

3. 运行 playbook：

   $ ansible-playbook ~/playbook.yml

步骤

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

   ---
   - name: Configure and enable metrics collection for Microsoft SQL Server
     hosts: localhost
     roles:
       - rhel-system-roles.metrics
     vars:
       metrics_from_mssql: true
       metrics_manage_firewall: true
       metrics_manage_selinux: true

   因为 metrics_manage_firewall 和 metrics_manage_selinux 都被设为 true，所以 metrics 角色使用 firewall 和 selinux 角色来管理 metrics 角色使用的端口。

2. 验证 playbook 语法：

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

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

3. 运行 playbook：

   $ ansible-playbook ~/playbook.yml

步骤

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

   1. 创建密码库：

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

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

      sa_pwd: <sa_password>

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

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

   ---
   - name: Installing and configuring Microsoft SQL Server
     hosts: managed-node-01.example.com
     vars_files:
       - vault.yml
     tasks:
       - name: SQL Server with an existing private key and certificate
         ansible.builtin.include_role:
           name: microsoft.sql.server
         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_version: 2022
           mssql_password: "{{ sa_pwd  }}"
           mssql_edition: Developer
           mssql_tcp_port: 1433
           mssql_manage_firewall: true
   
           mssql_tls_enable: true
           mssql_tls_cert: sql_crt.pem
           mssql_tls_private_key: sql_cert.key
           mssql_tls_version: 1.2
           mssql_tls_force: true

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

   mssql_tls_enable: true

   启用 TLS 加密。如果启用此设置，还必须定义 mssql_tls_cert 和 mssql_tls_private_key。

   mssql_tls_cert: <path>

   设置存储在控制节点上的 TLS 证书的路径。该角色将此文件复制到受管节点上的 /etc/pki/tls/certs/ 目录中。

   mssql_tls_private_key: < path>

   设置控制节点上 TLS 私钥的路径。该角色将此文件复制到受管节点上的 /etc/pki/tls/private/ 目录中。

   mssql_tls_force: true

   如果存在，替换其目标目录中的 TLS 证书和私钥。

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

3. 验证 playbook 语法：

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

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

4. 运行 playbook：

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

步骤

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

   1. 创建密码库：

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

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

      sa_pwd: <sa_password>

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

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

   ---
   - name: Installing and configuring Microsoft SQL Server
     hosts: managed-node-01.example.com
     vars_files:
       - vault.yml
     tasks:
       - name: SQL Server with certificates issued by Red Hat IdM
         ansible.builtin.include_role:
           name: microsoft.sql.server
         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_version: 2022
           mssql_password: "{{ sa_pwd  }}"
           mssql_edition: Developer
           mssql_tcp_port: 1433
           mssql_manage_firewall: true
   
           mssql_tls_enable: true
           mssql_tls_certificates:
             - name: sql_cert
               dns: server.example.com
               ca: ipa

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

   mssql_tls_enable: true

   启用 TLS 加密。如果启用此设置，还必须定义 mssql_tls_certificates。

   mssql_tls_certificates

   包含 证书 角色的设置的 YAML 字典列表。

   Name: & lt;file_name>

   定义证书和私钥的基本名称。certificate 角色将证书存储在 /etc/pki/tls/certs/ <file_name > .crt 和私钥 /etc/pki/tls/private/ <file_name>.key 文件中。

   dns: <hostname_or_list_of_hostnames>

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

   ca: <ca_type>

   定义 certificate 角色如何请求证书。如果主机在 IdM 域或 自签名 中注册，请将变量设置为 ipa，以请求自签名证书。

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

3. 验证 playbook 语法：

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

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

4. 运行 playbook：

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

步骤

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

   1. 创建密码库：

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

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

      sa_pwd: <sa_password>

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

2. 编辑现有的 playbook 文件，如 ~/playbook.yml，并添加 storage 和 log 相关的变量：

   ---
   - name: Installing and configuring Microsoft SQL Server
     hosts: managed-node-01.example.com
     vars_files:
       - vault.yml
     tasks:
       - name: SQL Server with custom storage paths
         ansible.builtin.include_role:
           name: microsoft.sql.server
         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_version: 2022
           mssql_password: "{{ sa_pwd  }}"
           mssql_edition: Developer
           mssql_tcp_port: 1433
           mssql_manage_firewall: true
   
           mssql_datadir: /var/lib/mssql/
           mssql_datadir_mode: '0700'
           mssql_logdir: /var/log/mssql/
           mssql_logdir_mode: '0700'

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

   mssql_datadir_mode and mssql_logdir_mode

   设置权限模式。以单引号为单位指定值，以确保角色以字符串形式解析值，而不是数值。

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

3. 验证 playbook 语法：

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

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

4. 运行 playbook：

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

验证

1. 显示数据目录的模式：

   $ ansible managed-node-01.example.com -m command -a 'ls -ld /var/lib/mssql/'
   drwx------. 12 mssql mssql 4096 Jul  3 13:53 /var/lib/mssql/

2. 显示日志目录的模式：

   $ ansible managed-node-01.example.com -m command -a 'ls -ld /var/log/mssql/'
   drwx------. 12 mssql mssql 4096 Jul  3 13:53 /var/log/mssql/

步骤

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

   1. 创建密码库：

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

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

      sa_pwd: <sa_password>
      sql_pwd: <SQL_AD_password>
      ad_admin_pwd: <AD_admin_password>

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

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

   ---
   - name: Installing and configuring Microsoft SQL Server
     hosts: managed-node-01.example.com
     vars_files:
       - vault.yml
     tasks:
       - name: SQL Server with AD authentication
         ansible.builtin.include_role:
           name: microsoft.sql.server
         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_version: 2022
           mssql_password: "{{ sa_pwd }}"
           mssql_edition: Developer
           mssql_tcp_port: 1433
           mssql_manage_firewall: true
   
           mssql_ad_configure: true
           mssql_ad_join: true
           mssql_ad_sql_user: sqluser
           mssql_ad_sql_password: "{{ sql_pwd }}"
           ad_integration_realm: ad.example.com
           ad_integration_user: Administrator
           ad_integration_password: "{{ ad_admin_pwd }}"

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

   mssql_ad_configure: true

   启用对 AD 进行身份验证。

   mssql_ad_join: true

   使用 ad_integration RHEL 系统角色将受管节点加入到 AD。该角色使用 ad_integration_realm、ad_integration_user 和 ad_integration_password 变量中的设置来加入域。

   mssql_ad_sql_user: <username>

   设置角色在 AD 和 SQL Server 中应该创建的 AD 帐户的名称，用于管理目的。

   ad_integration_user: &lt ;AD_user>

   设置具有特权的 AD 用户的名称，将机器加入到域中，并创建 mssql_ad_sql_user 中指定的 AD 用户。

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

3. 验证 playbook 语法：

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

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

4. 运行 playbook：

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

5. 在 AD 域中，为您在 playbook 中指定的 AD SQL 用户启用 128 位和 256 位 Kerberos 身份验证。使用以下选项之一：

   • 在 Active Directory 用户和 Computers 应用程序中：

     1. 进入 ad.example.com > Users > sqluser > Accounts。
     2. 在 Account options 列表中，选择 This account supports Kerberos AES 128 bit encryption 和 This account supports Kerberos AES 256 bit encryption。
     3. 点应用。

   • 在 admin 模式的 PowerShell 中，输入：

     C:\> Set-ADUser -Identity sqluser -KerberosEncryptionType AES128,AES256

6. 授权 AD 用户，其应能够向 SQL Server 进行身份验证。在 SQL Server 中，执行以下步骤：

   1. 为 Administrator 用户获取 Kerberos ticket：

      $ kinit Administrator@ad.example.com

   2. 授权 AD 用户：

      $ /opt/mssql-tools/bin/sqlcmd -S. -Q 'CREATE LOGIN [AD\<AD_user>] FROM WINDOWS;'

      对应该能够访问 SQL Server 的每个 AD 用户重复此步骤。

步骤

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

   ---
   - hosts: managed-node-01.example.com
     roles:
       - rhel-system-roles.nbde_server
     vars:
       nbde_server_rotate_keys: yes
       nbde_server_manage_firewall: true
       nbde_server_manage_selinux: true

   此 playbook 示例确保部署 Tang 服务器和密钥轮转。

   当 nbde_server_manage_firewall 和 nbde_server_manage_selinux 都被设置为 true 时，nbde_server 角色使用 firewall 和 selinux 角色来管理 nbde_server 角色使用的端口。

2. 验证 playbook 语法：

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

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

3. 运行 playbook：

   $ ansible-playbook ~/playbook.yml

步骤

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

   - hosts: managed-node-01.example.com
     roles:
       - rhel-system-roles.nbde_client
     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

   这个示例 playbook 配置 Clevis 客户端，以便在两个 Tang 服务器中至少有一个可用时自动解锁两个 LUKS 加密卷

   nbde_client 系统角色只支持使用动态主机配置协议(DHCP)的情况。要将 NBDE 用于带有静态 IP 配置的客户端，请使用以下 playbook：

   - hosts: managed-node-01.example.com
     roles:
       - rhel-system-roles.nbde_client
     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
     tasks:
       - name: Configure a client with a static IP address during early boot
         ansible.builtin.command:
           cmd: grubby --update-kernel=ALL --args='GRUB_CMDLINE_LINUX_DEFAULT="ip={{ <ansible_default_ipv4.address> }}::{{ <ansible_default_ipv4.gateway> }}:{{ <ansible_default_ipv4.netmask> }}::{{ <ansible_default_ipv4.alias> }}:none"'

   在这个 playbook 中，将 & lt;ansible_default_ipv4Galaxy > 字符串替换为您的网络的 IP 地址，例如： ip={{ 192.0.2.10 }}::{{ 192.0.2.1 }}:{{ 255.255.255.0 }}::{{ ens3 }}:none。

2. 验证 playbook 语法：

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

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

3. 运行 playbook：

   $ ansible-playbook ~/playbook.yml

步骤

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

   ---
   - name: Configure the network
     hosts: managed-node-01.example.com
     tasks:
       - name: Ethernet connection profile with static IP address settings
         ansible.builtin.include_role:
           name: rhel-system-roles.network
         vars:
           network_connections:
             - name: enp1s0
               interface_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
               state: up

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

2. 验证 playbook 语法：

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

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

3. 运行 playbook：

   $ ansible-playbook ~/playbook.yml

步骤

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

   ---
   - name: Configure the network
     hosts: managed-node-01.example.com
     tasks:
       - name: Ethernet connection profile with static IP address settings
         ansible.builtin.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

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

   match

   定义必须满足条件才能应用设置。您只能将此变量与 path 选项一起使用。

   path

   定义设备的持久路径。您可以将它设置为固定路径或表达式。其值可以包含修饰符和通配符。这个示例将设置应用到与 PCI ID 0000:00:0[1-3].0 匹配的设备，但不应用 0000:00:02.0。

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

2. 验证 playbook 语法：

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

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

3. 运行 playbook：

   $ ansible-playbook ~/playbook.yml

步骤

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

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

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

   dhcp4: yes

   启用自动 IPv4 地址分配，从 DHCP、PPP 或类似服务分配。

   auto6: yes

   启用 IPv6 自动配置。默认情况下，NetworkManager 使用路由器公告。如果路由器宣布 managed 标记，NetworkManager 会从 DHCPv6 服务器请求 IPv6 地址和前缀。

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

2. 验证 playbook 语法：

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

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

3. 运行 playbook：

   $ ansible-playbook ~/playbook.yml

步骤

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

   ---
   - name: Configure the network
     hosts: managed-node-01.example.com
     tasks:
       - name: Ethernet connection profile with dynamic IP address settings
         ansible.builtin.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

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

   match: path

   定义必须满足条件才能应用设置。您只能将此变量与 path 选项一起使用。

   path: & lt;path_and_expressions>

   定义设备的持久路径。您可以将它设置为固定路径或表达式。其值可以包含修饰符和通配符。这个示例将设置应用到与 PCI ID 0000:00:0[1-3].0 匹配的设备，但不应用 0000:00:02.0。

   dhcp4: yes

   启用自动 IPv4 地址分配，从 DHCP、PPP 或类似服务分配。

   auto6: yes

   启用 IPv6 自动配置。默认情况下，NetworkManager 使用路由器公告。如果路由器宣布 managed 标记，NetworkManager 会从 DHCPv6 服务器请求 IPv6 地址和前缀。

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

2. 验证 playbook 语法：

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

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

3. 运行 playbook：

   $ ansible-playbook ~/playbook.yml

步骤

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

   ---
   - name: Configure the network
     hosts: managed-node-01.example.com
     tasks:
       - name: VLAN connection profile with Ethernet port
         ansible.builtin.include_role:
           name: rhel-system-roles.network
         vars:
           network_connections:
             # Ethernet profile
             - name: enp1s0
               type: ethernet
               interface_name: enp1s0
               autoconnect: yes
               state: up
               ip:
                 dhcp4: no
                 auto6: no
   
             # VLAN profile
             - name: enp1s0.10
               type: vlan
               vlan:
                 id: 10
               ip:
                 dhcp4: yes
                 auto6: yes
               parent: enp1s0
               state: up

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

   type: & lt;profile_type>

   设置要创建的配置集的类型。示例 playbook 创建两个连接配置集：一个用于父以太网设备，另一个用于 VLAN 设备。

   dhcp4: &lt ;value>

   如果设置为 yes，则从 DHCP、PPP 或类似服务自动分配 IPv4 地址分配。禁用父设备上的 IP 地址配置。

   auto6: &lt ;value>

   如果设置为 yes，则启用 IPv6 自动配置。在这种情况下，NetworkManager 使用路由器公告，如果路由器宣布 受管 标志，NetworkManager 会从 DHCPv6 服务器请求 IPv6 地址和前缀。禁用父设备上的 IP 地址配置。

   parent: & lt;parent_device>

   设置 VLAN 连接配置集的父设备。在示例中，父进程是以太网接口。

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

2. 验证 playbook 语法：

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

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

3. 运行 playbook：

   $ ansible-playbook ~/playbook.yml

步骤

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

   ---
   - name: Configure the network
     hosts: managed-node-01.example.com
     tasks:
       - name: Bridge connection profile with two Ethernet ports
         ansible.builtin.include_role:
           name: rhel-system-roles.network
         vars:
           network_connections:
             # Bridge profile
             - name: bridge0
               type: bridge
               interface_name: bridge0
               ip:
                 dhcp4: yes
                 auto6: yes
               state: up
   
             # Port profile for the 1st Ethernet device
             - name: bridge0-port1
               interface_name: enp7s0
               type: ethernet
               controller: bridge0
               port_type: bridge
               state: up
   
             # Port profile for the 2nd Ethernet device
             - name: bridge0-port2
               interface_name: enp8s0
               type: ethernet
               controller: bridge0
               port_type: bridge
               state: up

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

   type: & lt;profile_type>

   设置要创建的配置集的类型。示例 playbook 会创建三个连接配置文件：一个用于网桥，另一个用于以太网设备。

   dhcp4: yes

   启用自动 IPv4 地址分配，从 DHCP、PPP 或类似服务分配。

   auto6: yes

   启用 IPv6 自动配置。默认情况下，NetworkManager 使用路由器公告。如果路由器宣布 managed 标记，NetworkManager 会从 DHCPv6 服务器请求 IPv6 地址和前缀。

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

2. 验证 playbook 语法：

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

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

3. 运行 playbook：

   $ ansible-playbook ~/playbook.yml

验证

1. 显示作为特定网桥端口的以太网设备的链接状态：

   # ansible managed-node-01.example.com -m command -a 'ip link show master bridge0'
   managed-node-01.example.com | CHANGED | rc=0 >>
   3: enp7s0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc fq_codel master bridge0 state UP mode DEFAULT group default qlen 1000
       link/ether 52:54:00:62:61:0e brd ff:ff:ff:ff:ff:ff
   4: enp8s0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc fq_codel master bridge0 state UP mode DEFAULT group default qlen 1000
       link/ether 52:54:00:9e:f1:ce brd ff:ff:ff:ff:ff:ff

2. 显示作为任意网桥设备的端口的以太网设备状态：

   # ansible managed-node-01.example.com -m command -a 'bridge link show'
   managed-node-01.example.com | CHANGED | rc=0 >>
   3: enp7s0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 master bridge0 state forwarding priority 32 cost 100
   4: enp8s0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 master bridge0 state listening priority 32 cost 100

步骤

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

   ---
   - name: Configure the network
     hosts: managed-node-01.example.com
     tasks:
       - name: Bond connection profile with two Ethernet ports
         ansible.builtin.include_role:
           name: rhel-system-roles.network
         vars:
           network_connections:
             # Bond profile
             - name: bond0
               type: bond
               interface_name: bond0
               ip:
                 dhcp4: yes
                 auto6: yes
               bond:
                 mode: active-backup
               state: up
   
             # Port profile for the 1st Ethernet device
             - name: bond0-port1
               interface_name: enp7s0
               type: ethernet
               controller: bond0
               state: up
   
             # Port profile for the 2nd Ethernet device
             - name: bond0-port2
               interface_name: enp8s0
               type: ethernet
               controller: bond0
               state: up

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

   type: & lt;profile_type>

   设置要创建的配置集的类型。示例 playbook 会创建三个连接配置文件：一个用于绑定，另一个用于以太网设备。

   dhcp4: yes

   启用自动 IPv4 地址分配，从 DHCP、PPP 或类似服务分配。

   auto6: yes

   启用 IPv6 自动配置。默认情况下，NetworkManager 使用路由器公告。如果路由器宣布 managed 标记，NetworkManager 会从 DHCPv6 服务器请求 IPv6 地址和前缀。

   mode: <bond_mode>

   设置绑定模式。可能的值有：

   • balance-rr （默认）
   • active-backup
   • balance-xor
   • broadcast
   • 802.3ad
   • balance-tlb
   • Balance-alb.

   根据您设置的模式，您需要在 playbook 中设置额外变量。

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

2. 验证 playbook 语法：

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

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

3. 运行 playbook：

   $ ansible-playbook ~/playbook.yml

步骤

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

   ---
   - name: Configure the network
     hosts: managed-node-01.example.com
     tasks:
       - name: IPoIB connection profile with static IP address settings
         ansible.builtin.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

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

   type: & lt;profile_type>

   设置要创建的配置集的类型。示例 playbook 创建两个连接配置集：一个用于 InfiniBand 连接，一个用于 IPoIB 设备。

   parent: & lt;parent_device>

   设置 IPoIB 连接配置集的父设备。

   P_Key: < value>

   设置 InfiniBand 分区密钥。如果您设置了此变量，请不要在 IPoIB 设备上设置 interface_name。

   transport_mode: < mode>

   设置 IPoIB 连接操作模式。您可以将此变量设置为 datagram （默认）或 已连接。

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

2. 验证 playbook 语法：

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

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

3. 运行 playbook：

   $ ansible-playbook ~/playbook.yml

验证

1. 显示 mlx4_ib0.8002 设备的 IP 设置：

   # ansible managed-node-01.example.com -m command -a 'ip address show mlx4_ib0.8002'
   managed-node-01.example.com | CHANGED | rc=0 >>
   ...
   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)：

   # ansible managed-node-01.example.com -m command -a 'cat /sys/class/net/mlx4_ib0.8002/pkey'
   managed-node-01.example.com | CHANGED | rc=0 >>
   0x8002

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

   # ansible managed-node-01.example.com -m command -a 'cat /sys/class/net/mlx4_ib0.8002/mode'
   managed-node-01.example.com | CHANGED | rc=0 >>
   datagram

步骤

1. 创建包含以下内容的 playbook 文件，如 ~/playbook.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
         ansible.builtin.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

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

   表：&lt ;value>

   将与 table 变量相同的列表条目中的路由分配给指定的路由表。

   routing_rule: < list>

   定义指定路由规则的优先级，以及从分配规则的路由表到的连接配置文件。

   zone: <zone_name>

   将网络接口从连接配置文件分配给指定的 firewalld 区域。

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

2. 验证 playbook 语法：

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

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

3. 运行 playbook：

   $ ansible-playbook ~/playbook.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. 将您的敏感变量存储在加密文件中：

   1. 创建密码库：

      $ 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: Configure an Ethernet connection with 802.1X authentication
     hosts: managed-node-01.example.com
     vars_files:
       - vault.yml
     tasks:
       - name: Copy client key for 802.1X authentication
         ansible.builtin.copy:
           src: "/srv/data/client.key"
           dest: "/etc/pki/tls/private/client.key"
           mode: 0600
   
       - name: Copy client certificate for 802.1X authentication
         ansible.builtin.copy:
           src: "/srv/data/client.crt"
           dest: "/etc/pki/tls/certs/client.crt"
   
       - name: Copy CA certificate for 802.1X authentication
         ansible.builtin.copy:
           src: "/srv/data/ca.crt"
           dest: "/etc/pki/ca-trust/source/anchors/ca.crt"
   
       - name: Ethernet connection profile with static IP address settings and 802.1X
         ansible.builtin.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: "{{ pwd }}"
                 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

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

   ieee802_1x

   此变量包含与 802.1X 相关的设置。

   EAP: tls

   将配置文件配置为对可扩展身份验证协议(EAP)使用基于证书的 TLS 身份验证方法。

   有关 playbook 中使用的所有变量的详情，请查看控制节点上的 /usr/share/ansible/roles/rhel-system-roles.network/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: Configure the network
     hosts: managed-node-01.example.com
     tasks:
       - name: Ethernet connection profile with static IP address settings
         ansible.builtin.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

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

2. 验证 playbook 语法：

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

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

3. 运行 playbook：

   $ ansible-playbook ~/playbook.yml

步骤

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

   ---
   - name: Configure the network
     hosts: managed-node-01.example.com
     tasks:
       - name: Ethernet connection profile with static IP address settings
         ansible.builtin.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

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

2. 验证 playbook 语法：

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

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

3. 运行 playbook：

   $ ansible-playbook ~/playbook.yml

验证

1. 显示 IPv4 路由：

   # ansible managed-node-01.example.com -m command -a 'ip -4 route'
   managed-node-01.example.com | CHANGED | rc=0 >>
   ...
   198.51.100.0/24 via 192.0.2.10 dev enp7s0

2. 显示 IPv6 路由：

   # ansible managed-node-01.example.com -m command -a 'ip -6 route'
   managed-node-01.example.com | CHANGED | rc=0 >>
   ...
   2001:db8:2::/64 via 2001:db8:1::10 dev enp7s0 metric 1024 pref medium

步骤

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

   ---
   - name: Configure the network
     hosts: managed-node-01.example.com
     tasks:
       - name: Ethernet connection profile with dynamic IP address settings and offload features
         ansible.builtin.include_role:
           name: rhel-system-roles.network
         vars:
           network_connections:
             - name: enp1s0
               type: ethernet
               autoconnect: yes
               ip:
                 dhcp4: yes
                 auto6: yes
               ethtool:
                 features:
                   gro: no
                   gso: yes
                   tx_sctp_segmentation: no
               state: up

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

   GRO: no

   禁用通用接收卸载(GRO)。

   gso: yes

   启用通用分段卸载(GSO)。

   tx_sctp_segmentation: no

   禁用 TX 流控制传输协议(SCTP)分段。

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

2. 验证 playbook 语法：

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

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

3. 运行 playbook：

   $ ansible-playbook ~/playbook.yml

步骤

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

   ---
   - name: Configure the network
     hosts: managed-node-01.example.com
     tasks:
       - name: Ethernet connection profile with dynamic IP address settings and coalesce settings
         ansible.builtin.include_role:
           name: rhel-system-roles.network
         vars:
           network_connections:
             - name: enp1s0
               type: ethernet
               autoconnect: yes
               ip:
                 dhcp4: yes
                 auto6: yes
               ethtool:
                 coalesce:
                   rx_frames: 128
                   tx_frames: 128
               state: up

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

   rx_frames: < value>

   设置 RX 帧数量。

   gso: &lt ;value>

   设置 TX 帧的数量。

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

2. 验证 playbook 语法：

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

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

3. 运行 playbook：

   $ ansible-playbook ~/playbook.yml

步骤

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

   ---
   - name: Configure the network
     hosts: managed-node-01.example.com
     tasks:
       - name: Ethernet connection profile with dynamic IP address setting and increased ring buffer sizes
         ansible.builtin.include_role:
           name: rhel-system-roles.network
         vars:
           network_connections:
             - name: enp1s0
               type: ethernet
               autoconnect: yes
               ip:
                 dhcp4: yes
                 auto6: yes
               ethtool:
                 ring:
                   rx: 4096
                   tx: 4096
               state: up

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

   rx: <value>

   设置接收环缓冲条目的最大数量。

   tx: &lt ;value>

   设置传输环缓冲条目的最大数量。

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

2. 验证 playbook 语法：

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

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

3. 运行 playbook：

   $ ansible-playbook ~/playbook.yml

步骤

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

   - hosts: managed-node-01.example.com
     vars:
       podman_create_host_directories: true
       podman_firewall:
         - port: 8080-8081/tcp
           state: enabled
         - port: 12340/tcp
           state: enabled
       podman_selinux_ports:
         - ports: 8080-8081
           setype: http_port_t
       podman_kube_specs:
         - state: started
           run_as_user: dbuser
           run_as_group: dbgroup
           kube_file_content:
             apiVersion: v1
             kind: Pod
             metadata:
               name: db
             spec:
               containers:
                 - name: db
                   image: quay.io/db/db:stable
                   ports:
                     - containerPort: 1234
                       hostPort: 12340
                   volumeMounts:
                     - mountPath: /var/lib/db:Z
                       name: db
               volumes:
                 - name: db
                   hostPath:
                     path: /var/lib/db
         - state: started
           run_as_user: webapp
           run_as_group: webapp
           kube_file_src: /path/to/webapp.yml
     roles:
       - linux-system-roles.podma

   此流程创建一个有两个容器的 pod。podman_kube_specs 角色变量描述了 pod。

   • run_as_user 和 run_as_group 字段指定容器是无根的。

   • 包含 Kubernetes YAML 文件的 kube_file_content 字段定义了名为 db 的第一个容器。您可以使用 podman kube generate 命令生成 Kubernetes YAML 文件。

     • db 容器是基于 quay.io/db/db:stable 容器镜像。
     • db 绑定挂载将主机上的 /var/lib/db 目录映射到容器中的 /var/lib/db 目录。Z 标志使用私有的 unshared 标签标记内容，因此只有 db 容器才能访问内容。
   • kube_file_src 字段定义第二个容器。控制器节点上 /path/to/webapp.yml 文件的内容将复制到受管节点上的 kube_file 字段中。
   • 设置 podman_create_host_directories: true 以在主机上创建目录。这指示角色检查 hostPath 卷的 kube 规格，并在主机上创建这些目录。如果您需要对所有权和权限有更多的控制，请使用 podman_host_directories。

2. 验证 playbook 语法：

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

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

3. 运行 playbook：

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

步骤

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

   - hosts: managed-node-01.example.com
     vars:
       podman_firewall:
         - port: 8080/tcp
           state: enabled
       podman_kube_specs:
         - state: started
           kube_file_content:
             apiVersion: v1
             kind: Pod
             metadata:
               name: ubi8-httpd
             spec:
               containers:
                 - name: ubi8-httpd
                   image: registry.access.redhat.com/ubi8/httpd-24
                   ports:
                     - containerPort: 8080
                       hostPort: 8080
                   volumeMounts:
                     - mountPath: /var/www/html:Z
                       name: ubi8-html
               volumes:
                 - name: ubi8-html
                   persistentVolumeClaim:
                     claimName: ubi8-html-volume
     roles:
       - linux-system-roles.podman

   此流程创建一个具有一个容器的 pod。podman_kube_specs 角色变量描述了 pod。

   • 默认情况下，podman 角色创建根容器。

   • 包含 Kubernetes YAML 文件的 kube_file_content 字段定义了名为 ubi8-httpd 的容器。

     • ubi8-httpd 容器是基于 registry.access.redhat.com/ubi8/httpd-24 容器镜像。

       • ubi8-html-volume 将主机上的 /var/www/html 目录映射到容器。Z 标志使用私有 unshared 标签标记内容，因此只有 ubi8-httpd 容器可以访问内容。
       • pod 使用挂载路径 /var/www/html 挂载名为 ubi8-html-volume 的现有持久性卷。

2. 验证 playbook 语法：

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

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

3. 运行 playbook：

   $ ansible-playbook ~/playbook.yml