Services

Instructions for getting started with Triton and LUMI

From this page you can find instructions for getting started with Triton and LUMI.

Logging in to Triton

Access to Triton is done first by creating an account and then establishing a connection to Triton.

Creating an account:

Triton uses the Aalto user account, but the account must first be activated:

Aalto users must request access to Triton via the form on the following page, under “Scientific computing” and then “Triton: New user account”: https://selfservice.esupport.aalto.fi/ssc/app#/home/
Creating the connection:

The connection is created via SSH remote access with the following command:

^{ssh triton.aalto.fi}

Or, if your username is different, use the following command:

^{ssh USERNAME@triton.aalto.fi}

If necessary, you can add the -X flag if you are using graphical applications.

The command opens a terminal session through which Triton is used. When running the command, Triton may ask for a password to log in. The password is the same as for your Aalto user account.

More information and instructions can be found at: https://scicomp.aalto.fi/triton/quickstart/connecting/

Triton FAQ at: https://scicomp.aalto.fi/triton/usage/faq/

Using Triton

General instructions for using Triton:

You can connect to Triton via SSH from within the Aalto network as shown in the example above. It is also possible to connect via SSH from outside the network using the Aalto VPN.

Other options for connecting include the web-based Open OnDemand interface, Jupyter, and the “Remote - SSH” extension in VS Code.

You can find more information about connecting at: https://scicomp.aalto.fi/triton/quickstart/connecting/

_{Will be updated}

Singularity and Triton

Using Singularity with Triton’s pre‑configured modules:

Some Triton modules automatically activate a Singularity image. When the correct image is selected, environment variables are set and the use of _{apptainer_wrapper} is enabled.

_{apptainer_wrapper} provides three commands:

1) _{apptainer_wrapper shell [SHELL]}
gives the user a shell inside the image

2) _{apptainer_wrapper exec CMD}
runs a program inside the image

3) _{apptainer_wrapper PARAMETERS}
runs the Apptainer/Singularity image
Transferring a Singularity image to Triton

1) Transferring a locally created image is done usingscporrsync:

^{scp <container-name>.sif USERNAME@triton.address:path/on/triton/}

^{rsync -avh <container-name>.sif USERNAME@triton.address:path/on/triton/}

After this, load and run Singularity as follows:

^{module load singularity}
^{singularity exec <container-name>.sif python script.py}

2) Transferring a Singularity definition file and building it on Triton is donewithscp:

^scp ^{<container-name>.def USERNAME@triton.address:path/on/triton/}

Then load and run Singularity as follows:

^{module load singularity}
^{singularity build <container-name>.sif <container-name>.def}

If the container is large or needs libraries that are only available on Triton, this approach is preferable.

_{Will be updated}

Logging in to LUMI and starting a project

Access to LUMI is obtained first by creating a user account and then by creating or joining a project. After creating an account, LUMI can be used either via the terminal or through the MyCSC page. Instructions for using the terminal can be found in the “Using LUMI” section below.

Creating a user account:

Aalto users create an account via Haka login. The account is created as follows:

1. Go to: https://my.csc.fi/welcome.

2. Click "Create account".

3. Choose Haka login and then select Aalto University.

4. Fill in your details on the account creation page.

5. You will then receive an email with a link to the MyCSC page to set the password for your CSC account.

6. After successful registration, you will receive a confirmation email. If you do not receive one, try logging in; if that also fails, try creating the account again.

After creating the account, you can log in at: https://my.csc.fi/login by selecting Haka login.
Creating or joining a project on the MyCSC page:

Creating a project:

On the MyCSC page, a project is created after logging in by selecting:
1) “Projects” from the menu on the left
2) “+ New project” on the right
3) the project category (“Academic”, “Course” or “LUMI”; more information below)
4) the project name and by filling in the project description and other required information
5) the needed services for the project and adjusting the resource packages
6) finally, accepting the terms and conditions
Joining a project:

For a user, joining a project is very straightforward on the MyCSC page. After logging in, select “Apply project membership”.

Only the project leader can manage the users belonging to the project. Users can be added directly or via an invitation link. More information can be found in the links below.

More information and instructions:

About user accounts: https://docs.csc.fi/accounts/
Creating a user account: https://docs.csc.fi/accounts/how-to-create-new-user-account/
Creating or joining a project and LUMI categories: https://docs.csc.fi/accounts/how-to-create-new-project/
Managing project members as a project leader: https://docs.csc.fi/accounts/how-to-add-members-to-project/

