SupportConsoleDevelopersStart a trialContact

Chapter 8. Deploying an HPC cluster on Azure by using RHEL system roles

Deploy scalable high-performance computing (HPC) clusters on Microsoft Azure by optimizing Red Hat Enterprise Linux (RHEL) images with the HPC RHEL system role. You can generalize virtual machines (VMs) for reuse with Azure CycleCloud and Slurm and manage software versions by using environment modules.

To configure a high-performance computing (HPC) RHEL system role on a customized Red Hat Enterprise Linux (RHEL) image, use the cloud-init utility on the Azure portal or Azure CLI. With cloud-init, automate the configuration of the Ansible collection and run Ansible playbooks on Microsoft Azure.

You can automate a custom RHEL image for Azure by using the ansible-core utility and RHEL system roles during image creation. Before deploying in Azure, use cloud-init to apply the high-performance computing (HPC) RHEL system role and configure the HPC image.

Prerequisites

  • You have an active Azure cloud subscription.

Procedure

  1. Go to the Azure Console.
  2. Click Virtual Machines Create Virtual Machine.

  3. Select the following configurations for a virtual machine from the Basics tab:

    1. In the Virtual machine name field, enter your VM name.
    2. Security type: Standard
    3. Image See All Images Search for Red Hat Enterprise Linux (RHEL) for High Performance Computing (HPC) on Azure Select Red Hat Enterprise Linux for HPC 9.6 VM - x64 Gen2
    4. VM architecture: x64

    5. Size: Standard_NC4as_T4_v3 - 4 vcpus, 28 GiB memory

      Note

      To get optimal performance, use only GPU-optimized VMs, such as NC and ND series. For details, see Virtual machine sizes in Azure.

    6. In the Disks section, select operating system disk > operating system disk size, and then choose 128 GiB (P10).

  4. Go to the Advanced tab and enter the following details to the Custom data field: 

    #cloud-config
#Please check RHEL HPC Ansible system role documentation for all available options

write_files:
  - path: /root/hpc_full_install.yaml
    permissions: 0644
    content: |
      ---
      - name: Install and configure HPC
        hosts: localhost
        become: true
        vars:
          hpc_reboot_ok: false
          hpc_update_all_packages: true
          hpc_manage_firewall: true
        roles:
          - redhat.rhel_system_roles.hpc
  - path: /etc/dnf/azure-rhel9-eus.config
    permissions: 0644
    content: |
      [rhui-microsoft-azure-rhel9]
      name=Microsoft Azure RPMs for Red Hat Enterprise Linux 9 (rhel9-eus)
      baseurl=https://rhui4-1.microsoft.com/pulp/repos/unprotected/microsoft-azure-rhel9-eus
      enabled=1
      gpgcheck=1
      sslverify=1
      gpgkey=/etc/pki/rpm-gpg/RPM-GPG-KEY-microsoft-azure-release
  - path: /etc/dnf/vars/releasever
    permissions: 0644
    content: |
      9.6

# Run custom commands
runcmd:
  # lock VM to RHEL9.6 and enable EUS channels
  # https://learn.microsoft.com/en-us/azure/virtual-machines/workloads/redhat/redhat-rhui
  - dnf --assumeyes --disablerepo='*' remove "rhui-azure-rhel9"
  - dnf --assumeyes --config /etc/dnf/azure-rhel9-eus.config install rhui-azure-rhel9-eus
  - dnf --assumeyes clean all
  - dnf --assumeyes install rhel-system-roles
  5. Click the Review + create button to create a VM with the given configuration.
  6. In the Azure Console, check that the VM has been deployed successfully and is ready for use.
  7. Click the Go to resource button.
  8. Copy the Public IP address.
  9. In the Azure Console, check that the VM is running.

  10. Connect to the VM: 

    $ ssh -i ~/.ssh/azure_hpc <example_azureuser>@<192.0.2.101>

  11. Check the VM status: 

    $ sudo cloud-init status --wait

  12. Once ready, run the HPC RHEL system role: 

    $ sudo ANSIBLE_LOG_PATH=/var/log/ansible_hpc_full_install.log ansible-playbook /root/hpc_full_install.yaml --verbose

  13. Reboot the VM.

    Important

    Wait for the completion of the initial reboot as the HPC RHEL system role configurations finalize during this phase.

