Alpine Linux - User contributions [en]

How to make a custom ISO image with mkimage

2023-11-20T23:11:13Z

Divyekapoor: Add info about freshness of test.

This document explains how to build a custom ISO image using the new mkimage scripts located in [[aports]] directory.

== Prerequisites ==

First make sure we have the needed tools
{{Cmd|apk add alpine-sdk alpine-conf syslinux xorriso squashfs-tools grub grub-efi doas}}
For efi you should add the following:
{{Cmd|apk add mtools dosfstools grub-efi}}

Create a user (e.g. build) and add them to the abuild group:
{{Cmd|adduser build -G abuild}}

Give the user root-like permissions:
{{Cmd|vi /etc/doas.d/doas.conf}}
<pre>
permit :abuild
permit persist :abuild
</pre>

Change to the build user:
{{Cmd|su - build}}

Then create signing keys (-i installs them in /etc/apk/keys which is required for later)
{{Cmd|abuild-keygen -i -a}}

{{Tip| Make sure your public keys are placed in /etc/apk/keys/ (example: build-xxxxxxxx.rsa.pub)}}
{{Cmd|ls /etc/apk/keys/}}

Clone (or update) the [https://gitlab.alpinelinux.org/alpine/aports git repository].
{{Cmd|git clone --depth=1 https://gitlab.alpinelinux.org/alpine/aports.git}}

Make sure the apk index is up to date (so apk can find the packages):
{{Cmd|doas apk update}}

Make sure your /tmp is large enough. If you have the default 1GB /tmp, then create a local one with:
<pre>mkdir -pv ~/tmp
export TMPDIR=~/tmp</pre>

== Configuration ==

The mkimg scripts are shipped with pre-configured profiles.

The format is '''mkimg.$PROFILENAME.sh'''

In order to have a custom ISO, you should create your own '''mkimg.$PROFILENAME.sh''' script.

This is an example used to make a ZFS module, overlayfs (which enables r/w mode for /lib/modules), a serial console output and some other useful apks to build a simple NAS:

<pre>export PROFILENAME=nas</pre>

<pre>
cat << EOF > ~/aports/scripts/mkimg.$PROFILENAME.sh
profile_$PROFILENAME() {
profile_standard
kernel_cmdline="unionfs_size=512M console=tty0 console=ttyS0,115200"
syslinux_serial="0 115200"
kernel_addons="zfs"
apks="\$apks iscsi-scst zfs-scripts zfs zfs-utils-py
cciss_vol_status lvm2 mdadm mkinitfs mtools nfs-utils
parted rsync sfdisk syslinux util-linux xfsprogs
dosfstools ntfs-3g
"
local _k _a
for _k in \$kernel_flavors; do
apks="\$apks linux-\$_k"
for _a in \$kernel_addons; do
apks="\$apks \$_a-\$_k"
done
done
apks="\$apks linux-firmware"
}
EOF
</pre>

Set the script as executable:
{{Cmd|chmod +x ~/aports/scripts/mkimg.$PROFILENAME.sh}}

== Making packages available on boot ==

A package may be made available in the live system by defining the generation of an apkovl which contains a corresponding /etc/apk/world file, and adding that overlay definition to the mkimg-profile, e.g. with `apkovl="genapkovl-mkimgoverlay.sh"`

Note that to *use* your added apks, you have to install them, with {{ic|apk add}}.

The definition may be done as in the [https://github.com/alpinelinux/aports/blob/master/scripts/genapkovl-dhcp.sh genapkovl-dhcp.sh] example.
Copy the relevant parts (including the rc_add lines) into a `genapkovl-mkimgoverlay.sh` file and add the package(s) that should be installed in the live system on separate lines in the file contents for /etc/apk/world.

{{Cmd|cp ~/aport/scripts/genapkovl-dhcp.sh ~/aport/scripts/genapkovl-mkimgoverlay.sh}}

Edit the file to add:
<pre>
...
mkdir -p "$tmp"/etc/apk
makefile root:root 0644 "$tmp"/etc/apk/world <<EOF
alpine-base
<apk1-service>
<apk2-service>
EOF

...
rc_add <apk1-service> boot
rc_add <apk2-service> boot
...
</pre>

in the relevant locations.

Then edit the profile build script above and add:
<pre>
apkovl="aports/scripts/genapkovl-mkimgoverlay.sh"
</pre>

immediately after the last apks= line.

== Create the ISO ==

{{Cmd|mkimage.sh [--tag RELEASE] [--outdir OUTDIR] [--workdir WORKDIR]
[--arch ARCH] [--profile PROFILE] [--hostkeys] [--simulate]
[--repository REPO] [--extra-repository REPO] [--yaml FILE]
mkimage.sh --help

options:
--arch Specify which architecture images to build
(default: x86_64)
--hostkeys Copy system apk signing keys to created images
--outdir Specify directory for the created images
--profile Specify which profiles to build
--repository Package repository to use for the image create
--extra-repository Add repository to search packages from
--simulate Don't execute commands
--tag Build images for tag RELEASE
--workdir Specify temporary working directory (cache)
--yaml

known profiles: ali rpi uboot base minirootfs standard vanilla extended virt xen}}

{{Tip| You can use the --repository option multiple times, which is very useful when mixing local and official repositories. The --extra-repository option is there only for backward-compatibility.}}

Create an iso directory in your home dir:

{{Cmd|mkdir -p ~/iso}}

Then create the actual ISO.
In this example we will use the edge version x86_64:
{{Cmd|sh aports/scripts/mkimage.sh --tag edge \
--outdir ~/iso \
--arch x86_64 \
--repository <nowiki>https://dl-cdn.alpinelinux.org/alpine/edge/main</nowiki> \
--profile $PROFILENAME
}}

'''Notes:'''

* If you want to make a customized installer, you need to create <code>.default_boot_services</code> which will cause <code>mkinitfs</code> to create the defaults for the live image.

* Several parts of this doc can be automated with a script, like the repository/arch/outdir settings.
Those steps are left to you and your imagination :)

== Testing your ISO image ==

[[QEMU#Live_mode|QEMU]] is useful for a quick test of your newly created ISO image.
This ISO build process has been tested to work and generate an ISO with auto-installed APKs as of Nov 20, 2023 with Alpine edge.

[[Category:Package Manager]]
[[Category:ISO]]

How to make a custom ISO image with mkimage

2023-11-20T23:09:20Z

Divyekapoor: Add the text to update the world file for an auto-install

How to make a custom ISO image with mkimage

2023-10-20T22:54:56Z

Divyekapoor: Show how to make packages available on boot.

This document explains how to build a custom ISO image using the new mkimage scripts located in [[aports]] directory.

== Prerequisites ==

First make sure we have the needed tools
{{Cmd|apk add alpine-sdk alpine-conf syslinux xorriso squashfs-tools grub grub-efi doas}}
For efi you should add the following:
{{Cmd|apk add mtools dosfstools grub-efi}}

Create a user (e.g. build) and add them to the abuild group:
{{Cmd|adduser build -G abuild}}

Give the user root-like permissions:
{{Cmd|vi /etc/doas.d/doas.conf}}
<pre>
permit :abuild
permit persist :abuild
</pre>

Change to the build user:
{{Cmd|su - build}}

Then create signing keys (-i installs them in /etc/apk/keys which is required for later)
{{Cmd|abuild-keygen -i -a}}

{{Tip| Make sure your public keys are placed in /etc/apk/keys/ (example: build-xxxxxxxx.rsa.pub)}}
{{Cmd|ls /etc/apk/keys/}}

Clone (or update) the [https://gitlab.alpinelinux.org/alpine/aports git repository].
{{Cmd|git clone --depth=1 https://gitlab.alpinelinux.org/alpine/aports.git}}

Make sure the apk index is up to date (so apk can find the packages):
{{Cmd|doas apk update}}

Make sure your /tmp is large enough. If you have the default 1GB /tmp, then create a local one with:
<pre>mkdir -pv ~/tmp
export TMPDIR=~/tmp</pre>

== Configuration ==

The mkimg scripts are shipped with pre-configured profiles.

The format is '''mkimg.$PROFILENAME.sh'''

In order to have a custom ISO, you should create your own '''mkimg.$PROFILENAME.sh''' script.

This is an example used to make a ZFS module, overlayfs (which enables r/w mode for /lib/modules), a serial console output and some other useful apks to build a simple NAS:

<pre>export PROFILENAME=nas</pre>

<pre>
cat << EOF > ~/aports/scripts/mkimg.$PROFILENAME.sh
profile_$PROFILENAME() {
profile_standard
kernel_cmdline="unionfs_size=512M console=tty0 console=ttyS0,115200"
syslinux_serial="0 115200"
kernel_addons="zfs"
apks="\$apks iscsi-scst zfs-scripts zfs zfs-utils-py
cciss_vol_status lvm2 mdadm mkinitfs mtools nfs-utils
parted rsync sfdisk syslinux util-linux xfsprogs
dosfstools ntfs-3g
"
local _k _a
for _k in \$kernel_flavors; do
apks="\$apks linux-\$_k"
for _a in \$kernel_addons; do
apks="\$apks \$_a-\$_k"
done
done
apks="\$apks linux-firmware"
}
EOF
</pre>

Set the script as executable:
{{Cmd|chmod +x ~/aports/scripts/mkimg.$PROFILENAME.sh}}

== Making packages available on boot ==

A package may be made available in the live system by defining the generation of an apkovl which contains a corresponding /etc/apk/world file, and adding that overlay definition to the mkimg-profile, e.g. with `apkovl="genapkovl-mkimgoverlay.sh"`

Note that to *use* your added apks, you have to install them, with <code>apk add</code>.

The definition may be done as in the [https://github.com/alpinelinux/aports/blob/master/scripts/genapkovl-dhcp.sh genapkovl-dhcp.sh] example.
Copy the relevant parts (including the rc_add lines) into a `genapkovl-mkimgoverlay.sh` file and add the package(s) that should be installed in the live system on separate lines in the file contents for /etc/apk/world.

{{Cmd|cp ~/aport/scripts/genapkovl-dhcp.sh ~/aport/scripts/genapkovl-mkimgoverlay.sh}}

Edit the file to add:
<pre>
rc_add <apk1-service> boot
rc_add <apk2-service> boot
...
</pre>

in the relevant locations.

Then edit the profile build script above and add:
<pre>
apkovl="genapkovl-mkimgoverlay.sh"
</pre>

immediately after the last apks= line.

== Create the ISO ==

{{Cmd|mkimage.sh [--tag RELEASE] [--outdir OUTDIR] [--workdir WORKDIR]
[--arch ARCH] [--profile PROFILE] [--hostkeys] [--simulate]
[--repository REPO] [--extra-repository REPO] [--yaml FILE]
mkimage.sh --help

options:
--arch Specify which architecture images to build
(default: x86_64)
--hostkeys Copy system apk signing keys to created images
--outdir Specify directory for the created images
--profile Specify which profiles to build
--repository Package repository to use for the image create
--extra-repository Add repository to search packages from
--simulate Don't execute commands
--tag Build images for tag RELEASE
--workdir Specify temporary working directory (cache)
--yaml

known profiles: ali rpi uboot base minirootfs standard vanilla extended virt xen}}

{{Tip| You can use the --repository option multiple times, which is very useful when mixing local and official repositories. The --extra-repository option is there only for backward-compatibility.}}

Create an iso directory in your home dir:

{{Cmd|mkdir -p ~/iso}}

Then create the actual ISO.
In this example we will use the edge version x86_64:
{{Cmd|sh aports/scripts/mkimage.sh --tag edge \
--outdir ~/iso \
--arch x86_64 \
--repository <nowiki>https://dl-cdn.alpinelinux.org/alpine/edge/main</nowiki> \
--profile $PROFILENAME
}}

'''Notes:'''

* If you want to make a customized installer, you need to create <code>.default_boot_services</code> which will cause <code>mkinitfs</code> to create the defaults for the live image.

* Several parts of this doc can be automated with a script, like the repository/arch/outdir settings.
Those steps are left to you and your imagination :)

== Testing your ISO image ==

[[QEMU#Live_mode|QEMU]] is useful for a quick test of your newly created ISO image.

[[Category:Package Manager]]
[[Category:ISO]]

How to make a custom ISO image with mkimage

2023-10-20T22:42:54Z

Divyekapoor:

This document explains how to build a custom ISO image using the new mkimage scripts located in [[aports]] directory.

== Prerequisites ==

First make sure we have the needed tools
{{Cmd|apk add alpine-sdk alpine-conf syslinux xorriso squashfs-tools grub grub-efi doas}}
For efi you should add the following:
{{Cmd|apk add mtools dosfstools grub-efi}}

Create a user (e.g. build) and add them to the abuild group:
{{Cmd|adduser build -G abuild}}

Give the user root-like permissions:
{{Cmd|vi /etc/doas.d/doas.conf}}
<pre>
permit :abuild
permit persist :abuild
</pre>

Change to the build user:
{{Cmd|su - build}}

Then create signing keys (-i installs them in /etc/apk/keys which is required for later)
{{Cmd|abuild-keygen -i -a}}

{{Tip| Make sure your public keys are placed in /etc/apk/keys/ (example: build-xxxxxxxx.rsa.pub)}}
{{Cmd|ls /etc/apk/keys/}}

Clone (or update) the [https://gitlab.alpinelinux.org/alpine/aports git repository].
{{Cmd|git clone --depth=1 https://gitlab.alpinelinux.org/alpine/aports.git}}

Make sure the apk index is up to date (so apk can find the packages):
{{Cmd|doas apk update}}

Make sure your /tmp is large enough. If you have the default 1GB /tmp, then create a local one with:
<pre>mkdir -pv ~/tmp
export TMPDIR=~/tmp</pre>

== Configuration ==

The mkimg scripts are shipped with pre-configured profiles.

The format is '''mkimg.$PROFILENAME.sh'''

In order to have a custom ISO, you should create your own '''mkimg.$PROFILENAME.sh''' script.

This is an example used to make a ZFS module, overlayfs (which enables r/w mode for /lib/modules), a serial console output and some other useful apks to build a simple NAS:

<pre>export PROFILENAME=nas</pre>

<pre>
cat << EOF > ~/aports/scripts/mkimg.$PROFILENAME.sh
profile_$PROFILENAME() {
profile_standard
kernel_cmdline="unionfs_size=512M console=tty0 console=ttyS0,115200"
syslinux_serial="0 115200"
kernel_addons="zfs"
apks="\$apks iscsi-scst zfs-scripts zfs zfs-utils-py
cciss_vol_status lvm2 mdadm mkinitfs mtools nfs-utils
parted rsync sfdisk syslinux util-linux xfsprogs
dosfstools ntfs-3g
"
local _k _a
for _k in \$kernel_flavors; do
apks="\$apks linux-\$_k"
for _a in \$kernel_addons; do
apks="\$apks \$_a-\$_k"
done
done
apks="\$apks linux-firmware"
}
EOF
</pre>

Set the script as executable:
{{Cmd|chmod +x ~/aports/scripts/mkimg.$PROFILENAME.sh}}

== Making packages available on boot ==

A package may be made available in the live system by defining the generation of an apkovl which contains a corresponding /etc/apk/world file, and adding that overlay definition to the mkimg-profile, e.g. with `apkovl="genapkovl-mkimgoverlay.sh"`

Note that to *use* your added apks, you have to install them, with <code>apk add</code>.

The definition may be done as in the [https://github.com/alpinelinux/aports/blob/master/scripts/genapkovl-dhcp.sh genapkovl-dhcp.sh] example.
Copy the relevant parts (including the rc_add lines) into a `genapkovl-mkimgoverlay.sh` file and add the package(s) that should be installed in the live system on separate lines in the file contents for /etc/apk/world.

{{Cmd|cp ~/aport/scripts/genapkovl-dhcp.sh ~/aport/scripts/genapkovl-mkimgoverlay.sh}}

Edit the file to add:
<pre>
rc_add <apk1-service> boot
rc_add <apk2-service> boot
...
</pre>

in the relevant locations.

== Create the ISO ==

{{Cmd|mkimage.sh [--tag RELEASE] [--outdir OUTDIR] [--workdir WORKDIR]
[--arch ARCH] [--profile PROFILE] [--hostkeys] [--simulate]
[--repository REPO] [--extra-repository REPO] [--yaml FILE]
mkimage.sh --help

options:
--arch Specify which architecture images to build
(default: x86_64)
--hostkeys Copy system apk signing keys to created images
--outdir Specify directory for the created images
--profile Specify which profiles to build
--repository Package repository to use for the image create
--extra-repository Add repository to search packages from
--simulate Don't execute commands
--tag Build images for tag RELEASE
--workdir Specify temporary working directory (cache)
--yaml

known profiles: ali rpi uboot base minirootfs standard vanilla extended virt xen}}

{{Tip| You can use the --repository option multiple times, which is very useful when mixing local and official repositories. The --extra-repository option is there only for backward-compatibility.}}

Create an iso directory in your home dir:

{{Cmd|mkdir -p ~/iso}}

Then create the actual ISO.
In this example we will use the edge version x86_64:
{{Cmd|sh aports/scripts/mkimage.sh --tag edge \
--outdir ~/iso \
--arch x86_64 \
--repository <nowiki>https://dl-cdn.alpinelinux.org/alpine/edge/main</nowiki> \
--profile $PROFILENAME
}}

'''Notes:'''

* If you want to make a customized installer, you need to create <code>.default_boot_services</code> which will cause <code>mkinitfs</code> to create the defaults for the live image.

* Several parts of this doc can be automated with a script, like the repository/arch/outdir settings.
Those steps are left to you and your imagination :)

== Testing your ISO image ==

[[QEMU#Live_mode|QEMU]] is useful for a quick test of your newly created ISO image.

[[Category:Package Manager]]
[[Category:ISO]]

How to make a custom ISO image with mkimage

2023-10-20T22:37:45Z

Divyekapoor: Grub is required for the build to finish.

This document explains how to build a custom ISO image using the new mkimage scripts located in [[aports]] directory.

== Prerequisites ==

First make sure we have the needed tools
{{Cmd|apk add alpine-sdk alpine-conf syslinux xorriso squashfs-tools grub doas}}
For efi you should add the following:
{{Cmd|apk add mtools dosfstools grub-efi}}

Create a user (e.g. build) and add them to the abuild group:
{{Cmd|adduser build -G abuild}}

Give the user root-like permissions:
{{Cmd|vi /etc/doas.d/doas.conf}}
<pre>
permit :abuild
permit persist :abuild
</pre>

Change to the build user:
{{Cmd|su - build}}

Then create signing keys (-i installs them in /etc/apk/keys which is required for later)
{{Cmd|abuild-keygen -i -a}}

{{Tip| Make sure your public keys are placed in /etc/apk/keys/ (example: build-xxxxxxxx.rsa.pub)}}
{{Cmd|ls /etc/apk/keys/}}

Clone (or update) the [https://gitlab.alpinelinux.org/alpine/aports git repository].
{{Cmd|git clone --depth=1 https://gitlab.alpinelinux.org/alpine/aports.git}}

Make sure the apk index is up to date (so apk can find the packages):
{{Cmd|doas apk update}}

Make sure your /tmp is large enough. If you have the default 1GB /tmp, then create a local one with:
<pre>mkdir -pv ~/tmp
export TMPDIR=~/tmp</pre>

== Configuration ==

The mkimg scripts are shipped with pre-configured profiles.

The format is '''mkimg.$PROFILENAME.sh'''

In order to have a custom ISO, you should create your own '''mkimg.$PROFILENAME.sh''' script.

This is an example used to make a ZFS module, overlayfs (which enables r/w mode for /lib/modules), a serial console output and some other useful apks to build a simple NAS:

<pre>export PROFILENAME=nas</pre>

<pre>
cat << EOF > ~/aports/scripts/mkimg.$PROFILENAME.sh
profile_$PROFILENAME() {
profile_standard
kernel_cmdline="unionfs_size=512M console=tty0 console=ttyS0,115200"
syslinux_serial="0 115200"
kernel_addons="zfs"
apks="\$apks iscsi-scst zfs-scripts zfs zfs-utils-py
cciss_vol_status lvm2 mdadm mkinitfs mtools nfs-utils
parted rsync sfdisk syslinux util-linux xfsprogs
dosfstools ntfs-3g
"
local _k _a
for _k in \$kernel_flavors; do
apks="\$apks linux-\$_k"
for _a in \$kernel_addons; do
apks="\$apks \$_a-\$_k"
done
done
apks="\$apks linux-firmware"
}
EOF
</pre>

Set the script as executable:
{{Cmd|chmod +x ~/aports/scripts/mkimg.$PROFILENAME.sh}}

== Making packages available on boot ==

A package may be made available in the live system by defining the generation of an apkovl which contains a corresponding /etc/apk/world file, and adding that overlay definition to the mkimg-profile, e.g. with `apkovl="genapkovl-mkimgoverlay.sh"`

Note that to *use* your added apks, you have to install them, with <code>apk add</code>.

The definition may be done as in the [https://github.com/alpinelinux/aports/blob/master/scripts/genapkovl-dhcp.sh genapkovl-dhcp.sh] example.
Copy the relevant parts (including the rc_add lines) into a `genapkovl-mkimgoverlay.sh` file and add the package(s) that should be installed in the live system on separate lines in the file contents for /etc/apk/world.

{{Cmd|cp ~/aport/scripts/genapkovl-dhcp.sh ~/aport/scripts/genapkovl-mkimgoverlay.sh}}

Edit the file to add:
<pre>
rc_add <apk1-service> boot
rc_add <apk2-service> boot
...
</pre>

in the relevant locations.

== Create the ISO ==

{{Cmd|mkimage.sh [--tag RELEASE] [--outdir OUTDIR] [--workdir WORKDIR]
[--arch ARCH] [--profile PROFILE] [--hostkeys] [--simulate]
[--repository REPO] [--extra-repository REPO] [--yaml FILE]
mkimage.sh --help

options:
--arch Specify which architecture images to build
(default: x86_64)
--hostkeys Copy system apk signing keys to created images
--outdir Specify directory for the created images
--profile Specify which profiles to build
--repository Package repository to use for the image create
--extra-repository Add repository to search packages from
--simulate Don't execute commands
--tag Build images for tag RELEASE
--workdir Specify temporary working directory (cache)
--yaml

known profiles: ali rpi uboot base minirootfs standard vanilla extended virt xen}}

{{Tip| You can use the --repository option multiple times, which is very useful when mixing local and official repositories. The --extra-repository option is there only for backward-compatibility.}}

Create an iso directory in your home dir:

{{Cmd|mkdir -p ~/iso}}

Then create the actual ISO.
In this example we will use the edge version x86_64:
{{Cmd|sh aports/scripts/mkimage.sh --tag edge \
--outdir ~/iso \
--arch x86_64 \
--repository <nowiki>https://dl-cdn.alpinelinux.org/alpine/edge/main</nowiki> \
--profile $PROFILENAME
}}

'''Notes:'''

* If you want to make a customized installer, you need to create <code>.default_boot_services</code> which will cause <code>mkinitfs</code> to create the defaults for the live image.

* Several parts of this doc can be automated with a script, like the repository/arch/outdir settings.
Those steps are left to you and your imagination :)

== Testing your ISO image ==

[[QEMU#Live_mode|QEMU]] is useful for a quick test of your newly created ISO image.

[[Category:Package Manager]]
[[Category:ISO]]

How to make a custom ISO image with mkimage

2023-10-20T21:48:23Z

Divyekapoor: Provide an example of updating the file to add packages to start on boot.

This document explains how to build a custom ISO image using the new mkimage scripts located in [[aports]] directory.

== Prerequisites ==

First make sure we have the needed tools
{{Cmd|apk add alpine-sdk alpine-conf syslinux xorriso squashfs-tools doas}}
For efi you should add the following:
{{Cmd|apk add mtools dosfstools grub-efi}}

Create a user (e.g. build) and add them to the abuild group:
{{Cmd|adduser build -G abuild}}

Give the user root-like permissions:
{{Cmd|vi /etc/doas.d/doas.conf}}
<pre>
permit :abuild
permit persist :abuild
</pre>

Change to the build user:
{{Cmd|su - build}}

Then create signing keys (-i installs them in /etc/apk/keys which is required for later)
{{Cmd|abuild-keygen -i -a}}

{{Tip| Make sure your public keys are placed in /etc/apk/keys/ (example: build-xxxxxxxx.rsa.pub)}}
{{Cmd|ls /etc/apk/keys/}}

Clone (or update) the [https://gitlab.alpinelinux.org/alpine/aports git repository].
{{Cmd|git clone --depth=1 https://gitlab.alpinelinux.org/alpine/aports.git}}

Make sure the apk index is up to date (so apk can find the packages):
{{Cmd|doas apk update}}

Make sure your /tmp is large enough. If you have the default 1GB /tmp, then create a local one with:
<pre>mkdir -pv ~/tmp
export TMPDIR=~/tmp</pre>

== Configuration ==

The mkimg scripts are shipped with pre-configured profiles.

The format is '''mkimg.$PROFILENAME.sh'''

In order to have a custom ISO, you should create your own '''mkimg.$PROFILENAME.sh''' script.

This is an example used to make a ZFS module, overlayfs (which enables r/w mode for /lib/modules), a serial console output and some other useful apks to build a simple NAS:

<pre>export PROFILENAME=nas</pre>

<pre>
cat << EOF > ~/aports/scripts/mkimg.$PROFILENAME.sh
profile_$PROFILENAME() {
profile_standard
kernel_cmdline="unionfs_size=512M console=tty0 console=ttyS0,115200"
syslinux_serial="0 115200"
kernel_addons="zfs"
apks="\$apks iscsi-scst zfs-scripts zfs zfs-utils-py
cciss_vol_status lvm2 mdadm mkinitfs mtools nfs-utils
parted rsync sfdisk syslinux util-linux xfsprogs
dosfstools ntfs-3g
"
local _k _a
for _k in \$kernel_flavors; do
apks="\$apks linux-\$_k"
for _a in \$kernel_addons; do
apks="\$apks \$_a-\$_k"
done
done
apks="\$apks linux-firmware"
}
EOF
</pre>

Set the script as executable:
{{Cmd|chmod +x ~/aports/scripts/mkimg.$PROFILENAME.sh}}

== Making packages available on boot ==

A package may be made available in the live system by defining the generation of an apkovl which contains a corresponding /etc/apk/world file, and adding that overlay definition to the mkimg-profile, e.g. with `apkovl="genapkovl-mkimgoverlay.sh"`

Note that to *use* your added apks, you have to install them, with <code>apk add</code>.

The definition may be done as in the [https://github.com/alpinelinux/aports/blob/master/scripts/genapkovl-dhcp.sh genapkovl-dhcp.sh] example.
Copy the relevant parts (including the rc_add lines) into a `genapkovl-mkimgoverlay.sh` file and add the package(s) that should be installed in the live system on separate lines in the file contents for /etc/apk/world.

{{Cmd|cp ~/aport/scripts/genapkovl-dhcp.sh ~/aport/scripts/genapkovl-mkimgoverlay.sh}}

Edit the file to add:
<pre>
rc_add <apk1-service> boot
rc_add <apk2-service> boot
...
</pre>

in the relevant locations.

== Create the ISO ==

{{Cmd|mkimage.sh [--tag RELEASE] [--outdir OUTDIR] [--workdir WORKDIR]
[--arch ARCH] [--profile PROFILE] [--hostkeys] [--simulate]
[--repository REPO] [--extra-repository REPO] [--yaml FILE]
mkimage.sh --help

options:
--arch Specify which architecture images to build
(default: x86_64)
--hostkeys Copy system apk signing keys to created images
--outdir Specify directory for the created images
--profile Specify which profiles to build
--repository Package repository to use for the image create
--extra-repository Add repository to search packages from
--simulate Don't execute commands
--tag Build images for tag RELEASE
--workdir Specify temporary working directory (cache)
--yaml

known profiles: ali rpi uboot base minirootfs standard vanilla extended virt xen}}

{{Tip| You can use the --repository option multiple times, which is very useful when mixing local and official repositories. The --extra-repository option is there only for backward-compatibility.}}

Create an iso directory in your home dir:

{{Cmd|mkdir -p ~/iso}}

Then create the actual ISO.
In this example we will use the edge version x86_64:
{{Cmd|sh aports/scripts/mkimage.sh --tag edge \
--outdir ~/iso \
--arch x86_64 \
--repository <nowiki>https://dl-cdn.alpinelinux.org/alpine/edge/main</nowiki> \
--profile $PROFILENAME
}}

'''Notes:'''

* If you want to make a customized installer, you need to create <code>.default_boot_services</code> which will cause <code>mkinitfs</code> to create the defaults for the live image.

* Several parts of this doc can be automated with a script, like the repository/arch/outdir settings.
Those steps are left to you and your imagination :)

== Testing your ISO image ==

[[QEMU#Live_mode|QEMU]] is useful for a quick test of your newly created ISO image.

[[Category:Package Manager]]
[[Category:ISO]]

How to make a custom ISO image with mkimage

2023-10-20T21:43:56Z

Divyekapoor: Add a command to replace the text in the above paragraph.

This document explains how to build a custom ISO image using the new mkimage scripts located in [[aports]] directory.

== Prerequisites ==

First make sure we have the needed tools
{{Cmd|apk add alpine-sdk alpine-conf syslinux xorriso squashfs-tools doas}}
For efi you should add the following:
{{Cmd|apk add mtools dosfstools grub-efi}}

Create a user (e.g. build) and add them to the abuild group:
{{Cmd|adduser build -G abuild}}

Give the user root-like permissions:
{{Cmd|vi /etc/doas.d/doas.conf}}
<pre>
permit :abuild
permit persist :abuild
</pre>

Change to the build user:
{{Cmd|su - build}}

Then create signing keys (-i installs them in /etc/apk/keys which is required for later)
{{Cmd|abuild-keygen -i -a}}

{{Tip| Make sure your public keys are placed in /etc/apk/keys/ (example: build-xxxxxxxx.rsa.pub)}}
{{Cmd|ls /etc/apk/keys/}}

Clone (or update) the [https://gitlab.alpinelinux.org/alpine/aports git repository].
{{Cmd|git clone --depth=1 https://gitlab.alpinelinux.org/alpine/aports.git}}

Make sure the apk index is up to date (so apk can find the packages):
{{Cmd|doas apk update}}

Make sure your /tmp is large enough. If you have the default 1GB /tmp, then create a local one with:
<pre>mkdir -pv ~/tmp
export TMPDIR=~/tmp</pre>

== Configuration ==

The mkimg scripts are shipped with pre-configured profiles.

The format is '''mkimg.$PROFILENAME.sh'''

In order to have a custom ISO, you should create your own '''mkimg.$PROFILENAME.sh''' script.

This is an example used to make a ZFS module, overlayfs (which enables r/w mode for /lib/modules), a serial console output and some other useful apks to build a simple NAS:

<pre>export PROFILENAME=nas</pre>

<pre>
cat << EOF > ~/aports/scripts/mkimg.$PROFILENAME.sh
profile_$PROFILENAME() {
profile_standard
kernel_cmdline="unionfs_size=512M console=tty0 console=ttyS0,115200"
syslinux_serial="0 115200"
kernel_addons="zfs"
apks="\$apks iscsi-scst zfs-scripts zfs zfs-utils-py
cciss_vol_status lvm2 mdadm mkinitfs mtools nfs-utils
parted rsync sfdisk syslinux util-linux xfsprogs
dosfstools ntfs-3g
"
local _k _a
for _k in \$kernel_flavors; do
apks="\$apks linux-\$_k"
for _a in \$kernel_addons; do
apks="\$apks \$_a-\$_k"
done
done
apks="\$apks linux-firmware"
}
EOF
</pre>

Set the script as executable:
{{Cmd|chmod +x ~/aports/scripts/mkimg.$PROFILENAME.sh}}

== Making packages available on boot ==

A package may be made available in the live system by defining the generation of an apkovl which contains a corresponding /etc/apk/world file, and adding that overlay definition to the mkimg-profile, e.g. with `apkovl="genapkovl-mkimgoverlay.sh"`

Note that to *use* your added apks, you have to install them, with <code>apk add</code>.

The definition may be done as in the [https://github.com/alpinelinux/aports/blob/master/scripts/genapkovl-dhcp.sh genapkovl-dhcp.sh] example.
Copy the relevant parts (including the rc_add lines) into a `genapkovl-mkimgoverlay.sh` file and add the package(s) that should be installed in the live system on separate lines in the file contents for /etc/apk/world.

{{Cmd|cp ~/aport/scripts/genapkovl-dhcp.sh ~/aport/scripts/genapkovl-mkimgoverlay.sh}}

== Create the ISO ==

{{Cmd|mkimage.sh [--tag RELEASE] [--outdir OUTDIR] [--workdir WORKDIR]
[--arch ARCH] [--profile PROFILE] [--hostkeys] [--simulate]
[--repository REPO] [--extra-repository REPO] [--yaml FILE]
mkimage.sh --help

options:
--arch Specify which architecture images to build
(default: x86_64)
--hostkeys Copy system apk signing keys to created images
--outdir Specify directory for the created images
--profile Specify which profiles to build
--repository Package repository to use for the image create
--extra-repository Add repository to search packages from
--simulate Don't execute commands
--tag Build images for tag RELEASE
--workdir Specify temporary working directory (cache)
--yaml

known profiles: ali rpi uboot base minirootfs standard vanilla extended virt xen}}

{{Tip| You can use the --repository option multiple times, which is very useful when mixing local and official repositories. The --extra-repository option is there only for backward-compatibility.}}

Create an iso directory in your home dir:

{{Cmd|mkdir -p ~/iso}}

Then create the actual ISO.
In this example we will use the edge version x86_64:
{{Cmd|sh aports/scripts/mkimage.sh --tag edge \
--outdir ~/iso \
--arch x86_64 \
--repository <nowiki>https://dl-cdn.alpinelinux.org/alpine/edge/main</nowiki> \
--profile $PROFILENAME
}}

'''Notes:'''

* If you want to make a customized installer, you need to create <code>.default_boot_services</code> which will cause <code>mkinitfs</code> to create the defaults for the live image.

* Several parts of this doc can be automated with a script, like the repository/arch/outdir settings.
Those steps are left to you and your imagination :)

== Testing your ISO image ==

[[QEMU#Live_mode|QEMU]] is useful for a quick test of your newly created ISO image.

[[Category:Package Manager]]
[[Category:ISO]]

How to make a custom ISO image with mkimage

2023-10-20T21:29:16Z

Divyekapoor: Doas apk update

This document explains how to build a custom ISO image using the new mkimage scripts located in [[aports]] directory.

== Prerequisites ==

First make sure we have the needed tools
{{Cmd|apk add alpine-sdk alpine-conf syslinux xorriso squashfs-tools doas}}
For efi you should add the following:
{{Cmd|apk add mtools dosfstools grub-efi}}

Create a user (e.g. build) and add them to the abuild group:
{{Cmd|adduser build -G abuild}}

Give the user root-like permissions:
{{Cmd|vi /etc/doas.d/doas.conf}}
<pre>
permit :abuild
permit persist :abuild
</pre>

Change to the build user:
{{Cmd|su - build}}

Then create signing keys (-i installs them in /etc/apk/keys which is required for later)
{{Cmd|abuild-keygen -i -a}}

{{Tip| Make sure your public keys are placed in /etc/apk/keys/ (example: build-xxxxxxxx.rsa.pub)}}
{{Cmd|ls /etc/apk/keys/}}

Clone (or update) the [https://gitlab.alpinelinux.org/alpine/aports git repository].
{{Cmd|git clone --depth=1 https://gitlab.alpinelinux.org/alpine/aports.git}}

Make sure the apk index is up to date (so apk can find the packages):
{{Cmd|doas apk update}}

Make sure your /tmp is large enough. If you have the default 1GB /tmp, then create a local one with:
<pre>mkdir -pv ~/tmp
export TMPDIR=~/tmp</pre>

== Configuration ==

The mkimg scripts are shipped with pre-configured profiles.

The format is '''mkimg.$PROFILENAME.sh'''

In order to have a custom ISO, you should create your own '''mkimg.$PROFILENAME.sh''' script.

This is an example used to make a ZFS module, overlayfs (which enables r/w mode for /lib/modules), a serial console output and some other useful apks to build a simple NAS:

<pre>export PROFILENAME=nas</pre>

<pre>
cat << EOF > ~/aports/scripts/mkimg.$PROFILENAME.sh
profile_$PROFILENAME() {
profile_standard
kernel_cmdline="unionfs_size=512M console=tty0 console=ttyS0,115200"
syslinux_serial="0 115200"
kernel_addons="zfs"
apks="\$apks iscsi-scst zfs-scripts zfs zfs-utils-py
cciss_vol_status lvm2 mdadm mkinitfs mtools nfs-utils
parted rsync sfdisk syslinux util-linux xfsprogs
dosfstools ntfs-3g
"
local _k _a
for _k in \$kernel_flavors; do
apks="\$apks linux-\$_k"
for _a in \$kernel_addons; do
apks="\$apks \$_a-\$_k"
done
done
apks="\$apks linux-firmware"
}
EOF
</pre>

Set the script as executable:
{{Cmd|chmod +x ~/aports/scripts/mkimg.$PROFILENAME.sh}}

== Making packages available on boot ==

A package may be made available in the live system by defining the generation of an apkovl which contains a corresponding /etc/apk/world file, and adding that overlay definition to the mkimg-profile, e.g. with `apkovl="genapkovl-mkimgoverlay.sh"`

Note that to *use* your added apks, you have to install them, with <code>apk add</code>.

The definition may be done as in the [https://github.com/alpinelinux/aports/blob/master/scripts/genapkovl-dhcp.sh genapkovl-dhcp.sh] example.
Copy the relevant parts (including the rc_add lines) into a `genapkovl-mkimgoverlay.sh` file and add the package(s) that should be installed in the live system on separate lines in the file contents for /etc/apk/world.

== Create the ISO ==

{{Cmd|mkimage.sh [--tag RELEASE] [--outdir OUTDIR] [--workdir WORKDIR]
[--arch ARCH] [--profile PROFILE] [--hostkeys] [--simulate]
[--repository REPO] [--extra-repository REPO] [--yaml FILE]
mkimage.sh --help

options:
--arch Specify which architecture images to build
(default: x86_64)
--hostkeys Copy system apk signing keys to created images
--outdir Specify directory for the created images
--profile Specify which profiles to build
--repository Package repository to use for the image create
--extra-repository Add repository to search packages from
--simulate Don't execute commands
--tag Build images for tag RELEASE
--workdir Specify temporary working directory (cache)
--yaml

known profiles: ali rpi uboot base minirootfs standard vanilla extended virt xen}}

{{Tip| You can use the --repository option multiple times, which is very useful when mixing local and official repositories. The --extra-repository option is there only for backward-compatibility.}}

Create an iso directory in your home dir:

{{Cmd|mkdir -p ~/iso}}

Then create the actual ISO.
In this example we will use the edge version x86_64:
{{Cmd|sh aports/scripts/mkimage.sh --tag edge \
--outdir ~/iso \
--arch x86_64 \
--repository <nowiki>https://dl-cdn.alpinelinux.org/alpine/edge/main</nowiki> \
--profile $PROFILENAME
}}

'''Notes:'''

* If you want to make a customized installer, you need to create <code>.default_boot_services</code> which will cause <code>mkinitfs</code> to create the defaults for the live image.

* Several parts of this doc can be automated with a script, like the repository/arch/outdir settings.
Those steps are left to you and your imagination :)

== Testing your ISO image ==

[[QEMU#Live_mode|QEMU]] is useful for a quick test of your newly created ISO image.

[[Category:Package Manager]]
[[Category:ISO]]

How to make a custom ISO image with mkimage

2023-10-20T21:28:31Z

Divyekapoor: Update to add doas user and permissions - doas is the standard as of 3.16

This document explains how to build a custom ISO image using the new mkimage scripts located in [[aports]] directory.

== Prerequisites ==

First make sure we have the needed tools
{{Cmd|apk add alpine-sdk alpine-conf syslinux xorriso squashfs-tools doas}}
For efi you should add the following:
{{Cmd|apk add mtools dosfstools grub-efi}}

Create a user (e.g. build) and add them to the abuild group:
{{Cmd|adduser build -G abuild}}

Give the user root-like permissions:
{{Cmd|vi /etc/doas.d/doas.conf}}
<pre>
permit :abuild
permit persist :abuild
</pre>

Change to the build user:
{{Cmd|su - build}}

Then create signing keys (-i installs them in /etc/apk/keys which is required for later)
{{Cmd|abuild-keygen -i -a}}

{{Tip| Make sure your public keys are placed in /etc/apk/keys/ (example: build-xxxxxxxx.rsa.pub)}}
{{Cmd|ls /etc/apk/keys/}}

Clone (or update) the [https://gitlab.alpinelinux.org/alpine/aports git repository].
{{Cmd|git clone --depth=1 https://gitlab.alpinelinux.org/alpine/aports.git}}

Make sure the apk index is up to date (so apk can find the packages):
{{Cmd|# apk update}}

Make sure your /tmp is large enough. If you have the default 1GB /tmp, then create a local one with:
<pre>mkdir -pv ~/tmp
export TMPDIR=~/tmp</pre>

== Configuration ==

The mkimg scripts are shipped with pre-configured profiles.

The format is '''mkimg.$PROFILENAME.sh'''

In order to have a custom ISO, you should create your own '''mkimg.$PROFILENAME.sh''' script.

This is an example used to make a ZFS module, overlayfs (which enables r/w mode for /lib/modules), a serial console output and some other useful apks to build a simple NAS:

<pre>export PROFILENAME=nas</pre>

<pre>
cat << EOF > ~/aports/scripts/mkimg.$PROFILENAME.sh
profile_$PROFILENAME() {
profile_standard
kernel_cmdline="unionfs_size=512M console=tty0 console=ttyS0,115200"
syslinux_serial="0 115200"
kernel_addons="zfs"
apks="\$apks iscsi-scst zfs-scripts zfs zfs-utils-py
cciss_vol_status lvm2 mdadm mkinitfs mtools nfs-utils
parted rsync sfdisk syslinux util-linux xfsprogs
dosfstools ntfs-3g
"
local _k _a
for _k in \$kernel_flavors; do
apks="\$apks linux-\$_k"
for _a in \$kernel_addons; do
apks="\$apks \$_a-\$_k"
done
done
apks="\$apks linux-firmware"
}
EOF
</pre>

Set the script as executable:
{{Cmd|chmod +x ~/aports/scripts/mkimg.$PROFILENAME.sh}}

== Making packages available on boot ==

A package may be made available in the live system by defining the generation of an apkovl which contains a corresponding /etc/apk/world file, and adding that overlay definition to the mkimg-profile, e.g. with `apkovl="genapkovl-mkimgoverlay.sh"`

Note that to *use* your added apks, you have to install them, with <code>apk add</code>.

The definition may be done as in the [https://github.com/alpinelinux/aports/blob/master/scripts/genapkovl-dhcp.sh genapkovl-dhcp.sh] example.
Copy the relevant parts (including the rc_add lines) into a `genapkovl-mkimgoverlay.sh` file and add the package(s) that should be installed in the live system on separate lines in the file contents for /etc/apk/world.

== Create the ISO ==

{{Cmd|mkimage.sh [--tag RELEASE] [--outdir OUTDIR] [--workdir WORKDIR]
[--arch ARCH] [--profile PROFILE] [--hostkeys] [--simulate]
[--repository REPO] [--extra-repository REPO] [--yaml FILE]
mkimage.sh --help

options:
--arch Specify which architecture images to build
(default: x86_64)
--hostkeys Copy system apk signing keys to created images
--outdir Specify directory for the created images
--profile Specify which profiles to build
--repository Package repository to use for the image create
--extra-repository Add repository to search packages from
--simulate Don't execute commands
--tag Build images for tag RELEASE
--workdir Specify temporary working directory (cache)
--yaml

known profiles: ali rpi uboot base minirootfs standard vanilla extended virt xen}}

{{Tip| You can use the --repository option multiple times, which is very useful when mixing local and official repositories. The --extra-repository option is there only for backward-compatibility.}}

Create an iso directory in your home dir:

{{Cmd|mkdir -p ~/iso}}

Then create the actual ISO.
In this example we will use the edge version x86_64:
{{Cmd|sh aports/scripts/mkimage.sh --tag edge \
--outdir ~/iso \
--arch x86_64 \
--repository <nowiki>https://dl-cdn.alpinelinux.org/alpine/edge/main</nowiki> \
--profile $PROFILENAME
}}

'''Notes:'''

* If you want to make a customized installer, you need to create <code>.default_boot_services</code> which will cause <code>mkinitfs</code> to create the defaults for the live image.

* Several parts of this doc can be automated with a script, like the repository/arch/outdir settings.
Those steps are left to you and your imagination :)

== Testing your ISO image ==

[[QEMU#Live_mode|QEMU]] is useful for a quick test of your newly created ISO image.

[[Category:Package Manager]]
[[Category:ISO]]

How to make a custom ISO image with mkimage

2023-09-19T06:31:15Z

Divyekapoor: Tentatively removing the merge proposal - it's confusing as the merge target page is less mature than this page.

This document explains how to build a custom ISO image using the new mkimage scripts located in [[aports]] directory.

== Prerequisites ==

First make sure we have the needed tools
{{Cmd|apk add alpine-sdk alpine-conf syslinux xorriso squashfs-tools}}
For efi you should add the following:
{{Cmd|apk add mtools dosfstools grub-efi}}

Create a user (e.g. build) and add them to the abuild group:
{{Cmd|adduser build -G abuild}}
Change to the build user:
{{Cmd|su - build}}

Then create signing keys (-i installs them in /etc/apk/keys which is required for later)
{{Cmd|abuild-keygen -i -a}}

{{Tip| Make sure your public keys are placed in /etc/apk/keys/ (example: build-xxxxxxxx.rsa.pub)}}
{{Cmd|ls /etc/apk/keys/}}

Clone (or update) the [https://gitlab.alpinelinux.org/alpine/aports git repository].
{{Cmd|git clone --depth=1 https://gitlab.alpinelinux.org/alpine/aports.git}}

Make sure the apk index is up to date (so apk can find the packages):
{{Cmd|# apk update}}

Make sure your /tmp is large enough. If you have the default 1GB /tmp, then create a local one with:
<pre>mkdir -pv ~/tmp
export TMPDIR=~/tmp</pre>

== Configuration ==

The mkimg scripts are shipped with pre-configured profiles.

The format is '''mkimg.$PROFILENAME.sh'''

In order to have a custom ISO, you should create your own '''mkimg.$PROFILENAME.sh''' script.

This is an example used to make a ZFS module, overlayfs (which enables r/w mode for /lib/modules), a serial console output and some other useful apks to build a simple NAS:

<pre>export PROFILENAME=nas</pre>

<pre>
cat << EOF > ~/aports/scripts/mkimg.$PROFILENAME.sh
profile_$PROFILENAME() {
profile_standard
kernel_cmdline="unionfs_size=512M console=tty0 console=ttyS0,115200"
syslinux_serial="0 115200"
kernel_addons="zfs"
apks="\$apks iscsi-scst zfs-scripts zfs zfs-utils-py
cciss_vol_status lvm2 mdadm mkinitfs mtools nfs-utils
parted rsync sfdisk syslinux util-linux xfsprogs
dosfstools ntfs-3g
"
local _k _a
for _k in \$kernel_flavors; do
apks="\$apks linux-\$_k"
for _a in \$kernel_addons; do
apks="\$apks \$_a-\$_k"
done
done
apks="\$apks linux-firmware"
}
EOF
</pre>

Set the script as executable:
{{Cmd|chmod +x ~/aports/scripts/mkimg.$PROFILENAME.sh}}

== Making packages available on boot ==

A package may be made available in the live system by defining the generation of an apkovl which contains a corresponding /etc/apk/world file, and adding that overlay definition to the mkimg-profile, e.g. with `apkovl="genapkovl-mkimgoverlay.sh"`

Note that to *use* your added apks, you have to install them, with <code>apk add</code>.

The definition may be done as in the [https://github.com/alpinelinux/aports/blob/master/scripts/genapkovl-dhcp.sh genapkovl-dhcp.sh] example.
Copy the relevant parts (including the rc_add lines) into a `genapkovl-mkimgoverlay.sh` file and add the package(s) that should be installed in the live system on separate lines in the file contents for /etc/apk/world.

== Create the ISO ==

{{Cmd|mkimage.sh [--tag RELEASE] [--outdir OUTDIR] [--workdir WORKDIR]
[--arch ARCH] [--profile PROFILE] [--hostkeys] [--simulate]
[--repository REPO] [--extra-repository REPO] [--yaml FILE]
mkimage.sh --help

options:
--arch Specify which architecture images to build
(default: x86_64)
--hostkeys Copy system apk signing keys to created images
--outdir Specify directory for the created images
--profile Specify which profiles to build
--repository Package repository to use for the image create
--extra-repository Add repository to search packages from
--simulate Don't execute commands
--tag Build images for tag RELEASE
--workdir Specify temporary working directory (cache)
--yaml

known profiles: ali rpi uboot base minirootfs standard vanilla extended virt xen}}

{{Tip| You can use the --repository option multiple times, which is very useful when mixing local and official repositories. The --extra-repository option is there only for backward-compatibility.}}

Create an iso directory in your home dir:

{{Cmd|mkdir -p ~/iso}}

Then create the actual ISO.
In this example we will use the edge version x86_64:
{{Cmd|sh aports/scripts/mkimage.sh --tag edge \
--outdir ~/iso \
--arch x86_64 \
--repository <nowiki>https://dl-cdn.alpinelinux.org/alpine/edge/main</nowiki> \
--profile $PROFILENAME
}}

'''Notes:'''

* If you want to make a customized installer, you need to create <code>.default_boot_services</code> which will cause <code>mkinitfs</code> to create the defaults for the live image.

* Several parts of this doc can be automated with a script, like the repository/arch/outdir settings.
Those steps are left to you and your imagination :)

== Testing your ISO image ==

[[QEMU#Live_mode|QEMU]] is useful for a quick test of your newly created ISO image.

[[Category:Package Manager]]
[[Category:ISO]]

How to make a custom ISO image

2023-09-19T06:24:55Z

Divyekapoor: Removing the "from dedicated boot media" since the text title says using an ISO

== ISO remastering ==

There are third party scripts to re-build completely custom images, like
* [https://github.com/alpinelinux/alpine-make-vm-image alpine-make-vm-image]
(works to only make a disk based VM image)

and there is Alpine's original
* [[How_to_make_a_custom_ISO_image_with_mkimage|mkimg]].
(creates a diskless ISO file - usually what you want for QEMU and Proxmox)

== An alternative ==

It's also possible to commit and load ISO image customizations to and from a writable partition when booting in [[Installation#Diskless_Mode|Diskless Mode]].

== Booting an ISO image with local customizations ==

* [[Directly_booting_an_ISO_file]]

[[Category:Package Manager]]
[[Category:ISO]]

How to make a custom ISO image

2023-09-19T06:23:56Z

Divyekapoor: Clarify diskless ISO file is useful for Proxmox and QEMU

== ISO remastering ==

There are third party scripts to re-build completely custom images, like
* [https://github.com/alpinelinux/alpine-make-vm-image alpine-make-vm-image]
(works to only make a disk based VM image)

and there is Alpine's original
* [[How_to_make_a_custom_ISO_image_with_mkimage|mkimg]].
(creates a diskless ISO file - usually what you want for QEMU and Proxmox)

== An alternative ==

It's also possible to commit and load ISO image customizations to and from a writable partition when booting in [[Installation#Diskless_Mode|Diskless Mode]].

== Booting an ISO image with local customizations ==

* From a dedicated boot media, obviously.
* [[Directly_booting_an_ISO_file]]

[[Category:Package Manager]]
[[Category:ISO]]

Directly booting an ISO file

2023-09-19T06:22:32Z

Divyekapoor: Add link to building a custom ISO with mkimage

It is technically possible to boot an <code>.iso</code> file directly, without flashing it to a disk or device.

== Using a virtual machine ==

The [[QEMU#Live_mode|QEMU]] page shows how an ISO image and .apkovl customizations are booted with a virtual machine. This works very well with Proxmox as well - just attach the ISO and Alpine boots to RAM on startup. You can customize your .iso file by building a custom ISO image by following the instructions on [[How to make a custom ISO image with mkimage]]

== Using an installed Bootloader ==

=== grub-imageboot ===

In addition to standard partitions or drives, the Debian package grub-imageboot allows booting .iso files placed in the /boot/images directory.

=== Manual Grub menu entry ===

No solution found yet.

=== syslinux ===

No solution found yet.

[[Category:Installation]]

Directly booting an ISO file

2023-09-19T06:20:51Z

Divyekapoor: Add text saying how Alpine works well with Proxmox.

It is technically possible to boot an <code>.iso</code> file directly, without flashing it to a disk or device.

== Using a virtual machine ==

The [[QEMU#Live_mode|QEMU]] page shows how an ISO image and .apkovl customizations are booted with a virtual machine. This works very well with Proxmox as well - just attach the ISO and Alpine boots to RAM on startup.

== Using an installed Bootloader ==

=== grub-imageboot ===

In addition to standard partitions or drives, the Debian package grub-imageboot allows booting .iso files placed in the /boot/images directory.

=== Manual Grub menu entry ===

No solution found yet.

=== syslinux ===

No solution found yet.

[[Category:Installation]]

Directly booting an ISO file

2023-09-19T06:19:31Z

Divyekapoor: Remove extra newline

It is technically possible to boot an <code>.iso</code> file directly, without flashing it to a disk or device.

== Using a virtual machine ==

The [[QEMU#Live_mode|QEMU]] page shows how an ISO image and .apkovl customizations are booted with a virtual machine.

== Using an installed Bootloader ==

=== grub-imageboot ===

In addition to standard partitions or drives, the Debian package grub-imageboot allows booting .iso files placed in the /boot/images directory.

=== Manual Grub menu entry ===

No solution found yet.

=== syslinux ===

No solution found yet.

[[Category:Installation]]

Talk:Directly booting an ISO file

2023-09-19T06:19:12Z

Divyekapoor: Moved from the main text

::::: I've given up. Couldn't make the intended setup work with my meager Linux knowledge. I did find a page here at the wiki, under the heading '[[Replacing_non-Alpine_Linux_with_Alpine_remotely|Install Alpine cd-rom image on hard disk]]' where a somewhat related solution is provided, but it involves extracting the distro files from the iso, something that [https://unetbootin.sourceforge.net/ unetbootin] does in a rather more easy and straightforward way -- at least, that's what I used to get Alpine to boot from a USB pendrive (plenty of recipes for that around). However, I still believe a simple 'boot from iso' procedure could do wonders for Alpine, so I'm leaving this here for future reference. Should anyone disagree, do feel free to delete. [[User:Pnin|Pnin]] 05:43, 8 February 2011 (UTC)

Current system is a 2.8 Prescott Pentium IV with 2MB RAM, booting from a 1GB CF plugged into the IDE interface, with an attached 500GB SATA HDD for data. When I tried to install Alpine from the LiveCD to this card, which is listed as a hard drive by the BIOS, it complained of insufficient space. Fair enough. Next I tried to follow [https://www.pendrivelinux.com/boot-multiple-iso-from-usb-via-grub2-using-linux/ this recipe] to boot from Alpine 2.1.4 iso. At the end, you find this tip:

:''Adding an Unlisted ISO: To try ISO Files that are not yet listed, use the existing menu entry examples in /boot/grub/grub.cfg and append any options normally found in the distribution's syslinux.cfg file on the "append" line, to the "linux" line of the menu entry.''

So I downloaded the latest Alpine iso via wget and modified the relevant ''grub.cfg'' lines to:

linux (loop)/boot/grsec initrd=/boot/grsec.gz iso-scan/filename=/alpine214.iso alpine_dev=usbdisk:vfat modules=loop,cramfs,sd-mod,usb-storage quiet
initrd (loop)/boot/grsec.gz

All I got when I tried to boot this was the following error:

'''Alpine Init 2.1.2'''
'''/init: eval: line 1: syntax error: unexpected "("'''
'''kernel panic - not syncing: attempted to kill init!'''
'''Pid: 1, comm: init Not tainted 2.6.35.10-grsec #1-Alpine'''
[...]

I must say all went well with the Linux Mint 10.10 and the TinyCore isos, into which I'm able to boot with no issues. Anyone care to advise?

[[User:Pnin|Pnin]]

----

Hi, that "linux (loop)/boot/...." thing looks funny to me.

According to: https://help.ubuntu.com/community/Grub2

Could you try:

set root=(loop0)
linux /boot/grsec initrd=/boot/grsec.gz iso-scan/filename=/alpine214.iso alpine_dev=usbdisk:vfat modules=loop,cramfs,sd-mod,usb-storage quiet
initrd /boot/grsec.gz

[[User:Nangel|Nangel]] 13:49, 6 February 2011 (UTC)

----

Hi & thanks, Nangel.

Tried that and got this error:

error: no such disk.
error: you need to load the kernel first.
press any key to continue...

Pressing any key returns to the grub menu. Maybe the full ''grub.cfg'' entry should be reported here:

menuentry "Alpine Linux" {
loopback loop /alpine214.iso
linux (loop)/boot/grsec initrd=/boot/grsec.gz iso-scan/filename=/alpine214.iso alpine_dev=usbdisk:vfat modules=loop,cramfs,sd-mod,usb-storage quiet
initrd (loop)/boot/grsec.gz
}

It should also be noted that the LiveCD used to perform the [https://www.pendrivelinux.com/boot-multiple-iso-from-usb-via-grub2-using-linux/ recipe] was "Linux Mint 9 LXDE", which caused Grub 1.98-1ubuntu5-1mint2 to be installed, not Grub2. And that (loop) part is present in every other successful menu entry.

[EDIT: Just to add that IMHO coupled with the [[Alpine_local_backup|Alpine Local Backup Utility]] (lbu), booting from iso would be a killer feature for Alpine, making systems really easy to troubleshoot (delete local backup) and upgrade (replace iso).]

[[User:Pnin|Pnin]] 14:34, 6 February 2011 (UTC)

----

Suppose alpine-extended-3.14.0-x86_64.iso is stored in directory boot in partition 1 on disk.
GRUB2 can be caused to load kernel and initramfs by entering:

grub> loopback lb /boot/alpine-extended-3.14.0-x86_64.iso
grub> linux (lb)/boot/vmlinuz-lts
grub> initrd (lb)/boot/initramfs-lts
grub> boot

A menu entry for GRUB2 can be created with these statements.

Initialising Alpine will then be aborted with messages:

Mounting boot media: failed
initramfs emergency recovery shell launched. Type 'exit' to continue boot

To mount the filesystem where alpine-extended-3.14.0-x86_64.iso is stored, enter:

# mount /dev/sda1 /media/sda1

To mount the ISO image, enter:

# mount -o loop -t iso9660 /media/sda1/boot/alpine-extended-3.14.0-x86_64.iso /media/cdrom

Continue initialisation with:

# exit

At last these messages will be displayed:

/lib/rc/sh/openrc-run.sh: eval: line 1: syntax error: unexpected "("
* ERROR: firstboot failed to start

but login root works and Alpine can be configured using

# alpine-setup

[[User:HGT|HGT]] 2021-07-08

----

Directly booting an ISO file

2023-09-19T06:18:47Z

Divyekapoor: Clean up discussion from the wiki text - move it to the discussions page

It is technically possible to boot an <code>.iso</code> file directly, without flashing it to a disk or device.

== Using a virtual machine ==

The [[QEMU#Live_mode|QEMU]] page shows how an ISO image and .apkovl customizations are booted with a virtual machine.

== Using an installed Bootloader ==

=== grub-imageboot ===

In addition to standard partitions or drives, the Debian package grub-imageboot allows booting .iso files placed in the /boot/images directory.

=== Manual Grub menu entry ===

No solution found yet.

=== syslinux ===

No solution found yet.

[[Category:Installation]]

How to make a custom ISO image

2023-07-14T06:52:09Z

Divyekapoor: Clarify the scope of the third party image building script

== ISO remastering ==

There are third party scripts to re-build completely custom images, like
* [https://github.com/alpinelinux/alpine-make-vm-image alpine-make-vm-image]
(works to only make a disk based VM image)

and there is Alpine's original
* [[How_to_make_a_custom_ISO_image_with_mkimage|mkimg]].
(creates a diskless ISO file)

== An alternative ==

It's also possible to commit and load ISO image customizations to and from a writable partition when booting in [[Installation#Diskless_Mode|Diskless Mode]].

== Booting an ISO image with local customizations ==

* From a dedicated boot media, obviously.
* [[Directly_booting_an_ISO_file]]

[[Category:Package Manager]]
[[Category:ISO]]