Installing with image mode for RHEL

1. Find and use a prebuilt MicroShift container image to install RHEL.
2. If the prebuilt MicroShift container image requires customization, build a custom MicroShift container image.
3. Run the container image.

Procedure

1. Set the REGISTRY_URL variable for the image by running the following command:

   $ REGISTRY_URL=<quay.io> 

   1

   Copy to Clipboard Toggle word wrap

   1

   Replace <quay.io> with the URL for your image registry.

2. Log in to your remote registry by running the following command:

   $ sudo podman login "${REGISTRY_URL}"

   Copy to Clipboard Toggle word wrap

3. Set the IMAGE_NAME variable for the image by running the following command:

   $ IMAGE_NAME=<microshift-4.19-bootc> 

   1

   Copy to Clipboard Toggle word wrap

   1

   Replace <microshift-4.19-bootc> with the name of the image you want to publish.

4. Set the REGISTRY_IMG variable for the image by running the following command:

   $ REGISTRY_IMG=<myorg/mypath>/"${IMAGE_NAME}" 

   1

   Copy to Clipboard Toggle word wrap

   1

   Replace <myorg/mypath> with your remote registry organization name and path.

5. Publish the image by running the following command:

   $ sudo podman push localhost/"${IMAGE_NAME}" "${REGISTRY_URL}/${REGISTRY_IMG}"

   Copy to Clipboard Toggle word wrap

Verification

1. Run the container using the image you pushed to your registry as described in the "Running the MicroShift bootc container" section.

Procedure

1. Set the AUTH_CONFIG environment variable to reference the secret file in the kickstart.ks file to authenticate private container registry access by running the following command:

   $ AUTH_CONFIG=~/.quay-auth.json

   Copy to Clipboard Toggle word wrap

2. Set the PULL_SECRET environment variable to reference the secret files in the kickstart.ks file to authenticate the OpenShift Container Platform registry access by running the following command:

   $ PULL_SECRET=~/.pull-secret.json

   Copy to Clipboard Toggle word wrap

3. Set the IMAGE_REF environment variable to reference the image mode for your container image to use during installation by running the following command:

   $ IMAGE_REF="quay.io/<myorg>/<mypath>/microshift-4.19-bootc" 

   1

   Copy to Clipboard Toggle word wrap

   1

   Replace <myorg/<mypath> with your remote registry organization name and path.

4. Create the kickstart.ks file to use during installation by running the following script:

   $ cat > kickstart.ks <<EOFKS
   lang en_US.UTF-8
   keyboard us
   timezone UTC
   text
   reboot
   
   # Partition the disk with hardware-specific boot and swap partitions, adding an
   # LVM volume that contains a 10GB+ system root. The remainder of the volume will
   # be used by the CSI driver for storing data.
   zerombr
   clearpart --all --initlabel
   # Create boot and swap partitions as required by the current hardware platform
   reqpart --add-boot
   # Add an LVM volume group and allocate a system root logical volume
   part pv.01 --grow
   volgroup rhel pv.01
   logvol / --vgname=rhel --fstype=xfs --size=10240 --name=root
   
   # Lock root user account
   rootpw --lock
   
   # Configure network to use DHCP and activate on boot
   network --bootproto=dhcp --device=link --activate --onboot=on
   
   %pre-install --log=/dev/console --erroronfail
   
   # Create a 'bootc' image registry authentication file
   mkdir -p /etc/ostree
   cat > /etc/ostree/auth.json <<'EOF'
   $(cat "${AUTH_CONFIG}")
   EOF
   
   %end
   
   # Pull a 'bootc' image from a remote registry
   ostreecontainer --url "${IMAGE_REF}"
   
   %post --log=/dev/console --erroronfail
   
   # Create an OpenShift pull secret file
   cat > /etc/crio/openshift-pull-secret <<'EOF'
   $(cat "${PULL_SECRET}")
   EOF
   chmod 600 /etc/crio/openshift-pull-secret
   
   %end
   EOFKS

   Copy to Clipboard Toggle word wrap

Procedure

1. Download the Red Hat Enterprise Linux (RHEL) boot ISO image from the Download Red Hat Enterprise Linux.
2. Copy the downloaded file to the /var/lib/libvirt/images directory.

3. Configure the VMNAME environment variable with your value by running the following command:

   $ VMNAME=microshift-4.19-bootc

   Copy to Clipboard Toggle word wrap

4. Configure the NETNAME environment variable with your value by running the following command:

   $ NETNAME=default

   Copy to Clipboard Toggle word wrap