Verification

  1. Connect to the VM through SSH: 

    $ ssh -i ~/.ssh/azure_hpc <example_azureuser>@<192.0.2.101>

  2. Verify the list of installed packages: 

    $ sudo dnf list installed| grep -i -E 'nvidia-driver|cuda-toolkit|nccl|fabric-manager|rdma|openmpi'
     
    cuda-toolkit-12-9.x86_64                12.9.1-1            @nvidia-cuda
cuda-toolkit-12-9-config-common.noarch  12.9.79.1           @nvidia-cuda
cuda-toolkit-12-config-common.noarch    12.9.79.1           @nvidia-cuda
cuda-toolkit-config-common.noarch       12.9.79.1           @nvidia-cuda
libnccl.x86_64                          2.27.5-1+cuda12.9   @nvidia-cuda
libnccl-devel.x86_64                    2.27.5-1+cuda12.9   @nvidia-cuda
librdma.x86_64                          54.0.1-e19          @rhel-9-for-x86_64-baseos-rhui-rpms
nvidia-driver.x86_64                    3:575.57.08-1.e19   @nvidia-cuda
nvidia-driver-cuda.x86_64               3:575.57.08-1.e19   @nvidia-cuda
nvidia-driver-cuda-libs.x86_64          3:575.57.08-1.e19   @nvidia-cuda
nvidia-driver-libs.x86_64               3:575.57.08-1.e19   @nvidia-cuda
nvidia-fabric-manager.x86_64            575.57.08-1         @nvidia-cuda
openmpi.x86_64                          2:4.1.7-7.e19       @rhel-9-for-x86_64-appstream-rhui-rpms
openmpi-devel.x86_64                    2:4.1.7-7.e19       @rhel-9-for-x86_64-appstream-rhui-rpms
rdma-core.x86_64                        54.0.1-e19          @rhel-9-for-x86_64-baseos-rhui-rpms

  3. Verify installed Lmod environment modules: 

    $ ml available
     
    -----------------------/usr/share/modulefiles------------------------
   mpi/hpcx-2.24.1-pmix-4.2.9    mpi/openmpi-5.0.8-cuda12-gpu (L,D)
   mpi/hpcx-2.24.1               pmix/pmix-4.2.9              (L)
   mpi/openmpi-x86_64

----------------/usr/share/lmod/lmod/modulefiles/Core----------------
   lmod    settarg

    where:

    • L: Module is loaded
    • D: Default Module

Next steps

You can automate a custom Red Hat Enterprise Linux (RHEL) image during image creation for Azure by using the ansible-core utility on Azure CLI and RHEL system roles. Before deploying in Azure, use cloud-init to apply the high-performance computing (HPC) RHEL system role and configure the HPC image.

Prerequisites

  • You have an active Azure cloud subscription.

Procedure

  1. Connect to the Azure portal: 

    $ az login

  2. Create a key pair: 

    $ ssh-keygen -t ed25519 -C "<azureuser@hpc>" -f ~/.ssh/azure_hpc

  3. Edit the user-data.yml file with the following details: 

    $ vi user-data.yml
     
    #cloud-config
# Please check RedHat HPC Ansible system role documentation for all available options

write_files:
  - path: /root/hpc_full_install.yaml
    permissions: 0644
    content: |
      ---
      - name: Install and configure HPC
        hosts: localhost
        become: true
        vars:
          hpc_reboot_ok: false
          hpc_update_all_packages: true
          hpc_manage_firewall: true
        roles:
          - redhat.rhel_system_roles.hpc
  - path: /etc/dnf/azure-rhel9-eus.config
    permissions: 0644
    content: |
      [rhui-microsoft-azure-rhel9]
      name=Microsoft Azure RPMs for Red Hat Enterprise Linux 9 (rhel9-eus)
      baseurl=https://rhui4-1.microsoft.com/pulp/repos/unprotected/microsoft-azure-rhel9-eus
      enabled=1
      gpgcheck=1
      sslverify=1
      gpgkey=/etc/pki/rpm-gpg/RPM-GPG-KEY-microsoft-azure-release
  - path: /etc/dnf/vars/releasever
    permissions: 0644
    content: |
      9.6

