流程

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

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

   此命令将 ansible-core 软件包安装为依赖项。

   注意

   在 RHEL 8.5 及更早的版本中，Ansible 软件包是通过 Ansible Engine 而不是 Ansible Core 提供的，并具有不同的支持级别。不要使用 Ansible Engine，因为软件包可能与 RHEL 8.6 及之后的版本中的 Ansible 自动化内容不兼容。如需更多信息，请参阅 在 RHEL 9 和 RHEL 8.6 及之后的 AppStream 存储库中包含的 Ansible Core 软件包的支持范围。

2. 创建名为 ansible 的用户，以管理并运行 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):
   Enter passphrase (empty for no passphrase): <password>
   Enter same passphrase again: <password>
   ...

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

5. 可选： 要防止 Ansible 每次建立连接时提示您输入 SSH 密钥密码，请配置 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.cfg 文件中的设置具有更高的优先级，并覆盖全局 /etc/ansible/ansible.cfg 文件中的设置。

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

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

7. 创建一个列出受管主机主机名的 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 地址。

流程

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 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-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 和 /etc/rsyslog.d 的语法：

   # 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. 创建一个 vault 来保存敏感信息：

   $ ansible-vault create secrets.yml
   New Vault password: password
   Confirm New Vault password: password

2. ansible-vault create 命令会创建一个加密的 vault 文件，并在编辑器中打开它。输入您要保存在密码库中的敏感数据，例如：

   activationKey: activation_key
   username: username
   password: password

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

   之后，您可以使用 ansible-vault edit secrets.yml 命令编辑 vault 中的数据。

4. 可选：显示 vault 内容：

   $ ansible-vault view secrets.yml

5. 创建一个 playbook 文件，如 ~/registration.yml，并根据您要执行的操作使用以下选项之一：

   1. 要使用激活码和机构 ID （推荐）注册，请使用以下 playbook：

      ---
      - name: Registering system using activation key and organization ID
        hosts: managed-node-01.example.com
        vars_files:
          - secrets.yml
        vars:
          rhc_auth:
            activation_keys:
              keys:
                -  "{{ activationKey }}"
          rhc_organization: organizationID
        roles:
          - role: rhel-system-roles.rhc

   2. 要使用用户名和密码注册，请使用以下 playbook：

      ---
      - name: Registering system with username and password
        hosts:  managed-node-01.example.com
        vars_files:
          - secrets.yml
        vars:
          rhc_auth:
            login:
              username: "{{ username }}"
              password: "{{ password }}"
        roles:
          - role: rhel-system-roles.rhc

6. 运行 playbook：

   # ansible-playbook ~/registration.yml --ask-vault-pass

流程

1. 创建一个 vault 来保存敏感信息：

   $ ansible-vault create secrets.yml
   New Vault password: password
   Confirm New Vault password: password

2. ansible-vault create 命令创建一个加密的文件，并在编辑器中打开它。输入您要保存在密码库中的敏感数据，例如：

   activationKey: activation_key

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

   之后，您可以使用 ansible-vault edit secrets.yml 命令编辑 vault 中的数据。

4. 可选：显示 vault 内容：

   $ ansible-vault view secrets.yml

5. 创建一个 playbook 文件，如 ~/registration-sat.yml。

6. 使用 ~/registration-sat.yml 中的以下文本，使用激活码和机构 ID 注册系统：

   ---
   - name: Register to the custom registration server and CDN
     hosts: managed-node-01.example.com
     vars_files:
       - secrets.yml
     vars:
       rhc_auth:
         login:
           activation_keys:
             keys:
               - "{{ activationKey }}"
           rhc_organization: organizationID
       rhc_server:
         hostname: example.com
           port: 443
           prefix: /rhsm
       rhc_baseurl: http://example.com/pulp/content
      roles:
        - role: rhel-system-roles.rhc

7. 运行 playbook：

   # ansible-playbook ~/registration-sat.yml --ask-vault-pass

流程

1. 创建一个 playbook 文件，如 ~/dis-insights.yml，并在其中添加以下内容：

   ---
   - name: Disable Insights connection
     hosts: managed-node-01.example.com
     vars:
       rhc_insights:
         state: absent
     roles:
       - role: rhel-system-roles.rhc