5. Create a RHEL virtual machine with 2 cores, 2GB of RAM and 20GB of storage by running the following command:

   $ sudo virt-install \
       --name ${VMNAME} \
       --vcpus 2 \
       --memory 2048 \
       --disk path=/var/lib/libvirt/images/${VMNAME}.qcow2,size=20 \
       --network network=${NETNAME},model=virtio \
       --events on_reboot=restart \
       --location /var/lib/libvirt/images/rhel-9.6-$(uname -m)-boot.iso \
       --initrd-inject kickstart.ks \
       --extra-args "inst.ks=file://kickstart.ks" \
       --wait

   Copy to Clipboard Toggle word wrap
   Note

   The sudo virt-install command uses the Kickstart file to pull a bootc image from the remote registry and install the RHEL operating system.

6. Log in to the virtual machine by using your redhat credentials.

Verification

1. Verify that all of the MicroShift pods are running without error by entering the following command:

   $ watch sudo oc get pods -A \
       --kubeconfig /var/lib/microshift/resources/kubeadmin/kubeconfig

   Copy to Clipboard Toggle word wrap

   Example output

   NAMESPACE                  NAME                                       READY   STATUS    RESTARTS      AGE
   kube-system                csi-snapshot-controller-7cfb9df49c-kc9dx   1/1     Running   0             31s
   openshift-dns              dns-default-rpnlt                          2/2     Running   0             14s
   openshift-dns              node-resolver-rxvdk                        1/1     Running   0             31s
   openshift-ingress          router-default-69cd7b5545-7zcw7            1/1     Running   0             29s
   openshift-ovn-kubernetes   ovnkube-master-c7hlh                       4/4     Running   1 (16s ago)   31s
   openshift-ovn-kubernetes   ovnkube-node-mkpht                         1/1     Running   1 (17s ago)   31s
   openshift-service-ca       service-ca-5d5d96459d-5pd5s                1/1     Running   0             28s
   openshift-storage          topolvm-controller-677cbfcdb9-28dqr        5/5     Running   0             31s
   openshift-storage          topolvm-node-6fzbl                         3/3     Running   0             14s

   Copy to Clipboard Toggle word wrap

Procedure

1. Add the pull secret to the container build procedure to ensure that images can be pulled by running the following command:

   $ podman build --secret id=pullsecret,src=/<path/to/pull/secret>.json 

   1

   Copy to Clipboard Toggle word wrap

   1

   Specify the path to your pull secret in <path/to/pull/secret>.

2. Add the instructions to physically embed the image at build time by adding the following to your Containerfile:

   ENV IMAGE_STORAGE_DIR=/usr/lib/containers/storage
   ENV IMAGE_LIST_FILE=${IMAGE_STORAGE_DIR}/image-list.txt
   
   RUN dnf install -y microshift-release-info
   RUN --mount=type=secret,id=pullsecret,dst=/run/secrets/pull-secret.json \
       images="$(jq -r ".images[]" /usr/share/microshift/release/release-"$(uname -m)".json)" ; \
       mkdir -p "${IMAGE_STORAGE_DIR}" ; \
       for img in ${images} ; do \
           sha="$(echo "${img}" | sha256sum | awk '{print $1}')" ; \
           skopeo copy --all --preserve-digests \
               --authfile /run/secrets/pull-secret.json \
               "docker://${img}" "dir:$IMAGE_STORAGE_DIR/${sha}" ; \
           echo "${img},${sha}" >> "${IMAGE_LIST_FILE}" ; \
       done

   Copy to Clipboard Toggle word wrap

   When run, the Containerfile extracts the list of MicroShift container image dependencies from the microshift-release-info RPM and pulls them into a custom /usr/lib/containers/storage directory. The resulting image list file is saved at /usr/lib/containers/storage/image-list.txt.

3. Next, you must copy container images from the custom directory to the main container storage directory so that they are available to MicroShift. Add a script and a systemd service to your Containerfile to copy the embedded images from the /usr/lib/containers/storage directory to the local container storage. Copying happens at runtime before each MicroShift start. Use the following example:

   RUN cat > /usr/bin/microshift-copy-images <<EOF
   #!/bin/bash
   set -eux -o pipefail
   while IFS="," read -r img sha ; do
       skopeo copy --preserve-digests \
           "dir:${IMAGE_STORAGE_DIR}/\${sha}" \
           "containers-storage:\${img}"
   done < "${IMAGE_LIST_FILE}"
   EOF
   
   RUN chmod 755 /usr/bin/microshift-copy-images && \
       mkdir -p /usr/lib/systemd/system/microshift.service.d
   
   RUN cat > /usr/lib/systemd/system/microshift.service.d/microshift-copy-images.conf <<EOF
   [Service]
   ExecStartPre=/usr/bin/microshift-copy-images
   EOF

   Copy to Clipboard Toggle word wrap

Next steps

1. Build the image.
2. Test and deploy per your use case.