Containers allow you to:

• Package applications along with all their dependencies, configurations, libraries, and binaries. This comprehensive packaging ensures that the application runs consistently everywhere.
• Easily deploy and run them across different systems, facilitating scalability and flexibility.

1. Hardware Virtualization
   • Creates virtual machines with independent OS and resources on a single physical host.
   • Ideal for running different operating systems or when complete OS isolation is required.
   • Example: VirtualBox, VMware, AWS EC2
2. Operating System Virtualization (Containers)
   • Allows multiple isolated user-space instances on the same OS kernel.
   • Efficient and lightweight, suitable for microservices and scalable applications.
   • Example: Docker, Apptainer, Kubernetes
3. Application Virtualization
   • Packages applications and their dependencies for execution on any compatible system.
   • Perfect for deploying apps without worrying about system compatibility or installing dependencies.
   • Example: App-V, ThinApp, Turbo

• ‘Bare metal’ refers to physical servers running directly on hardware without virtualization. 🔧
• Software and applications are installed directly on the host operating system. 💿
• Resources such as CPU, memory, and storage are dedicated and not shared with other virtual machines. 📊
• Advantages: High performance, direct access to hardware, low overhead. 👍
• Limitations: Less flexibility, limited isolation between applications, potential underutilization of resources. 👎

• Virtual machines (VMs) emulate physical computers and run multiple operating systems on a single host. ⏫
• Each VM has its own virtual hardware, including CPU, memory, and storage. 💾
• VMs are managed by a hypervisor (e.g., VirtualBox, VMware) that abstracts the physical hardware. 🎛️
• VMs provide strong isolation between environments and are ideal for development, testing, and legacy applications. 🛡️
• Limitations: Additional overhead due to full OS in each VM, performance may be affected by virtualization layer. ⏳

• OS virtualization with containers allows multiple, isolated user-space instances to run on a single host OS.
• Containers share the host OS kernel but have their own file system, libraries, and dependencies.
• Containers are lightweight, start quickly, and have lower overhead compared to VMs.
• Containerization provides a consistent and reproducible environment across platforms.
• Containers are ideal for microservices, cloud-native applications, and scalable deployments.

• Researchers face difficulties in managing software installations:
  • Spend time setting up software on Hoffman2
  • Figuring out which versions and modules to load for dependencies
  • Having to wait for System Admins to help
• Then start all over when using software on a different HPC resource

• Traditional Deployment:
  • Software dependencies must be installed on the host system. 📁
  • Conflicts can occur between different software versions. ⚠️
  • Challenging to achieve consistent environments across platforms. 📉
• Containerization:
  • Dependencies are packaged within the container. 🎁
  • No conflicts with the host system or other containers. ☮️
  • Consistent and reproducible environments on any platform. 📈

To use Apptainer on Hoffman2, simply load the module:

module load apptainer

• Only module you need to load!
  • Except for a MPI module if running parallel

apptainer pull [options]
apptainer pull docker://ubuntu:20.04

apptainer build [options]
apptainer build myapp.sif myapp.def

Common Apptainer commands:

3. Run a command within a container

apptainer exec [options] container.sif
apptainer exec mypython.sif python3 test.py
# Runs the command `python3 test.py` inside the container

4. Start an interactive session inside your container

apptainer shell [options] container.sif
apptainer shell mypython.sif

• Apptainer containers run like any other application.
• Run the same commands as you normally would
  • Just add an Apptainer command to any command you want to run inside the container

So….

python3 test.py
R CMD BATCH test.R

Turns into

apptainer exec myPython.sif python3 test.py
apptainer exec myR.sif R CMD BATCH test.R

• This example will use Tensorflow

  • Great library for developing Machine Learning models

• Go to EX1 directory
• Look at tf-example.py
  • This example uses TF to train from the MINIST data

module load python
python3 tf-example.py

• Going interactively inside the container (Previous slide)
  • apptainer shell [container.sif]
• Run a single command in the container
  • apptainer exec [container.sif] [command]

qrsh -l h_data=20G
module load apptainer
apptainer pull docker://tensorflow/tensorflow:2.7.1
apptainer exec tensorflow_2.7.1.sif python3 tf-example.py

qsub tf-example.job

• This example uses PyTorch with GPU support for faster speed 🚀
  • Another great Machine Learning framework

Let’s run python3 pytorch_gpu.py on a GPU node

qrsh -l h_data=20G,gpu,V100

module load apptainer
apptainer pull docker://nvcr.io/nvidia/pytorch:22.03-py3

apptainer shell --nv pytorch_22.03-py3.sif
python3 -c "import torch; print(f'GPU is available: {torch.cuda.get_device_name(0)}' if torch.cuda.is_available() else 'GPU is NOT available')"

apptainer exec --nv pytorch_22.03-py3.sif python3 pytorch_gpu.py

qsub pytorch_gpu.job

In this example, we’ll run a parallel MPI container using NWChem, a popular computational chemistry application.

Many applications use MPI to run across multiple CPUs, and NWChem is one of them.

module load intel/2022.1.1
module load nwchem/7.0.2
`which mpirun` -np 5 nwchem water.nw > water.out

qrsh -l h_data=10,arch=intel-gold* -pe shared 5
module load intel/2022.1.1
`which mpirun` -np 5 apptainer exec $H2_CONTAINER_LOC/h2-nwchem_7.0.2.sif nwchem water.nw  > water.out

qsub nwchem.job