Automating system administration by using RHEL System Roles in RHEL 7.9

Procedure

1. Install the rhel-system-roles package:

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

   Copy to Clipboard Toggle word wrap

   This command installs the ansible-core package as a dependency.

2. Create a user named ansible to manage and run playbooks:

   [root@control-node]# useradd ansible

   Copy to Clipboard Toggle word wrap

3. Switch to the newly created ansible user:

   [root@control-node]# su - ansible

   Copy to Clipboard Toggle word wrap

   Perform the rest of the procedure as this user.

4. Create an SSH public and private key:

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

   Copy to Clipboard Toggle word wrap

   Use the suggested default location for the key file.

5. Optional: To prevent Ansible from prompting you for the SSH key password each time you establish a connection, configure an SSH agent.

6. Create the ~/.ansible.cfg file with the following content:

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

   Copy to Clipboard Toggle word wrap
   Note

   Settings in the ~/.ansible.cfg file have a higher priority and override settings from the global /etc/ansible/ansible.cfg file.

   With these settings, Ansible performs the following actions:

   • Manages hosts in the specified inventory file.
   • Uses the account set in the remote_user parameter when it establishes SSH connections to managed nodes.
   • Uses the sudo utility to execute tasks on managed nodes as the root user.
   • Prompts for the root password of the remote user every time you apply a playbook. This is recommended for security reasons.

7. Create an ~/inventory file in INI or YAML format that lists the hostnames of managed hosts. You can also define groups of hosts in the inventory file. For example, the following is an inventory file in the INI format with three hosts and one host group named US:

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

   Copy to Clipboard Toggle word wrap

   Note that the control node must be able to resolve the hostnames. If the DNS server cannot resolve certain hostnames, add the ansible_host parameter next to the host entry to specify its IP address.

Procedure

1. Create a user named ansible:

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

   Copy to Clipboard Toggle word wrap

   The control node later uses this user to establish an SSH connection to this host.

2. Set a password for the ansible user:

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

   Copy to Clipboard Toggle word wrap

   You must enter this password when Ansible uses sudo to perform tasks as the root user.

3. Install the ansible user’s SSH public key on the managed node:

   1. Log in to the control node as the ansible user, and copy the SSH public key to the managed node:

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

      Copy to Clipboard Toggle word wrap

   2. When prompted, connect by entering 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

      Copy to Clipboard Toggle word wrap

   3. When prompted, enter the password:

      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.

      Copy to Clipboard Toggle word wrap

   4. Verify the SSH connection by remotely executing a command on the control node:

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

      Copy to Clipboard Toggle word wrap

4. Create a sudo configuration for the ansible user:

   1. Create and edit the /etc/sudoers.d/ansible file by using the visudo command:

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

      Copy to Clipboard Toggle word wrap

      The benefit of using visudo over a normal editor is that this utility provides basic sanity checks and checks for parse errors before installing the file.

   2. Configure a sudoers policy in the /etc/sudoers.d/ansible file that meets your requirements, for example:

      • To grant permissions to the ansible user to run all commands as any user and group on this host after entering the ansible user’s password, use:

        ansible ALL=(ALL) ALL

        Copy to Clipboard Toggle word wrap

      • To grant permissions to the ansible user to run all commands as any user and group on this host without entering the ansible user’s password, use:

        ansible ALL=(ALL) NOPASSWD: ALL

        Copy to Clipboard Toggle word wrap

   Alternatively, configure a more fine-granular policy that matches your security requirements. For further details on sudoers policies, see the sudoers(5) man page.

Verification

1. Verify that you can execute commands from the control node on an all managed nodes:

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

   Copy to Clipboard Toggle word wrap

   The hard-coded all group dynamically contains all hosts listed in the inventory file.

