### Run Engine Setup

Source: https://www.ovirt.org/documentation/data_warehouse_guide

Initiate the interactive installation process.

```bash
# engine-setup
```

--------------------------------

### Install Data Warehouse Setup

Source: https://www.ovirt.org/documentation/data_warehouse_guide/index.html

Commands to prepare and initiate the Data Warehouse installation.

```bash
# dnf upgrade --nobest
```

```bash
# dnf install ovirt-engine-dwh-setup
```

```bash
# engine-setup
```

--------------------------------

### Install Hosted Engine Setup Package

Source: https://www.ovirt.org/documentation/migrating_from_a_standalone_manager_to_a_self-hosted_engine

Installs the necessary setup package on Enterprise Linux hosts.

```bash
# dnf install ovirt-hosted-engine-setup
```

--------------------------------

### Install and Initialize PostgreSQL

Source: https://www.ovirt.org/documentation/installing_ovirt_as_a_standalone_manager_with_local_databases/index.html

Installs the PostgreSQL server and initializes the database instance.

```bash
# dnf install postgresql-server postgresql-contrib
```

--------------------------------

### Install Data Warehouse Setup Package

Source: https://www.ovirt.org/documentation/data_warehouse_guide

Install the ovirt-engine-dwh-setup package.

```bash
# dnf install ovirt-engine-dwh-setup
```

--------------------------------

### Install and Start Tmux

Source: https://www.ovirt.org/documentation/migrating_from_a_standalone_manager_to_a_self-hosted_engine

Installs and initializes tmux to maintain the deployment session during potential network interruptions.

```bash
# dnf -y install tmux
# tmux
```

--------------------------------

### Initialize PostgreSQL Database

Source: https://www.ovirt.org/documentation/installing_ovirt_as_a_standalone_manager_with_remote_databases

Install and start the PostgreSQL service on the remote database host.

```bash
# dnf install postgresql-server postgresql-contrib
```

```bash
# postgresql-setup --initdb
```

```bash
# systemctl enable postgresql
# systemctl start postgresql
```

--------------------------------

### Initialize and Start PostgreSQL

Source: https://www.ovirt.org/documentation/installing_ovirt_as_a_self-hosted_engine_using_the_command_line

Initializes the database and configures the service to start on boot.

```bash
# su - postgres -c 'initdb'
# systemctl enable postgresql
# systemctl start postgresql
```

--------------------------------

### Complete Kickstart Example

Source: https://www.ovirt.org/documentation/installing_ovirt_as_a_standalone_manager_with_remote_databases

A full example of a Kickstart file for deploying oVirt Node.

```text
liveimg --url=http://_FQDN_/tmp/usr/share/redhat-virtualization-host/image/redhat-virtualization-host-_version_number__version.squashfs.img
clearpart --all
autopart --type=thinp
rootpw --plaintext ovirt
timezone --utc America/Phoenix
zerombr
text

reboot

%post --erroronfail
nodectl init
%end
```

--------------------------------

### Start a virtual machine

Source: https://www.ovirt.org/documentation/doc-Python_SDK_Guide

Execute the start action on a virtual machine service.

```python
# Start the virtual machine:
vm_service.start()
```

--------------------------------

### PXE Boot Configuration for oVirt Node

Source: https://www.ovirt.org/documentation/installing_ovirt_as_a_standalone_manager_with_remote_databases/index.html

Example configuration for a PXE boot loader to initiate the oVirt Node installation.

```text
# Created for booting new hosts
#

DEFAULT rhvh

LABEL rhvh
KERNEL <%= @kernel %>
APPEND initrd=<%= @initrd %> inst.ks=<%= foreman_url("provision") %> inst.stage2=<%= @host.params["rhvh_image"] %> intel_iommu=on console=tty0 console=ttyS1,115200n8 ssh_pwauth=1 local_boot_trigger=<%= foreman_url("built") %>
IPAPPEND 2
```

