How To Make Singularity Look Like A Formal Shell

7 min read Sep 30, 2024

How to Make Singularity Look Like a Formal Shell

The world of containerization offers powerful tools for managing and deploying applications, and Singularity is a popular choice for its security and reproducibility features. But sometimes, you might find yourself needing to bridge the gap between the practicality of Singularity and the expectations of a more formal shell environment.

Let's explore how you can make Singularity resemble a conventional shell experience, offering a blend of functionality and familiarity.

The "Singularity Shell" Illusion

The core idea is to create a seamless interaction within your Singularity container while maintaining the look and feel of a standard shell. This is achieved through strategic use of environment variables and shell scripts.

1. Environment Variables: At the heart of this approach is leveraging environment variables to customize the Singularity environment.

PS1: This variable defines the shell prompt. You can tailor it to reflect the container's name, image, or other relevant details. For example:
```
PS1='[Singularity:$(basename $(pwd))] $ '
```
This will display a prompt like [Singularity:my-container] $.
PATH: Ensure that the necessary tools and executables within the Singularity container are accessible. You can modify the PATH variable to include the container's specific paths.
```
PATH=$PATH:/usr/local/bin:/usr/bin
```
SINGULARITY_ENV: This variable allows you to load a specific configuration file within the container. You can create a file containing environment variable settings for your Singularity environment.

2. Custom Shell Scripts: To enhance the shell experience further, consider creating custom shell scripts that execute within the Singularity container:

singularity-entry.sh: This script can be used as the entry point for your Singularity container. It can set up the environment, execute commands, and even manage the container's lifecycle.
singularity-functions.sh: Create a file to house reusable functions for common tasks. These functions can be sourced within your singularity-entry.sh script.

Example

Let's illustrate this with a basic example:

1. Create a singularity-entry.sh script:

#!/bin/bash

# Set a custom prompt
PS1='[Singularity:$(basename $(pwd))] $ '

# Modify PATH to include container-specific tools
PATH=$PATH:/usr/local/bin:/usr/bin

# Source functions
. singularity-functions.sh 

# Execute commands or run a specific application
echo "Welcome to the Singularity shell!"

2. Create a singularity-functions.sh script:

#!/bin/bash

# Define a function to list files
list_files() {
    ls -l
}

# Define a function to check for a specific package
check_package() {
  if command -v $1 &> /dev/null; then
    echo "$1 is installed."
  else
    echo "$1 is not installed."
  fi
}

3. Create a Singularity definition file:

Bootstrap: docker
From: ubuntu:latest

%post
   yum update -y
   yum install -y bash
   echo '#!/bin/bash' > singularity-entry.sh
   echo 'PS1="[Singularity:$(basename $(pwd))] \$ "' >> singularity-entry.sh
   echo 'PATH=$PATH:/usr/local/bin:/usr/bin' >> singularity-entry.sh
   echo '. singularity-functions.sh' >> singularity-entry.sh
   echo 'echo "Welcome to the Singularity shell!"' >> singularity-entry.sh
   chmod +x singularity-entry.sh
   echo '#!/bin/bash' > singularity-functions.sh
   echo 'list_files() { ls -l; }' >> singularity-functions.sh
   echo 'check_package() { if command -v \$1 &> /dev/null; then echo "\$1 is installed."; else echo "\$1 is not installed."; fi; }' >> singularity-functions.sh
   chmod +x singularity-functions.sh
   mkdir /tmp/singularity_env
   echo 'PS1="[Singularity:$(basename $(pwd))] \$ "' > /tmp/singularity_env/env.sh
   chmod +x /tmp/singularity_env/env.sh

%runscript
   /bin/bash singularity-entry.sh

%environment
   SINGULARITY_ENV /tmp/singularity_env/env.sh

4. Build the Singularity image:

singularity build my-container.sif my-container.def

5. Run the image:

singularity run my-container.sif

This will start a shell session with a modified prompt, access to container-specific tools, and the ability to execute commands or run applications.

Tips

Modularize your scripts: Break down functionalities into separate scripts for better organization.
Use environment variables extensively: Employ environment variables to control various aspects of your Singularity environment, from prompt customization to path settings.
Document your scripts: Make sure to add comments to your scripts for clarity and maintainability.
Test thoroughly: Test your scripts and modifications extensively to ensure they work as expected within your Singularity container.

Conclusion

By implementing these techniques, you can create a more user-friendly Singularity experience. You can tailor the container's environment to match the familiar shell interactions, making it easier for developers and users to work within the containerized environment. The key is to leverage the flexibility of Singularity's configuration options to customize the shell experience.

How To Make Singularity Look Like A Formal Shell