# Run custom commands
runcmd:
  # lock VM to RHEL9.6 and enable EUS channels
  # https://learn.microsoft.com/en-us/azure/virtual-machines/workloads/redhat/redhat-rhui
  - dnf --assumeyes --disablerepo='*' remove "rhui-azure-rhel9"
  - dnf --assumeyes --config /etc/dnf/azure-rhel9-eus.config install rhui-azure-rhel9-eus
  - dnf --assumeyes clean all
  - dnf --assumeyes install rhel-system-roles
    Note

    The cloud-config creates the playbook file at /root/hpc_full_install.yaml during cloud-init. You then run it manually in Step 10 so that you can monitor the output interactively.

  4. Create a resource group: 

    $ az group create --name <example_vm_resource_group> --location <example_region_name>

  5. Select the publisher based on your Azure billing account region of subscription.

    • For North America (NA) or Global accounts, use: 

      $ az vm image terms accept --urn "redhat:rh-rhel-hpc:rh-rhel-hpc96:latest"

    • For Europe, the Middle East and Africa (EMEA) accounts, use: 

      $ az vm image terms accept --urn "redhat-limited:rh-rhel-hpc:rh-rhel-hpc96:latest"

  6. Create an image based on the specified configuration in the last step: 

    $ az vm create \
--resource-group <example_vm_resource_group> \
--name <example_vm_name> \
--image <example_rhel_hpc_image_urn> \
--size Standard_NC4as_T4_v3 \
--os-disk-size-gb 128 \
--admin-username <example_azureuser> \
--ssh-key-values ~/.ssh/azure_hpc.pub \
--custom-data user-data.yml \
--security-type Standard \
--public-ip-address-dns-name <example_vm_name>-$(openssl rand -hex 4) \
--tags owner=$USER project=hpc

    where

    • <example_disk_size>: The minimum size of the operating system disk is 128 GB.
  7. Check the Azure Console if the VM is running.

  8. Connect to the VM through SSH: 

    $ ssh -i ~/.ssh/azure_hpc <example_azureuser>@<192.0.2.101>

  9. Check the VM status: 

    $ sudo cloud-init status --wait

  10. Once ready, run the HPC RHEL system role: 

    $ sudo ANSIBLE_LOG_PATH=/var/log/ansible_hpc_full_install.log ansible-playbook /root/hpc_full_install.yaml --verbose

  11. Reboot the VM.

    Important

    Wait for the completion of the initial reboot as the HPC RHEL system role configurations finalize during this phase.

Verification

  1. Verify SSH connectivity: 

    $ ssh -i ~/.ssh/azure_hpc <example_azureuser>@<192.0.2.101>

  2. Verify the list of installed packages: 

    $ sudo dnf list installed| grep -i -E 'nvidia-driver|cuda-toolkit|nccl|fabric-manager|rdma|openmpi'
     
    cuda-toolkit-12-9.x86_64                 12.9.1-1           @nvidia-cuda
cuda-toolkit-12-9-config-common.noarch   12.9.79.1          @nvidia-cuda
cuda-toolkit-12-config-common.noarch     12.9.79.1          @nvidia-cuda
cuda-toolkit-config-common.noarch        12.9.79.1          @nvidia-cuda
libnccl.x86_64                           2.27.5-1+cuda12.9  @nvidia-cuda
libnccl-devel.x86_64                     2.27.5-1+cuda12.9  @nvidia-cuda
librdma.x86_64                           54.0.1-e19         @rhel-9-for-x86_64-baseos-rhui-rpms
nvidia-driver.x86_64                     3:575.57.08-1.e19  @nvidia-cuda
nvidia-driver-cuda.x86_64                3:575.57.08-1.e19  @nvidia-cuda
nvidia-driver-cuda-libs.x86_64           3:575.57.08-1.e19  @nvidia-cuda
nvidia-driver-libs.x86_64                3:575.57.08-1.e19  @nvidia-cuda
nvidia-fabric-manager.x86_64             575.57.08-1        @nvidia-cuda
openmpi.x86_64                           2:4.1.7-7.e19      @rhel-9-for-x86_64-appstream-rhui-rpms
openmpi-devel.x86_64                     2:4.1.7-7.e19      @rhel-9-for-x86_64-appstream-rhui-rpms
rdma-core.x86_64                         54.0.1-e19         @rhel-9-for-x86_64-baseos-rhui-rpms

  3. Verify installed Lmod environment modules: 

    $ ml available
     
    -----------------------/usr/share/modulefiles------------------------
   mpi/hpcx-2.24.1-pmix-4.2.9    mpi/openmpi-5.0.8-cuda12-gpu (L,D)
   mpi/hpcx-2.24.1               pmix/pmix-4.2.9              (L)
   mpi/openmpi-x86_64

----------------/usr/share/lmod/lmod/modulefiles/Core----------------
   lmod    settarg

    where:

    • L: Module is loaded
    • D: Default Module