--------------------------------

### Install Backup Tools

Source: https://www.ovirt.org/documentation/installing_ovirt_as_a_self-hosted_engine_using_the_command_line

Installs the engine-backup utility on the destination machine.

```bash
# dnf install ovirt-engine-tools-backup
```

--------------------------------

### Add Third-Party Repository Entry

Source: https://www.ovirt.org/documentation/installing_ovirt_as_a_standalone_manager_with_remote_databases

Example entry for a third-party repository file to enable package installation.

```ini
[third-party]
name=Third Party Repository
baseurl=http://example.com/repo
enabled=1
gpgcheck=0
```

--------------------------------

### Start a Virtual Machine

Source: https://www.ovirt.org/documentation/doc-Ruby_SDK_Guide/chap-Using_the_Software_Development_Kit.html

Executes the start action on a virtual machine service.

```ruby
vm_service.start
```

--------------------------------

### Start a Virtual Machine with Cloud-Init

Source: https://www.ovirt.org/documentation/doc-Ruby_SDK_Guide/chap-Using_the_Software_Development_Kit.html

Starts a virtual machine with the use_cloud_init parameter enabled.

```ruby
vm_service.start(use_cloud_init: true)
```

--------------------------------

### Boot oVirt Node Installation

Source: https://www.ovirt.org/documentation/installing_ovirt_as_a_standalone_manager_with_local_databases/index.html

Select the installation option from the boot menu.

```text
Install oVirt Node 4.5
```

--------------------------------

### Start a virtual machine with cloud-init

Source: https://www.ovirt.org/documentation/doc-Python_SDK_Guide

Start a virtual machine using cloud-init by setting the cloud_init parameter to True.

```python
# Start the virtual machine:
vm_service.start(cloud_init=True)
```

--------------------------------

### Add and Start a Virtual Machine

Source: https://www.ovirt.org/documentation/doc-Python_SDK_Guide

Initializes a virtual machine creation request and immediately triggers the start command.

```python
# Add the virtual machine:
vm = vms_service.add(
  ...
)

# Find the service that manages the virtual machine:
vm_service = vms_service.vm_service(vm.id)

# Start the virtual machine
vm_service.start()
```

--------------------------------

### Start Deployment Script

Source: https://www.ovirt.org/documentation/installing_ovirt_as_a_self-hosted_engine_using_the_command_line

Initiates the hosted engine deployment process.

```bash
# hosted-engine --deploy
```

--------------------------------

### Enable and Start PostgreSQL Service

Source: https://www.ovirt.org/documentation/installing_ovirt_as_a_standalone_manager_with_local_databases/index.html

Enable the PostgreSQL service to start on boot and initiate the service.

```bash
# systemctl enable postgresql
# systemctl start postgresql
```

--------------------------------

### Start a Virtual Machine

Source: https://www.ovirt.org/documentation/doc-Python_SDK_Guide

Initiates the start sequence for a virtual machine and polls the status until it reaches the UP state.

```python
import time
import ovirtsdk4 as sdk
import ovirtsdk4.types as types

connection = sdk.Connection(
    url='https://engine.example.com/ovirt-engine/api',
    username='admin@internal',
    password='password',
    ca_file='ca.pem',
)

# Get the reference to the "vms" service:
vms_service = connection.system_service().vms_service()

# Find the virtual machine:
vm = vms_service.list(search='name=vm1')[0]

# Locate the service that manages the virtual machine, as that is where
# the action methods are defined:
vm_service = vms_service.vm_service(vm.id)

# Call the "start" method of the service to start it:
vm_service.start()

# Wait until the virtual machine is up:
while True:
    time.sleep(5)
    vm = vm_service.get()
    if vm.status == types.VmStatus.UP:
        break

print("Started '%s'." % vm.name())

# Close the connection to the server:
connection.close()
```

--------------------------------

### Start a Virtual Machine with Cloud-Init