Using LUMI

General instructions for using LUMI:

LUMI can also be used via the terminal, in which case you need to have an SSH key pair created. Instructions for creating a key pair can be found at:
https://docs.lumi-supercomputer.eu/firststeps/SSH-keys/

After creating the key pair, you can log in to LUMI via the terminal with the command

^{ssh -i <path-to-private-key> <username>@lumi.csc.fi}

where ^{<path-to-private-key>} is replaced with the path to the file containing your private key, and ^<username> is replaced with your username.

If creating the connection fails, you should check the version of your ssh key. Due to LUMI's strict security policies, you might have to create your ssh keypair again as LUMI accepts RSA (4069 bit) or ed25519 algorithm keys.

For troubleshooting, you can run the following command, which gives a verbose output of different phases of trying to create a connection:

_{ssh -vvv <lumi-account>@lumi.csc.fi}

More information about SSH login can be found at:
https://docs.lumi-supercomputer.eu/firststeps/loggingin/
Transferring data to and from LUMI

There are two options for data transfer:

1. scp (Secure Copy Protocol)
The scp command can be used to copy and transfer files between different UNIX-like operating systems. scp copies and transfers complete files. Files can be transferred either between a local and a remote host, or between two remote hosts.

The command is used as follows:

^{scp <source-path> <destination-path>}
where _source-path is the path to the file to be transferred, which will be copied to the location specified by _{destination-path}

^{scp <source-path> [user@]host:<destination-path>}
where the user on the destination host is specified

^{scp [user@]host:<source-path> <destination-path>}
where the user on the source host is specified

2. rsync (Remote Sync)
The rsync command is used to synchronize a remote host and a local host. When using this command, the amount of copied data is minimal, as only modified files are copied and transferred. The command is also a better option for transferring large files, because rsync keeps track of transfer progress.

The command is used as follows:

^{rsync <options> <source-path> <destination-path>}
where _options are attributes/flags that are applied directly to the destination file

^{rsync <options> <source-path> [user@]host:<destination-path>}
where the user on the destination host is specified

^{rsync <options> [user@]host:<source-path> <destination-path>}
where the user on the source host is specified

More information on using the scp and rsync commands:
https://docs.lumi-supercomputer.eu/firststeps/movingdata/

_{Will be updated}

Singularity and LUMI

It is possible to use Singularity containers on LUMI as well. There are two options for creating and adding containers: pulling container images from a registry (such as DockerHub), or creating your own Singularity SIF container on LUMI.

Using a pre-built container from a registry

Containers can be pulled with the pull command (the example below pulls an Ubuntu image from DockerHub):

_{singularity pull docker://ubuntu:24.04}

Remember to be careful when pulling images and only use trusted, verified sources to avoid vulnerabilities or even malware.
Creating your own container

The _{singularity build} command requires root privileges, such as using sudo or fakeroot. However, these are disabled on LUMI due to security policies.

There are three possible ways to build a container:

1) Using the containr tool on LUMI

containr is loaded with the following commands:

^{module load CrayEnv}
^{module load containr}

After this, containers can be built using:

^{containr build}

You can attach either LUMI’s recommended base image with the --system flag, or use your own base image via --<image-name>.

2) Building your own container on local hardware (your own machine)

When the container is built on your local machine, it is transferred to LUMI using the data transfer methods described in the section above. The file transferred to LUMI must be a SIF file.

An example of a Singularity definition file can be found at:
https://docs.lumi-supercomputer.eu/software/containers/singularity/#building-containers-on-local-hardware.

3) Building or extending a container using Singularity’s PRoot unprivileged build mode

This option does not require root privileges and is aligned with LUMI’s security practices.

PRoot is used on LUMI through modules. The easiest way is to run:

^{module load CrayEnv}
^{module load PRoot}

You must define a definition file for the container. After that, the image is created with:

^{singularity build <image-name>.sif <definition-file>.def}

More information about using PRoot on LUMI:
https://lumi-supercomputer.github.io/LUMI-EasyBuild-docs/p/PRoot/#pre-installed-modules-and-easyconfigs

More information about the PRoot build model itself:
https://docs.sylabs.io/guides/3.11/user-guide/build_a_container.html#unprivilged-proot-builds.

More information about using Singularity on LUMI:
https://docs.lumi-supercomputer.eu/software/containers/singularity/.

Communication between Triton and LUMI

will be updated...

This service is provided by:

IT Services

For further support, please contact us.

Updated: 6.5.2026
Published: 4.3.2026