By generalizing a virtual machine (VM), you prepare the VM to use as a template or base image for image versioning. In this process, you need to remove specific data, stop the VM, deallocate resources, and mark the VM as generalized. By using generalized images, you can create multiple image versions from the same image.

Prerequisites

Procedure

  1. Connect to the VM through SSH: 

    $ ssh -i ~/.ssh/azure_hpc <example_azureuser>@<192.0.2.101>

  2. Remove any temporary users, network and host information: 

    $ sudo waagent -deprovision+user -force
  3. Log out or press Ctrl + D to close the SSH session.

  4. Stop the VM: 

    $ az vm stop --name <example_vm_name> --resource-group <example_vm_resource_group>

  5. Deallocate the resources to stop incurring Azure charges: 

    $ az vm deallocate --name <example_vm_name> --resource-group <example_vm_resource_group>

  6. Generalize the VM to make sure that this image is generic and ready to clone: 

    $ az vm generalize --name <example_vm_name> --resource-group <example_vm_resource_group>

To generate a reusable Azure image version from a generalized virtual machine (VM), you must create a resource group to organize resources. In the resource group, set up an Azure Compute Gallery to create a marketplace compatible custom images, which you can manage across your organization.

Prerequisites

Procedure

  1. Create a resource group for hosting the gallery: 

    $ az group create --name <example_image_resource_group> \
--location <example_region_name>

  2. Create a gallery in the above resource group: 

    $ az sig create --resource-group <example_image_resource_group> \
--gallery-name <example_image_gallery_name>

  3. Set security type to Standard for subscription: 

    $ az feature register --name UseStandardSecurityType \
--namespace Microsoft.Compute

  4. Register the provider: 

    $ az provider register --namespace Microsoft.Compute

  5. Create an image definition to manage image versions: 

    $ az sig image-definition create --resource-group <example_image_resource_group> \
--gallery-name <example_image_gallery_name> \
--gallery-image-definition <example_image_definition> \
--publisher <example_publisher> \
--offer <example_offer> \
--sku <example_sku> \
--os-type Linux \
--os-state Generalized \
--hyper-v-generation V2 \
--features SecurityType=Standard
    <Publisher>
    The entity or organization that provides the image.
    <Offer>
    A collection of related images from a publisher.
    <Stock Keeping Unit (SKU)>
    An edition within an offer, indicating a major release.

  6. Get information about the image: 

    $ az vm list --output table

  7. Use generalized image name from the output: 

    $ az vm get-instance-view --resource-group <example_vm_resource_group> \
--name <example_vm_name> \
--query id
  8. Copy the VM resource ID from the output of the previous step. Use it as the --virtual-machine value in the next step.

  9. Create the image version by using the image ID obtained in the previous step: 

    $ az sig image-version create \
--resource-group <example_image_resource_group> \
--gallery-name <example_image_gallery_name> \
--gallery-image-definition <example_image_definition> \
--gallery-image-version <example_version> \
--virtual-machine <example_id>

  10. Optional: Delete the VM and associated resources: 

    $ az vm delete --resource-group <example_image_resource_group> \
--name <example_vm_name>

You can configure a Red Hat Enterprise Linux (RHEL) high-performance computing (HPC) cluster on Azure Cloud. HPC clusters are useful for solving complex problems that require intense processing and computation, by distributing tasks across multiple machines, also known as nodes.

Azure CycleCloud, a cloud-native orchestrator, manages HPC clusters for Azure Cloud. With Azure CycleCloud, you can administer HPC clusters for automatic deployment and scaling suitable workloads. Azure CycleCloud manages parallel computing jobs, resources, and sets the Slurm workload manager. Slurm, however, manages resource allocation for scheduling and running tasks in a cluster. The following steps use Slurm and Azure CycleCloud 8.x for deployment and managing a RHEL HPC cluster.

Warning

To configure a RHEL HPC cluster in the Azure environment, you can use Microsoft Azure services such as Azure CycleCloud. Use these tools at your own risk.

Prerequisites

Procedure

  1. Install and deploy CycleCloud on Azure:

  2. Display ID of the custom RHEL HPC image: 

    $ az sig image-version show --resource-group="<example_resource_group>" \