Source: https://www.ovirt.org/documentation/doc-Python_SDK_Guide

Locates a specific virtual machine and initiates a start command with cloud-init parameters for network and user configuration.

```python
vms_service = connection.system_service().vms_service()
vm = vms_service.list(search = 'name=vm1')[0]

# Find the service that manages the virtual machine:
vm_service = vms_service.vm_service(vm.id)

# Start the virtual machine enabling cloud-init and providing the
# password for the `root` user and the network configuration:
vm_service.start(
    use_cloud_init=True,
    vm=types.Vm(
        initialization=types.Initialization(
        user_name='root',
        root_password='password',
        host_name='MyHost.example.com',
        nic_configurations=[
            types.NicConfiguration(
                name='eth0',
                on_boot=True,
                boot_protocol=types.BootProtocol.STATIC,
                ip=types.Ip(
                    version=types.IpVersion.V4,
                    address='10.10.10.1',
                    netmask='255.255.255.0',
                    gateway='10.10.10.1'
                )
            )
        ]
    )
)
)

# Close the connection to the server:
connection.close()
```

--------------------------------

### Install Ruby SDK

Source: https://www.ovirt.org/documentation/doc-Ruby_SDK_Guide

Install the Ruby SDK using either dnf or the gem command.

```bash
# dnf install rubygem-ovirt-engine-sdk4
```

```bash
# gem install ovirt-engine-sdk
```

--------------------------------

### Update CDROM and Start VM

Source: https://www.ovirt.org/documentation/doc-Python_SDK_Guide

Demonstrates locating a VM, changing its CDROM image, and starting the VM with a specific boot device configuration.

```python
vms_service = connection.system_service().vms_service()

# Find the virtual machine:
vm = vms_service.list(search='name=vm1')[0]

# Locate the service that manages the virtual machine:
vm_service = vms_service.vm_service(vm.id)

# Locate the service that manages the CDROM devices of the virtual machine:
cdroms_service = vm_service.cdroms_service()

# Get the first CDROM:
cdrom = cdroms_service.list()[0]

# Locate the service that manages the CDROM device found in previous step:
cdrom_service = cdroms_service.cdrom_service(cdrom.id)

# Change the CD of the VM to 'windows_example.iso':
cdrom_service.update(
    cdrom=types.Cdrom(
        file=types.File(
            id='windows_example.iso'
        ),
    ),
    current=False,
)

# Call the "start" method of the service to start it:
vm_service.start(
    vm=types.Vm(
        os=types.OperatingSystem(
            boot=types.Boot(
                devices=[
                    types.BootDevice.CDROM,
                ]
            )
        ),
    )
)

# Wait until the virtual machine's status is "UP":
while True:
    time.sleep(5)
    vm = vm_service.get()
    if vm.status == types.VmStatus.UP:
        break

print("Started '%s'." % vm.name())

# Close the connection to the server:
connection.close()
```

--------------------------------

### Confirm Installation Settings

Source: https://www.ovirt.org/documentation/data_warehouse_guide

Final prompt to confirm the configured installation settings.

```text
Please confirm installation settings (OK, Cancel) [OK]:
```

--------------------------------

### Start a virtual machine using Ruby SDK

Source: https://www.ovirt.org/documentation/doc-Ruby_SDK_Guide/topics/Starting_a_virtual_machine.html

Locates a VM by name and triggers the start action, followed by a polling loop to verify the status reaches UP.

```ruby
# Get the reference to the "vms" service:
vms_service = connection.system_service.vms_service

# Find the virtual machine:
vm = vms_service.list(search: 'name=myvm')[0]

# Locate the service that manages the virtual machine, as that is where
# the action methods are defined:
vm_service = vms_service.vm_service(vm.id)

# Call the "start" method of the service to start it:
vm_service.start

# Wait until the virtual machine status is UP:
loop do
  sleep(5)
  vm = vm_service.get
  break if vm.status == OvirtSDK4::VmStatus::UP
end
```