2. 运行 playbook：

   # ansible-playbook ~/dis-insights.yml

流程

1. 创建一个 playbook 文件，如 ~/configure-repos.yml ：

   1. 要启用存储库：

      ---
      - name: Enable repository
        hosts: managed-node-01.example.com
        vars:
          rhc_repositories:
            - {name: "RepositoryName", state: enabled}
         roles:
           - role: rhel-system-roles.rhc

   2. 要禁用存储库：

      ---
      - name: Disable repository
        hosts: managed-node-01.example.com
        vars:
          rhc_repositories:
            - {name: "RepositoryName", state: disabled}
         roles:
           - role: rhel-system-roles.rhc

2. 运行 playbook：

   # ansible-playbook ~/configure-repos.yml

流程

1. 创建一个 playbook 文件，如 ~/release.yml ：

   ---
   - name: Set Release
     hosts: managed-node-01.example.com
     vars:
       rhc_release: "8.6"
     roles:
       - role: rhel-system-roles.rhc

2. 运行 playbook：

   # ansible-playbook ~/release.yml

流程

1. 创建一个 vault 来保存敏感信息：

   $ ansible-vault create secrets.yml
   New Vault password: password
   Confirm New Vault password: password

2. ansible-vault create 命令创建一个加密的文件，并在编辑器中打开它。输入您要保存在密码库中的敏感数据，例如：

   username: username
   password: password
   proxy_username: proxyusernme
   proxy_password: proxypassword

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

   之后，您可以使用 ansible-vault edit secrets.yml 命令编辑 vault 中的数据。

4. 可选：显示 vault 内容：

   $ ansible-vault view secrets.yml

5. 创建一个 playbook 文件，如 ~/configure-proxy.yml ：

   1. 要使用代理注册到 RHEL 客户门户网站：

      ---
      - name: Register using proxy
        hosts: managed-node-01.example.com
        vars_files:
          - secrets.yml
        vars:
          rhc_auth:
            login:
              username: "{{ username }}"
              password: "{{ password }}"
          rhc_proxy:
            hostname: proxy.example.com
            port: 3128
            username: "{{ proxy_username }}"
            password: "{{ proxy_password }}"
        roles:
          - role: rhel-system-roles.rhc

   2. 要从 Red Hat Subscription Manager 服务的配置中删除代理服务器：

      ---
      - name: To stop using proxy server for registration
        hosts: managed-node-01.example.com
        vars_files:
          - secrets.yml
        vars:
          rhc_auth:
            login:
              username: "{{ username }}"
              password: "{{ password }}"
           rhc_proxy: {"state":"absent"}
        roles:
          - role: rhel-system-roles.rhc

6. 运行 playbook：

   # ansible-playbook ~/configure-proxy.yml --ask-vault-pass

流程

1. 创建一个 vault 来保存敏感信息：

   $ ansible-vault create secrets.yml
   New Vault password: password
   Confirm New Vault password: password

2. ansible-vault create 命令创建一个加密的文件，并在编辑器中打开它。输入您要保存在密码库中的敏感数据，例如：

   username: username
   password: password

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

   之后，您可以使用 ansible-vault edit secrets.yml 命令编辑 vault 中的数据。

4. 可选：显示 vault 内容：

   $ ansible-vault view secrets.yml

5. 创建一个 playbook 文件，如 ~/auto-update.yml，并将以下内容添加到其中：

   ---
    - name: Disable Red Hat Insights autoupdates
      hosts: managed-node-01.example.com
      vars_files:
        - secrets.yml
      vars:
       rhc_auth:
         login:
           username: "{{ username }}"
           password: "{{ password }}"
       rhc_insights:
          autoupdate: false
          state: present
       roles:
         - role: rhel-system-roles.rhc

6. 运行 playbook：

   # ansible-playbook ~/auto-update.yml --ask-vault-pass

流程

1. 要启用补救，请创建一个 playbook 文件，如 ~/remediation.yml ：

   ---
   - name: Disable remediation
     hosts: managed-node-01.example.com
     vars:
       rhc_insights:
         remediation: absent
         state: present
     roles:
       - role: rhel-system-roles.rhc

