절차

1. rhel-system-roles 패키지를 설치합니다.

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

   이 명령은 Ansible Core 를 종속성으로 설치합니다.

2. 나중에 플레이북을 관리하고 실행하는 데 사용하는 사용자를 생성합니다.

   [root@control-node]# useradd ansible

3. 새로 생성된 ansible 사용자로 전환합니다.

   [root@control-node]# su - ansible

   이 사용자로 나머지 절차를 수행합니다.

4. SSH 공개 및 개인 키 생성

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

   키 파일에 제안된 기본 위치를 사용합니다.

5. 선택 사항: 연결을 설정할 때마다 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은 지정된 인벤토리 파일에서 호스트를 관리합니다.
   • Ansible은 관리 노드에 SSH 연결을 설정할 때 remote_user 매개변수에 설정된 계정을 사용합니다.

   • Ansible은 sudo 유틸리티를 사용하여 관리 노드에서 root 사용자로 작업을 실행합니다.

     보안상의 이유로 관리 노드에서 sudo 를 구성하여 root 가 되도록 원격 사용자의 암호를 입력해야 합니다. ~/.ansible.cfg 에서 become_ask_pass=True 설정을 지정하면 Ansible에서 플레이북을 실행할 때 이 암호를 묻는 메시지를 표시합니다.

   ~/.ansible.cfg 파일의 설정은 우선 순위가 높으며 전역 /etc/ansible/ansible.cfg 파일의 설정을 재정의합니다.

7. ~/inventory 파일을 만듭니다. 예를 들어 다음은 3개의 호스트와 US 라는 호스트 그룹 1개가 있는 INI 형식의 인벤토리 파일입니다.

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

   제어 노드에서 호스트 이름을 확인할 수 있어야 합니다. DNS 서버가 특정 호스트 이름을 확인할 수 없는 경우 호스트 항목 옆에 있는 ansible_host 매개변수를 추가하여 IP 주소를 지정합니다.

검증

1. 관리형 노드 를 준비합니다.
2. 제어 노드에서 관리형 노드로의 액세스 확인

절차

1. 사용자를 생성합니다.

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

   나중에 제어 노드는 이 사용자를 사용하여 이 호스트에 대한 SSH 연결을 설정합니다.

2. 암호를 ansible 사용자로 설정합니다.

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

   Ansible에서 sudo 를 사용하여 작업을 root 사용자로 수행할 때 이 암호를 입력해야 합니다.

3. 관리 노드에 ansible 사용자의 SSH 공개 키를 설치합니다.

   1. 제어 노드에 ansible 사용자로 로그인하고 SSH 공개 키를 관리 노드에 복사합니다.

      [ansible@control-node]$ ssh-copy-id managed-node-01.example.com
      /usr/bin/ssh-copy-id: INFO: Source of key(s) to be installed: "/home/ansible/.ssh/id_rsa.pub"
      The authenticity of host 'managed-node-01.example.com (192.0.2.100)' can't be established.
      ECDSA key fingerprint is SHA256:9bZ33GJNODK3zbNhybokN/6Mq7hu3vpBXDrCxe7NAvo.
      Are you sure you want to continue connecting (yes/no/[fingerprint])? yes
      /usr/bin/ssh-copy-id: INFO: attempting to log in with the new key(s), to filter out any that are already installed
      /usr/bin/ssh-copy-id: INFO: 1 key(s) remain to be installed -- if you are prompted now it is to install the new keys
      ansible@managed-node-01.example.com's password: password
      
      Number of key(s) added: 1
      
      Now try logging into the machine, with:   "ssh 'managed-node-01.example.com'"
      and check to make sure that only the key(s) you wanted were added.

   2. 제어 노드에서 원격으로 명령을 실행하여 SSH 연결을 확인합니다.

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

4. ansible 사용자에 대한 sudo 구성을 생성합니다.

   1. visudo 명령을 사용하여 /etc/sudoers.d/ansible 파일을 생성하고 편집합니다.

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

      일반 편집기에서 visudo 를 사용하면 이 유틸리티에서 기본 온전성 검사를 제공하고 파일을 설치하기 전에 구문 분석 오류를 점검할 수 있습니다.

   2. 요구 사항을 충족하는 /etc/ sudoers.d/ansible 파일에서 sudoers 정책을 구성합니다. 예를 들면 다음과 같습니다.

      • ansible 사용자 암호를 입력한 후 이 호스트의 모든 사용자 및 그룹으로 모든 명령을 실행할 수 있는 권한을 ansible 사용자에게 부여하려면 다음을 사용합니다.

        ansible ALL=(ALL) ALL

      • ansible 사용자 암호를 입력하지 않고 이 호스트의 모든 사용자 및 그룹으로 모든 명령을 실행할 수 있는 권한을 ansible 사용자에게 부여하려면 다음을 사용합니다.

        ansible ALL=(ALL) NOPASSWD: ALL

   또는 보안 요구 사항과 일치하는 더 세분화된 정책을 구성합니다. sudoers 정책에 대한 자세한 내용은 sudoers(5) 매뉴얼 페이지를 참조하십시오.

