Linux

Cara Membuat Custom ISO Ubuntu Server 26.04 dengan Autoinstall di Windows 10

November 10, 2026 · 20 menit baca · Walid Umar

Ubuntu Server 26.04 TKJ Praktikum Edition – Unattended Installation

Instalasi sistem operasi server merupakan salah satu kompetensi penting dalam pembelajaran Teknik Komputer dan Jaringan (TKJ). Dalam kegiatan praktikum, proses instalasi Ubuntu Server sering dilakukan berulang kali pada komputer fisik maupun virtual machine.

Jika setiap instalasi dilakukan secara manual, administrator atau peserta didik harus mengatur hostname, akun pengguna, jaringan, partisi disk, SSH Server, dan paket aplikasi satu per satu.

Proses tersebut dapat disederhanakan menggunakan fitur Ubuntu Autoinstall. Dengan menyiapkan konfigurasi instalasi terlebih dahulu, Ubuntu Server dapat dipasang secara otomatis tanpa harus mengisi seluruh tahapan konfigurasi secara manual.

Pada tutorial ini kita akan membuat custom ISO bernama:

Ubuntu Server 26.04 TKJ Praktikum Edition

Custom ISO ini dirancang untuk kebutuhan praktikum Teknik Komputer dan Jaringan dengan beberapa fitur:

Instalasi Ubuntu Server 26.04 AMD64 secara otomatis.
Hostname ubuntu-server-praktikum.
Username tkj.
Konfigurasi jaringan menggunakan DHCP.
SSH Server aktif setelah instalasi.
Partisi disk menggunakan GPT.
Partisi EFI 1 GB dan root menggunakan ext4.
Instalasi sejumlah utilitas administrasi sistem dan jaringan.
Banner informasi server yang muncul setelah login.
Informasi hostname, kernel, CPU, RAM, kapasitas disk, dan alamat IP.

Seluruh proses pembuatan ISO dilakukan menggunakan Windows 10, PowerShell, dan xorriso.

1. Gambaran Proses Pembuatan

Secara umum, proses pembuatan custom ISO terdiri dari beberapa tahapan:

Menyiapkan ISO asli Ubuntu Server 26.04.
Mengunduh dan menyiapkan xorriso untuk Windows.
Membuat struktur direktori proyek.
Membuat password hash untuk Autoinstall.
Menyiapkan konfigurasi autoinstall.yaml.
Membuat script banner informasi server.
Membuat script PowerShell build-ubuntu.ps1.
Mengekstrak konfigurasi GRUB dari ISO asli.
Memodifikasi parameter boot GRUB agar mengaktifkan Autoinstall.
Memasukkan file konfigurasi ke dalam ISO.
Membangun ulang ISO menggunakan xorriso.
Memvalidasi struktur boot dan integritas ISO.
Menguji instalasi menggunakan VMware.

Alur kerjanya:

ISO Ubuntu Server 26.04
          |
          v
Persiapan direktori proyek
          |
          v
Persiapan autoinstall.yaml
          |
          v
Persiapan tkj-banner.sh
          |
          v
Pembuatan build-ubuntu.ps1
          |
          v
Ekstraksi konfigurasi GRUB
          |
          v
Modifikasi parameter Autoinstall
          |
          v
Penambahan file konfigurasi
          |
          v
     Xorriso Rebuild
          |
          v
  Custom ISO Ubuntu Server
          |
          v
    Validasi dan Testing
          |
          v
 Ubuntu Server TKJ Praktikum

2. Persiapan Peralatan dan Bahan

Sebelum memulai, siapkan beberapa kebutuhan berikut.

2.1. Sistem operasi komputer

Komputer yang digunakan untuk membuat ISO:

Windows 10 64-bit.
Windows PowerShell 5.1 atau lebih baru.
Ruang penyimpanan yang mencukupi.
Koneksi internet untuk mengunduh ISO dan tools.

Disarankan menyediakan ruang kosong beberapa gigabyte karena proses modifikasi dan rebuild ISO membutuhkan ruang kerja tambahan.

2.2. Download ISO Ubuntu Server 26.04

Unduh ISO Ubuntu Server 26.04 AMD64 dari halaman resmi Ubuntu:

https://ubuntu.com/download/server

Gunakan image instalasi:

ubuntu-26.04-live-server-amd64.iso

Simpan ISO ke direktori:

D:\UBUNTU-AUTOINSTALL\ISO\

Pastikan file ISO sudah selesai diunduh dan dapat dibaca.

2.3. Download xorriso untuk Windows

xorriso merupakan aplikasi command-line untuk membuat, membaca, memodifikasi, dan membangun ulang image ISO.

Dalam proyek ini digunakan xorriso versi 1.5.2 prebuilt untuk Windows.

Repository GitHub:

https://github.com/PeyTy/xorriso-exe-for-windows

Download langsung:

https://github.com/PeyTy/xorriso-exe-for-windows/archive/refs/heads/master.zip

Langkah download:

Buka repository GitHub tersebut.
Klik tombol Code.
Pilih Download ZIP.
Tunggu proses download selesai.
Ekstrak file ZIP.
Cari file xorriso.exe.

Nama arsip:

xorriso-exe-for-windows-master.zip

Salin folder hasil ekstraksi ke:

D:\UBUNTU-AUTOINSTALL\TOOLS\

Contoh struktur:

TOOLS\
└── xorriso-exe-for-windows-master\
    ├── xorriso.exe
    ├── DLL pendukung
    └── file lainnya

Pertahankan seluruh file bawaan paket. Jangan hanya memindahkan xorriso.exe apabila terdapat DLL pendukung di dalam folder tersebut.

