Build a Linux Admin Portfolio

Build an Ubuntu VM and document core Linux admin skills on GitHub.

Introduction

30 Second Summary

Reading tutorials can feel productive until you have to repeat the work without the instructions beside you. A portfolio turns that practice into evidence another person can inspect.

In this project, you will build an isolated Linux administration lab on a Windows 10 computer with Oracle VirtualBox and Ubuntu Server. You will turn terminal navigation, safe failure recovery, account permissions, server updates, and technical documentation into a public GitHub portfolio entry.

What You'll Build

Your finished lab boots into a real Ubuntu Server terminal while a public README shows the commands, recovery evidence, permissions, updates, and resume bullets you can demonstrate.

By the end of this project, you'll have:

  • An isolated Linux lab that boots into an Ubuntu Server terminal without changing files on your Windows host.
  • A repeatable administration workflow covering files, directories, safe failure recovery, user accounts, group membership, permissions, and server updates.
  • A public GitHub runbook that documents your environment, commands, designed failure, diagnosis, recovery, validation, demonstrated skills, and two honest resume bullets.
  • Secret Mission: Independently audit a file, predict the effect of octal permission mode 755, apply it, and explain the resulting access.

Are there any prerequisites?

You need a Windows 10 computer with an x86_64 processor, administrator access, hardware virtualization, internet access, at least 2 GB of spare RAM, and at least 15 GB of free disk space.

Windows 10 reached end of support on October 14, 2025, so Windows 11 or an applicable Extended Security Updates program provides a safer long-term host.

Before We Start

Before any hands-on work, this checkpoint connects your Linux practice to an entry-level role you want to pursue. That goal keeps each later task focused on portfolio evidence instead of disconnected tutorials.

Set Up Your Windows 10 Linux Lab

Your portfolio needs a safe place where you can practise administration without changing your Windows files. A virtual machine creates that boundary.

First, you'll check your Windows 10 host. Then you'll use Oracle VirtualBox 7.2.20 to run Ubuntu Server 24.04.5 LTS.

Your public GitHub repository will preserve the evidence from this lab.

In this step, get ready to:
  • Confirm that your Windows host can run an isolated virtual machine safely.
  • Install Oracle VirtualBox and build the Ubuntu Server VM.
  • Create a public GitHub repository for your evidence.
Check Windows host readiness

Hardware virtualization lets your processor run the Ubuntu guest inside an isolated VM. Windows reports the required Hyper-V capabilities through its system information command.

  • Press the Windows key to open Windows search.
  • Type Command Prompt.
  • Press Enter to open Command Prompt.
  • Check your host readiness by running this command:
Systeminfo.exe

What does this command check?

  • The Systeminfo.exe command prints information about your Windows host.
  • The Hyper-V requirements indicate whether the processor can support the VM.
  • A detected hypervisor message also confirms that the virtualization layer is active.
  • Scroll to the Hyper-V requirements near the bottom of the report.
  • Continue when every listed requirement shows Yes.
  • Continue when Windows reports that a hypervisor has been detected.
  • Follow your computer manufacturer's official UEFI instructions if any requirement shows No.

Keep the lab local

Windows 10 reached the end of standard support on October 14, 2025. Keep the host and VM away from direct exposure to the public internet.

Install Oracle VirtualBox and Ubuntu Server

Oracle VirtualBox provides the virtual hardware for your server. The Ubuntu ISO image supplies the operating system installer.

Why use a full virtual machine?

A full VM makes virtual hardware allocation visible. You also complete the operating system installation yourself.

WSL 2 manages those layers for you. Oracle VirtualBox gives this project a disposable server boundary that you control.

The version check below can report the required version, an older version, or a missing installation.

  • Return to the Command Prompt window from earlier.
  • Check the installed Oracle VirtualBox version by running this command:
"C:\Program Files\Oracle\VirtualBox\VBoxManage.exe" --version

What does this command do?

This command runs the Oracle VirtualBox management tool from its Windows installation folder. Its output identifies the installed version.

✔️ I see version 7.2.20

Your Oracle VirtualBox installation has the version required for this lab. Continue below to download the Ubuntu ISO.

ⓧ I see an older version