2. Verify that privilege escalation works correctly by running the whoami utility on a managed host by using the Ansible command module:

   [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

   Copy to Clipboard Toggle word wrap

   If the command returns root, you configured sudo on the managed nodes correctly.

1. Run the following command:

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

   Copy to Clipboard Toggle word wrap

Procedure

1. Define Red Hat Automation Hub as the default source for content in the ansible.cfg configuration file. See Configuring Red Hat Automation Hub as the primary source for content .

2. Install the redhat.rhel_system_roles collection from the Automation Hub:

   # ansible-galaxy collection install redhat.rhel_system_roles

   Copy to Clipboard Toggle word wrap

   After the installation is finished, the roles are available as redhat.rhel_system_roles.<role_name>. Additionally, you can find the documentation for each role at /usr/share/ansible/collections/ansible_collections/redhat/rhel_system_roles/roles/<role_name>/README.md.

1. Run the following command:

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

   Copy to Clipboard Toggle word wrap

Procedure

1. Create a playbook that defines the required role:

   1. Create a new YAML file and open it in a text editor, for example:

      # vi logging-playbook.yml

      Copy to Clipboard Toggle word wrap

   2. Insert the following content into the YAML file:

      ---
      - 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]

      Copy to Clipboard Toggle word wrap

2. Execute the playbook on a specific inventory:

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

   Copy to Clipboard Toggle word wrap

   Where:

   • inventory-file is the name of your inventory file.
   • logging-playbook.yml is the playbook you use.

Verification steps

1. Test the syntax of the configuration files /etc/rsyslog.conf and /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.

   Copy to Clipboard Toggle word wrap

2. Verify that the system sends messages to the log:

   1. Send a test message:

      # logger test

      Copy to Clipboard Toggle word wrap

   2. View the /var/log/messages log, for example:

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

      Copy to Clipboard Toggle word wrap

      The hostname is the hostname of the client system. The log displays the user name of the user that entered the logger command, in this case, root.

Procedure

1. Create a new playbook.yml file with the following content:

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

   Copy to Clipboard Toggle word wrap

2. Execute the playbook against localhost:

   # ansible-playbook playbook.yml

   Copy to Clipboard Toggle word wrap

Procedure

1. Create a new playbook.yml file with the following content:

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

   Copy to Clipboard Toggle word wrap

2. Execute the playbook:

   # ansible-playbook playbook.yml

   Copy to Clipboard Toggle word wrap

1. redfish_info: The redfish_info module retrieves information about the remote Out-Of-Band (OOB) controller such as systems inventory.
2. redfish_command: The redfish_command module performs Out-Of-Band (OOB) controller operations like log management and user management, and power operations such as system restart, power on and off.
3. redfish_config: The redfish_config module performs OOB controller operations such as changing OOB configuration, or setting the BIOS configuration.

Procedure

1. Create a new playbook.yml file with the following content:

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

   Copy to Clipboard Toggle word wrap

2. Execute the playbook against localhost:

   # ansible-playbook playbook.yml

   Copy to Clipboard Toggle word wrap

Procedure

1. Create a new playbook.yml file with the following content:

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

   Copy to Clipboard Toggle word wrap

2. Execute the playbook against localhost:

   # ansible-playbook playbook.yml

   Copy to Clipboard Toggle word wrap

Procedure

1. Create a new playbook.yml file with the following content:

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

   Copy to Clipboard Toggle word wrap

2. Execute the playbook against localhost:

   # ansible-playbook playbook.yml

   Copy to Clipboard Toggle word wrap

Procedure

1. Optionally, review the inventory file for illustration purposes:

   #  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

   Copy to Clipboard Toggle word wrap

   The file defines the [testingservers] group and other groups. It allows you to run Ansible more effectively against a specific set of systems.

2. Create a configuration file to set defaults and privilege escalation for Ansible operations.

   1. Create a new YAML file and open it in a text editor, for example:

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

      Copy to Clipboard Toggle word wrap

   2. Insert the following content into the file:

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

      Copy to Clipboard Toggle word wrap

      The [defaults] section specifies a path to the inventory file of managed hosts. The [privilege_escalation] section defines that user privileges be shifted to root on the specified managed hosts. This is necessary for successful configuration of kernel parameters. When Ansible playbook is run, you will be prompted for user password. The user automatically switches to root by means of sudo after connecting to a managed host.

