Summary of "VirtualBox Setup, Rocky Linux Installation & Linux Kernel Compilation Step-by-Step Guide"

Main Ideas / Concepts

• Goal: Solve a “lab problem” in a 3-part sequence:

  1. Part 1: Download and install VirtualBox (a Type 2 hypervisor).
  2. Part 2: Create a Rocky Linux 10 virtual machine in VirtualBox using the correct ISO for the CPU architecture, then install Rocky Linux and run specific terminal commands.
  3. Part 3: Add a new Linux kernel alongside the original Rocky Linux kernel, configure it, compile and install it, reboot into it, and run validation commands to prove the correct kernel was booted and built.

• Output requirement (critical): The presenter repeatedly emphasizes that the work must be proven with screenshots placed into an answer field.

  • A folder/template is mentioned (e.g., “Slab”).
  • It initially suggests three screenshots total (one per part).

• Hypervisor concept (Type 2):

  • Type 2 hypervisors run on top of a host operating system.
  • VirtualBox is used to install and run the guest OS inside the virtual machine.
  • Alternatives mentioned:
    • Windows: Visual/VirtualBox
    • Mac: UTM or Fusion/Workstation Pro (noting these are free after registration)
    • All are described as Type 2 hypervisors.

---

Methodology / Step-by-Step Instructions

Part 1 — Install VirtualBox and Submit Proof

Download VirtualBox

• Go to the official Oracle VirtualBox website → Downloads
• Choose the appropriate installer (Windows/Mac/Linux)

Install VirtualBox

• Use the standard installer flow (e.g., Next, Next, Next) while keeping defaults.

Screenshot requirement

• Take a screenshot showing the installed program/version.
  • Using Help → About is suggested to reveal the version number.

Place screenshot in submission area

• Paste/insert into the answer field for Assignment 1
• The presenter also mentions centering/formatting guidance (e.g., right-click “behind the text” and center).

---

Part 2 — Install Rocky Linux 10 in VirtualBox and Run 3 Commands

Prepare the Rocky Linux ISO

• Rocky Linux download sources are referenced:
  • Official Rocky Linux site
  • Alternative ISO stored on Google Drive
• Select the correct architecture and ISO type:
  • Intel x86 / older Intel Macs: choose x86 → Rocky Linux 10 → DVD ISO
  • Apple Silicon (M1/M2/etc.): choose ARM → DVD ISO

Create a new Virtual Machine in VirtualBox

• Machine → New
• Name the VM using a pattern tied to the student identity (example provided)
• Choose the VM folder
• Attach the Rocky Linux ISO:
  • auto-detect or select manually

Configure VM resources

• RAM: at least 1 GB (larger improves performance)
• CPU/Processors: 2–4
• Disk: around 100 GB (described as temporary project storage)

Fix input device / GUI startup

• In VirtualBox settings, adjust mouse/input device (the presenter notes an option like USB tablet worked; wireless input may cause issues).
• Start the VM with GUI/display.

Install Rocky Linux

• Language/Region: English → United States
• Installation destination: select the hard drive (check the box)
• Enable root account:
  • enable root and set a root password (shown as 0)
• Create a user:
  • Username: first name + last three digits of student ID (example given)
  • Password: shown as 0
  • Ensure the user is in the wheel group (subtitles show “wellgroup”)

Run the required terminal commands (3 commands)

• Log in to the created student account
• Open terminal and execute:
  1. yourname-mins (exact spelling unclear from subtitle errors; shown as a command to display distro/user info)
  2. groups
  3. date

Take and place the screenshot

• Take a screenshot showing the output of these commands.
• Place it in Assignment 2 screenshot, aligned with instructions/hints in the submission document.

---

Part 3 — Compile and Install a New Kernel, Then Prove Boot

Concept

• Add a new kernel version (the video references a target of around 6.12) alongside the original kernel shipped with Rocky Linux 10.
• The original is stated as kernel 6.12.

Create a working directory

• Create a directory in root (example shown conceptually as MyKernel, e.g., sudo mkdir mykernel ...).

Install build tools / compilers

• The presenter emphasizes needing internet connectivity.
• Run package installation commands to install kernel build dependencies/toolchain (exact package names are not perfectly captured in the subtitles).

Download kernel source

• Use wget to download the kernel tarball from kernel.org
  • Example size cited: ~229 MB
• Extract using tar (command shown conceptually with extraction flags and kernel name)

Copy the original kernel config

• Copy the original kernel config into the new build directory as .config
• The config is taken from a boot directory and reused for the build.

Configure the new kernel

• Use menu configuration:
  • sudo make menuconfig
• In General Setup → Version:
  • set a version string including student identifiers (student name/ID digits)
• Save and exit.

Optional feature reduction

• Run menu configuration again:
  • sudo make menuconfig (or equivalent described in subtitles)
• Disable selected options to reduce features/size (security-related and “kernel hacking” style options are discussed).

Compile the kernel

• Determine CPU core count:
  • a command pipeline described as reading core count (e.g., lscpu-style output)
• Compile using parallelism:
  • behavior described as make -j$(nproc)-style (subtitles also show an example with shorthand like “G24”)
• Take proof screenshots after compilation/prep steps.

Install the built kernel

Run:

• sudo make modules_install
• sudo make install

This installs the kernel and modules and updates bootloader entries. The presenter states it will be placed in the boot folder alongside the original kernel.

Reboot and boot into the new kernel

• sudo reboot
• At boot menu, select the newly added kernel entry (named using the student ID digits as configured earlier).

Validate you booted the compiled kernel

Run the commands presented near the end:

• uname -mnr (intent: show kernel identity via uname)
• cat /proc/cmdline (intent: show kernel boot command line/kernel info)
• Search the kernel .config file for the configured student marker:
  • locate/view the .config and search for a student name marker with wildcard (e.g., *)
• date

Final screenshot requirement (Part 3)

Take a final screenshot showing:

• kernel identity output
• boot/config evidence tied to the student-added marker
• date/time stamp

Place screenshot for Part 3

• Paste into the third/final submission section
• Add colored arrows/pointers to commands in the screenshot:
  • commands 2–5 indicated
  • last command is the date

---

Overall Lesson / Takeaway

This project demonstrates an end-to-end workflow:

1. Use virtualization to run an OS safely (Rocky Linux in VirtualBox).
2. Install dependencies and build software (kernel compilation).
3. Configure builds so results are uniquely attributable (student marker/version string).
4. Prove correctness using command outputs + screenshots, after booting into the newly compiled kernel.

---

Speakers / Sources Featured

Speaker(s)

• Unnamed presenter (speaks throughout; no specific name given in subtitles)

Sources Mentioned

• Oracle VirtualBox official website (VirtualBox download)
• Rocky Linux official website (Rocky ISO downloads)
• kernel.org (Linux kernel source download)
• Google Drive (presenter-hosted ISO backup)
• YouTube (suggested for learning Linux administration commands)
• WhatsApp / Email / Google Drive sharing (used to transfer a PDF/commands into the VM)
• Other virtualization tools mentioned (options only):
  • UTM
  • Fusion / Fusion Pro
  • Framework Workstation Pro (name appears distorted in subtitles)
  • VisualBox / VirtualBox (“VisualBox” likely a subtitle error; VirtualBox is used)

Category

Educational

---

Share this summary

Share on X/Twitter Share on Facebook Share on LinkedIn Share on Reddit Share on WhatsApp Share on Telegram

---

Is the summary off?

If you think the summary is inaccurate, you can reprocess it with the latest model.

Reprocess summary

Video