Windows may request administrator permission because Oracle VirtualBox is system-level software. This approval is expected during installation.

  • Close any running virtual machines before updating Oracle VirtualBox.
  • Download VirtualBox-7.2.20-175154-Win.exe from the Oracle VirtualBox 7.2.20 download page.
  • Double-click VirtualBox-7.2.20-175154-Win.exe in your Downloads folder.
  • Approve the Windows administrator request.
  • Complete the installation using the default features.
  • Return to the Command Prompt window from earlier.
  • Verify the updated version by running this command:
"C:\Program Files\Oracle\VirtualBox\VBoxManage.exe" --version

What should this confirm?

The command reads the version from the updated Oracle VirtualBox installation. The output should begin with 7.2.20.

ⓧ Command not found

This result means the expected Oracle VirtualBox installation is missing. Windows may request administrator permission during the installation.

  • Download VirtualBox-7.2.20-175154-Win.exe from the Oracle VirtualBox 7.2.20 download page.
  • Double-click VirtualBox-7.2.20-175154-Win.exe in your Downloads folder.
  • Approve the Windows administrator request.
  • Complete the installation using the default features.
  • Return to the Command Prompt window from earlier.
  • Verify the installation by running this command:
"C:\Program Files\Oracle\VirtualBox\VBoxManage.exe" --version

What should this confirm?

The command now reaches the installed Oracle VirtualBox management tool. The output should begin with 7.2.20.

Installer will not complete?

Confirm that you downloaded the exact Windows package named VirtualBox-7.2.20-175154-Win.exe. Use a Windows administrator account when the installer requests permission.

Check that no existing virtual machines are running before trying the installer again.

Help me troubleshoot the Oracle VirtualBox installation

You have the correct virtualization software in place. Next, you'll give it the Ubuntu installation media.

  • Download ubuntu-24.04.5-live-server-amd64.iso from the official Ubuntu release page.
  • Press the Windows key to open Windows search.
  • Type Oracle VirtualBox.
  • Press Enter to open Oracle VirtualBox Manager.
  • Click Home.
  • Click New.
  • Enter linux-admin-lab as the VM name.
  • Select ubuntu-24.04.5-live-server-amd64.iso in the ISO selector.

What is the ISO image?

An ISO image contains the files needed to install an operating system. Oracle VirtualBox presents this file to the VM as installation media.

  • Deselect Install OS Using Unattended Installation.
  • Set the VM memory to 2 GB.
  • Create a virtual disk with its size set to 15 GB.
  • Choose dynamically allocated storage for the virtual disk.
  • Complete the VM creation wizard.

You should now see linux-admin-lab in Oracle VirtualBox Manager. Its configuration shows 2 GB of memory and a 15 GB virtual disk.

The storage confirmation applies only to the new virtual disk. Your Windows files remain outside this VM.

  • Select linux-admin-lab in Oracle VirtualBox Manager.
  • Click Start.
  • Keep the installer defaults until you reach storage configuration.
  • Choose the entire virtual disk for the Ubuntu installation.
  • Confirm the proposed virtual-disk layout.
  • Enter your Ubuntu hostname as the hostname.
  • Enter your Ubuntu username as the username.
  • Set a strong password that you can retrieve safely.

What happens during installation?

Ubuntu writes the server operating system to the virtual disk. The progress screen may sit quietly for a few moments while files are installed.

The password stays inside the VM. Keep it out of screenshots and portfolio notes.

  • Select Done on the SSH screen.
  • Select Done on the snap screen.
  • Wait until the installer reports that installation is complete.
  • Restart the VM when the installer finishes.
  • Sign in as your Ubuntu username with the strong password you created.

That's the biggest setup task complete. Your Ubuntu Server VM now boots into a real Linux terminal.

VM will not reach the login prompt?

Confirm that the host-readiness report showed virtualization support. Check that linux-admin-lab still has the downloaded Ubuntu ISO attached.

Help me troubleshoot the Ubuntu VM startup

Create your public evidence repository

The VM gives you a place to practise. The repository gives another person a clear record of what you completed.

Choose the account path that matches what you have now.

✔️ I'm signed in to GitHub

Your GitHub account is ready. Continue below to create the portfolio repository.

ⓧ I need a GitHub account

  • Open the GitHub signup page in your browser.
  • Create your personal GitHub account.
  • Verify the email address associated with the account.
  • Sign in to GitHub after verification.