Catatan: paket Windows ini merupakan prebuilt pihak ketiga. Versi 1.5.2 digunakan dalam proyek ini karena telah berhasil menjalankan proses rebuild ISO pada lingkungan pengujian. Jika terjadi kegagalan saat replay boot image, periksa kompatibilitas versi xorriso dan pertimbangkan menggunakan versi yang lebih baru.

2.4. Memeriksa xorriso

Buka PowerShell, kemudian jalankan:

$Xorriso = "D:\UBUNTU-AUTOINSTALL\TOOLS\xorriso-exe-for-windows-master\xorriso.exe"

& $Xorriso -version

Contoh hasil:

GNU xorriso 1.5.2

Jika informasi versi muncul, xorriso sudah dapat dijalankan.

Dokumentasi resmi:

https://www.gnu.org/software/xorriso

3. Membuat Struktur Direktori Proyek

Agar seluruh file proyek tersusun rapi, buat direktori utama:

D:\UBUNTU-AUTOINSTALL

Kemudian buat struktur berikut:

D:\UBUNTU-AUTOINSTALL\
│
├── ISO\
│   └── ubuntu-26.04-live-server-amd64.iso
│
├── TOOLS\
│   └── xorriso-exe-for-windows-master\
│       ├── xorriso.exe
│       └── file pendukung lainnya
│
├── CONFIG\
│   ├── autoinstall.yaml
│   └── tkj-banner.sh
│
├── WORK\
│
├── OUTPUT\
│
└── build-ubuntu.ps1

Direktori tersebut dapat dibuat langsung menggunakan PowerShell:

$Root = "D:\UBUNTU-AUTOINSTALL"

$Folders = @(
    "ISO",
    "TOOLS",
    "CONFIG",
    "WORK",
    "OUTPUT"
)