--------------------------------

### Start a Newly Added Virtual Machine

Source: https://www.ovirt.org/documentation/doc-Ruby_SDK_Guide/chap-Using_the_Software_Development_Kit.html

Locates the service for a newly created virtual machine to perform subsequent actions like starting it.

```ruby
# Add the virtual machine:
vm = vms_service.add(
  ...
)

# Find the service that manages the virtual machine:
vm_service = vms_service.vm_service(vm.id)

# Start the virtual machine:
vm_service.start
```

--------------------------------

### Start a Virtual Machine with Custom Boot Order in Ruby

Source: https://www.ovirt.org/documentation/doc-Ruby_SDK_Guide/topics/Starting_a_virtual_machine_with_specific_boot_devices.html

Use this snippet to start a virtual machine by explicitly defining the boot device sequence. Ensure the virtual machine is retrieved via the system service before calling the start method.

```ruby
# Find the root of the tree of services:
system_service = connection.system_service

# Find the virtual machine:
vms_service = system_service.vms_service
vm = vms_service.list(search: 'name=myvm').first

# Find the service that manages the virtual machine:
vm_service = vms_service.vm_service(vm.id)

# Start the virtual machine explicitly indicating the boot devices and order:
vm_service.start(
  vm: {
    os: {
      boot: {
        devices: [
          OvirtSDK4::BootDevice::NETWORK,
          OvirtSDK4::BootDevice::CDROM
        ]
      }
    }
  }
)

# Wait until the virtual machine is up:
loop do
  sleep(5)
  vm = vm_service.get
  break if vm.status == OvirtSDK4::VmStatus::UP
end
```

--------------------------------

### Install NFS Utilities

Source: https://www.ovirt.org/documentation/migrating_from_a_standalone_manager_to_a_self-hosted_engine

Install the required NFS utilities package on the storage server.

```bash
# dnf install nfs-utils -y
```

--------------------------------

### Install Java SDK V4

Source: https://www.ovirt.org/documentation/doc-Java_SDK_Guide/topics/Downloading_the_Java_SDK.html

Command to install the Java SDK V4 package.

```bash
# dnf install java-ovirt-engine-sdk4
```

--------------------------------

### Install Ruby SDK via Gem

Source: https://www.ovirt.org/documentation/doc-Ruby_SDK_Guide/chap-Overview.html

Install the Ruby SDK using the Ruby gem command.

```bash
# gem install ovirt-engine-sdk
```

--------------------------------

### Install and Configure Data Warehouse

Source: https://www.ovirt.org/documentation/installing_ovirt_as_a_standalone_manager_with_remote_databases

Commands and prompts for installing and setting up the Data Warehouse service.

```bash
# dnf upgrade --nobest
```

```bash
# dnf install ovirt-engine-dwh-setup
```

```bash
# engine-setup
```

```text
Configure Data Warehouse on this host (Yes, No) [Yes]:
```

```text
Configure Grafana on this host (Yes, No) [Yes]:
```

```text
Host fully qualified DNS name of this server [_autodetected hostname_]:
```

```text
Setup can automatically configure the firewall on this system.
Note: automatic configuration of the firewall may overwrite current settings.
Do you want Setup to configure the firewall? (Yes, No) [Yes]:
```

--------------------------------

### Install and Configure NFS Utilities

Source: https://www.ovirt.org/documentation/installing_ovirt_as_a_standalone_manager_with_remote_databases

Commands to install NFS packages and verify enabled versions.

```bash
# dnf install nfs-utils -y
```

```bash
# cat /proc/fs/nfsd/versions
```

--------------------------------

### vm_service.start

Source: https://www.ovirt.org/documentation/doc-Ruby_SDK_Guide

Starts a virtual machine using its specific service instance.

```APIDOC
## vm_service.start

### Description
Initiates the start sequence for a virtual machine. The service must be located using the VM's ID first.

### Usage
```ruby
vm_service = vms_service.vm_service(vm.id)
vm_service.start
```
```

