Installing

Procedure

1. Install the AWS command-line tool by following the AWS documentation

2. You need to create a S3 bucket and set the permissions to allow image file conversion to AWS snapshots.

   1. Create the necessary environment variables by running the following commands:

      $ export BUCKET=<custom_bucket_name>
      $ export RAW_AMI=nvidia-bootc.ami
      $ export AMI_NAME="rhel-ai"
      $ export DEFAULT_VOLUME_SIZE=1000

      Copy to Clipboard
      Note

      On AWS, the DEFAULT_VOLUME_SIZE is measured GBs.

   2. You can create an S3 bucket by running the following command:

      $ aws s3 mb s3://$BUCKET

      Copy to Clipboard

   3. You must create a trust-policy.json file with the necessary configurations for generating a S3 role for your bucket:

      $ printf '{ "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "Service": "vmie.amazonaws.com" }, "Action": "sts:AssumeRole", "Condition": { "StringEquals":{ "sts:Externalid": "vmimport" } } } ] }' > trust-policy.json

      Copy to Clipboard

   4. Create an S3 role for your bucket that you can name. In the following example command, vmiport is the name of the role.

      $ aws iam create-role --role-name vmimport --assume-role-policy-document file://trust-policy.json

      Copy to Clipboard

   5. You must create a role-policy.json file with the necessary configurations for generating a policy for your bucket:

      $ printf '{ "Version":"2012-10-17", "Statement":[ { "Effect":"Allow", "Action":[ "s3:GetBucketLocation", "s3:GetObject", "s3:ListBucket" ], "Resource":[ "arn:aws:s3:::%s", "arn:aws:s3:::%s/*" ] }, { "Effect":"Allow", "Action":[ "ec2:ModifySnapshotAttribute", "ec2:CopySnapshot", "ec2:RegisterImage", "ec2:Describe*" ], "Resource":"*" } ] }' $BUCKET $BUCKET > role-policy.json

      Copy to Clipboard

   6. Create a policy for your bucket by running the following command:

      $ aws iam put-role-policy --role-name vmimport --policy-name vmimport-$BUCKET --policy-document file://role-policy.json

      Copy to Clipboard
3. Now that your S3 bucket is set up, you need to download the RAW image from Red Hat Enterprise Linux AI download page

4. Copy the RAW image link and add it to the following command:

   $ curl -Lo disk.raw.gz <link-to-raw-file>

   Copy to Clipboard

5. Unzip the raw.gz file with the following command:

   $ gunzip disk.raw.gz

   Copy to Clipboard

6. Upload the image to the S3 bucket with the following command:

   $ aws s3 cp disk.raw s3://$BUCKET/$RAW_AMI

   Copy to Clipboard