foreach ($Folder in $Folders) {
    New-Item `
        -Path "$Root\$Folder" `
        -ItemType Directory `
        -Force | Out-Null
}

Salin ISO Ubuntu Server yang sudah diunduh ke folder ISO.

Pastikan lokasi file sesuai:

D:\UBUNTU-AUTOINSTALL\ISO\ubuntu-26.04-live-server-amd64.iso

4. Memahami Ubuntu Autoinstall

Ubuntu Autoinstall adalah mekanisme instalasi otomatis yang digunakan Ubuntu Server Installer.

Dengan konfigurasi YAML, kita dapat menentukan berbagai parameter instalasi seperti:

Identitas komputer.
Akun pengguna.
Password terenkripsi.
Konfigurasi jaringan.
Partisi disk.
Paket aplikasi.
SSH Server.
Perintah tambahan setelah instalasi.

Autoinstall berbeda dengan Debian Preseed. Autoinstall menggunakan format YAML dan diproses oleh Ubuntu Server Installer, sedangkan Preseed merupakan mekanisme otomatisasi installer Debian Installer.

Dokumentasi resmi:

https://canonical-subiquity.readthedocs-hosted.com/en/latest

4.1. Membuat password terenkripsi

Ubuntu Autoinstall membutuhkan password dalam bentuk hash, bukan password plaintext.

Untuk membuat hash di Windows, instal OpenSSL:

winget install OpenSSL

Setelah instalasi, jalankan executable OpenSSL menggunakan lokasi berikut:

& "C:\Program Files\OpenSSL-Win64\bin\openssl.exe" version

Buat hash password menggunakan algoritma SHA-512:

& "C:\Program Files\OpenSSL-Win64\bin\openssl.exe" passwd -6

Masukkan password ketika diminta oleh OpenSSL.

Contoh format hasil:

$6$randomsalt$hasilhashyangpanjang...

Salin hasil hash tersebut untuk digunakan pada konfigurasi autoinstall.yaml.

Jangan menggunakan hash contoh dari tutorial sebagai password milik sendiri. Buat hash baru dan jangan membagikan password maupun hash aktual ke publik.

4.2. Membuat file autoinstall.yaml

Buka folder:

D:\UBUNTU-AUTOINSTALL\CONFIG

Buat file:

autoinstall.yaml

autoinstall Unduh

Isi dengan konfigurasi berikut:

#cloud-config
autoinstall:
  version: 1

  locale: en_US.UTF-8

  timezone: Asia/Makassar

  keyboard:
    layout: us

  identity:
    realname: "TKJ Praktikum"
    hostname: ubuntu-server-praktikum
    username: tkj
    password: '$6$GANTI_DENGAN_HASH_PASSWORD'

    groups:
      - adm
      - sudo

  network:
    version: 2
    ethernets:
      all-ethernet:
        match:
          name: "e*"
        dhcp4: true
        dhcp6: false
        optional: true

  ssh:
    install-server: true
    allow-pw: true

  packages:
    - openssh-server
    - lshw
    - pciutils
    - dmidecode
    - curl
    - wget
    - vim
    - htop
    - net-tools
    - dnsutils
    - git

  storage:
    config:
      - type: disk
        id: disk0
        match:
          size: largest
        ptable: gpt
        wipe: superblock-recursive
        preserve: false
        grub_device: true

      - type: partition
        id: bios-grub
        device: disk0
        size: 1M
        flag: bios_grub

      - type: partition
        id: esp
        device: disk0
        size: 1G
        flag: boot

      - type: format
        id: esp-fs
        volume: esp
        fstype: fat32

      - type: mount
        id: esp-mount
        device: esp-fs
        path: /boot/efi

      - type: partition
        id: root-partition
        device: disk0
        size: -1

      - type: format
        id: root-fs
        volume: root-partition
        fstype: ext4

      - type: mount
        id: root-mount
        device: root-fs
        path: /

  updates: security

  late-commands:
    - cp /cdrom/tkj-banner.sh /target/usr/local/sbin/tkj-banner.sh
    - chmod 0755 /target/usr/local/sbin/tkj-banner.sh
    - ln -sf /usr/local/sbin/tkj-banner.sh /target/etc/update-motd.d/99-tkj-praktikum
    - curtin in-target --target=/target -- systemctl enable ssh
    - curtin in-target --target=/target -- sh -c "printf '%s\n' 'PasswordAuthentication yes' > /etc/ssh/sshd_config.d/99-tkj-praktikum.conf"

  shutdown: reboot

Ganti bagian:

password: '$6$GANTI_DENGAN_HASH_PASSWORD'

dengan hash SHA-512 yang dihasilkan OpenSSL.

Gunakan tanda petik tunggal agar karakter $ pada hash tidak diperlakukan sebagai bagian dari ekspresi YAML.

4.3. Penjelasan konfigurasi

Identity

Bagian ini mengatur hostname, nama pengguna, dan password.

hostname: ubuntu-server-praktikum
username: tkj

Network

Bagian jaringan menggunakan DHCP untuk interface Ethernet yang sesuai dengan pola nama e*.

dhcp4: true
dhcp6: false

Pastikan pola interface tersebut sesuai dengan nama interface pada mesin target.

SSH

ssh:
  install-server: true
  allow-pw: true

Konfigurasi ini memasang OpenSSH Server dan mengizinkan autentikasi menggunakan password.

Storage

Disk menggunakan tabel partisi GPT. Konfigurasi membuat:

Partisi BIOS boot sebesar 1 MB.
Partisi EFI sebesar 1 GB.
Partisi root ext4 menggunakan sisa ruang disk.

Perhatikan konfigurasi berikut:

match:
  size: largest
wipe: superblock-recursive
preserve: false

Konfigurasi tersebut memilih disk terbesar yang terdeteksi dan menghapus struktur data pada disk target. Gunakan hanya pada mesin atau virtual machine khusus pengujian. Jangan menjalankannya pada komputer yang memiliki data penting.

Packages

Paket yang didefinisikan akan diminta untuk dipasang oleh installer. Keberhasilan pemasangan paket bergantung pada ketersediaan repository dan koneksi jaringan selama proses instalasi.

Konfigurasi ini belum menyediakan repository offline khusus. Karena itu, jangan menganggap seluruh paket dapat dipasang tanpa koneksi internet.

5. Membuat Banner Informasi Server

Selanjutnya kita membuat banner yang menampilkan informasi server setelah pengguna berhasil login.

Informasi yang ditampilkan:

Hostname.
Nama sistem operasi.
Kernel.
Arsitektur.
CPU.
RAM.
Kapasitas disk root.
IP Address.
Username.
Identitas custom ISO.
Kredit pembuat.

Buat file:

D:\UBUNTU-AUTOINSTALL\CONFIG\tkj-banner.sh

Isi dengan script berikut:

#!/usr/bin/env bash

set +e

HOST="$(hostname -f 2>/dev/null || hostname)"

OS_NAME="$(
  . /etc/os-release 2>/dev/null
  printf '%s' "${PRETTY_NAME:-Ubuntu Server}"
)"

KERNEL="$(uname -r 2>/dev/null)"
ARCH="$(uname -m 2>/dev/null)"

CPU="$(
  lscpu 2>/dev/null |
  awk -F: '/Model name/ {
    gsub(/^[ \t]+/, "", $2);
    print $2;
    exit
  }'
)"

CPU="${CPU:-Informasi CPU tidak tersedia}"

MEM="$(
  free -h 2>/dev/null |
  awk '/^Mem:/ {
    print $3 " digunakan / " $2 " total"
  }'
)"

MEM="${MEM:-Informasi RAM tidak tersedia}"

ROOT_DISK="$(
  df -hP / 2>/dev/null |
  awk 'NR==2 {
    print $3 " digunakan / " $2 " total (" $5 ")"
  }'
)"

ROOT_DISK="${ROOT_DISK:-Informasi disk tidak tersedia}"

IPV4="$(
  ip -o -4 addr show scope global 2>/dev/null |
  awk '{
    sub(/\/.*/, "", $4);
    printf "%s%s", sep, $4;
    sep="  "
  }'
)"

IPV4="${IPV4:-Belum ada IPv4 aktif}"

LINE="=============================================================="

printf '\n%s\n' "$LINE"
printf '             UBUNTU SERVER - TKJ PRAKTIKUM\n'
printf '%s\n' "$LINE"

printf ' HOSTNAME      : %s\n' "$HOST"
printf ' OPERATING SYS : %s\n' "$OS_NAME"
printf ' KERNEL        : %s\n' "$KERNEL"
printf ' ARCHITECTURE  : %s\n' "$ARCH"
printf ' CPU           : %s\n' "$CPU"
printf ' MEMORY        : %s\n' "$MEM"
printf ' ROOT DISK     : %s\n' "$ROOT_DISK"
printf ' IP ADDRESS    : %s\n' "$IPV4"

printf '%s\n' "$LINE"

printf ' LOGIN INFORMATION\n'
printf ' USERNAME      : tkj\n'
printf '%s\n' "$LINE"

printf ' SSH ACCESS\n'
printf ' ssh tkj@<SERVER-IP>\n'

printf '%s\n' "$LINE"

printf ' CREDIT\n'
printf ' CUSTOM ISO    : Ubuntu Server 26.04 TKJ Praktikum Edition\n'
printf ' CREATOR       : Walid Umar\n'
printf ' CHANNEL       : https://youtube.com/walidumar\n'
printf ' PURPOSE       : Praktikum Teknik Komputer dan Jaringan\n'

printf '%s\n' "$LINE"
printf '       SYSTEM READY - HAPPY LEARNING & PRACTICING\n'
printf '%s\n\n' "$LINE"

Catatan keamanan: jangan menampilkan password aktual pada banner server. Banner cukup menampilkan username dan informasi akses umum.

5.1. Cara kerja banner

Perintah	Fungsi
`hostname`	Membaca hostname
`uname -r`	Membaca versi kernel
`uname -m`	Membaca arsitektur
`lscpu`	Membaca informasi CPU
`free -h`	Membaca penggunaan RAM
`df -hP /`	Membaca kapasitas filesystem root
`ip -o -4 addr`	Membaca alamat IPv4

Script ini akan dipasang ke direktori /usr/local/sbin/ pada sistem hasil instalasi.

6. Memahami Struktur Boot ISO Ubuntu Server

Sebelum memodifikasi ISO, kita perlu memahami beberapa komponen penting di dalam ISO Ubuntu Server.

Struktur ISO secara umum:

ubuntu-26.04-live-server-amd64.iso
│
├── .disk
├── EFI
│   └── boot
│       ├── bootx64.efi
│       ├── grubx64.efi
│       └── mmx64.efi
│
├── boot
│   └── grub
│       └── grub.cfg
│
├── casper
│   ├── initrd
│   ├── vmlinuz
│   └── filesystem.squashfs
│
├── dists
├── pool
└── ubuntu

Beberapa komponen penting:

GRUB

GRUB merupakan bootloader yang menampilkan menu dan mengatur proses boot installer.

vmlinuz

File kernel Linux yang digunakan untuk menjalankan installer.

initrd

Initial RAM filesystem yang berisi komponen awal untuk memulai proses boot.

autoinstall.yaml

File konfigurasi yang digunakan Ubuntu Installer untuk menjalankan instalasi otomatis.

Dalam proyek ini, kita akan memodifikasi konfigurasi GRUB agar parameter autoinstall ditambahkan pada proses boot.

7. Membuat Script PowerShell build-ubuntu.ps1

Setelah semua file konfigurasi selesai dibuat, tahap berikutnya adalah membuat script PowerShell untuk mengotomatisasi proses rebuild ISO.

Script ini bertugas:

Memeriksa keberadaan ISO sumber dan file konfigurasi.
Memeriksa executable xorriso.
Mengekstrak grub.cfg dari ISO asli.
Menambahkan parameter autoinstall pada baris kernel.
Menyimpan konfigurasi GRUB hasil modifikasi.
Memasukkan file Autoinstall dan banner ke ISO.
Mempertahankan metadata boot asli melalui -boot_image any replay.
Menghasilkan ISO baru.
Menghitung checksum SHA256.

7.1. Membuat file build-ubuntu.ps1

Simpan file berikut di direktori utama proyek:

Isi lengkap script:


#requires -Version 5.1
# ============================================================
# BUILD CUSTOM UBUNTU SERVER 26.04
# TKJ PRAKTIKUM EDITION
# ============================================================

$ErrorActionPreference = "Stop"

# ------------------------------------------------------------
# 1. PROJECT CONFIGURATION
# ------------------------------------------------------------

$Root = "D:\UBUNTU-AUTOINSTALL"

$SourceISO = Join-Path $Root "ISO\ubuntu-26.04-live-server-amd64.iso"
$Xorriso   = Join-Path $Root "TOOLS\xorriso-exe-for-windows-master\xorriso.exe"

$Config    = Join-Path $Root "CONFIG"
$Work      = Join-Path $Root "WORK"
$OutputDir = Join-Path $Root "OUTPUT"

$OutputISO = Join-Path $OutputDir "ubuntu-26.04-tkj-praktikum-amd64.iso"

$Autoinstall = Join-Path $Config "autoinstall.yaml"
$Banner      = Join-Path $Config "tkj-banner.sh"

$GrubSource = Join-Path $Work "grub-original.cfg"
$GrubTarget = Join-Path $Work "grub-modified.cfg"

# ------------------------------------------------------------
# 2. RELATIVE PATH FOR XORRISO
# ------------------------------------------------------------
# Semua argumen file untuk xorriso menggunakan path relatif
# terhadap $Root.
#
# Hindari D:/... karena dapat menyebabkan direktori D: dibuat
# secara keliru oleh beberapa build xorriso Windows.

$RelSourceISO = "ISO/ubuntu-26.04-live-server-amd64.iso"
$RelOutputISO = "OUTPUT/ubuntu-26.04-tkj-praktikum-amd64.iso"

$RelAutoinstall = "CONFIG/autoinstall.yaml"
$RelBanner      = "CONFIG/tkj-banner.sh"

$RelGrubSource = "WORK/grub-original.cfg"
$RelGrubTarget = "WORK/grub-modified.cfg"

# ------------------------------------------------------------
# 3. HELPER FUNCTIONS
# ------------------------------------------------------------

function Stop-Build([string]$Message) {
    Write-Host "`nERROR: $Message" -ForegroundColor Red
    throw $Message
}