절차

1. Ansible ping 모듈을 사용하여 모든 관리 호스트에서 명령을 실행할 수 있는지 확인합니다.

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

   하드 코딩된 모든 호스트 그룹에는 인벤토리 파일에 나열된 모든 호스트가 동적으로 포함됩니다.

2. Ansible command 모듈을 사용하여 관리 호스트에서 whoami 유틸리티를 실행합니다.

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

   명령이 root 를 반환하는 경우 관리 노드에 sudo 를 올바르게 구성하고 권한 에스컬레이션이 작동합니다.

절차

1. Ansible Engine 설치 제거:

   # dnf remove ansible

2. ansible-2-for-rhel-8-x86_64-rpms 리포지토리를 비활성화합니다.

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

3. RHEL 8 AppStream 리포지토리에서 사용할 수 있는 Ansible Core를 설치합니다.

   # dnf install ansible-core

1. 다음 명령을 실행합니다.

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

절차

1. ansible.cfg 구성 파일의 콘텐츠의 기본 소스로 Red Hat Automation Hub를 정의합니다. 컨텐츠의 기본 소스로 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.yml 파일을 생성합니다.

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

   여기서,

   • tlog_scope_sssd:

     • 일부는 일부 또는 none 이 아닌 특정 사용자와 그룹만 기록하려는 경우 도 있습니다.

   • tlog_users_sssd:

     • recordeduser 는 세션을 기록하려는 사용자를 지정합니다. 이 경우 사용자를 추가하지 않습니다. 사용자를 직접 설정해야 합니다.

2. 필요한 경우 플레이북 구문을 확인합니다.

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

3. 인벤토리 파일에서 플레이북을 실행합니다.

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

검증 단계

1. /etc/journal.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. SSSD 구성 드롭 파일이 생성된 폴더로 이동합니다.

   # cd /etc/sssd/conf.d

2. 파일 내용을 확인합니다.

   # cat sssd-session-recording.conf

절차

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에 대해 플레이북을 실행합니다.

   # 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 모듈은 시스템 인벤토리와 같은 원격 OOB(Out-Of-Band) 컨트롤러에 대한 정보를 검색합니다.
2. redfish_command: redfish_command 모듈은 로그 관리 및 사용자 관리와 같은 OOB(Out-Of-Band) 컨트롤러 작업, 시스템 재시작, 전원 켜기, 끄기와 같은 전원 작업을 수행합니다.
3. redfish_config: redfish_config 모듈은 OOB 구성 변경 또는 BIOS 설정과 같은 OOB 컨트롤러 작업을 수행합니다.

절차

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에 대해 플레이북을 실행합니다.

   # 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에 대해 플레이북을 실행합니다.

   # 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에 대해 플레이북을 실행합니다.

   # ansible-playbook playbook.yml

절차

1. 선택적으로 설명을 위해 인벤토리 파일을 검토합니다.

   #  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 플레이북이 실행되면 사용자 암호를 입력하라는 메시지가 표시됩니다. 사용자는 관리 호스트에 연결한 후 sudo 를 통해 root 로 자동 전환합니다.

3. kernel_settings 역할을 사용하는 Ansible 플레이북을 생성합니다.

   1. 새 YAML 파일을 생성하고 텍스트 편집기에서 엽니다. 예를 들면 다음과 같습니다.

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

      이 파일은 플레이북을 나타내며 일반적으로 인벤토리 파일에서 선택한 특정 관리 호스트에 대해 실행되는 플레이 라고도 하는 순서가 지정된 작업 목록을 포함합니다.

   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 키는 선택 사항입니다. 임의의 문자열을 플레이와 레이블로 연결하고 플레이의 기능을 식별합니다. 플레이의 hosts 키는 플레이가 실행되는 호스트를 지정합니다. 이 키의 값 또는 값은 관리 호스트의 개별 이름 또는 인벤토리 파일에 정의된 호스트 그룹으로 제공될 수 있습니다.

      vars 섹션은 선택한 커널 매개변수 이름과 값을 설정해야 하는 변수 목록을 나타냅니다.

      roles 키는 vars 섹션에 언급된 매개변수와 값을 구성하려는 시스템 역할을 지정합니다.

      참고

      필요에 맞게 플레이북에서 커널 매개변수 및 해당 값을 수정할 수 있습니다.

4. 선택적으로 플레이의 구문이 올바른지 확인합니다.

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

   이 예는 플레이북의 성공적인 확인을 보여줍니다.

5. 플레이북을 실행합니다.

   #  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이 플레이북을 실행하기 전에 암호를 입력하라는 메시지가 표시되고 관리 호스트의 사용자가 커널 매개 변수를 구성하는 데 필요한 root 으로 전환할 수 있습니다.

   recap 섹션은 모든 관리 호스트에 대해 플레이가 성공적으로 완료됨(failed=0)하고 4 커널 매개변수가 적용됨을 보여줍니다(changed=4).