3. Create an Ansible playbook that uses the kernel_settings role.

   1. Create a new YAML file and open it in a text editor, for example:

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

      Copy to Clipboard Toggle word wrap

      This file represents a playbook and usually contains an ordered list of tasks, also called plays, that are run against specific managed hosts selected from your inventory file.

   2. Insert the following content into the file:

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

      Copy to Clipboard Toggle word wrap

      The name key is optional. It associates an arbitrary string with the play as a label and identifies what the play is for. The hosts key in the play specifies the hosts against which the play is run. The value or values for this key can be provided as individual names of managed hosts or as groups of hosts as defined in the inventory file.

      The vars section represents a list of variables containing selected kernel parameter names and values to which they have to be set.

      The roles key specifies what system role is going to configure the parameters and values mentioned in the vars section.

      Note

      You can modify the kernel parameters and their values in the playbook to fit your needs.

4. Optionally, verify that the syntax in your play is correct.

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

   Copy to Clipboard Toggle word wrap

   This example shows the successful verification of a playbook.

5. Execute your 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

   Copy to Clipboard Toggle word wrap

   Before Ansible runs your playbook, you are going to be prompted for your password and so that a user on managed hosts can be switched to root, which is necessary for configuring kernel parameters.

   The recap section shows that the play finished successfully (failed=0) for all managed hosts, and that 4 kernel parameters have been applied (changed=4).

6. Restart your managed hosts and check the affected kernel parameters to verify that the changes have been applied and persist across reboots.

Procedure

1. Create a vault to save the sensitive information:

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

   Copy to Clipboard Toggle word wrap

2. The ansible-vault create command creates an encrypted vault file and opens it in an editor. Enter the sensitive data you want to save in the vault, for example:

   activationKey: activation_key
   username: username
   password: password

   Copy to Clipboard Toggle word wrap

3. Save the changes, and close the editor. Ansible encrypts the data in the vault.

   You can later edit the data in the vault by using the ansible-vault edit secrets.yml command.

4. Optional: Display the vault content:

   $ ansible-vault view secrets.yml

   Copy to Clipboard Toggle word wrap

5. Create a playbook file, for example ~/registration.yml, and use one of the following options depending on the action you want to perform:

   1. To register by using an activation key and organization ID (recommended), use the following 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

      Copy to Clipboard Toggle word wrap

   2. To register by using a username and password, use the following 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

      Copy to Clipboard Toggle word wrap

6. Run the playbook:

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

   Copy to Clipboard Toggle word wrap

Procedure

1. Create a vault to save the sensitive information:

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

   Copy to Clipboard Toggle word wrap

2. The ansible-vault create command creates an encrypted file and opens it in an editor. Enter the sensitive data you want to save in the vault, for example:

   activationKey: activation_key

   Copy to Clipboard Toggle word wrap

3. Save the changes, and close the editor. Ansible encrypts the data in the vault.

   You can later edit the data in the vault by using the ansible-vault edit secrets.yml command.

4. Optional: Display the vault content:

   $ ansible-vault view secrets.yml

   Copy to Clipboard Toggle word wrap
5. Create a playbook file, for example ~/registration-sat.yml.

6. Use the following text in ~/registration-sat.yml to register the system by using an activation key and organization 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

   Copy to Clipboard Toggle word wrap

7. Run the playbook:

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

   Copy to Clipboard Toggle word wrap

Procedure

1. Create a playbook file, for example ~/dis-insights.yml and add the following content in it:

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

   Copy to Clipboard Toggle word wrap

2. Run the playbook:

   # ansible-playbook ~/dis-insights.yml

   Copy to Clipboard Toggle word wrap

Procedure

1. Create a playbook file, for example ~/configure-repos.yml:

   1. To enable a repository:

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

      Copy to Clipboard Toggle word wrap

   2. To disable a repository:

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

      Copy to Clipboard Toggle word wrap

2. Run the playbook:

   # ansible-playbook ~/configure-repos.yml

   Copy to Clipboard Toggle word wrap

Procedure

1. Create a playbook file, for example ~/release.yml:

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

   Copy to Clipboard Toggle word wrap

2. Run the playbook:

   # ansible-playbook ~/release.yml

   Copy to Clipboard Toggle word wrap

Procedure

1. Create a vault to save the sensitive information:

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

   Copy to Clipboard Toggle word wrap

2. The ansible-vault create command creates an encrypted file and opens it in an editor. Enter the sensitive data you want to save in the vault, for example:

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

   Copy to Clipboard Toggle word wrap

3. Save the changes, and close the editor. Ansible encrypts the data in the vault.

   You can later edit the data in the vault by using the ansible-vault edit secrets.yml command.