Review public evidence carefully

Anyone can read a public repository. Keep passwords, tokens, private hostnames, and personal information out of the README.

  • Select New repository from the GitHub web interface.
  • Enter linux-admin-foundation as the repository name.
  • Choose Public as the repository visibility.
  • Enable the option that creates a README.
  • Click Create repository.

Your browser should display the public linux-admin-foundation repository. The page should also render its new README.

  • Switch back to the running linux-admin-lab VM.
  • Sign in as your Ubuntu username if the terminal requests your credentials.

Before you run this check, pause to predict the directory and user you expect the terminal to report.

  • Verify the Ubuntu terminal session by running this command:
ls; pwd; whoami

What do these commands confirm?

  • The ls command lists the contents of your current directory.
  • The pwd command prints your current directory path.
  • The whoami command prints the account running the terminal session.

You should see a directory listing from ls. The pwd output should show the home directory for your Ubuntu account.

The whoami output should match your Ubuntu username.

  • Return to the browser tab showing linux-admin-foundation.
  • Confirm that the repository visibility is Public.
  • Confirm that the repository page displays its rendered README.

Terminal check looks different?

Confirm that you signed in to the Ubuntu terminal inside linux-admin-lab. The Windows Command Prompt produces different results.

Help me interpret my Ubuntu terminal output

Your isolated Linux lab is running and your evidence repository is public. Next, you'll build a filesystem workspace inside the VM.

Build a Filesystem Workspace

Your Ubuntu Server lab is running. Your public repository is ready for the evidence you create.

Administrators need to know their exact location before changing files. A verified filesystem workspace gives you a safe place to practice that skill.

In this step, get ready to:
  • Create three practice files in your Ubuntu home directory.
  • Move the practice files into my-folder.
  • Verify the workspace path plus its file metadata.
Create the practice files

A file can exist before it contains any text. Empty practice files give you safe objects for learning directory operations.

  • Create and verify the three practice files by running these commands:
touch my-first-file.txt my-second-file.txt my-third-file.txt
ls

What do these commands do?

  • The touch command creates the three empty practice files.
  • The ls command displays the names in your current directory.

Your first visible win is here: the terminal now lists my-first-file.txt, my-second-file.txt, and my-third-file.txt.

Don't see all three files?

  • Check each filename against the command above.
  • Run the command block again if one filename was mistyped.

Help me diagnose why one of my practice files is missing.

Organize the files in a directory

Directories group related files under one path. A wildcard lets one command select every file that matches *.txt.

  • Create my-folder plus move the matching files into it by running these commands:
mkdir my-folder
mv *.txt my-folder

How does the move work?

  • The mkdir command creates my-folder inside your home directory.
  • The mv command moves every matching .txt file into that directory.
  • Confirm the files left your home directory by running this command:
ls

What does this check prove?

The listing should show my-folder. The three .txt filenames should no longer appear in your home directory listing.

Files still in your home directory?

  • Confirm that my-folder appears in the current listing.
  • Check the earlier mv command for a mistyped folder name.

Help me fix a practice file that did not move into my-folder.

Inspect the completed workspace

A long listing adds each file's owner. It also exposes the group plus the permission string.

Before you run this check, predict the path plus the three filenames you expect to see.

  • Enter my-folder plus inspect the workspace by running these commands:
cd my-folder/
pwd
ls
ls -l

What does this verification show?

  • The cd command changes your current directory to my-folder.
  • The pwd command confirms that your path ends in /my-folder.
  • The ls command confirms that all three practice files are present.
  • The ls -l command adds ownership details plus permission information.
  • Read the pwd output to confirm the path ends in /my-folder.
  • Read the ls output to confirm the three practice filenames.
  • Read the ls -l output to identify each file's owner, group, plus permission string.

That is your first verified filesystem workspace. You can now show its location plus file metadata from the terminal.

Path or files look wrong?

  • Check that the directory change completed before the verification commands ran.
  • Compare the three filenames with the names you created earlier.
  • Return to your home directory if the path shows a different location.

Help me diagnose why my workspace path or file listing looks different.

Your workspace is organized and verified. Next, you'll practice responding to a safe filesystem problem.