function Check-File(
    [string]$Path,
    [string]$Label
) {
    if (-not (Test-Path -LiteralPath $Path -PathType Leaf)) {
        Stop-Build "$Label tidak ditemukan: $Path"
    }
}

function Run-Xorriso([string[]]$ArgsList) {

    Write-Host "`nMenjalankan xorriso:" -ForegroundColor DarkGray
    Write-Host ($ArgsList -join " ") -ForegroundColor DarkGray

    & $Xorriso @ArgsList

    if ($LASTEXITCODE -ne 0) {
        Stop-Build "xorriso gagal dengan exit code $LASTEXITCODE."
    }
}

# ------------------------------------------------------------
# 4. INITIAL VALIDATION
# ------------------------------------------------------------

Write-Host "`n============================================" -ForegroundColor Cyan
Write-Host " UBUNTU 26.04 TKJ PRAKTIKUM ISO BUILDER" -ForegroundColor Cyan
Write-Host "============================================" -ForegroundColor Cyan

Write-Host "`n[1/6] Memeriksa direktori dan file..." -ForegroundColor Cyan

if (-not (Test-Path -LiteralPath $Root -PathType Container)) {
    Stop-Build "Root project tidak ditemukan: $Root"
}

Check-File $SourceISO "ISO Ubuntu Server"
Check-File $Xorriso "xorriso.exe"
Check-File $Autoinstall "autoinstall.yaml"
Check-File $Banner "tkj-banner.sh"