6. 관리 호스트를 재시작하고 영향을 받는 커널 매개 변수를 확인하여 변경 사항이 적용되고 재부팅해도 지속되는지 확인합니다.

절차

1. 다음 콘텐츠를 사용하여 플레이북 파일(예: ~/ethernet-static-IP.yml )을 만듭니다.

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

2. 플레이북을 실행합니다.

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

절차

1. 다음 콘텐츠를 사용하여 플레이북 파일(예: ~/ethernet-static-IP.yml )을 만듭니다.

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

   이 예제의 match 매개 변수는 Ansible이 PCI ID 0000:00:0[1-3].0 과 일치하는 장치에 플레이를 적용하지만 0000:00:00 :02.0이 아닌 장치에 플레이를 적용하도록 정의합니다. 사용할 수 있는 특수 수정자 및 와일드카드에 대한 자세한 내용은 /usr/share/ansible/roles/rhel-system-roles.network/README.md 파일에서 일치하는 매개변수 설명을 참조하십시오.

2. 플레이북을 실행합니다.

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

절차

1. 다음 콘텐츠를 사용하여 플레이북 파일(예: ~/ethernet-dynamic-IP.yml )을 만듭니다.

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

2. 플레이북을 실행합니다.

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

절차

1. 다음 콘텐츠를 사용하여 플레이북 파일(예: ~/ethernet-dynamic-IP.yml )을 만듭니다.

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

   이 예제의 match 매개 변수는 Ansible이 PCI ID 0000:00:0[1-3].0 과 일치하는 장치에 플레이를 적용하지만 0000:00:00 :02.0이 아닌 장치에 플레이를 적용하도록 정의합니다. 사용할 수 있는 특수 수정자 및 와일드카드에 대한 자세한 내용은 /usr/share/ansible/roles/rhel-system-roles.network/README.md 파일에서 일치하는 매개변수 설명을 참조하십시오.

2. 플레이북을 실행합니다.

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

절차