--------------------------------

### Emergency Mode Output Example

Source: https://www.ovirt.org/documentation/installing_ovirt_as_a_standalone_manager_with_remote_databases

Example output when a host fails to boot due to missing drivers.

```text
Warning: /dev/test/rhvh-4.4-20210202.0+1 does not exist
Warning: /dev/test/swap does not exist
Entering emergency mode. Exit the shell to continue.
```

--------------------------------

### Start a VM with Cloud-Init configuration

Source: https://www.ovirt.org/documentation/doc-Ruby_SDK_Guide/topics/Starting_a_virtual_machine_with_cloud-init.html

Uses the VmService to start a virtual machine while injecting custom Cloud-Init scripts, network settings, and root credentials.

```ruby
# Find the virtual machine:
vms_service = connection.system_service.vms_service
vm = vms_service.list(search: 'name=myvm')[0]

# Find the service that manages the virtual machine:
vm_service = vms_service.vm_service(vm.id)

# Create a cloud-init script to execute in the
# deployed virtual machine. The script must be correctly
# formatted and indented because it uses YAML.
my_script = "
write_files:
  - content: |
      Hello, world!
    path: /tmp/greeting.txt
    permissions: '0644'
"

# Start the virtual machine, enabling cloud-init and providing the
# password for the `root` user and the network configuration:
vm_service.start(
  use_cloud_init: true,
  vm: {
    initialization: {
      user_name: 'root',
      root_password: 'redhat123',
      host_name: 'myvm.example.com',
      nic_configurations: [
        {
          name: 'eth0',
          on_boot: true,
          boot_protocol: OvirtSDK4::BootProtocol::STATIC,
          ip: {
            version: OvirtSDK4::IpVersion::V4,
            address: '192.168.0.100',
            netmask: '255.255.255.0',
            gateway: '192.168.0.1'
          }
        }
      ],
      dns_servers: '192.168.0.1 192.168.0.2 192.168.0.3',
      dns_search: 'example.com',
      custom_script: my_script
    }
  }
)
```

--------------------------------

### Synchronize and Install Appliance

Source: https://www.ovirt.org/documentation/installing_ovirt_as_a_self-hosted_engine_using_the_command_line

Update system packages and manually install the engine appliance to facilitate the deployment process.

```bash
# dnf distro-sync --nobest
```

```bash
# dnf install ovirt-engine-appliance
```

--------------------------------

### Initiate Self-Hosted Engine Deployment

Source: https://www.ovirt.org/documentation/installing_ovirt_as_a_self-hosted_engine_using_the_command_line

Start the deployment process using the hosted-engine command.

```bash
hosted-engine --deploy --ansible-extra-vars=he_pause_host=true
```

--------------------------------

### Configure Engine on host

Source: https://www.ovirt.org/documentation/installing_ovirt_as_a_standalone_manager_with_remote_databases

Confirm the installation of the Engine on the current host.

```text
Configure Engine on this host (Yes, No) [Yes]:
```

--------------------------------

### Enable NFS Services

Source: https://www.ovirt.org/documentation/migrating_from_a_standalone_manager_to_a_self-hosted_engine

Enable the NFS server and rpcbind services to start on boot.

```bash
# systemctl enable nfs-server
# systemctl enable rpcbind
```

--------------------------------

### Configure Custom SSO Setup

Source: https://www.ovirt.org/documentation/installing_ovirt_as_a_standalone_manager_with_remote_databases

Path for the custom SSO configuration file.

```bash
# vi /etc/ovirt-engine/engine.conf.d/99-custom-sso-setup.conf
```

--------------------------------

### Start Hosted Engine VM

Source: https://www.ovirt.org/documentation/planning_and_prerequisites_guide/index.html

Powers on the Hosted Engine virtual machine.

```bash
# hosted-engine --vm-start
```