--gallery-name="<example_gallery>" \
--gallery-image-definition="<example_image>" \
--gallery-image-version="<example_version>" \
--query="id" \
--output="tsv"

  3. Provision a Slurm workload manager with Azure CycleCloud by following the steps in the Run Slurm with CycleCloud:

    Warning

    Due to a known limitation of IPv4 addresses, selecting the Public Head Node option causes provisioning failure with the Slurm head node. As a workaround, ensure the Public Head Node option is unchecked and determine the most suitable way of accessing the Slurm head node in your environment. For details, see the related Slurm issue on GitHub.

    Note

    Use the custom RHEL image ID obtained in the earlier step for all cluster nodes. For details, see how to specify a custom OS image.

  4. On the CycleCloud homepage, select the existing Slurm cluster.
  5. To launch the Slurm cluster, click Start.
  6. Log in to the Slurm head node by selecting the cluster view and clicking Connect. Use the standard Slurm command-line tools to schedule HPC jobs. For details, see How do I submit jobs? (Slurm) section.

8.5. Managing Environment Modules for HPC clusters
Copy link

The environment module subsystem uses Lua-based environment modules (Lmod) to list installed modules. With Lmod, you can dynamically modify the environment by loading and unloading various software packages and their dependencies. It manages multiple versions of compilers, libraries, and applications in the high-performance computing (HPC) environment, so you can select specific software configurations for each version. To do this, you can use the module utility, which is shortened to ml.

8.5.1. Commands for environment modules management
Copy link

You can use the following commands to manage environment modules:

  • Display all commands related to the module utility: 

    $ module help

  • Display the individual command options and syntax: 

    $ module <command> help

  • Display details for a specific module: 

    $ ml whatis pmix/pmix-4.2.9
     
    pmix/pmix-4.2.9   : Description: PMIx 4.2.9 installed in /opt/pmix/4.2.9
pmix/pmix-4.2.9   : Version: 4.2.9-1

  • List available modules in the HPC environment: 

    $ ml available
     
    -----------------------/usr/share/modulefiles------------------------
  mpi/hpcx-2.24.1-pmix-4.2.9    mpi/openmpi-5.0.8-cuda12-gpu (L,D)
  mpi/hpcx-2.24.1               pmix/pmix-4.2.9              (L)
  mpi/openmpi-x86_64

----------------/usr/share/lmod/lmod/modulefiles/Core----------------
  lmod    settarg

    where:

    • L: Module is loaded
    • D: Default Module
    • The (L) annotation indicates that the mpi/openmpi-5.0.8-cuda12-gpu module is loaded.
    • This also loads the pmix/pmix-4.2.9 module as a dependency.
    • The module system automatically loads and unloads dependent modules as needed.

  • List the loaded modules: 

    $ ml list
     
    Currently Loaded Modules:
1) pmix/pmix-4.2.9
2) mpi/openmpi-5.0.8-cuda12-gpu

  • Unload a module and its dependencies: 

    $ ml unload mpi/openmpi-5.0.8-cuda12-gpu
$ ml list
     
    No modules loaded

  • Unload an existing module and load a new module: 

    $ ml load mpi/openmpi-5.0.8-cuda12-gpu
$ ml list
     
    Currently Loaded Modules:

1) pmix/pmix-4.2.9
2) mpi/openmpi-5.0.8-cuda12-gpu

  • Switch the loaded module: 

    $ ml swap mpi/openmpi-x86_64
     
    The following have been reloaded with a version change:

1) mpi/openmpi-5.0.8-cuda12-gpu => mpi/openmpi-x86_64

  • List the available modules: 

    $ ml list
     
    Currently Loaded Modules:

1) mpi/openmpi-x86_64

8.5.2. Modulefiles layout and rules
Copy link

A modulefile is a script that defines and manages environment variables for loading, unloading, and switching software environments on HPC systems. The recommended directory structure and naming conventions enable efficient organization of environment modulefiles, including module definitions, wrapper modules, and consistent rules for managing multiple software environments in RHEL-based HPC deployments.

Manual method for module definitions
The module utility automatically discovers the module definitions placed in the /usr/share/modulefiles directory. If you have other directories with module definitions, you need to add them to the MODULEPATH environment variable.
Wrapper modules
To avoid modifying environment variables and allow Lmod to find package-specific modules, place the wrapper modules in the /usr/share/modulefiles directory so that these modules modify MODULEPATH and load the relevant module from the external location. An example of this style of wrapper is the mpi/hpcx-2.24.1 environment module.
Module file format