2. 运行 playbook：

   # ansible-playbook ~/remediation.yml

流程

1. 创建一个 vault 来保存敏感信息：

   $ ansible-vault create secrets.yml
   New Vault password: password
   Confirm New Vault password: password

2. ansible-vault create 命令创建一个加密的文件，并在编辑器中打开它。输入您要保存在密码库中的敏感数据，例如：

   username: username
   password: password

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

   之后，您可以使用 ansible-vault edit secrets.yml 命令编辑 vault 中的数据。

4. 可选：显示 vault 内容：

   $ ansible-vault view secrets.yml

5. 创建一个 playbook 文件，如 ~/tags.yml，并将以下内容添加到其中：

   ---
   - name: Creating tags
     hosts: managed-node-01.example.com
     vars_files:
       - secrets.yml
     vars:
       rhc_auth:
         login:
           username: "{{ username }}"
           password: "{{ password }}"
       rhc_insights:
         tags:
           group: group-name-value
             location: location-name-value
             description:
               - RHEL8
               - SAP
              sample_key:value
           state: present
     roles:
       - role: rhel-system-roles.rhc

6. 运行 playbook：

   # ansible-playbook ~/remediation.yml --ask-vault-pass

流程

1. 要取消注册，请创建一个 playbook 文件，如 ~/unregister.yml ，并在其中添加以下内容：

   ---
   - name: Unregister the system
     hosts: managed-node-01.example.com
     vars:
       rhc_state: absent
     roles:
       - role: rhel-system-roles.rhc

2. 运行 playbook：

   # ansible-playbook ~/unregister.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: 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

   这些设置使用以下设置为 enp1s0 设备定义一个以太网连接配置文件：

   • 静态 IPv4 地址 - 192.0.2.1 和 /24 子网掩码
   • 静态 IPv6 地址 - 2001:db8:1::1 和 /64 子网掩码
   • IPv4 默认网关 - 192.0.2.254
   • IPv6 默认网关 - 2001:db8:1::fffe
   • IPv4 DNS 服务器 - 192.0.2.200
   • IPv6 DNS 服务器 - 2001:db8:1::ffbb
   • DNS 搜索域 - example.com

2. 验证 playbook 语法：

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

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

3. 运行 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

   这些设置使用以下设置定义以太网连接配置文件：

   • 静态 IPv4 地址 - 192.0.2.1 和 /24 子网掩码
   • 静态 IPv6 地址 - 2001:db8:1::1 和 /64 子网掩码
   • IPv4 默认网关 - 192.0.2.254
   • IPv6 默认网关 - 2001:db8:1::fffe
   • IPv4 DNS 服务器 - 192.0.2.200
   • IPv6 DNS 服务器 - 2001:db8:1::ffbb
   • DNS 搜索域 - example.com

   本例中的 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 --syntax-check

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

3. 运行 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: enp1s0
             interface_name: enp1s0
             type: ethernet
             autoconnect: yes
             ip:
               dhcp4: yes
               auto6: yes
             state: up

   这些设置为 enp1s0 设备定义一个以太网连接配置文件。连接从 DHCP 服务器和 IPv6 无状态地址自动配置(SLAAC)检索 IPv4 地址、IPv6 地址、默认网关、路由、DNS 服务器和搜索域。

2. 验证 playbook 语法：

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

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

3. 运行 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

   这些设置定义一个以太网连接配置文件。连接从 DHCP 服务器和 IPv6 无状态地址自动配置(SLAAC)检索 IPv4 地址、IPv6 地址、默认网关、路由、DNS 服务器和搜索域。

   本例中的 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 --syntax-check

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

3. 运行 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 以在 enp1s0 设备上操作。VLAN 接口有以下设置：

   • 静态 IPv4 地址 - 192.0.2.1 和 /24 子网掩码
   • 静态 IPv6 地址 - 2001:db8:1::1 和 /64 子网掩码
   • IPv4 默认网关 - 192.0.2.254
   • IPv6 默认网关 - 2001:db8:1::fffe
   • IPv4 DNS 服务器 - 192.0.2.200
   • IPv6 DNS 服务器 - 2001:db8:1::ffbb
   • DNS 搜索域 - example.com
   • VLAN ID - 10

   VLAN 配置文件中的 parent 属性将 VLAN 配置为在 enp1s0 设备之上运行。作为子设备，VLAN 连接包含 IP、默认网关和 DNS 配置。