--------------------------------

### Interact with Boot Menu

Source: https://www.ovirt.org/documentation/installing_ovirt_as_a_standalone_manager_with_local_databases/index.html

Keyboard commands for interacting with the installation boot menu.

```text
Enter
```

```text
Tab
```

```text
Esc
```

--------------------------------

### Disable Engine Setup Configuration

Source: https://www.ovirt.org/documentation/installing_ovirt_as_a_self-hosted_engine_using_the_command_line

Modify the setup configuration file to disable the engine core and remove the FQDN setting.

```bash
# sed -i \
     -e 's;^\(OVESETUP_ENGINE_CORE/enable=bool\):True;\1:False;' \
     -e '/^OVESETUP_CONFIG/fqdn/d' \
     /etc/ovirt-engine-setup.conf.d/20-setup-ovirt-post.conf
```

--------------------------------

### Modify oVirt Engine Setup Configuration

Source: https://www.ovirt.org/documentation/installing_ovirt_as_a_self-hosted_engine_using_the_command_line

Update the setup configuration file to disable Data Warehouse and Grafana components.

```bash
# sed -i \
     -e 's;^\(OVESETUP_DWH_CORE/enable=bool\):True;\1:False;' \
     -e 's;^\(OVESETUP_DWH_CONFIG/remoteEngineConfigured=bool\):True;\1:False;' \
     /etc/ovirt-engine-setup.conf.d/20-setup-ovirt-post.conf

# sed -i \
     -e 's;^\(OVESETUP_GRAFANA_CORE/enable=bool\):True;\1:False;' \
     /etc/ovirt-engine-setup.conf.d/20-setup-ovirt-post.conf
```

--------------------------------

### Enable Required Repositories

Source: https://www.ovirt.org/documentation/doc-Ruby_SDK_Guide/chap-Overview.html

Enable the necessary RHEL 8 repositories before installing the SDK.

```bash
# subscription-manager repos \
    --enable=rhel-8-for-x86_64-baseos-rpms \
    --enable=rhel-8-for-x86_64-appstream-rpms \
    --enable=rhv-4.4-manager-for-rhel-8-x86_64-rpms
```

--------------------------------

### Configure Manual Partitioning in Kickstart

Source: https://www.ovirt.org/documentation/installing_ovirt_as_a_standalone_manager_with_remote_databases

Example Kickstart configuration for manual partitioning using LVM thin provisioning.

```bash
clearpart --all
part /boot --fstype xfs --size=1000 --ondisk=sda
part pv.01 --size=42000 --grow
volgroup HostVG pv.01 --reserved-percent=20
logvol swap --vgname=HostVG --name=swap --fstype=swap --recommended
logvol none --vgname=HostVG --name=HostPool --thinpool --size=40000 --grow
logvol / --vgname=HostVG --name=root --thin --fstype=ext4 --poolname=HostPool --fsoptions="defaults,discard" --size=6000 --grow
logvol /var --vgname=HostVG --name=var --thin --fstype=ext4 --poolname=HostPool
--fsoptions="defaults,discard" --size=15000
logvol /var/crash --vgname=HostVG --name=var_crash --thin --fstype=ext4 --poolname=HostPool --fsoptions="defaults,discard" --size=10000
logvol /var/log --vgname=HostVG --name=var_log --thin --fstype=ext4 --poolname=HostPool --fsoptions="defaults,discard" --size=8000
logvol /var/log/audit --vgname=HostVG --name=var_audit --thin --fstype=ext4 --poolname=HostPool --fsoptions="defaults,discard" --size=2000
logvol /home --vgname=HostVG --name=home --thin --fstype=ext4 --poolname=HostPool --fsoptions="defaults,discard" --size=1000
logvol /tmp --vgname=HostVG --name=tmp --thin --fstype=ext4 --poolname=HostPool --fsoptions="defaults,discard" --size=1000
```

--------------------------------