7. Convert the image to a snapshot and store it in the task_id variable name by running the following commands:

   $ printf '{ "Description": "my-image", "Format": "raw", "UserBucket": { "S3Bucket": "%s", "S3Key": "%s" } }' $BUCKET $RAW_AMI > containers.json

   Copy to Clipboard

   $ task_id=$(aws ec2 import-snapshot --disk-container file://containers.json | jq -r .ImportTaskId)

   Copy to Clipboard

8. You can check the progress of the disk image to snapshot conversion job with the following command:

   $ aws ec2 describe-import-snapshot-tasks --filters Name=task-state,Values=active

   Copy to Clipboard

9. Once the conversion job is complete, you can get the snapshot ID and store it in a variable called snapshot_id by running the following command:

   $ snapshot_id=$(aws ec2 describe-import-snapshot-tasks | jq -r '.ImportSnapshotTasks[] | select(.ImportTaskId=="'${task_id}'") | .SnapshotTaskDetail.SnapshotId')

   Copy to Clipboard

10. Add a tag name to the snapshot, so it’s easier to identify, by running the following command:

    $ aws ec2 create-tags --resources $snapshot_id --tags Key=Name,Value="$AMI_NAME"

    Copy to Clipboard

11. Register an AMI from the snapshot with the following command:

    $ ami_id=$(aws ec2 register-image  \
        --name "$AMI_NAME" \
        --description "$AMI_NAME" \
        --architecture x86_64 \
        --root-device-name /dev/sda1 \
        --block-device-mappings "DeviceName=/dev/sda1,Ebs={VolumeSize=${DEFAULT_VOLUME_SIZE},SnapshotId=${snapshot_id}}" \
        --virtualization-type hvm \
        --ena-support \
        | jq -r .ImageId)

    Copy to Clipboard

12. You can add another tag name to identify the AMI by running the following command:

    $ aws ec2 create-tags --resources $ami_id --tags Key=Name,Value="$AMI_NAME"

    Copy to Clipboard

Procedure

1. For various parameters, you need to gather the ID of the variable.

   1. To access the image ID, run the following command:

      $ aws ec2 describe-images --owners self

      Copy to Clipboard

   2. To access the security group ID, run the following command:

      $ aws ec2 describe-security-groups

      Copy to Clipboard

   3. To access the subnet ID, run the following command:

      $ aws ec2 describe-subnets

      Copy to Clipboard

2. Populate environment variables for when you create the instance

   $ instance_name=rhel-ai-instance
   $ ami=<ami-id>
   $ instance_type=<instance-type-size>
   $ key_name=<key-pair-name>
   $ security_group=<sg-id>
   $ disk_size=<size-of-disk>

   Copy to Clipboard

3. Create your instance using the variables by running the following command:

   $ aws ec2 run-instances \
       --image-id $ami \
       --instance-type $instance_type \
       --key-name $key_name \
       --security-group-ids $security_group \
       --subnet-id $subnet \
       --block-device-mappings DeviceName=/dev/sda1,Ebs='{VolumeSize='$disk_size'}' \
       --tag-specifications 'ResourceType=instance,Tags=[{Key=Name,Value='$instance_name'}]'

   Copy to Clipboard

Procedure

1. Log in to IBM Cloud with the following command:

   $ ibmcloud login

   Copy to Clipboard

   When prompted, select your desired account to log in to.

   Example output of the login

   $ ibmcloud login
   API endpoint: https://cloud.ibm.com
   Region: us-east
   
   Get a one-time code from https://identity-1.eu-central.iam.cloud.ibm.com/identity/passcode to proceed.
   Open the URL in the default browser? [Y/n] >
   One-time code >
   Authenticating...
   OK
   
   Select an account:
   1. <account-name>
   2. <account-name-2>
   
   API endpoint:     https://cloud.ibm.com
   Region:           us-east
   User:             <user-name>
   Account:          <selected-account>
   Resource group:   No resource group targeted, use 'ibmcloud target -g RESOURCE_GROUP'

   Copy to Clipboard

2. You need to set up various IBM Cloud configurations and create your COS bucket before generating a QCOW2 image.

   1. You can install the necessary IBM Cloud plugins by running the following command:

      $ ibmcloud plugin install cloud-object-storage infrastructure-service

      Copy to Clipboard

   2. Set your preferred resource group, the following example command sets the resource group named Default.

      $ ibmcloud target -g Default

      Copy to Clipboard

   3. Set your preferred region, the following example command sets the us-east region.

      $ ibmcloud target -r us-east

      Copy to Clipboard

   4. You need to select a deployment plan for your service instance. Ensure you check the properties and pricing on the IBM cloud website.

      1. You can list the available deployment plans by running the following command:

         $ ibmcloud catalog service cloud-object-storage --output json | jq -r '.[].children[] | select(.children != null) | .children[].name'

         Copy to Clipboard

      2. The following example command uses the premium-global-deployment plan and puts it in the environment variable cos_deploy_plan:

         $ cos_deploy_plan=premium-global-deployment

         Copy to Clipboard

      3. Create a Cloud Object Storage (COS) service instance and save the name in an environment variable named cos_si_name and create the cloud-object-storage and by running the following commands:

         $ cos_si_name=THE_NAME_OF_YOUR_SERVICE_INSTANCE

         Copy to Clipboard

         $ ibmcloud resource service-instance-create ${cos_si_name} cloud-object-storage standard global -d ${cos_deploy_plan}

         Copy to Clipboard

   5. Get the Cloud Resource Name (CRN) for your Cloud Object Storage (COS) bucket in a variable named cos_crn by running the following commands:

      $ cos_crn=$(ibmcloud resource service-instance ${cos_si_name} --output json| jq -r '.[] | select(.crn | contains("cloud-object-storage")) | .crn')

      Copy to Clipboard

      $ ibmcloud cos config crn --crn ${cos_crn} --force

      Copy to Clipboard

   6. Create your Cloud Object Storage (COS) bucket named as the environment variable bucket_name with the following commands:

      $ bucket_name=NAME_OF_MY_BUCKET

      Copy to Clipboard

      $ ibmcloud cos bucket-create --bucket ${bucket_name}

      Copy to Clipboard

   7. Allow the infrastructure service to read the buckets that are in the service instance ${cos_si_guid} variable by running the following commands:

      $ cos_si_guid=$(ibmcloud resource service-instance ${cos_si_name} --output json| jq -r '.[] | select(.crn | contains("cloud-object-storage")) | .guid')

      Copy to Clipboard

      $ ibmcloud iam authorization-policy-create is cloud-object-storage Reader --source-resource-type image --target-service-instance-id ${cos_si_guid}

      Copy to Clipboard
3. Now that your IBM Cloud Object Storage (CoS) service instance bucket is set up, you need to download the QCOW2 image from Red Hat Enterprise Linux AI download page

4. Copy the QCOW2 image link and add it to the following command:

   $ curl -Lo disk.qcow2 "PASTE_HERE_THE_LINK_OF_THE_QCOW2_FILE"

   Copy to Clipboard

5. Set the name you want to use as the RHEL AI IBM Cloud image

   $ image_name=rhel-ai-20240703v0

   Copy to Clipboard

6. Upload the QCOW2 image to the Cloud Object Storage (COS) bucket with your selected region by running following command:

   $ ibmcloud cos upload --bucket ${bucket_name} --key ${image_name}.qcow2 --file disk.qcow2 --region <region>

   Copy to Clipboard

7. Convert the QCOW2 you just uploaded to an IBM Cloud image with the following commands:

   $ ibmcloud is image-create ${image_name} --file cos://<region>/${bucket_name}/${image_name}.qcow2 --os-name red-ai-9-amd64-nvidia-byol

   Copy to Clipboard

8. Once the job launches, set the IBM Cloud image configurations into a variable called image_id by running the following command:

   $ image_id=$(ibmcloud is images --visibility private --output json | jq -r '.[] | select(.name=="'$image_name'") | .id')

   Copy to Clipboard

9. You can view the progress of the job with the following command:

   $ while ibmcloud is image --output json ${image_id} | jq -r .status | grep -xq pending; do sleep 1; done

   Copy to Clipboard

10. You can view the information of the newly created image with the following command:

    $ ibmcloud is image ${image_id}

    Copy to Clipboard

Procedure

1. Log in to your IBM Cloud account and select the Account, Region and Resource Group by running the following command:

   $ ibmcloud login -c <ACCOUNT_ID> -r <REGION> -g <RESOURCE_GROUP>

   Copy to Clipboard

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

   1. Install the infrastructure-service plugin for IBM Cloud by running the following command

      $ ibmcloud plugin install infrastructure-service

      Copy to Clipboard

   2. You need to create an SSH public key for your IBM Cloud account. IBM Cloud supports RSA and ed25519 keys. The following example command uses the ed25519 key types and names it ibmcloud.

      $ ssh-keygen -f ibmcloud -t ed25519

      Copy to Clipboard

   3. You can now upload the public key to your IBM Cloud account by following the example command.

      $ ibmcloud is key-create my-ssh-key @ibmcloud.pub --key-type ed25519

      Copy to Clipboard

   4. You need to create a Floating IP for your IBM Cloud instance by following the example command. Ensure you change the region to your preferred zone.

      $ ibmcloud is floating-ip-reserve my-public-ip --zone <region>

      Copy to Clipboard

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

   $ ibmcloud is instance-profiles

   Copy to Clipboard

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

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

   name=my-rhelai-instance
   vpc=my-vpc-in-us-east
   zone=us-east-1
   subnet=my-subnet-in-us-east-1
   instance_profile=gx3-64x320x4l4
   image=my-custom-rhelai-image
   sshkey=my-ssh-key
   floating_ip=my-public-ip
   disk_size=250

   Copy to Clipboard

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

   $ ibmcloud is instance-create \
       $name \
       $vpc \
       $zone \
       $instance_profile \
       $subnet \
       --image $image \
       --keys $sshkey \
       --boot-volume '{"name": "'${name}'-boot", "volume": {"name": "'${name}'-boot", "capacity": '${disk_size}', "profile": {"name": "general-purpose"}}}' \
       --allow-ip-spoofing false

   Copy to Clipboard

6. Link the Floating IP to the instance by running the following command:

   $ ibmcloud is floating-ip-update $floating_ip --nic primary --in $name

   Copy to Clipboard

Procedure

1. Create an environment variable called name that has the name of your instance by running the following command:

   $ name=my-rhelai-instance

   Copy to Clipboard

2. Set the size of the new volume by running the following command:

   $ data_volume_size=1000

   Copy to Clipboard

3. Create and attach the instance volume by running the following command:

   $ ibmcloud is instance-volume-attachment-add data ${name} \
       --new-volume-name ${name}-data \
       --profile general-purpose \
       --capacity ${data_volume_size}

   Copy to Clipboard

4. You can list all the disks with the following command:

   $ lsblk

   Copy to Clipboard

5. Create a disk variable with the content of the disk path your using. The following example command uses the /dev/vdb path.

   $ disk=/dev/vdb

   Copy to Clipboard

6. Create a partition on your disk by running the following command:

   $ sgdisk -n 1:0:0 $disk

   Copy to Clipboard

7. Format and label the partition by running the following command:

   $ mkfs.xfs -L ilab-data ${disk}1

   Copy to Clipboard

8. You can configure your system to auto mount to your preferred directory. The following example command uses the /mnt directory.

   $ echo LABEL=ilab-data /mnt xfs defaults 0 0 >> /etc/fstab

   Copy to Clipboard

9. Reload the systemd service to acknowledge the new configuration on mounts by running the following command:

   $ systemctl daemon-reload

   Copy to Clipboard

10. Mount the disk with the following command:

    $ mount -a

    Copy to Clipboard

11. Grant write permissions to all users in the new file system by running the following command:

    $ chmod 1777 /mnt/

    Copy to Clipboard

Procedure

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

   $ gcloud auth login

   Copy to Clipboard

   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

   Copy to Clipboard

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

      Copy to Clipboard

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

      $ gcloud_region=us-central1

      Copy to Clipboard

   3. Create a Google Cloud Platform Storage Container.

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

      Copy to Clipboard
3. Now that your GCP Storage Container is set up, you need to download the GCP tar.gz image from the Red Hat Enterprise Linux AI download page.

4. Unzip the tar.gz file with the following command:

   $ gunzip <downloaded-gcp-gz-image>

   Copy to Clipboard

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

   $ image_name=rhel-ai-1-2

   Copy to Clipboard

6. 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"

   Copy to Clipboard

7. 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

   Copy to Clipboard

Procedure

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

   $ gcloud auth login

   Copy to Clipboard
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>

   Copy to Clipboard

   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

   Copy to Clipboard

5. Configure the zone to be used.

   $ gcloud config set compute/zone $zone

   Copy to Clipboard

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

   Copy to Clipboard

Procedure

1. Log in to Azure by running the following command:

   $ az login

   Copy to Clipboard

   Example output of the login

   $ az login
   A web browser has been opened at https://login.microsoftonline.com/organizations/oauth2/v2.0/authorize. Please continue the login in the web browser. If no web browser is available or if the web browser fails to open, use device code flow with `az login --use-device-code`.
   [
     {
       "cloudName": "AzureCloud",
       "homeTenantId": "c7b976df-89ce-42ec-b3b2-a6b35fd9c0be",
       "id": "79d7df51-39ec-48b9-a15e-dcf59043c84e",
       "isDefault": true,
       "managedByTenants": [],
       "name": "Team Name",
       "state": "Enabled",
       "tenantId": "0a873aea-428f-47bd-9120-73ce0c5cc1da",
       "user": {
         "name": "user@example.com",
         "type": "user"
       }
     }
   ]

   Copy to Clipboard

2. Log in with the azcopy tool using the following commands:

   $ keyctl new_session
   $ azcopy login

   Copy to Clipboard

3. You need to set up various Azure configurations and create your Azure Storage Container before creating the Azure image.

   1. Create an environment variable defining the location of your instance with the following command:

      $ az_location=eastus

      Copy to Clipboard

   2. Create a resource group and save the name in an environment variable named az_resource_group. The following example creates a resource group named Default in the location eastus. (You can omit this step if you want to use an already existing resource group).

      $ az_resource_group=Default
      $ az group create --name ${az_resource_group} --location ${az_location}

      Copy to Clipboard

   3. Create an Azure storage account and save the name in an environment variable named az_storage_account by running the following commands:

      $ az_storage_account=THE_NAME_OF_YOUR_STORAGE_ACCOUNT

      Copy to Clipboard

      $ az storage account create \
          --name ${az_storage_account} \
          --resource-group ${az_resource_group} \
          --location ${az_location} \
          --sku Standard_LRS

      Copy to Clipboard

   4. Create your Azure Storage Container named as the environment variable az_storage_container with the following commands:

      $ az_storage_container=NAME_OF_MY_BUCKET
      $ az storage container create \
          --name ${az_storage_container} \
          --account-name ${az_storage_account} \
          --public-access off

      Copy to Clipboard

   5. You can get your Subscription ID from the Azure account list by running the following command:

      $ az account list --output table

      Copy to Clipboard

   6. Create a variable named ` az_subscription_id` with your Subscription ID .

      $ az_subscription_id=46c08fb3-83c5-4b59-8372-bf9caf15a681

      Copy to Clipboard

   7. Grant azcopy write permission to user into the storage container. This example grants permission to the user user@example.com.

      $ az role assignment create \
          --assignee user@example.com \
          --role "Storage Blob Data Contributor" \
          --scope /subscriptions/${az_subscription_id}/resourceGroups/${az_resource_group}/providers/Microsoft.Storage/storageAccounts/${az_storage_account}/blobServices/default/containers/${az_storage_container}

      Copy to Clipboard
4. Now that your Azure storage container is set up, you need to download the Azure VHD image from Red Hat Enterprise Linux AI download page.

5. Unzip the vhd.gz file with the following command:

   $ gunzip <downloaded-azure-gz-image>

   Copy to Clipboard

6. Set the name you want to use as the RHEL AI Azure image.

   $ image_name=rhel-ai-1.5

   Copy to Clipboard

7. Upload the VHD file to the Azure Storage Container by running the following command:

   $ az_vhd_url="https://${az_storage_account}.blob.core.windows.net/${az_storage_container}/$(basename ${vhd_file})"
   $ azcopy copy "$vhd_file" "$az_vhd_url"

   Copy to Clipboard

8. Create an Azure image from the VHD file you just uploaded with the following command:

   $ az image create --resource-group $az_resource_group \
       --name "$image_name" \
       --source "${az_vhd_url}" \
       --location ${az_location} \
       --os-type Linux \
       --hyper-v-generation V2

   Copy to Clipboard

Procedure

1. Log in to your Azure account by running the following command:

   $ az login

   Copy to Clipboard

2. 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:

   $ az vm list-sizes --location <region> --output table

   Copy to Clipboard

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

3. You can now start creating your Azure instance. Populate environment variables for when you create the instance.

   name=my-rhelai-instance
   az_location=eastus
   az_resource_group=my_resource_group
   az_admin_username=azureuser
   az_vm_size=Standard_ND96isr_H100_v5
   az_image=my-custom-rhelai-image
   sshpubkey=$HOME/.ssh/id_rsa.pub
   disk_size=1024

   Copy to Clipboard

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

   $ az vm create \
       --resource-group $az_resource_group \
       --name ${name} \
       --image ${az_image} \
       --size ${az_vm_size} \
       --location ${az_location} \
       --admin-username ${az_admin_username} \
       --ssh-key-values @$sshpubkey \
       --authentication-type ssh \
       --nic-delete-option Delete \
       --accelerated-networking true \
       --os-disk-size-gb 1024 \
       --os-disk-name ${name}-${az_location}

   Copy to Clipboard

Procedure

1. You can configure the ILAB_HOME environment variable by writing it to the $HOME/.bash_profile file by running the following commands:

   $ echo 'export ILAB_HOME=/mnt' >> $HOME/.bash_profile

   Copy to Clipboard

2. You can make that change effective by reloading the $HOME/.bash_profile file with the following command:

   $ source $HOME/.bash_profile

   Copy to Clipboard

3. You then need to create a containers directory with the following command:

   $ mkdir /mnt/.config/containers

   Copy to Clipboard

4. Copy over the storage.conf file to the containers directory with the following command:

   $ cp /etc/skel/.config/containers/storage.conf /mnt/.config/containers/

   Copy to Clipboard