1. 다음 내용과 함께 플레이북 파일(예: ~/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을 구성합니다.

2. 플레이북을 실행합니다.

   # ansible-playbook ~/vlan-ethernet.yml

절차

1. 다음 내용으로 플레이북 파일(예: ~/bridge-ethernet.yml )을 만듭니다.

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

2. 플레이북을 실행합니다.

   # ansible-playbook ~/bridge-ethernet.yml

절차

1. 다음 내용으로 플레이북 파일(예: ~/bond-ethernet.yml )을 만듭니다.

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

2. 플레이북을 실행합니다.

   # ansible-playbook ~/bond-ethernet.yml

절차

1. 다음 내용으로 플레이북 파일(예: ~/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. 플레이북을 실행합니다.

   # 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. 다음 콘텐츠를 사용하여 플레이북 파일(예: ~/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. 플레이북을 실행합니다.

   # ansible-playbook ~/pbr.yml

검증

1. 내부 워크스테이션 서브넷의 RHEL 호스트에서 다음을 수행합니다.

   1. traceroute 패키지를 설치합니다.

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

      명령의 출력은 라우터가 공급자 B의 네트워크인 192.0.2.1 을 통해 패킷을 전송함을 표시합니다.

2. 서버 서브넷의 RHEL 호스트에서 다음을 수행합니다.

   1. traceroute 패키지를 설치합니다.

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

      명령의 출력은 라우터가 공급자 A의 네트워크인 198.51.100.2 를 통해 패킷을 전송함을 표시합니다.

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에는 로컬, 기본 및 기본 테이블에 대한 규칙이 포함되어 있습니다.

   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. 외부 영역에 masquerading이 활성화되어 있는지 확인합니다.

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

절차

1. 다음 내용이 포함된 플레이북 파일(예: ~/enable-802.1x.yml )을 생성합니다.

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

2. 플레이북을 실행합니다.

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

절차

1. 다음 내용이 포함된 플레이북 파일(예: ~/enable-802.1x.yml )을 생성합니다.

   ---
   - name: Configure a wifi 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: 0400
   
       - 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"
   
       - block:
           - import_role:
               name: linux-system-roles.network
             vars:
               network_connections:
                 - name: Configure the Example-wifi profile
                   interface_name: wlp1s0
                   state: up
                   type: wireless
                   autoconnect: yes
                   ip:
                     dhcp4: true
                     auto6: true
                   wireless:
                     ssid: "Example-wifi"
                     key_mgmt: "wpa-eap"
                   ieee802_1x:
                     identity: "user_name"
                     eap: tls
                     private_key: "/etc/pki/tls/client.key"
                     private_key_password: "password"
                     private_key_password_flags: none
                     client_cert: "/etc/pki/tls/client.pem"
                     ca_cert: "/etc/pki/tls/cacert.pem"
                     domain_suffix_match: "example.com"

2. 플레이북을 실행합니다.

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

절차

1. 다음 콘텐츠를 사용하여 플레이북 파일(예: ~/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. 플레이북을 실행합니다.

   # ansible-playbook ~/ethernet-connection.yml

절차

1. 다음 콘텐츠를 사용하여 플레이북 파일(예: ~/add-static-routes.yml )을 만듭니다.

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

2. 플레이북을 실행합니다.

   # 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. 다음 콘텐츠를 사용하여 플레이북 파일(예: ~/configure-ethernet-device-with-ethtool-features.yml )을 생성합니다.

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

2. 플레이북을 실행합니다.

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

절차

1. 다음 콘텐츠를 사용하여 플레이북 파일(예: ~/configure-ethernet-device-with-ethtoolcoalesce-settings.yml )을 생성합니다.

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

2. 플레이북을 실행합니다.

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

절차

1. 다음과 같은 내용과 함께 플레이북 파일(예: ~/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. 플레이북을 실행합니다.

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

절차

1. 다음 콘텐츠를 사용하여 플레이북 파일(예: ~/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. 플레이북을 실행합니다.

   # ansible-playbook ~/port_forwarding.yml

절차

1. 다음 콘텐츠를 사용하여 플레이북 파일(예: ~/opening-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. 플레이북을 실행합니다.

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

절차

1. 다음 콘텐츠를 사용하여 플레이북 파일(예: ~/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. 플레이북을 실행합니다.

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

절차

1. 플레이북을 준비합니다. 처음부터 시작하거나 rhel-system-roles 패키지의 일부로 설치된 예제 플레이북을 수정할 수 있습니다.

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

2. 시나리오에 맞게 플레이북의 내용을 변경합니다. 예를 들어 다음 부분에서는 시스템이 selinux-local-1.pp SELinux 모듈을 설치하고 활성화합니다.

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

3. 변경 사항을 저장하고 텍스트 편집기를 종료합니다.

4. host1,host2 및 host3 시스템에서 플레이북을 실행합니다.

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

절차

1. 필요한 역할을 정의하는 플레이북을 생성합니다.

   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. 특정 인벤토리에서 플레이북을 실행합니다.

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

   다음과 같습니다.

   • inventory-file 은 인벤토리 파일입니다.
   • logging-playbook.yml 은 사용하는 플레이북입니다.

검증

1. /etc/journal.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 명령을 입력한 사용자의 사용자 이름이 포함됩니다(이 경우 루트 ).

절차

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]

   이 구성을 사용하면 오류 문자열이 포함된 모든 메시지가 /var/log/errors.log 에 기록되고 기타 모든 메시지는 /var/log/others.log 에 기록됩니다.

   error 속성 값을 필터링하려는 문자열로 교체할 수 있습니다.

   환경 설정에 따라 변수를 수정할 수 있습니다.

2. 선택 사항: 플레이북 구문을 확인합니다.

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

3. 인벤토리 파일에서 플레이북을 실행합니다.

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

검증

1. /etc/journal.conf 파일의 구문을 테스트합니다.

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

2. 시스템에서 오류 문자열이 포함된 메시지를 로그에 전송하는지 확인합니다.

   1. 테스트 메시지를 보냅니다.

      # logger error

   2. /var/log/errors.log 로그를 확인합니다. 예를 들면 다음과 같습니다.

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

      여기서 hostname 은 클라이언트 시스템의 호스트 이름입니다. 로그에는 logger 명령을 입력한 사용자의 사용자 이름이 포함됩니다(이 경우 루트 ).

절차

1. 필요한 역할을 정의하는 플레이북을 생성합니다.

   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 은 로깅 서버입니다.

      참고

      필요에 맞게 플레이북의 매개변수를 수정할 수 있습니다.

      주의

      로깅 솔루션은 서버 또는 클라이언트 시스템의 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. 인벤토리에서 플레이북을 실행합니다.

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

   다음과 같습니다.

   • inventory.ini 는 인벤토리 파일입니다.
   • logging-playbook.yml 은 사용자가 생성한 플레이북입니다.

검증

1. 클라이언트 및 서버 시스템에서 /etc/rsyslog.conf 파일의 구문을 테스트합니다.

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

2. 클라이언트 시스템이 서버에 메시지를 전송하는지 확인합니다.

   1. 클라이언트 시스템에서 테스트 메시지를 보냅니다.

      # logger test

   2. 서버 시스템에서 /var/log/messages 로그를 확인합니다. 예를 들면 다음과 같습니다.

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

      여기서 host2.example.com 은 클라이언트 시스템의 호스트 이름입니다. 로그에는 logger 명령을 입력한 사용자의 사용자 이름이 포함됩니다(이 경우 루트 ).

절차

1. sshd 시스템 역할에 대한 예제 플레이북을 복사합니다.

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

2. 텍스트 편집기를 사용하여 복사된 플레이북을 엽니다. 예를 들면 다음과 같습니다.

   # 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

   플레이북은 다음을 수행하도록 구성된 SSH 서버로 관리 노드를 구성합니다.

   • 암호 및 root 사용자 로그인이 비활성화되어 있습니다
   • 암호 및 root 사용자 로그인은 서브넷 192.0.2.0/24에서만 활성화됩니다.

   환경 설정에 따라 변수를 수정할 수 있습니다. 자세한 내용은 SSH Server 시스템 역할 변수를 참조하십시오.

3. 선택 사항: 플레이북 구문을 확인합니다.

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

4. 인벤토리 파일에서 플레이북을 실행합니다.

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

검증

1. SSH 서버에 로그인합니다.

   $ ssh user1@10.1.1.1

   다음과 같습니다.

   • user1 은 SSH 서버의 사용자입니다.
   • 10.1.1.1 은 SSH 서버의 IP 주소입니다.

2. SSH 서버에서 sshd_config 파일의 내용을 확인합니다.

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

3. 192.0.2.0/24 서브넷에서 root로 서버에 연결할 수 있는지 확인합니다.

   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

   이 플레이북은 다음 구성을 사용하여 관리 노드에서 root 사용자의 SSH 클라이언트 기본 설정을 구성합니다.

   • 압축이 활성화됩니다.
   • ControlMaster 멀티플렉싱이 auto 로 설정되어 있습니다.
   • example.com 호스트에 연결하는 예제 별칭은 user1 입니다.
   • 예제 호스트 별칭은 example.com 호스트에 대한 연결을 나타내는 user1 사용자 이름으로 생성됩니다.
   • X11 전달이 비활성화되어 있습니다.

   선택적으로 환경 설정에 따라 이러한 변수를 수정할 수 있습니다. 자세한 내용은 ssh 시스템 역할 변수를 참조하십시오.

2. 선택 사항: 플레이북 구문을 확인합니다.

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

3. 인벤토리 파일에서 플레이북을 실행합니다.

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

절차

1. sshd_config_file 변수의 구성 스니펫을 플레이북에 추가합니다.

   ---
   - hosts: all
     tasks:
     - name: <Configure sshd to accept some useful environment variables>
       include_role:
         name: rhel-system-roles.sshd
       vars:
         sshd_config_file: /etc/ssh/sshd_config.d/<42-my-application>.conf
         sshd:
           # Environment variables to accept
           AcceptEnv:
             LANG
             LS_COLORS
             EDITOR

   sshd_config_file 변수에서 sshd 시스템 역할이 구성 옵션을 쓰는 .conf 파일을 정의합니다.

   2자리 접두사를 사용합니다(예: 42- )를 사용하여 구성 파일이 적용되는 순서를 지정합니다.

   인벤토리에 플레이북을 적용하면 역할은 sshd_config_file 변수에서 정의한 파일에 다음 구성 옵션을 추가합니다.

   # Ansible managed
   #
   AcceptEnv LANG LS_COLORS EDITOR

절차

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:

   이 플레이북은 시스템 역할로 자동 생성되는 키와 사전 공유 키 인증을 사용하여 managed_node1-to-managed_node2 연결을 구성합니다.

2. 선택 사항: 다음 섹션을 호스트의 vpn_connections 목록에 추가하여 인벤토리 파일에 나열되지 않은 외부 호스트로의 연결을 구성합니다.

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

   이렇게 하면 managed_node1-to-external_node및 managed_node2- to-external_node 의 두 개의 추가 연결이 구성됩니다.

1. 선택 사항: vpn_connections 내의 추가 섹션을 사용하여 관리형 노드에 대해 여러 VPN 연결을 지정할 수 있습니다(예: 컨트롤 플레인 및 데이터 플레인).

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

2. 선택 사항: 환경 설정에 따라 변수를 수정할 수 있습니다. 자세한 내용은 /usr/share/doc/rhel-system-roles/vpn/README.md 파일을 참조하십시오.

3. 선택 사항: 플레이북 구문을 확인합니다.

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

4. 인벤토리 파일에서 플레이북을 실행합니다.

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

검증

1. 관리형 노드에서 연결이 성공적으로 로드되었는지 확인합니다.

   # ipsec status | grep connection.name

   connection.name을 이 노드의 연결 이름으로 교체합니다(예: managed_node1-to-managed_node2).

1. 관리형 노드에서 연결이 성공적으로 시작되었는지 확인합니다.

   # ipsec trafficstatus | grep connection.name

2. 선택 사항: 연결이 성공적으로 로드되지 않은 경우 다음 명령을 입력하여 연결을 수동으로 추가합니다. 이렇게 하면 연결 설정 실패 이유를 나타내는 더 구체적인 정보를 제공합니다.

   # ipsec auto --add connection.name

   참고

   연결을 로드하고 시작하는 동안 발생한 모든 오류는 로그에 보고되며, /var/log/pluto.log에서 확인할 수 있습니다. 이러한 로그는 구문 분석하기 어렵기 때문에 대신 표준 출력에서 로그 메시지를 가져오기 위해 수동으로 연결을 추가합니다.

절차

1. 다음 내용으로 새 playbook.yml 파일을 생성합니다.

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

2. 선택 사항: 환경 설정에 따라 변수를 수정할 수 있습니다. 자세한 내용은 /usr/share/doc/rhel-system-roles/vpn/README.md 파일을 참조하십시오.

3. 선택 사항: 플레이북 구문을 확인합니다.

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

4. 인벤토리 파일에서 플레이북을 실행합니다.

   # 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 System Role variables and facts 를 참조하십시오.

2. 선택 사항: 플레이북 구문을 확인합니다.

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

3. 인벤토리 파일에서 플레이북을 실행합니다.

   # ansible-playbook -i inventory_file playbook.yml

검증

1. 제어 노드에서 이름이 (예: verify_playbook.yml )인 다른 플레이북을 생성합니다.

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

   이 플레이북은 시스템의 구성을 변경하지 않으며, 관리형 노드에서 활성 정책만 보고합니다.

2. 동일한 인벤토리 파일에서 플레이북을 실행합니다.

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

   "crypto_policies_active": 변수는 관리 노드에서 정책을 활성 상태로 표시합니다.

절차

1. Tang 서버에 대한 설정이 포함된 플레이북을 준비합니다. 처음부터 시작하거나 /usr/share/ansible/roles/rhel-system-roles.nbde_server/examples/ 디렉터리에서 예제 플레이북 중 하나를 사용할 수 있습니다.

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

2. 선택한 텍스트 편집기에서 플레이북을 편집합니다. 예를 들면 다음과 같습니다.

   # vi my-tang-playbook.yml

3. 필수 매개 변수를 추가합니다. 다음 예제 Playbook은 Tang 서버와 키 교체를 배포합니다.

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

4. 완료된 플레이북을 적용합니다.

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

   여기서: * inventory-file 은 인벤토리 파일입니다. * logging-playbook.yml 은 사용하는 플레이북입니다.

절차

1. Clevis 클라이언트에 대한 설정이 포함된 플레이북을 준비합니다. 처음부터 시작하거나 /usr/share/ansible/roles/rhel-system-roles.nbde_client/examples/ 디렉터리에서 예제 플레이북 중 하나를 사용할 수 있습니다.

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

2. 선택한 텍스트 편집기에서 플레이북을 편집합니다. 예를 들면 다음과 같습니다.

   # vi my-clevis-playbook.yml

3. 필수 매개 변수를 추가합니다. 다음 예제 Playbook은 두 개 이상의 Tang 서버를 사용할 수 있는 경우 두 개 이상의 LUKS 암호화 볼륨을 자동으로 잠금 해제하도록 Clevis 클라이언트를 구성합니다.

   ---
   - 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. 완료된 플레이북을 적용합니다.

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

절차

1. 선택 사항: 인벤토리 파일(예: inventory.file )을 생성합니다.

   $ *touch inventory.file*

2. 인벤토리 파일을 열고 인증서를 요청할 호스트를 정의합니다. 예를 들면 다음과 같습니다.

   [webserver]
   server.idm.example.com

3. 플레이북 파일을 만듭니다(예: request-certificate.yml ):

   • 웹 서버와 같이 인증서를 요청할 호스트를 포함하도록 호스트를 설정합니다.

   • 다음을 포함하도록 certificate_requests 변수를 설정합니다.

     • name 매개변수를 mycert 와 같은 인증서의 원하는 이름으로 설정합니다.
     • dns 매개 변수를 인증서에 포함할 도메인(예: *.example.com )으로 설정합니다.
     • ca 매개 변수를 자체 서명 으로 설정합니다.

   • 역할에 rhel-system- roles.certificate 역할을 설정합니다.

     이 예제는 플레이북 파일입니다.

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

4. 파일을 저장합니다.

5. 플레이북을 실행합니다.

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

절차

1. 선택 사항: 인벤토리 파일(예: inventory.file )을 생성합니다.

   $ *touch inventory.file*

2. 인벤토리 파일을 열고 인증서를 요청할 호스트를 정의합니다. 예를 들면 다음과 같습니다.

   [webserver]
   server.idm.example.com

3. 플레이북 파일을 만듭니다(예: request-certificate.yml ):

   • 웹 서버와 같이 인증서를 요청할 호스트를 포함하도록 호스트를 설정합니다.

   • 다음을 포함하도록 certificate_requests 변수를 설정합니다.

     • name 매개변수를 mycert 와 같은 인증서의 원하는 이름으로 설정합니다.
     • dns 매개변수를 인증서에 포함할 도메인(예: www.example.com)으로 설정합니다.
     • principal 매개 변수를 설정하여 HTTP/www.example.com@EXAMPLE.COM 와 같은 Kerberos 주체를 지정합니다.
     • ca 매개변수를 ipa 로 설정합니다.

   • 역할에 rhel-system- roles.certificate 역할을 설정합니다.

     이 예제는 플레이북 파일입니다.

     ---
     - 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. 플레이북을 실행합니다.

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

절차

1. 선택 사항: 인벤토리 파일(예: inventory.file )을 생성합니다.

   $ *touch inventory.file*

2. 인벤토리 파일을 열고 인증서를 요청할 호스트를 정의합니다. 예를 들면 다음과 같습니다.

   [webserver]
   server.idm.example.com

3. 플레이북 파일을 만듭니다(예: request-certificate.yml ):

   • 웹 서버와 같이 인증서를 요청할 호스트를 포함하도록 호스트를 설정합니다.

   • 다음을 포함하도록 certificate_requests 변수를 설정합니다.

     • name 매개변수를 mycert 와 같은 인증서의 원하는 이름으로 설정합니다.
     • dns 매개변수를 인증서에 포함할 도메인(예: www.example.com)으로 설정합니다.
     • self-sign 과 같은 인증서를 발급하는 데 사용할 ca 매개변수를 CA로 설정합니다.
     • 이 인증서를 발행하거나 갱신하기 전에 실행할 명령에 run_before 매개 변수를 systemctl stop httpd.service 와 같이 설정합니다.
     • 이 인증서가 발행되거나 갱신된 후 실행할 명령에 run_after 매개 변수를 다음과 같이 설정합니다(예: systemctl start httpd.service ).

   • 역할에 rhel-system- roles.certificate 역할을 설정합니다.

     이 예제는 플레이북 파일입니다.

     ---
     - 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. 플레이북을 실행합니다.

   $ *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. 선택 사항: 플레이북 구문을 확인합니다.

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

3. 인벤토리 파일에서 플레이북을 실행합니다.

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

절차

1. 다음 콘텐츠를 사용하여 새 playbook.yml 파일을 생성합니다.

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

   주의

   장치 이름은 예를 들어 시스템에 새 디스크를 추가하는 경우와 같이 특정 상황에서 변경될 수 있습니다. 따라서 데이터 손실을 방지하려면 플레이북에서 특정 디스크 이름을 사용하지 마십시오.

2. 선택 사항: 플레이북 구문을 확인합니다.

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

3. 플레이북을 실행합니다.

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

절차

1. 다음 내용으로 새 playbook.yml 파일을 생성합니다.

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

   참고

   RAID를 사용하여 LVM 풀을 생성하려면 raid_level 매개변수를 사용하여 RAID 유형을 지정해야 합니다.

2. 선택 사항: 플레이북 구문을 확인합니다.

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

3. 인벤토리 파일에서 플레이북을 실행합니다.

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

절차

1. 다음 내용으로 새 playbook.yml 파일을 생성합니다.

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

2. 선택 사항: 플레이북 구문을 확인합니다.

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

3. 인벤토리 파일에서 플레이북을 실행합니다.

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

절차

1. 다음 내용으로 새 playbook.yml 파일을 생성합니다.

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

2. 선택 사항: 플레이북 구문을 확인합니다.

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

3. 인벤토리 파일에서 플레이북을 실행합니다.

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

절차

1. 다음 콘텐츠를 사용하여 playbook.yml 파일을 생성합니다.

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

   ptbtime1.ptb.de 는 공용 서버의 예입니다. 다른 공용 서버 또는 자체 서버를 사용하려는 경우도 있습니다.

2. 선택 사항: 플레이북 구문을 확인합니다.

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

3. 인벤토리 파일에서 플레이북을 실행합니다.

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

검증

1. 클라이언트 머신에서 테스트를 수행합니다.

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

2. 보고된 쿠키 수가 0보다 큰지 확인합니다.

절차

1. 인벤토리에 다음 콘텐츠를 추가하여 /etc/ansible/hosts Ansible 인벤토리에 localhost 를 구성합니다.

   localhost ansible_connection=local

2. 다음 콘텐츠를 사용하여 Ansible 플레이북을 생성합니다.

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

3. Ansible Playbook을 실행합니다.

   # ansible-playbook name_of_your_playbook.yml

   참고

   metrics_graph_service 부울이 value="yes"로 설정되어 있으므로 Grafana 는 데이터 소스로 pcp 를 추가하여 자동으로 설치되고 프로비저닝됩니다.

4. 시스템에서 수집되는 지표의 시각화를 보려면 Grafana 웹 UI 액세스에 설명된 대로 grafana 웹 인터페이스에 액세스합니다.

절차

1. 플레이북을 통해 모니터링할 머신의 이름 또는 IP를 대괄호로 묶은 식별 그룹 이름 아래에 /etc/ansible/hosts Ansible 인벤토리 파일에 추가합니다.

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

2. 다음 콘텐츠를 사용하여 Ansible 플레이북을 생성합니다.

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

3. Ansible Playbook을 실행합니다.

   # ansible-playbook name_of_your_playbook.yml -k

절차

1. 다음 콘텐츠를 사용하여 Ansible 플레이북을 생성합니다.

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

2. Ansible Playbook을 실행합니다.

   # ansible-playbook name_of_your_playbook.yml

   참고

   metrics_graph_service 부울 및 metrics_query_service 부울이 value="yes"로 설정되므로 grafana 는 자동으로 pcp 데이터 레코딩을 사용하여 redis 로 인덱싱된 데이터 소스로 추가되어 pcp 쿼리 언어를 사용하여 데이터를 쉽게 쿼리할 수 있습니다.

3. 시스템에서 중앙 집중적으로 수집하고 데이터를 쿼리하려면 Grafana 웹 UI에 액세스하는 데 설명된 대로 grafana 웹 인터페이스에 액세스합니다.

절차

1. 다음을 위한 인증을 설정하려는 Ansible 플레이북에 다음 변수를 포함합니다.

   ---
     vars:
       metrics_username: your_username
       metrics_password: your_password

2. Ansible Playbook을 실행합니다.

   # ansible-playbook name_of_your_playbook.yml

절차

1. 인벤토리에 다음 콘텐츠를 추가하여 /etc/ansible/hosts Ansible 인벤토리에 localhost 를 구성합니다.

   localhost ansible_connection=local

2. 다음 콘텐츠가 포함된 Ansible 플레이북을 생성합니다.

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

3. Ansible Playbook을 실행합니다.

   # ansible-playbook name_of_your_playbook.yml

절차

1. 다음 내용으로 새 playbook.yml 파일을 생성합니다.

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

   여기서,

   • tlog_scope_sssd:

     • 일부는 일부 또는 none 이 아닌 특정 사용자와 그룹만 기록하려는 경우 도 있습니다.

   • tlog_users_sssd:

     • recorded-user 는 세션을 기록할 사용자를 지정합니다. 이 경우 사용자를 추가하지 않습니다. 사용자를 직접 설정해야 합니다.

2. 필요한 경우 플레이북 구문을 확인합니다.

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

3. 인벤토리 파일에서 플레이북을 실행합니다.

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

1. SSSD 구성 드롭 파일이 생성된 폴더로 이동합니다.

   # cd /etc/sssd/conf.d

2. 파일 내용을 확인합니다.

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

절차

1. 다음 내용으로 새 playbook.yml 파일을 생성합니다.

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

   여기서,

   • tlog_scope_sssd:

     • all : 모든 사용자 및 그룹을 기록하도록 지정합니다.

   • tlog_exclude_users_sssd:

     • 사용자 이름: 세션 기록에서 제외하려는 사용자의 사용자 이름을 지정합니다.

   • tlog_exclude_groups_sssd:

     • admins 는 세션 레코딩에서 제외할 그룹을 지정합니다.

2. 필요한 경우 플레이북 구문을 확인합니다.

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

3. 인벤토리 파일에서 플레이북을 실행합니다.

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

1. SSSD 구성 드롭 파일이 생성된 폴더로 이동합니다.

   # cd /etc/sssd/conf.d

2. 파일 내용을 확인합니다.

   # cat sssd-session-recording.conf

절차

1. 사용자를 생성하고 이 사용자의 암호를 할당합니다.

   # useradd recorded-user
   # passwd recorded-user

2. 방금 만든 사용자로 시스템에 로그인합니다.

   # ssh recorded-user@localhost

3. 시스템이 yes 또는 no를 입력하여 인증할 것인지 묻는 메시지가 표시되면 "yes"를 입력합니다.

4. recorded-user의 암호를 삽입합니다.

   시스템은 기록되고 있는 세션에 대한 메시지를 표시합니다.

   ATTENTION! Your session is being recorded!

5. 세션 레코딩을 완료한 후 다음을 입력합니다.

   # exit

   시스템은 사용자가 로그아웃한 후 localhost와의 연결을 종료합니다.

1. 아래 명령을 실행하십시오.

   # journalctl -o verbose -r

2. tlog-rec 기록된 저널 항목의 MESSAGE 필드를 검색합니다.

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

절차

1. CLI 터미널에서 사용자 세션 레코딩을 재생합니다.

   # journalctl -o verbose -r

2. tlog 레코딩을 검색합니다.

   $ /tlog-rec

   다음과 같은 세부 정보를 볼 수 있습니다.

   • 사용자 세션 기록의 사용자 이름입니다.
   • out_txt 필드, 기록된 세션의 원시 출력 인코딩
   • 식별자 번호 TLOG_REC=ID_number
3. 식별자 번호 TLOG_REC=ID_number 를 복사합니다.

4. TLOG_REC=ID_number 를 사용하여 레코딩을 재생합니다.

   # tlog-play -r journal -M TLOG_REC=ID_number