2. 验证 playbook 语法：

   # ansible-playbook ~/vlan-ethernet.yml --syntax-check

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

3. 运行 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

   这些设置使用以下设置定义一个网桥：

   • 静态 IPv4 地址 - 192.0.2.1 和 /24 子网掩码
   • 静态 IPv6 地址 - 2001:db8:1::1 和 /64 子网掩码
   • IPv4 默认网关 - 192.0.2.254
   • IPv6 默认网关 - 2001:db8:1::fffe
   • IPv4 DNS 服务器 - 192.0.2.200
   • IPv6 DNS 服务器 - 2001:db8:1::ffbb
   • DNS 搜索域 - example.com

   • 网桥的端口 - enp7s0 和 enp8s0

     注意

     在网桥上设置 IP 配置,而不是在 Linux 网桥的端口上设置。

2. 验证 playbook 语法：

   # ansible-playbook ~/bridge-ethernet.yml --syntax-check

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

3. 运行 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

   这些设置使用以下设置定义网络绑定：

   • 静态 IPv4 地址 - 192.0.2.1 和 /24 子网掩码
   • 静态 IPv6 地址 - 2001:db8:1::1 和 /64 子网掩码
   • IPv4 默认网关 - 192.0.2.254
   • IPv6 默认网关 - 2001:db8:1::fffe
   • IPv4 DNS 服务器 - 192.0.2.200
   • IPv6 DNS 服务器 - 2001:db8:1::ffbb
   • DNS 搜索域 - example.com
   • 绑定的端口 - enp7s0 和 enp8s0

   • 绑定模式 - active-backup

     注意

     在绑定上设置 IP 配置，而不是在 Linux 绑定的端口上设置。

2. 验证 playbook 语法：

   # ansible-playbook ~/bond-ethernet.yml --syntax-check

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

3. 运行 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 --syntax-check

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

3. 运行 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 --syntax-check

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

3. 运行 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

   这些设置使用以下设置为 enp1s0 设备定义一个以太网连接配置文件：

   • 静态 IPv4 地址 - 192.0.2.1 和 /24 子网掩码
   • 静态 IPv6 地址 - 2001:db8:1::1 和 /64 子网掩码
   • IPv4 默认网关 - 192.0.2.254
   • IPv6 默认网关 - 2001:db8:1::fffe
   • IPv4 DNS 服务器 - 192.0.2.200
   • IPv6 DNS 服务器 - 2001:db8:1::ffbb
   • DNS 搜索域 - example.com
   • 使用 TLS 可扩展身份验证协议(EAP)的 802.1X 网络身份验证.

2. 验证 playbook 语法：

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

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

3. 运行 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 --syntax-check

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

3. 运行 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

   根据它是否已存在，流程使用以下设置创建或更新 enp7s0 连接配置文件：

   • 静态 IPv4 地址 - 192.0.2.1 和 /24 子网掩码
   • 静态 IPv6 地址 - 2001:db8:1::1 和 /64 子网掩码
   • IPv4 默认网关 - 192.0.2.254
   • IPv6 默认网关 - 2001:db8:1::fffe
   • IPv4 DNS 服务器 - 192.0.2.200
   • IPv6 DNS 服务器 - 2001:db8:1::ffbb
   • DNS 搜索域 - example.com

   • 静态路由：

     • 198.51.100.0/24，网关为 192.0.2.10
     • 2001:db8:2::/64，网关为 2001:db8:1::10

2. 验证 playbook 语法：

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

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

3. 运行 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

   根据它是否已存在，此 playbook 会使用以下设置创建或更新 enp1s0 连接配置文件：

   • 静态 IPv4 地址 - 198.51.100.20 ，子网掩码为 /24
   • 静态 IPv6 地址 - 2001:db8:1::1 ，子网掩码为 /64
   • IPv4 默认网关 - 198.51.100.254
   • IPv6 默认网关 - 2001:db8:1::fffe
   • IPv4 DNS 服务器 - 198.51.100.200
   • IPv6 DNS 服务器 - 2001:db8:1::ffbb
   • DNS 搜索域 - example.com

   • ethtool 功能：

     • 通用接收卸载(GRO)：禁用
     • 通用分段卸载(GSO)：启用
     • TX 流控制传输协议(SCTP)分段：禁用