Lmod supports environment modules written in Lua as well as the Tool Command Language (Tcl) format. Lua scripting is the preferred method for defining environment modules. Use the .lua extension with the 755 permission set. The module name for the ml command omits the .lua suffix. Examples given in this document use the Lua script interfaces. It has the following requirements:

  • All packages that provide the same functionality, for example MPI libraries, are in a common module subdirectory. In this case, ../mpi/ for all the MPI library variants.
  • Add a conflict() definition to the module for the package subdirectory (e.g. conflict("mpi")) which allows only one module of that package type to load at a time.
  • Keep package naming consistent.

  • Use the feature name as the subdirectory name, while the individual modules for each package instance should be named according to the following pattern: 

    <package provider>-<version>-<build>-<options>

    For multiple MPI library variants, some are from different providers, while others are multiple builds of a given package with different compilers and build options. In such cases, the naming scheme provides consistency.

8.5.3. Available MPI environments
Copy link

In an HPC Slurm cluster, the message passing interface (MPI) environment provides runtime support for applications to communicate and synchronize across nodes. Slurm integrates with MPI implementations such as OpenMPI to manage distributed jobs efficiently and optimize use of cluster resources. Slurm uses mpirun to orchestrate execution across allocated nodes for scalable, high-performance jobs. With the provided RHEL HPC cluster, the following MPI environments are available:

  • Openmpi.x86_64: Standard open MPI build that does not provide CUDA or GPU acceleration support.
  • Openmpi-5.0.8-cuda-gpu: Open MPI module compiled with CUDA support for GPU-aware MPI communication
  • Hpcx-2.24.1: NVIDIA comprehensive HPC software stack based on Open MPI.
  • Hpcx-2.24.1-pmix: HPC-X build configured with Process Management Interface (PMIx) for Slurm integration and job scheduling.

For consistency in naming of MPI libraries, specify Unified Communication X (UCX) as the point to point messaging layer (PML) implementation for the MPI infrastructure: 

$ mpirun -mca pml ucx .
openmpi.x86_64
This module provides a standard build of OpenMPI 4.1.1. Although it includes PMIx 3.x support, it does not provide CUDA or GPU acceleration support. The RHEL InfiniBand drivers and infrastructure provide InfiniBand (IB)/Remote Direct Memory Access (RDMA) functionality. The OpenMPI libraries are compiled with gcc-11.4. Use this module if your application does not use CUDA language extension or require GPU offload support.
openmpi-5.0.8-cuda-gpu

This module provides OpenMPI 5.0.8 with PMIx 4.x support and CUDA and NVIDIA GPU acceleration support by using the NVIDIA HPC-X package libraries. The RHEL InfiniBand drivers and infrastructure provide InfiniBand (IB)/Remote Direct Memory Access (RDMA) functionality. The OpenMPI libraries are compiled with gcc-11.5. Only select this module if you are using CUDA-enabled applications that require GPU acceleration.

Note

In the absence of InfiniBand NICs, a warning is displayed for failure of InfiniBand NIC autodiscovery: 

$ mpirun -n 2 /lib64/openmpi/bin/mpitests-osu_allreduce
 
...
[test-vm] Error: coll_hcoll_module.c:312 - mca_coll_hcoll_comm_query() Hcol library init failed
...

You can remove this warning by adding the -mca coll ^hcoll parameter to the mpirun command: 

$ mpirun -mca coll ^hcoll -n 2 /lib64/openmpi/bin/mpitests-osu_allreduce
 
# Size   Avg Latency(us)
  1      8.36
  2      6.85
hpcx-2.24.1
This module provides an NVIDIA built OpenMPI 4.1.5 environment. It has no PMIx support, but provides CUDA and NVIDIA GPU acceleration support. The RHEL InfiniBand drivers and infrastructure provide InfiniBand (IB)/Remote Direct Memory Access (RDMA) functionality.
hpcx-2.24.1-pmix
This module provides the same environment as the mpi/hpcx-2.24.1 module and also has PMIx 4.x support enabled.
Red Hat logoGithubRedditYoutubeTwitter

Learn

Try, buy, & sell

Communities

About Red Hat

We deliver hardened solutions that make it easier for enterprises to work across platforms and environments, from the core datacenter to the network edge.

Making open source more inclusive

Red Hat is committed to replacing problematic language in our code, documentation, and web properties. For more details, see the Red Hat Blog.

About Red Hat Documentation

We help Red Hat users innovate and achieve their goals with our products and services with content they can trust. Explore our recent updates.

Legal Notice

Theme

© 2026 Red HatBack to top