# Pastikan struktur direktori tersedia.

@(
    $Config,
    $Work,
    $OutputDir
) | ForEach-Object {

    New-Item -ItemType Directory -Force -Path $_ | Out-Null

}

Write-Host "Semua file ditemukan." -ForegroundColor Green

# ------------------------------------------------------------
# 5. BACKUP EXISTING OUTPUT
# ------------------------------------------------------------

if (Test-Path -LiteralPath $OutputISO) {

    $Backup = "$OutputISO.$(Get-Date -Format 'yyyyMMdd-HHmmss').bak"

    Move-Item -LiteralPath $OutputISO -Destination $Backup

    Write-Host "Backup ISO lama: $Backup" -ForegroundColor Yellow
}

# ------------------------------------------------------------
# 6. SET WORKING DIRECTORY
# ------------------------------------------------------------

Push-Location $Root

try {

    # --------------------------------------------------------
    # STEP 1: EXTRACT ORIGINAL GRUB
    # --------------------------------------------------------

    Write-Host "`n[2/6] Mengekstrak konfigurasi GRUB..." -ForegroundColor Cyan

    # Hapus file lama agar tidak menggunakan hasil ekstraksi
    # dari proses build sebelumnya.

    if (Test-Path -LiteralPath $GrubSource) {
        Remove-Item -LiteralPath $GrubSource -Force
    }

    Run-Xorriso @(
        "-osirrox", "on",
        "-indev", $RelSourceISO,
        "-extract", "/boot/grub/grub.cfg", $RelGrubSource,
        "-end"
    )

    Check-File $GrubSource "grub.cfg hasil ekstraksi"

    if ((Get-Item -LiteralPath $GrubSource).Length -eq 0) {
        Stop-Build "grub-original.cfg kosong."
    }

    Write-Host "GRUB berhasil diekstrak:" -ForegroundColor Green
    Write-Host $GrubSource

    # --------------------------------------------------------
    # STEP 2: MODIFY GRUB CONFIGURATION
    # --------------------------------------------------------

    Write-Host "`n[3/6] Memodifikasi konfigurasi GRUB..." -ForegroundColor Cyan

    $Lines = Get-Content -LiteralPath $GrubSource
    $Changed = 0

    $KernelRegex = '^\s*linux(?:efi)?\s+/casper/vmlinuz'

    $AutoinstallRegex = '(^|\s)autoinstall(\s|$)'

    $SeparatorRegex = '\s---'

    $SeparatorReplace = [regex]::new($SeparatorRegex)

    for ($i = 0; $i -lt $Lines.Count; $i++) {

        if ($Lines[$i] -match $KernelRegex) {

            if ($Lines[$i] -notmatch $AutoinstallRegex) {

                if ($Lines[$i] -match $SeparatorRegex) {

                    $Lines[$i] = $SeparatorReplace.Replace(
                        $Lines[$i],
                        ' autoinstall ---',
                        1
                    )

                }
                else {

                    $Lines[$i] += " autoinstall"

                }

                $Changed++

            }

        }

    }

    if ($Changed -eq 0) {

        $AllContent = $Lines -join "`n"

        if ($AllContent -notmatch $AutoinstallRegex) {

            Stop-Build "Baris kernel /casper/vmlinuz tidak ditemukan atau parameter autoinstall gagal ditambahkan."

        }

        Write-Host "Parameter autoinstall sudah tersedia." -ForegroundColor Yellow

    }
    else {

        Write-Host "$Changed baris kernel diperbarui." -ForegroundColor Green

    }

    # Simpan tanpa BOM agar GRUB tidak terganggu karakter BOM UTF-8.

    $UTF8NoBOM = New-Object System.Text.UTF8Encoding($false)

    [System.IO.File]::WriteAllLines(
        $GrubTarget,
        [string[]]$Lines,
        $UTF8NoBOM
    )

    Check-File $GrubTarget "grub.cfg hasil modifikasi"

    # Validasi parameter autoinstall.

    $ModifiedContent = Get-Content -LiteralPath $GrubTarget -Raw

    if ($ModifiedContent -notmatch $AutoinstallRegex) {

        Stop-Build "Parameter autoinstall tidak ditemukan pada grub-modified.cfg."

    }

    # --------------------------------------------------------
    # STEP 3: BUILD CUSTOM ISO
    # --------------------------------------------------------

    Write-Host "`n[4/6] Membangun ISO Ubuntu custom..." -ForegroundColor Cyan

    Run-Xorriso @(
        "-indev", $RelSourceISO,
        "-outdev", $RelOutputISO,

        "-map", $RelAutoinstall, "/autoinstall.yaml",
        "-map", $RelBanner, "/tkj-banner.sh",
        "-map", $RelGrubTarget, "/boot/grub/grub.cfg",

        "-boot_image", "any", "replay",

        "-commit",
        "-end"
    )

    # --------------------------------------------------------
    # STEP 4: VALIDATE OUTPUT
    # --------------------------------------------------------

    Write-Host "`n[5/6] Memvalidasi ISO hasil build..." -ForegroundColor Cyan

    Check-File $OutputISO "ISO hasil build"

    $OutputSize = (Get-Item -LiteralPath $OutputISO).Length

    if ($OutputSize -eq 0) {
        Stop-Build "ISO hasil build kosong."
    }

}
finally {

    Pop-Location

}