Reproduce a Safe Filesystem Failure

Your three practice files now sit inside my-folder. The next skill is learning how Linux responds when a safe operation cannot proceed.

Safe administration depends on reading an error before choosing a more powerful command. This controlled failure gives you a real incident to diagnose without damaging the workspace.

In this step, get ready to:
  • Reproduce a protected-directory failure.
  • Confirm that the workspace remains intact.
  • Record the incident in your GitHub README.
Prepare the removal test

The rmdir command targets a directory from its parent location. Your home directory is the parent of my-folder.

  • Return to your home directory by running this command:
cd ~

What does this command do?

The ~ symbol represents your Ubuntu home directory. This places your terminal one level above my-folder so the removal command can target it.

Test the directory boundary

The rmdir command requests directory removal without traversing the directory's contents. This makes it a safe way to test whether the current workspace can be removed.

  • Before you run this, decide whether you expect my-folder to be removed while it still contains the three files.
  • Test the removal by running this command:
rmdir my-folder

The Failure Is Intentional

The terminal shows rmdir: failed to remove 'my-folder': Directory not empty.

Linux leaves the directory in place because it contains files. This is the safe failure you set out to reproduce.

Seeing a Different Result?

Confirm that your terminal is in the home directory. Check that you entered my-folder with the same spelling used earlier.

Avoid running a recursive removal command until you have inspected the current state.

Help me diagnose a different result.

Turn the failure into evidence

A complete incident record links the failed command to the unchanged system state. Your README captures that evidence for someone reviewing your work.

  • Before you check, decide where you expect my-folder to appear after the failed removal.
  • Confirm that the directory still exists by running this command:
ls -l

What Does This Listing Prove?

  • The ls -l command lists the items in your home directory with their details.
  • The my-folder row proves that the failed removal preserved the workspace.

Cannot See the Directory?

Check that the listing came from your home directory. Look for the exact name my-folder in the output.

Help me inspect the missing directory.

  • Switch back to the browser tab showing your public linux-admin-foundation repository.
  • Select the repository's README from the file list.
  • Select the pencil-shaped edit control in the upper-right corner of the README.
  • Add the incident draft beneath the existing README text by copying this record:
Failed command: `rmdir my-folder`.
Observed error: `rmdir: failed to remove 'my-folder': Directory not empty`.
Diagnosis: `~/my-folder` contains `my-first-file.txt`, `my-second-file.txt`, and `my-third-file.txt`.
Intended recovery: Confirm the contents are disposable, then remove the directory recursively with `rm -r my-folder` and verify removal.

What Makes This an Incident Record?

  • The failed command records the action that triggered the incident.
  • The observed error preserves the terminal's response.
  • The diagnosis connects the failure to the files inside my-folder.
  • The intended recovery records the next safe action for the recovery step.
  • Select Preview.
  • Check that the preview shows all four incident labels without passwords or personal information.
  • Select Commit changes....
  • Enter Document rmdir failure in the commit message field.
  • Select Commit changes.
  • Verify that the rendered README displays the failed command, observed error, diagnosis, and intended recovery.

Draft Missing From the README?

Return to edit mode if the preview omits the incident record. Confirm that the draft sits below the existing README text before committing again.

Help me find my missing README changes.

That is your first documented Linux incident. The command failed safely because the directory contained files.

You reproduced the failure without losing the workspace. Next, you will recover deliberately before applying account permissions.

Recover and Administer Accounts

The failed rmdir attempt proved that Linux protects a non-empty directory from accidental removal. The workspace still exists, so this step begins with a deliberate recovery.

A safe recovery starts with inspecting the contents before choosing a recursive removal command.

Next, you'll create a test user with group membership. You'll apply least-privilege permissions to its home directory.

In this step, get ready to:
  • Recover the disposable filesystem workspace safely.
  • Create a test account with group membership.
  • Apply private permissions to the test account's home directory.
Recover the practice workspace

Recursive removal tells Linux to delete a directory plus everything inside it. Your earlier incident record gives you a reason to verify those contents once more before deletion.

  • Inspect the disposable workspace in the Ubuntu Server terminal from earlier by running these commands:
cd my-folder/
ls
cd ~

