Chapter 5. Installing RHEL AI on Google Cloud Platform (GCP) (Technology preview)

Procedure

1. Log in to Google Cloud Platform with the following command:

   $ gcloud auth login

   Example output of the login.

   $ gcloud auth login
   Your browser has been opened to visit:
   
       https://accounts.google.com/o/oauth2/auth?XXXXXXXXXXXXXXXXXXXX
   
   
   You are now logged in as [user@example.com].
   Your current project is [your-project].  You can change this setting by running:
     $ gcloud config set project PROJECT_ID

2. You need to set up some Google Cloud Platform configurations and create your GCP Storage Container before creating the GCP image.

   1. Configure Google Cloud Platform CLI to use your project.

      $ gcloud_project=your-gcloud-project
      $ gcloud config set project $gcloud_project

   2. Create an environment variable defining the region where you want to operate.

      $ gcloud_region=us-central1

   3. Create a Google Cloud Platform Storage Container.

      $ gcloud_bucket=name-for-your-bucket
      $ gsutil mb -l $gcloud_region gs://$gcloud_bucket

3. Red Hat currently does not provide RHEL AI Google Cloud Platform images. You need to create a GCP disk image using RHEL AI bootc image as base.

   1. Create this Containerfile file, using the appropriate version of RHEL AI in the FROM line.

      FROM registry.redhat.io/rhelai1/bootc-nvidia-rhel9:1.2
      
      RUN eval $(grep VERSION_ID /etc/os-release) \
        && echo -e "[google-compute-engine]\nname=Google Compute Engine\nbaseurl=https://packages.cloud.google.com/yum/repos/google-compute-engine-el${VERSION_ID/.*}-x86_64-stable\nenabled=1\ngpgcheck=1\nrepo_gpgcheck=0\ngpgkey=https://packages.cloud.google.com/yum/doc/yum-key.gpg\n      https://packages.cloud.google.com/yum/doc/rpm-package-key.gpg" > /etc/yum.repos.d/google-cloud.repo \
        && dnf install -y --nobest \
           acpid \
           cloud-init \
           google-compute-engine \
           google-osconfig-agent \
           langpacks-en \
           rng-tools \
           timedatex \
           tuned \
           vim \
        && curl -sSo /tmp/add-google-cloud-ops-agent-repo.sh https://dl.google.com/cloudagents/add-google-cloud-ops-agent-repo.sh \
        && bash /tmp/add-google-cloud-ops-agent-repo.sh --also-install --remove-repo \
        && rm /tmp/add-google-cloud-ops-agent-repo.sh \
        && mkdir -p /var/lib/rpm-state \
        && dnf remove -y irqbalance microcode_ctl \
        && rmdir /var/lib/rpm-state \
        && rm -f /etc/yum.repos.d/google-cloud.repo \
        && sed -i -e '/^pool /c\server metadata.google.internal iburst' /etc/chrony.conf \
        && echo -e 'PermitRootLogin no\nPasswordAuthentication no\nClientAliveInterval 420' >> /etc/ssh/sshd_config \
        && echo -e '[InstanceSetup]\nset_boto_config = false' > /etc/default/instance_configs.cfg \
        && echo 'blacklist floppy' > /etc/modprobe.d/blacklist_floppy.conf \
        && echo -e '[install]\nkargs = ["net.ifnames=0", "biosdevname=0", "scsi_mod.use_blk_mq=Y", "console=ttyS0,38400n8d", "cloud-init=disabled"]' > /usr/lib/bootc/install/05-cloud-kargs.toml

   2. Build the bootc image, in the same directory that holds the Containerfile, by running the following commands:

      $ GCP_BOOTC_IMAGE=quay.io/yourquayusername/bootc-nvidia-rhel9-gcp
      $ podman build --file Containerfile --tag ${GCP_BOOTC_IMAGE} .

1. Create a config.toml file that will be used in disk image generation.

   [customizations.kernel]
   name = "gcp"
   append = "net.ifnames=0 biosdevname=0 scsi_mod.use_blk_mq=Y console=ttyS0,38400n8d cloud-init=disabled"

2. Build the disk image using bootc-image-builder by running the following commands:

   $ mkdir -p build/store build/output
   $ podman run --rm -ti --privileged --pull newer \
     -v /var/lib/containers/storage:/var/lib/containers/storage \
     -v ./build/store:/store -v ./build/output:/output \
     -v ./config.toml:/config.toml \
     quay.io/centos-bootc/bootc-image-builder \
       --config /config.toml \
       --chown 0:0 \
       --local \
       --type raw \
       --target-arch x86_64 \
       ${GCP_BOOTC_IMAGE}

   1. Set the name you want to use as the RHEL AI Google Cloud Platform image.

      $ image_name=rhel-ai-1-2

   2. Create a tar.gz file containing the RAW file you created.

      $ raw_file=<path-to-raw-file>
      $ tar cf rhelai_gcp.tar.gz --transform "s|$raw_file|disk.raw|" --use-compress-program=pigz "$raw_file"

      Note

      You can use gzip instead of pigz.

   3. Upload the tar.gz file to the Google Cloud Platform Storage Container by running the following command:

      $ gsutil cp rhelai_gcp.tar.gz "gs://${gcloud_bucket}/$image_name.tar.gz"

   4. Create an Google Cloud Platform image from the tar.gz file you just uploaded with the following command:

      $ gcloud compute images create \
          "$image_name" \
          --source-uri="gs://${gcloud_bucket}/$image_name.tar.gz" \
          --family "rhel-ai" \
          --guest-os-features=GVNIC

Procedure

1. Log in to your Google Cloud Platform account by running the following command:

   $ gcloud auth login

2. Before launching your Google Cloud Platform instance on the CLI, you need to create several configuration variables for your instance.

3. You need to select the instance profile that you want to use for the deployment. List all the profiles in the desired region by running the following command:

   $ gcloud compute machine-types list --zones=<zone>

   Make a note of your preferred machine type, you will need it for your instance deployment.

4. You can now start creating your Google Cloud Platform instance. Populate environment variables for when you create the instance.

   name=my-rhelai-instance
   zone=us-central1-a
   machine_type=a3-highgpu-8g
   accelerator="type=nvidia-h100-80gb,count=8"
   image=my-custom-rhelai-image
   disk_size=1024
   subnet=default

5. Configure the zone to be used.

   $ gcloud config set compute/zone $zone

6. You can now launch your instance, by running the following command:

   $ gcloud compute instances create \
       ${name} \
       --machine-type ${machine_type} \
       --image $image \
       --zone $zone \
       --subnet $subnet \
       --boot-disk-size ${disk_size} \
       --boot-disk-device-name ${name} \
       --accelerator=$accelerator