# ------------------------------------------------------------
# STEP 5: SHA256
# ------------------------------------------------------------

Write-Host "`n[6/6] Menghitung SHA256..." -ForegroundColor Cyan

$Hash = Get-FileHash -LiteralPath $OutputISO -Algorithm SHA256
$Item = Get-Item -LiteralPath $OutputISO

# ------------------------------------------------------------
# BUILD SUMMARY
# ------------------------------------------------------------

Write-Host "`n============================================" -ForegroundColor Green
Write-Host " BUILD BERHASIL" -ForegroundColor Green
Write-Host "============================================" -ForegroundColor Green

Write-Host "ISO     : $($Item.FullName)"
Write-Host ("Ukuran  : {0:N2} GB" -f ($Item.Length / 1GB))
Write-Host "SHA256  : $($Hash.Hash)"

Write-Host "`nUji ISO pada VM dengan konfigurasi:" -ForegroundColor Cyan

Write-Host "[1] BIOS / Legacy"
Write-Host "[2] UEFI"
Write-Host "`nPERINGATAN:" -ForegroundColor Yellow
Write-Host "Konfigurasi storage Autoinstall dapat menghapus disk target."

Write-Host "`nBUILD SELESAI." -ForegroundColor Green

7.2. Penjelasan bagian penting script

Menentukan lokasi proyek

$Root = "D:\UBUNTU-AUTOINSTALL"

Variabel ini menjadi direktori utama yang digunakan oleh seluruh proses build.

Mengekstrak konfigurasi GRUB

"-osirrox","on",
"-indev",(XPath $SourceISO),
"-extract","/boot/grub/grub.cfg",(XPath $GrubSource),
"-end"

Bagian ini mengambil file grub.cfg dari ISO asli dan menyimpannya ke direktori WORK.

File asli dan hasil modifikasi menggunakan nama berbeda:

grub-original.cfg
grub-modified.cfg

Pemisahan ini penting agar file asli tidak tertimpa saat proses modifikasi berlangsung.

Menambahkan parameter Autoinstall

Script mencari baris kernel yang menggunakan /casper/vmlinuz, kemudian menambahkan parameter:

autoinstall

Contoh perubahan:

Sebelum:

linux /casper/vmlinuz ---

Sesudah:

linux /casper/vmlinuz autoinstall ---

Memasukkan file ke dalam ISO

"-map",(XPath $Autoinstall),"/autoinstall.yaml",
"-map",(XPath $Banner),"/tkj-banner.sh",
"-map",(XPath $GrubTarget),"/boot/grub/grub.cfg",

Opsi -map digunakan untuk menambahkan atau mengganti file pada lokasi yang ditentukan di dalam ISO.

Mempertahankan konfigurasi boot

"-boot_image","any","replay"

Opsi ini meminta xorriso mereplay konfigurasi boot dari image sumber.

Menyelesaikan proses penulisan ISO

"-commit",
"-end"

-commit menyelesaikan penulisan perubahan yang sudah disiapkan, sedangkan -end mengakhiri sesi xorriso.

8. Menjalankan Script Build Custom ISO

Tempatkan script build-ubuntu.ps1 pada lokasi / path berikut

D:\UBUNTU-AUTOINSTALL\build-ubuntu.ps1

Kemudian jalankan:

Set-ExecutionPolicy -Scope Process Bypass
cd D:\UBUNTU-AUTOINSTALL
.\build-ubuntu.ps1

Setelah seluruh file tersedia, jalankan proses build.

Buka PowerShell, kemudian masuk ke direktori proyek:

cd D:\UBUNTU-AUTOINSTALL

Jika Windows memblokir eksekusi script, izinkan eksekusi hanya untuk sesi PowerShell saat ini:

Set-ExecutionPolicy -Scope Process Bypass

Jalankan script:

.\build-ubuntu.ps1

Script akan menjalankan proses secara berurutan:

Memeriksa ISO sumber.
Memeriksa xorriso.
Memeriksa file Autoinstall dan banner.
Mengekstrak konfigurasi GRUB.
Menambahkan parameter Autoinstall.
Menyisipkan file konfigurasi.
Membangun ulang ISO.
Menghitung checksum SHA256.

Hasil ISO akan disimpan di:

D:\UBUNTU-AUTOINSTALL\OUTPUT\ubuntu-26.04-tkj-praktikum-amd64.iso

Jika proses gagal, baca pesan error yang ditampilkan PowerShell. Jangan menggunakan ISO hasil proses yang gagal atau belum selesai.

9. Memvalidasi ISO Hasil Modifikasi

Jangan langsung menggunakan ISO hanya karena proses rebuild menampilkan pesan berhasil.

Lakukan beberapa pemeriksaan.

9.1. Memeriksa keberadaan ISO

$OutputISO = "D:\UBUNTU-AUTOINSTALL\OUTPUT\ubuntu-26.04-tkj-praktikum-amd64.iso"

Test-Path $OutputISO

Hasil yang diharapkan:

True

9.2. Memeriksa isi root ISO

$Xorriso = "D:\UBUNTU-AUTOINSTALL\TOOLS\xorriso-exe-for-windows-master\xorriso.exe"