What do these commands prove?

  • cd my-folder/ enters the workspace that survived the failed removal.
  • ls lets you compare the contents with your incident record.
  • cd ~ returns you to your home directory before the recovery command.

You should see my-first-file.txt, my-second-file.txt, and my-third-file.txt in the listing.

Your content check makes this permanent deletion safe for the disposable workspace.

  • Remove the confirmed workspace and list the remaining home-directory contents by running these commands:
rm -r my-folder
ls

Why is this recovery safe?

rm -r my-folder removes the directory tree you just inspected. The following ls checks whether the workspace remains.

The new listing should omit my-folder. This confirms that the recovery is complete.

Still see the workspace?

  • Check that your terminal prompt points to your home directory.
  • Check that my-folder uses the same spelling in the command and the listing.
  • Confirm that your signed-in account owns the practice directory if the command reports a permission problem.

Help me diagnose why the practice workspace was not removed.

  • Return to the linux-admin-foundation repository on GitHub.
  • Select the README from the repository file list.
  • Locate the incident record from the previous step.
  • Replace its diagnosis and intended recovery lines with this completed record:
Diagnosis: ~/my-folder contained the three disposable practice files.
Recovery completed: contents confirmed disposable, rm -r my-folder run, and removal verified with ls.

Why update the incident now?

The updated record turns a recovery plan into verified evidence. A reader can now follow the failure from diagnosis through resolution.

  • Click Preview to check the updated incident record.
  • Click Commit changes....
  • Enter Record filesystem recovery as the commit message.
  • Click Commit changes to save the update.

That closes the loop. Your incident record now shows the diagnosis plus a verified recovery.

Create the test user and group

A user account creates a separate identity with its own home directory. A group provides a shared access boundary for related accounts.

The user-creation command is interactive. It pauses for a password plus optional account details before returning to the terminal prompt.

  • Prepare a strong password for the test account.
  • Enter that password when the command requests it.
  • Leave optional account-detail fields blank.
  • Confirm the account details when requested.
  • Create the test user by running this command:
sudo adduser username

What does this command create?

sudo adduser username creates the local username account. It also creates /home/username as the account's home directory.

The interactive password prompts protect the new account. Password characters stay hidden while you type.

When the command returns to the terminal prompt, the test user and its home directory are ready.

User creation did not finish?

  • Enter the same password at both password prompts.
  • Use a password that meets the server's displayed requirements.
  • Confirm that your signed-in Ubuntu account can run administrative commands if permission is denied.

Help me complete the interactive user-creation process.

Group membership lets you grant shared access without giving every account ownership of the same files.

  • Create groupname and add username to it by running these commands:
sudo addgroup groupname
sudo adduser username groupname

How do these commands work together?

  • sudo addgroup groupname creates the local test group.
  • sudo adduser username groupname adds the test user to that group.

You'll see confirmation that groupname exists and username belongs to it.

Group membership failed?

  • Check that username matches the test account you created.
  • Check that groupname matches the group created by the first command.
  • Run the group-creation command again if the first command did not complete.

Help me diagnose why the test user was not added to the test group.

Apply private home permissions

Linux permissions divide access between the owner, the group, and everyone else. Octal mode 0750 defines one permission set for each class.

Before you run this, make a prediction about the access that 0750 gives to each permission class.

  • Apply the private mode and inspect the home directory by running these commands:
sudo chmod 0750 /home/username
ls -ld /home/username

How does 0750 map to the result?

  • The owner receives rwx access for reading, writing, and entering the directory.
  • The group receives r-x access for reading and entering the directory.
  • Everyone else receives --- with no access.
  • The complete permission field appears as drwxr-x--- because the first d identifies a directory.

You should see drwxr-x--- at the start of the listing. This confirms that mode 0750 is active.

You now have a verified private home directory for the test account.

Permission string not correct?

  • Check that the permission command uses 0750 with a zero at the beginning.
  • Confirm that the directory path is /home/username.
  • Check that the verification command includes -d so it reports the directory itself.

Help me compare my home-directory permissions with the expected mode.

  • Scroll the terminal until only the final permission command and its result are visible.

Your filesystem recovery is documented and your test account has verified access controls. Next up, you'll update the server and turn the completed lab into portfolio evidence.

Update the Server and Publish Evidence