2. 验证 playbook 语法：

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

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

3. 运行 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

   根据它是否已存在，此 playbook 会使用以下设置创建或更新 enp1s0 连接配置文件：

   • 静态 IPv4 地址 - 198.51.100.20 ，子网掩码为 /24
   • 静态 IPv6 地址 - 2001:db8:1::1 和 /64 子网掩码
   • IPv4 默认网关 - 198.51.100.254
   • IPv6 默认网关 - 2001:db8:1::fffe
   • IPv4 DNS 服务器 - 198.51.100.200
   • IPv6 DNS 服务器 - 2001:db8:1::ffbb
   • DNS 搜索域 - example.com

   • ethtool coalesce 设置：

     • RX 帧：128
     • TX 帧：128

2. 验证 playbook 语法：

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

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

3. 运行 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 ~/configure-ethernet-device-with-ethtoolcoalesce-settings.yml --syntax-check

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

3. 运行 playbook：

   # ansible-playbook ~/reset-firewalld.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 --syntax-check

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

3. 运行 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 --syntax-check

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

3. 运行 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 --syntax-check

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

3. 运行 playbook：

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

流程

1. 创建定义 postfix 角色的 playbook：

   1. 创建一个新的 YAML 文件，如 ~/postfix-playbook.yml，并在文本编辑器中打开该文件，例如：

      # vi postfix-playbook.yml

   2. 配置 relay_domains=$mydestination 和 relayhost=example.com 变量：

      - name: Manage postfix
        hosts: all
        vars:
      	postfix_conf:
        		relay_domains: $mydestination
        		relayhost: example.com
        roles:
      	- linux-system-roles.postfix

   3. 如果您希望 Postfix 使用与 gethostname （） 函数返回的完全限定域名(FQDN)不同的主机名，请在文件中的 postfix_conf: 行下添加 myhostname 参数：

      myhostname = smtp.example.com

   4. 如果域名与 myhostname 参数中的域名不同，请添加 mydomain 参数。否则，会使用 $myhostname 减去第一个组件。

      mydomain = <example.com>

   5. 使用 postfix_manage_firewall: true 变量来确保在服务器的防火墙中打开 SMTP 端口。

      管理 SMTP 相关端口 25/tcp、465/tcp 和 587/tcp。如果变量设为 false，则 postfix 角色不管理防火墙。默认值为 false。

      注意

      postfix_manage_firewall 变量仅限于添加端口。它不能用来删除端口。如果要删除端口，请直接使用 firewall RHEL 系统角色。

   6. 如果您的场景涉及使用非标准端口，请设置 postfix_manage_selinux: true 变量，以确保为服务器上的 SELinux 正确标记端口。

      注意

      postfix_manage_selinux 变量仅限于向 SELinux 策略添加规则。它不能从策略中删除规则。如果要删除规则，请直接使用 selinux 系统角色。

2. 对特定清单运行 playbook:

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

   其中：

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

流程

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.yml 文件：

   - name: Deploy and start systemd unit
     hosts: all
     vars:
       systemd_unit_files:
         - <name1>.service
         - <name2>.service
         - <name3>.service
       systemd_started_units:
         - <name1>.service
         - <name2>.service
         - <name3>.service
       systemd_enabled_units:
         - <name1>.service
         - <name2>.service
         - <name3>.service
     roles:
       - linux-system-roles.systemd

2. 可选：验证 playbook 语法：

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

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

   # ansible-playbook -i inventory_file /path/to/file/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 </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...
   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/<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.yml 文件：

   ---
   - hosts: all
     vars:
       journald_persistent: true
       journald_max_disk_size: 2048
       journald_per_user: true
       journald_sync_interval: 1
     roles:
       - linux-system-roles.journald
   ---

   因此，journald 服务会将日志在磁盘上永久保存到 2048 MB 的最大大小，并为每个用户单独保留日志数据。同步每分钟发生。

2. 可选：验证 playbook 语法。

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

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

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