### Configure Firewall during Engine Setup

Source: https://www.ovirt.org/documentation/installing_ovirt_as_a_standalone_manager_with_remote_databases

Prompt for automatic firewall configuration via engine-setup.

```text
Setup can automatically configure the firewall on this system.
Note: automatic configuration of the firewall may overwrite current settings.
Do you want Setup to configure the firewall? (Yes, No) [Yes]:
```

--------------------------------

### Configure Firewalld

Source: https://www.ovirt.org/documentation/installing_ovirt_as_a_self-hosted_engine_using_the_command_line

Commands to unmask, start, and enable the firewalld service for the deployment.

```bash
# systemctl unmask firewalld
# systemctl start firewalld
```

```bash
# systemctl enable firewalld
```

--------------------------------

### Perform actions on a resource

Source: https://www.ovirt.org/documentation/doc-Java_SDK_Guide/chap-Using_the_Software_Development_Kit.html

Demonstrates starting a virtual machine using explicit action parameters or an inner method approach.

```Java
 VM vm = api.getVMs().get("test");
```

```Java
Action actionParam = new Action();
org.ovirt.engine.sdk.entities.VM vmParam = new org.ovirt.engine.sdk.entities.VM();
actionParam.setVm(vmParam);
```

```Java
Action res = vm.start(actionParam);
```

```Java
Action res = vm.start(new Action()
{
    {
        setVm(new org.ovirt.engine.sdk.entities.VM());
    }
});
```

--------------------------------

### Start a Virtual Machine with Overridden Parameters

Source: https://www.ovirt.org/documentation/doc-Python_SDK_Guide

Boots a virtual machine with specific configuration overrides, such as mounting an ISO or attaching a floppy disk.

```python
import time
import ovirtsdk4 as sdk
import ovirtsdk4.types as types

connection = sdk.Connection(
    url='https://engine.example.com/ovirt-engine/api',
    username='admin@internal',
    password='password',
    ca_file='ca.pem',
)
```

--------------------------------

### Clean up self-hosted engine configuration

Source: https://www.ovirt.org/documentation/installing_ovirt_as_a_self-hosted_engine_using_the_command_line

Run this command to de-configure the host and prepare for a fresh installation.

```bash
# /usr/sbin/ovirt-hosted-engine-cleanup
```

--------------------------------

### Engine Status Output Example

Source: https://www.ovirt.org/documentation/installing_ovirt_as_a_self-hosted_engine_using_the_command_line

Displays the expected output when the Engine virtual machine is running correctly.

```text
--== Host 1 status ==--

Status up-to-date              : True
Hostname                       : hypervisor.example.com
Host ID                        : 1
Engine status                  : {"health": "good", "vm": "up", "detail": "up"}
Score                          : 3400
stopped                        : False
Local maintenance              : False
crc32                          : 99e57eba
Host timestamp                 : 248542
```

--------------------------------

### Standard Hosted Engine Deployment

Source: https://www.ovirt.org/documentation/installing_ovirt_as_a_self-hosted_engine_using_the_command_line

Example Ansible playbook for a standard self-hosted engine deployment.

```yaml
---
- hosts: localhost
  connection: local
  become: true
  roles:
    - ovirt.ovirt.hosted_engine_setup
  vars:
    he_bridge_if: eth0
    he_fqdn: engine.example.com
    he_vm_mac_addr: "52:54:00:11:22:33"
    he_domain_type: nfs
    he_storage_domain_addr: "192.168.1.100"
    he_storage_domain_path: "/exports/hosted-engine"
    he_appliance_password: "{{ vault_appliance_password }}"
    he_admin_password: "{{ vault_admin_password }}"
```

--------------------------------

### Install Cockpit Dashboard

Source: https://www.ovirt.org/documentation/installing_ovirt_as_a_standalone_manager_with_remote_databases

Install the cockpit-ovirt-dashboard package.

```bash
# dnf install cockpit-ovirt-dashboard
```