Your Linux lab now has a recovered filesystem workspace. You also have a test account with verified private home-directory permissions.

The next goal is to maintain your Ubuntu Server system. You will also turn the work into public evidence on GitHub.

A maintained system shows responsible administration. A clear runbook lets another person trace every claim to evidence.

In this step, get ready to:
  • Refresh the Ubuntu package index.
  • Apply the available package upgrades.
  • Publish an evidence-based runbook on GitHub.
Complete server maintenance

APT uses a package index to identify available software versions. Refreshing that index gives the server current package information.

  • Refresh the package index by running this command:
sudo apt update

What does this command do?

The sudo apt update command downloads current package information from the configured Ubuntu archives. APT uses that information to identify available upgrades.

  • Review the package-index result shown in the terminal.

You should see the package-index refresh finish before the terminal returns to its prompt.

Package index not refreshing?

Check that the VM can access the internet. A network or archive connection problem can prevent the package information from downloading.

Help me diagnose the package-index problem.

Package upgrades can take several minutes while files download and install. The terminal may request your account password or ask you to approve the proposed changes.

  • Start reviewing the available upgrades by running this command:
sudo apt upgrade

What does this command do?

The sudo apt upgrade command presents the available package upgrades. It installs the proposed changes after you approve them.

  • Review the proposed package changes.
  • Confirm the upgrade when the terminal asks whether to continue.
  • Wait for the command to return to the prompt.

Good progress. Your package indexes are current after the reviewed upgrades have finished.

Upgrade not completing?

Confirm that the package-index refresh completed successfully. Check the VM network connection if package downloads stop.

Help me diagnose the interrupted upgrade.

Turn the lab into a runbook

Technical documentation turns terminal work into evidence another person can review. Your README connects each administration claim to a command or observed result.

Protect your public evidence

Publishing terminal evidence can feel risky because this repository is public. Remove passwords from every excerpt before you publish it.

Remove personal information from the evidence. Remove any other secret that could identify an account or provide access.

  • Return to the signed-in GitHub tab from earlier.
  • Select the linux-admin-foundation repository.
  • Select README.md.
  • Select the file editing control.

Plan Each README Section

  • Overview explains the lab's purpose. It names the entry-level role your portfolio supports.
  • Environment records Windows 10 as the host. It records Oracle VirtualBox 7.2.20 as the virtualization platform. It records Ubuntu Server 24.04.5 LTS as the guest. It identifies linux-admin-lab as the VM.
  • Commands Practiced groups the terminal commands by administration task.
  • Designed Failure records the failed rmdir my-folder command. It records the observed non-empty-directory error.
  • Diagnosis explains that ~/my-folder contained the three disposable practice files.
  • Recovery records the content check. It records rm -r my-folder as the recovery command. It records the final ls check.
  • Validation records the verified permission result drwxr-x---. It records the completed package maintenance.
  • Skills Demonstrated lists only skills supported by the evidence on the page.
  • Resume Bullets contains claims that match completed tasks.
  • Next Project names the administration project you plan to build next.
  • Restructure README.md around the ten sections above while preserving the incident draft from earlier.
  • Complete each section with evidence you personally observed.
  • Select Preview.

You should see all ten headings rendered as a structured runbook. The earlier failure record should now sit inside the relevant incident sections.

Missing README sections?

Compare the preview with the ten section names above. Add any missing heading before continuing.

Help me organize my Linux administration README.

Resume claims are strongest when every phrase can be traced to evidence on the same page. These two bullets describe only the work completed in this lab.

  • Add the two evidence-based resume bullets by using this text:
- Built and administered an Ubuntu Server 24.04.5 LTS virtual machine on Windows 10 with Oracle VirtualBox, practicing filesystem operations, account management, permissions, and package updates.
- Diagnosed a controlled non-empty-directory failure, recovered the workspace safely, and documented commands and validation results in a public GitHub runbook.

Why Are These Bullets Credible?

The first bullet matches the VM maintenance work plus the account and permission tasks. The second bullet matches the recorded failure plus the verified recovery.

Each claim points back to evidence elsewhere in the README. That traceability keeps the resume accurate.

  • Select Preview.

You should see two separate resume bullets in the rendered Resume Bullets section.

Resume bullets not rendering?