& $Xorriso `
    -indev $OutputISO `
    -ls /

Pastikan file berikut tersedia:

autoinstall.yaml
tkj-banner.sh

9.3. Memeriksa konfigurasi GRUB

& $Xorriso `
    -indev $OutputISO `
    -ls /boot/grub

Pastikan konfigurasi GRUB tersedia.

9.4. Memeriksa struktur boot

Jalankan:

& $Xorriso `
    -indev $OutputISO `
    -report_el_torito plain

Periksa apakah informasi boot BIOS dan EFI masih terdeteksi.

Laporan struktur boot belum membuktikan ISO berhasil melakukan boot pada semua mode firmware. Pengujian BIOS dan UEFI tetap perlu dilakukan secara terpisah.

9.5. Membuat checksum SHA256

Gunakan PowerShell:

Get-FileHash `
    -Path $OutputISO `
    -Algorithm SHA256

Contoh hasil dari build proyek ini:

66C454AB0D85722454A78B1723D354A4C2B156708BE2649D353667713BD4B329

Checksum tersebut merupakan identitas file hasil build yang diuji dalam proyek, bukan checksum universal untuk setiap hasil rebuild.

Jika ada perubahan konfigurasi atau proses build, nilai SHA256 akan berubah.

10. Pengujian Instalasi Menggunakan VMware

Setelah ISO selesai dibangun dan divalidasi, lakukan pengujian menggunakan VMware Workstation.

Buat virtual machine baru dengan spesifikasi pengujian:

Guest OS: Linux Ubuntu 64-bit.
CPU: 2 core atau lebih.
RAM: 4 GB atau lebih.
Disk: 80 GB.
Network Adapter: NAT atau Bridged.
CD/DVD: gunakan ISO hasil modifikasi.

Pastikan firmware virtual machine diatur sesuai mode yang ingin diuji.

10.1. Pengujian UEFI

Pada pengujian ini gunakan firmware UEFI.

Boot virtual machine menggunakan ISO:

ubuntu-26.04-tkj-praktikum-amd64.iso

Periksa apakah installer dapat dimulai dan proses Autoinstall berjalan.

Jika konfigurasi berhasil dibaca, installer akan menjalankan tahapan instalasi sesuai YAML.

Setelah proses selesai, virtual machine akan melakukan reboot.

Lepaskan ISO dari virtual CD/DVD atau ubah urutan boot agar sistem menjalankan disk hasil instalasi.

10.2. Pengujian login

Setelah sistem berhasil boot, login menggunakan akun yang sudah dibuat pada konfigurasi Autoinstall.

Contoh:

Username: tkj
Password: password yang ditentukan saat membuat hash

10.3. Memeriksa hostname

Jalankan:

hostnamectl

Hostname yang diharapkan:

ubuntu-server-praktikum

10.4. Memeriksa alamat IP

Jalankan:

ip -br address

Jika DHCP berhasil, interface jaringan akan mendapatkan alamat IPv4.

10.5. Memeriksa SSH Server

Jalankan:

systemctl status ssh

Jika SSH aktif, status service akan menunjukkan:

active (running)

Periksa port SSH:

ss -tlnp | grep ':22'

Dari komputer lain yang dapat menjangkau server, uji koneksi:

ssh tkj@IP-SERVER

Contoh:

ssh tkj@192.168.18.75

Pastikan aturan firewall dan jaringan mengizinkan koneksi tersebut.

11. Memeriksa Partisi Disk

Salah satu bagian penting dalam pengujian adalah memastikan partisi disk dibuat sesuai konfigurasi.

Jalankan:

lsblk -o NAME,SIZE,TYPE,FSTYPE,MOUNTPOINTS

Contoh hasil pengujian pada VMware:

NAME    SIZE TYPE FSTYPE MOUNTPOINTS
sda      80G disk
├─sda1    1M part
├─sda2    1G part vfat   /boot/efi
└─sda3   79G part ext4   /
sr0    1024M rom

Hasil tersebut menunjukkan:

sda1 digunakan sebagai partisi BIOS boot.
sda2 digunakan sebagai EFI System Partition.
sda3 digunakan sebagai filesystem root.
Filesystem EFI menggunakan FAT.
Filesystem root menggunakan ext4.

Keberadaan mount point /boot/efi pada pengujian ini menunjukkan instalasi berjalan menggunakan UEFI.

12. Hasil Pengujian Proyek

Berikut ringkasan hasil pengujian Ubuntu Server 26.04 TKJ Praktikum Edition.

Komponen	Hasil
Sistem operasi	Ubuntu Server 26.04
Arsitektur	AMD64 / x86_64
Hostname	ubuntu-server-praktikum
Username	tkj
Kernel pengujian	7.0.0-43-generic
CPU VM	Intel Core i5-9300H
RAM terbaca	Sekitar 3,3 GiB
Disk VM	80 GB
IP pengujian	192.168.18.75
Root filesystem	ext4
EFI filesystem	FAT32
SSH	Diuji
Banner login	Berhasil ditampilkan
Rebuild ISO	Berhasil
SHA256	66C454AB0D85722454A78B1723D354A4C2B156708BE2649D353667713BD4B329

Pengujian ini dilakukan menggunakan VMware. Struktur partisi dan proses instalasi UEFI telah diperiksa.

Untuk menyatakan dukungan BIOS dan UEFI secara menyeluruh, lakukan pengujian boot pada kedua mode firmware.

15. Mengapa Autoinstall Penting untuk Praktikum TKJ?

Autoinstall bukan sekadar fitur untuk mempercepat instalasi sistem operasi. Fitur ini juga dapat menjadi bagian dari standardisasi lingkungan laboratorium dan pembelajaran administrasi sistem.