--------------------------------

### Install sssd-ldap Package

Source: https://www.ovirt.org/documentation/installing_ovirt_as_a_standalone_manager_with_remote_databases

Command to install the sssd-ldap package using dnf.

```bash
# dnf install sssd-ldap
```

--------------------------------

### Reboot Engine Virtual Machine

Source: https://www.ovirt.org/documentation/installing_ovirt_as_a_self-hosted_engine_using_the_command_line

Manually shuts down and starts the engine virtual machine from a host node.

```bash
# hosted-engine --vm-shutdown
# hosted-engine --vm-start
```

--------------------------------

### Define Kickstart Post-Installation

Source: https://www.ovirt.org/documentation/installing_ovirt_as_a_standalone_manager_with_remote_databases

Required post-installation command for oVirt Node initialization.

```text
%post
nodectl init
%end
```

--------------------------------

### Get Active Firewall Zones

Source: https://www.ovirt.org/documentation/installing_ovirt_as_a_self-hosted_engine_using_the_command_line

List the active firewall zones to ensure the management interface is correctly configured.

```bash
# firewall-cmd --get-active-zones
```

--------------------------------

### Resetting the virt module on Enterprise Linux

Source: https://www.ovirt.org/documentation/installing_ovirt_as_a_self-hosted_engine_using_the_command_line

Reset the virt module before proceeding with the engine appliance installation.

```bash
# dnf module reset virt
```

--------------------------------

### Install oVirt Engine package

Source: https://www.ovirt.org/documentation/installing_ovirt_as_a_standalone_manager_with_remote_databases

Install the core oVirt Engine package and its dependencies.

```bash
# dnf install ovirt-engine
```

--------------------------------

### Append Kickstart to PXE Boot

Source: https://www.ovirt.org/documentation/installing_ovirt_as_a_standalone_manager_with_remote_databases

Example of adding the Kickstart file location to the PXE server boot configuration.

```text
APPEND initrd=/var/tftpboot/pxelinux/initrd.img inst.stage2=_URL/to/oVirt Node-ISO_ inst.ks=_URL/to/oVirt Node-ks_.cfg
```

--------------------------------

### Update setup packages

Source: https://www.ovirt.org/documentation/migrating_from_a_standalone_manager_to_a_self-hosted_engine

Update the oVirt setup packages before running the engine-setup script.

```bash
# dnf update ovirt\*setup\*
```

--------------------------------

### Install Driver RPM

Source: https://www.ovirt.org/documentation/installing_ovirt_as_a_standalone_manager_with_remote_databases

Installs the driver package using dnf or rpm if no internet connection is available.

```bash
# dnf install /root/kmod-3w-9xxx-2.26.02.014-5.el8_3.elrepo.x86_64.rpm
```

```bash
# rpm -ivh /root/kmod-3w-9xxx-2.26.02.014-5.el8_3.elrepo.x86_64.rpm
```

--------------------------------

### Install SDK Dependencies on RHEL

Source: https://www.ovirt.org/documentation/doc-Ruby_SDK_Guide/chap-Overview.html

Install required system dependencies for the Ruby SDK on RHEL-based systems.

```bash
# dnf install gcc libcurl-devel libxml2-devel ruby-devel
```

--------------------------------

### Create a Virtual Machine

Source: https://www.ovirt.org/documentation/doc-Python_SDK_Guide

Initializes a connection to the system service and adds a new virtual machine with specified memory, cluster, template, and boot device settings.

```python
vms_service = connection.system_service().vms_service()

vms_service.add(
    types.Vm(
        name='vm1',
        memory = 512*1024*1024
        cluster=types.Cluster(
            name='Default',
        ),
        template=types.Template(
            name='Blank',
        ),
        os=types.OperatingSystem(boot=types.Boot(devices=[types.BootDevice.HD)]
    ),
)

print("Virtual machine '%s' added." % vm.name)

connection.close()
```