流程

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 用户登录

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

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 文件的内容：

   $ cat /etc/ssh/sshd_config
   …
   PasswordAuthentication no
   PermitRootLogin no
   …
   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：

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

      # vi <cryptographic-playbook.yml>

   2. 插入以下示例：

      ---
      - name: Overriding the system-wide cryptographic policy
        hosts: all
        become: true
        roles:
          - rhel_system_roles.sshd
        vars:
          sshd_sysconfig: true
          sshd_sysconfig_override_crypto_policy: true
          sshd_KexAlgorithms: ecdh-sha2-nistp521
          sshd_Ciphers: aes256-ctr
          sshd_MACs: hmac-sha2-512-etm@openssh.com
          sshd_HostKeyAlgorithms: rsa-sha2-512,rsa-sha2-256

      在 RHEL 9 受管节点上，系统角色会将配置写入 /etc/ssh/sshd_config.d/00-ansible_system_role.conf 文件中，其中加密选项会被自动应用。您可以使用 sshd_config_file 变量更改文件。但是，要确保配置有效，请使用 lexicographicaly 之前 /etc/ssh/sshd_config.d/50-redhat.conf 文件的文件名，其中包括配置的加密策略。如需更多信息，请参阅 选择不使用系统范围的加密策略的示例。

      在 RHEL 8 受管节点上，您必须通过将 sshd_sysconfig_override_crypto_policy 和 sshd_sysconfig 变量设置为 true 来启用覆盖。

      您可以使用 rhel_system_roles.sshd RHEL 系统角色的以下变量进一步自定义 SSH 服务器上的配置：

      sshd_Ciphers

      您可以选择密码，例如 aes128-ctr、es192-ctr 或 aes256-ctr。

      sshd_MACs

      您可以选择 MACs，例如 hmac-sha2-256、hmac-sha2-512 或 hmac-sha1。

      sshd_HostKeyAlgorithms

      您可以选择公钥算法，例如 ecdsa-sha2-nistp256,ecdsa-sha2-nistp384,ecdsa-sha2-nistp521,ssh-rsa, 或 ssh-dss。

      sshd_KexAlgorithms

      您可以选择密钥交换算法，例如 ecdh-sha2-nistp256,ecdh-sha2-nistp384,ecdh-sha2-nistp521,diffie-hellman-group14-sha1, 或 diffie-hellman-group-exchange-sha256。

      有关更多变量及其可能的值，请参阅 sshd_config (5) 手册页。

2. 运行 playbook:

   $ ansible-playbook <cryptographic-playbook.yml>

验证

1. 您可以使用详细 SSH 连接验证流程是否成功，并在以下输出中检查定义的变量：

   $ ssh -vvv localhost
   ...
   debug2: peer server KEXINIT proposal
   debug2: KEX algorithms: ecdh-sha2-nistp521
   debug2: host key algorithms: rsa-sha2-512,rsa-sha2-256
   debug2: ciphers ctos: aes256-ctr
   debug2: ciphers stoc: aes256-ctr
   debug2: MACs ctos: hmac-sha2-512-etm@openssh.com
   debug2: MACs stoc: hmac-sha2-512-etm@openssh.com
   ...

流程

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:
       vpn_manage_firewall: true
       vpn_manage_selinux: true

   此 playbook 使用系统角色自动生成的密钥进行预共享密钥身份验证，来配置 managed_node1-to-managed_node2 的连接。因为 vpn_manage_firewall 和 vpn_manage_selinux 都被设为 true，因此 vpn 角色使用 firewall 和 selinux 角色来管理 vpn 角色使用的端口。

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
       vpn_manage_firewall: true
       vpn_manage_selinux: true

   注意

   因为 vpn_manage_firewall 和 vpn_manage_selinux 都被设为 true，因此 vpn 角色使用 firewall 和 selinux 角色来管理 vpn 角色使用的端口。

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
       nbde_server_manage_firewall: true
       nbde_server_manage_selinux: true
   
     roles:
       - rhel-system-roles.nbde_server

   注意

   因为 nbde_server_manage_firewall 和 nbde_server_manage_selinux 都被设为 true，所以 nbde_server 角色使用 firewall 和 selinux 角色来管理 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，如 自签名。
     • 将 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