Beberapa manfaatnya:

1. Menghemat waktu instalasi

Administrator atau guru tidak perlu mengatur hostname, akun, jaringan, partisi, dan layanan secara manual pada setiap komputer.

2. Menghasilkan konfigurasi yang konsisten

Setiap server dapat menggunakan konfigurasi dasar yang sama sehingga lebih mudah dikelola dan dibandingkan ketika kegiatan praktikum berlangsung.

3. Mengurangi kesalahan konfigurasi

Parameter instalasi ditentukan terlebih dahulu dalam satu file YAML sehingga kesalahan pengaturan manual dapat dikurangi.

4. Memudahkan deployment banyak server

Custom ISO dapat digunakan berulang kali untuk menyiapkan beberapa virtual machine atau komputer laboratorium.

5. Mendukung pembelajaran Infrastructure as Code

Peserta didik dapat mempelajari bagaimana konfigurasi sistem didefinisikan dalam file, disimpan, diperiksa, dan digunakan kembali.

6. Menjadi fondasi otomatisasi lanjutan

Konsep ini dapat dikembangkan menuju konfigurasi server otomatis menggunakan Ansible, cloud-init, Terraform, atau sistem provisioning lainnya.

16. Pengembangan Selanjutnya

Custom ISO ini dapat dikembangkan lebih lanjut untuk mendukung kebutuhan pembelajaran dan administrasi server.

Beberapa pengembangan yang dapat dilakukan:

Menambahkan toolkit administrasi jaringan.
Menambahkan monitoring server.
Menambahkan konfigurasi firewall.
Menambahkan hardening SSH.
Menambahkan konfigurasi VLAN dan routing.
Menambahkan service DHCP dan DNS.
Menambahkan web server Apache atau Nginx.
Menambahkan konfigurasi server database.
Menyediakan repository paket offline.
Membuat beberapa profil instalasi untuk kebutuhan praktikum yang berbeda.

Untuk paket tambahan, pastikan ketersediaan repository dan dependensinya. Jika ingin instalasi benar-benar offline, paket beserta dependensinya perlu disediakan dalam repository lokal di dalam media instalasi.

Pengembangan repository offline tidak termasuk dalam proses pembuatan ISO pada tutorial ini.

17. Kesimpulan

Dengan memanfaatkan Ubuntu Autoinstall dan xorriso, kita dapat membuat custom ISO Ubuntu Server yang memiliki konfigurasi instalasi sesuai kebutuhan.

Proses ini memungkinkan administrator maupun pengajar TKJ menyiapkan media instalasi yang lebih konsisten, mengurangi konfigurasi manual, dan mempercepat persiapan lingkungan praktikum.

Pada proyek ini, Ubuntu Server 26.04 berhasil dikustomisasi menjadi:

Ubuntu Server 26.04 TKJ Praktikum Edition

Hasil pengujian menunjukkan instalasi UEFI melalui VMware berhasil, hostname dan konfigurasi partisi sesuai rancangan, serta banner informasi server berhasil ditampilkan setelah login.

Pendekatan ini dapat menjadi dasar pengembangan media instalasi khusus untuk laboratorium komputer, pembelajaran administrasi sistem Linux, dan praktikum jaringan komputer di SMK.

Referensi

Ubuntu Server Documentation: https://ubuntu.com/server/docs/
Ubuntu Autoinstall Documentation: https://canonical-subiquity.readthedocs-hosted.com/en/latest/
GNU xorriso: https://www.gnu.org/software/xorriso/
xorriso Windows Prebuilt: https://github.com/PeyTy/xorriso-exe-for-windows
Ubuntu Server Download: https://ubuntu.com/download/server

Materi ini dibuat sebagai dokumentasi praktik kustomisasi ISO Ubuntu Server untuk pembelajaran Teknik Komputer dan Jaringan.

Cara Membuat Custom ISO Ubuntu Server 26.04 dengan Autoinstall di Windows 10

Ubuntu Server 26.04 TKJ Praktikum Edition – Unattended Installation

1. Gambaran Proses Pembuatan

2. Persiapan Peralatan dan Bahan

2.1. Sistem operasi komputer

2.2. Download ISO Ubuntu Server 26.04

2.3. Download xorriso untuk Windows

2.4. Memeriksa xorriso

3. Membuat Struktur Direktori Proyek

4. Memahami Ubuntu Autoinstall

4.1. Membuat password terenkripsi

4.2. Membuat file autoinstall.yaml

4.3. Penjelasan konfigurasi

5. Membuat Banner Informasi Server

5.1. Cara kerja banner

6. Memahami Struktur Boot ISO Ubuntu Server

7. Membuat Script PowerShell build-ubuntu.ps1

7.1. Membuat file build-ubuntu.ps1

7.2. Penjelasan bagian penting script

8. Menjalankan Script Build Custom ISO

9. Memvalidasi ISO Hasil Modifikasi

9.1. Memeriksa keberadaan ISO

9.2. Memeriksa isi root ISO

9.3. Memeriksa konfigurasi GRUB

9.4. Memeriksa struktur boot

9.5. Membuat checksum SHA256

10. Pengujian Instalasi Menggunakan VMware

10.1. Pengujian UEFI

10.2. Pengujian login

10.3. Memeriksa hostname

10.4. Memeriksa alamat IP

10.5. Memeriksa SSH Server

11. Memeriksa Partisi Disk

12. Hasil Pengujian Proyek

15. Mengapa Autoinstall Penting untuk Praktikum TKJ?

16. Pengembangan Selanjutnya

17. Kesimpulan

Referensi

Terkait

Tinggalkan komentar Batalkan balasan