Place each bullet on its own line. Check the preview again before committing the file.

Help me fix the README bullet formatting.

Commit and verify the public README

A repository commit records a stable version of your runbook. A meaningful message explains why that version matters.

  • Select Commit changes....
  • Enter Document Linux administration lab evidence as the commit message.
  • Select Commit changes.

Your README changes are now recorded in the repository history.

Commit not saving?

Check that the commit message contains text. Confirm that you are still signed in to the GitHub account that owns the repository.

Help me diagnose the GitHub commit problem.

Before you check the public page, do you expect a reviewer to find visible evidence for every resume claim?

  • Return to the linux-admin-foundation repository page.
  • Confirm that the repository remains publicly accessible.
  • Review the rendered README.md.

You should see all ten named sections in the rendered public README. Each section should contain evidence from your lab.

The resume bullets should match tasks shown elsewhere on the page. No password or personal information should appear.

That closes the loop. Your server maintenance is now documented in a public runbook with evidence-based resume claims.

Secret mission

Audit and Correct File Permissions

Audit a file without copying the answer first. Predict the access granted by mode 755, apply it, verify the permission string, and publish the evidence in your portfolio README.

Clean Up Your Resources

Clean Up Your Resources

Your Ubuntu Server lab runs locally through Oracle VirtualBox. The GitHub Free repository has no recurring project charge.

Resources you used:

  • Local linux-admin-lab VM running Ubuntu Server 24.04.5 LTS.
  • Virtual disk attached to linux-admin-lab with 15 GB of dynamically allocated storage.
  • Local test user named username inside the Ubuntu VM.
  • Local test group named groupname inside the Ubuntu VM.
  • Permission audit file named numeric-test.sh inside the Ubuntu VM.
  • Public linux-admin-foundation repository containing your portfolio runbook.

Keep everything running

No action is needed. This option preserves the lab as the starting point for your next administration project.

  • Continue using the linux-admin-lab VM for future Linux practice.
  • Keep the linux-admin-foundation repository public as evidence of your completed work.
  • Retain numeric-test.sh as a reference for future permission exercises.

Pause - I'll come back to this later

Pausing stops the Ubuntu guest from using host memory. The virtual disk and public repository remain available.

  • Return to the signed-in Ubuntu terminal.
  • Shut down the Ubuntu guest.
  • Confirm that linux-admin-lab is powered off.
  • Close Oracle VirtualBox.
  • Leave the linux-admin-foundation repository unchanged for your next project.

Delete - I don't want to use this again

Deleting removes this project's VM and public portfolio repository. This option clears the lab when you no longer need its evidence.

Deletion Is Permanent

Deleting this work can feel drastic. The steps below target only linux-admin-lab and linux-admin-foundation.

  • Copy the README text into a local document if you want to keep its evidence.
  • Shut down the Ubuntu guest.
  • Return to Oracle VirtualBox Manager.
  • Select the linux-admin-lab VM.
  • Use the manager's removal control for the selected VM.
  • Choose the option that also deletes the VM files from disk.

Removing the VM files also removes its virtual disk. The deletion includes username, groupname, and numeric-test.sh.

  • Confirm that linux-admin-lab no longer appears in Oracle VirtualBox Manager.
  • Close Oracle VirtualBox.
  • Return to the public linux-admin-foundation repository on GitHub.
  • Open the repository settings page.
  • Use the repository deletion control to delete linux-admin-foundation.
  • Complete the repository confirmation prompt.
  • Return to your GitHub repositories list.
  • Confirm that linux-admin-foundation is no longer listed.

Nice Work!

Nice Work!

Mission complete! Your bootable Ubuntu Server lab now runs inside Oracle VirtualBox on Windows 10.

What you learned:

  • Built an isolated Linux lab. Configured a bootable virtual machine for safe administration practice. Managed files from the terminal.
  • Diagnosed a controlled filesystem failure. Recovered the disposable workspace safely. Created a test user and group. Applied private home-directory permissions.
  • Completed APT maintenance. Published a public GitHub runbook with verified evidence. Added accurate resume bullets supported by that evidence.
  • Secret Mission: Audited numeric-test.sh. Predicted the access granted by mode 755. Applied and explained executable permissions using before-and-after evidence.

Ready to quiz yourself?