4. Optional: Display the vault content:

   $ ansible-vault view secrets.yml

   Copy to Clipboard Toggle word wrap

5. Create a playbook file, for example ~/configure-proxy.yml:

   1. To register to the RHEL customer portal by using a proxy:

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

      Copy to Clipboard Toggle word wrap

   2. To remove the proxy server from the configuration of the Red Hat Subscription Manager service:

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

      Copy to Clipboard Toggle word wrap

6. Run the playbook:

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

   Copy to Clipboard Toggle word wrap

Procedure

1. Create a vault to save the sensitive information:

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

   Copy to Clipboard Toggle word wrap

2. The ansible-vault create command creates an encrypted file and opens it in an editor. Enter the sensitive data you want to save in the vault, for example:

   username: username
   password: password

   Copy to Clipboard Toggle word wrap

3. Save the changes, and close the editor. Ansible encrypts the data in the vault.

   You can later edit the data in the vault by using the ansible-vault edit secrets.yml command.

4. Optional: Display the vault content:

   $ ansible-vault view secrets.yml

   Copy to Clipboard Toggle word wrap

5. Create a playbook file, for example ~/auto-update.yml and add following content to it:

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

   Copy to Clipboard Toggle word wrap

6. Run the playbook:

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

   Copy to Clipboard Toggle word wrap

Procedure

1. To enable the remediation, create a playbook file, for example ~/remediation.yml:

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

   Copy to Clipboard Toggle word wrap

2. Run the playbook:

   # ansible-playbook ~/remediation.yml

   Copy to Clipboard Toggle word wrap

Procedure

1. Create a vault to save the sensitive information:

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

   Copy to Clipboard Toggle word wrap

2. The ansible-vault create command creates an encrypted file and opens it in an editor. Enter the sensitive data you want to save in the vault, for example:

   username: username
   password: password

   Copy to Clipboard Toggle word wrap

3. Save the changes, and close the editor. Ansible encrypts the data in the vault.

   You can later edit the data in the vault by using the ansible-vault edit secrets.yml command.

4. Optional: Display the vault content:

   $ ansible-vault view secrets.yml

   Copy to Clipboard Toggle word wrap

5. Create a playbook file, for example ~/tags.yml, and add following content to it:

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

   Copy to Clipboard Toggle word wrap

6. Run the playbook:

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

   Copy to Clipboard Toggle word wrap

Procedure

1. To unregister, create a playbook file, for example, ~/unregister.yml and add the following content to it:

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

   Copy to Clipboard Toggle word wrap

2. Run the playbook:

   # ansible-playbook ~/unregister.yml

   Copy to Clipboard Toggle word wrap

Procedure

1. Create a playbook file, for example ~/ethernet-static-IP.yml, with the following content:

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

   Copy to Clipboard Toggle word wrap

2. Run the playbook:

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

   Copy to Clipboard Toggle word wrap

Procedure

1. Create a playbook file, for example ~/ethernet-static-IP.yml, with the following content:

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

   Copy to Clipboard Toggle word wrap

   The match parameter in this example defines that Ansible applies the play to devices that match PCI ID 0000:00:0[1-3].0, but not 0000:00:02.0. For further details about special modifiers and wild cards you can use, see the match parameter description in the /usr/share/ansible/roles/rhel-system-roles.network/README.md file.

2. Run the playbook:

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

   Copy to Clipboard Toggle word wrap

Procedure

1. Create a playbook file, for example ~/ethernet-dynamic-IP.yml, with the following content:

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

   Copy to Clipboard Toggle word wrap

2. Run the playbook:

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

   Copy to Clipboard Toggle word wrap

Procedure

1. Create a playbook file, for example ~/ethernet-dynamic-IP.yml, with the following content:

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

   Copy to Clipboard Toggle word wrap

   The match parameter in this example defines that Ansible applies the play to devices that match PCI ID 0000:00:0[1-3].0, but not 0000:00:02.0. For further details about special modifiers and wild cards you can use, see the match parameter description in the /usr/share/ansible/roles/rhel-system-roles.network/README.md file.

2. Run the playbook:

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

   Copy to Clipboard Toggle word wrap

Procedure

1. Create a playbook file, for example ~/vlan-ethernet.yml, with the following content:

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

   Copy to Clipboard Toggle word wrap

   The parent attribute in the VLAN profile configures the VLAN to operate on top of the enp1s0 device.

2. Run the playbook:

   # ansible-playbook ~/vlan-ethernet.yml

   Copy to Clipboard Toggle word wrap

Procedure

1. Create a playbook file, for example ~/bridge-ethernet.yml, with the following content:

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

   Copy to Clipboard Toggle word wrap

2. Run the playbook:

   # ansible-playbook ~/bridge-ethernet.yml

   Copy to Clipboard Toggle word wrap

Procedure

1. Create a playbook file, for example ~/bond-ethernet.yml, with the following content:

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

   Copy to Clipboard Toggle word wrap

2. Run the playbook:

   # ansible-playbook ~/bond-ethernet.yml

   Copy to Clipboard Toggle word wrap

Procedure

1. Create a playbook file, for example ~/IPoIB.yml, with the following content:

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

   Copy to Clipboard Toggle word wrap

   If you set a p_key parameter as in this example, do not set an interface_name parameter on the IPoIB device.

2. Run the playbook:

   # ansible-playbook ~/IPoIB.yml

   Copy to Clipboard Toggle word wrap

Verification

1. On the managed-node-01.example.com host, display the IP settings of the mlx4_ib0.8002 device:

   # 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

   Copy to Clipboard Toggle word wrap

2. Display the partition key (P_Key) of the mlx4_ib0.8002 device:

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

   Copy to Clipboard Toggle word wrap

3. Display the mode of the mlx4_ib0.8002 device:

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

   Copy to Clipboard Toggle word wrap

Procedure

1. Create a playbook file, for example ~/pbr.yml, with the following content:

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

   Copy to Clipboard Toggle word wrap

2. Run the playbook:

   # ansible-playbook ~/pbr.yml

   Copy to Clipboard Toggle word wrap

Verification

1. On a RHEL host in the internal workstation subnet:

   1. Install the traceroute package:

      # yum install traceroute

      Copy to Clipboard Toggle word wrap

   2. Use the traceroute utility to display the route to a host on the Internet:

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

      Copy to Clipboard Toggle word wrap

      The output of the command displays that the router sends packets over 192.0.2.1, which is the network of provider B.

2. On a RHEL host in the server subnet:

   1. Install the traceroute package:

      # yum install traceroute

      Copy to Clipboard Toggle word wrap

   2. Use the traceroute utility to display the route to a host on the Internet:

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

      Copy to Clipboard Toggle word wrap

      The output of the command displays that the router sends packets over 198.51.100.2, which is the network of provider A.

3. On the RHEL router that you configured using the RHEL System Role:

   1. Display the rule list:

      # 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

      Copy to Clipboard Toggle word wrap

      By default, RHEL contains rules for the tables local, main, and default.

   2. Display the routes in table 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

      Copy to Clipboard Toggle word wrap

   3. Display the interfaces and firewall zones:

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

      Copy to Clipboard Toggle word wrap

   4. Verify that the external zone has masquerading enabled:

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

      Copy to Clipboard Toggle word wrap

Procedure

1. Create a playbook file, for example ~/enable-802.1x.yml, with the following content:

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

   Copy to Clipboard Toggle word wrap

2. Run the playbook:

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

   Copy to Clipboard Toggle word wrap

Procedure

1. Create a playbook file, for example ~/ethernet-connection.yml, with the following content:

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

   Copy to Clipboard Toggle word wrap

2. Run the playbook:

   # ansible-playbook ~/ethernet-connection.yml

   Copy to Clipboard Toggle word wrap

Procedure

1. Create a playbook file, for example ~/add-static-routes.yml, with the following content:

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

   Copy to Clipboard Toggle word wrap

2. Run the playbook:

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

   Copy to Clipboard Toggle word wrap

Verification

1. On the managed nodes:

   1. Display the IPv4 routes:

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

      Copy to Clipboard Toggle word wrap

   2. Display the IPv6 routes:

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

      Copy to Clipboard Toggle word wrap

Procedure

1. Create a playbook file, for example ~/configure-ethernet-device-with-ethtool-features.yml, with the following content:

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

   Copy to Clipboard Toggle word wrap

2. Run the playbook:

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

   Copy to Clipboard Toggle word wrap