Skip to main content

Transfer data between you computer/cluster and EDITO

Upload or download data directly between a computer, workstation or HPC cluster and EDITO storage without using the Datalab interface.

Context


EDITO uses S3-compatible object storage for personal and project data.

Depending on your context, the storage you want to access may be:

  • Your personal EDITO storage, hosted on EDITO MinIO;

  • A project bucket hosted on EDITO MinIO;

  • An additional project bucket hosted on CloudFerro and managed by EDITO;

  • Another external S3-compatible bucket connected to EDITO, such as CloudFerro, AWS, OVH or another provider.

The commands in this article use the same syntax for all of these cases.

📌 Note: S3 object storage is not a traditional filesystem. What appears as a folder is generally a prefix in an object key rather than a real directory.

This article applies when you are working outside a running EDITO service, for example from:

  • Your laptop;

  • A workstation;

  • An HPC login or compute node;

  • A batch job;

  • A CI/CD or processing pipeline.

Inside a running EDITO service such as Jupyter, the selected S3 configuration and credentials are normally injected automatically and the MinIO Client alias s3 is already configured. See Manage files in EDITO Storage and Access EDITO Storage from code, services and processes for that use case.

Understand the storage values used in this article


To keep all commands independent of the storage provider, the examples below use three values:

Variable

Meaning

Example

<ALIAS>

Local name used by MinIO Client (mc) for the S3 endpoint. You choose this name.

edito_personal, edito_project, cf_project

<ENDPOINT>

Complete URL of the S3-compatible service.

https://minio.dive.edito.eu or https://s3.waw3-1.cloudferro.com

<WORKING_DIRECTORY_PATH>

Complete path to your storage after the alias: the bucket name, optionally followed by a prefix. Do not start it with /.

oidc-[YOUR_USERNAME] or

project-PROJECT_NAME/ or

PROJECT_NAME-bucket/

The generic remote path is therefore:

<ALIAS>/<WORKING_DIRECTORY_PATH>

For shell commands, it can be convenient to define:

  • ALIAS="my_storage"

  • WORKING_DIRECTORY_PATH="my-bucket/optional-prefix"

  • REMOTE_ROOT="${ALIAS}/${WORKING_DIRECTORY_PATH}"

All transfer commands can then use $REMOTE_ROOT, regardless of where the bucket is hosted.

💡 In the following article, all <ALIAS>/<WORKING_DIRECTORY_PATH> commands can be replaced with "$REMOTE_BOOT" if necessary (don't forget the quotation marks). For example, mc ls <ALIAS>/<WORKING_DIRECTORY_PATH> would become mc ls "$REMOTE_BOOT".

Get credentials for access outside EDITO


Personal EDITO storage

The default personal storage is hosted on EDITO MinIO.

Typical values are:

  • ALIAS=edito_personal (example, you set this value yourself when creating the alias)

  • ENDPOINT=https://minio.dive.edito.eu

  • WORKING_DIRECTORY_PATH=oidc-[YOUR_USERNAME]

You might also need:

  • Region: waw3-1

  • Access key: temporary or static access-key identifier

  • Secret key: corresponding secret

  • Token: session token when using temporary credentials

⚠️ Temporary EDITO S3 credentials are valid for 24 hours and must be used together with their session token.

Get the credentials and exact values from My Account → Connect to storage.

This section displays the storage variables for your personal bucket and lets you copy or download an initialization script in a supported programming language. The Datalab also exposes S3 snippets for several languages and libraries, so you can use the client that best fits your workflow.

Group project storage

Check the current project's configuration in Project Settings → S3 Configurations:

For an additional or external bucket, use the values supplied by that provider or displayed in Project Settings:

  • Endpoint URL;

  • Region;

  • Working-directory path, if configured;

  • Access Key ID;

  • Secret Access Key;

  • Session token, if the provider uses temporary credentials.

Access your S3 configuration:

Get the access values:

📌 Note: a private external bucket does not require an EDITO account when accessed directly. The external bucket credentials are sufficient.

Group-project storage on MinIO

Select the relevant project, then open Project Settings → S3 Configurations:

Use the endpoint and working-directory path shown in the project configuration.

For example:

  • ALIAS=edito_project (example, you set this value yourself when creating the alias)

  • ENDPOINT=https://minio.dive.edito.eu

  • WORKING_DIRECTORY_PATH=<VALUE_FROM_PROJECT_SETTINGS> (usually project-NAME_OF_THE_PROJECT)

⚠️ All project members can access group-project storage. Use credentials appropriate to the project and avoid placing unrestricted personal credentials in a shared script or service.

Group-project storage hosted on CloudFerro and managed by EDITO

If your project requires a lot of storage, you can request that user support increase your quota. In that case, the team will set up a bucket for your project that is hosted directly by the cloud provider, CloudFerro.

Select the project and open Project Settings → S3 Configurations:

The configuration may look conceptually like:

  • ALIAS=cf_project (example, you set this value yourself when creating the alias)

  • ENDPOINT=https://s3.waw3-1.cloudferro.com

  • WORKING_DIRECTORY_PATH=<VALUE_FROM_PROJECT_SETTINGS> (usually NAME_OF_THE_PROJECT-bucket)

The exact endpoint and path depend on the project configuration.

A project may have more than one S3 configuration. The configuration with Use for EDITO explorers enabled is the one displayed by default in File Explorer, but the other configurations can still represent valid storage targets.

Other external S3-compatible storage

For an external bucket managed outside EDITO, use the values supplied by the storage provider:

  • ALIAS=external_s3 (example, you set this value yourself when creating the alias)

  • ENDPOINT=https://<PROVIDER_ENDPOINT>

  • WORKING_DIRECTORY_PATH=<BUCKET>/<OPTIONAL_PREFIX>

Credentials are provided by the external storage provider.

💡Your project may be using an S3 bucket outside of EDITO: you can add its configuration in EDITO if you'd like and its settings can be reviewed in Project Settings → S3 Configurations.

Install MinIO Client


Install the MinIO Client command-line tool, named mc, on your computer or cluster.

After installation, confirm that it is available:

mc --version

Use the installation method appropriate to your operating system or cluster environment. On a managed HPC platform, you may need to install it in your home directory, use a module or ask the platform administrator.


​Configure the S3 alias

The endpoint identifies the S3 service. The alias is the local name that mc will use to refer to it.

Once the alias is configured, the endpoint no longer appears in the transfer commands via:

mc ls <ALIAS>/<WORKING_DIRECTORY_PATH>

How the alias is configured depends on whether the credentials include a session token:

Temporary credentials with a session token

Temporary EDITO credentials normally contain:

  • An access key;

  • A secret key;

  • A session token.

mc alias set only takes the endpoint, access key and secret key in its basic syntax. For credentials requiring a session token, configure an MC_HOST_<ALIAS> environment variable instead.

For example, for:

Configure:

export MC_HOST_edito_personal='https://ACCESS_KEY:SECRET_KEY:SESSION_TOKEN@minio.dive.edito.eu'

The suffix of MC_HOST_<ALIAS> is the alias used by subsequent commands:

mc ls edito_personal 

And:

 mc ls edito_personal/oidc-[YOUR_USERNAME]

💡 If you use MC_HOST_<ALIAS>, prefer an alias containing only letters, numbers and underscores, for example edito_personal or cf_project, so that it can be used safely as part of a shell environment-variable name.

⚠️ Credentials and session tokens are secrets. Do not commit them to Git, include them in shared scripts or expose them in logs.

Temporary EDITO S3 credentials normally expire after 24 hours. Obtain a new credential set when they expire.

Static credentials without a session token

Set the alias with:

mc alias set <ALIAS> <ENDPOINT> <ACCESS_KEY> <SECRET_KEY>

Then verify the connection:

mc ls <ALIAS>

And your configured storage root:

mc ls <ALIAS>/<WORKING_DIRECTORY_PATH>

Verify the configuration


As explained above, before transferring a large amount of data, test that the remote storage is accessible:

mc ls <ALIAS>/<WORKING_DIRECTORY_PATH>

If this fails, check:

  • ENDPOINT;

  • WORKING_DIRECTORY_PATH;

  • Access key and Secret key;

  • Session token, when applicable;

  • Credential expiration;

  • Network access to the S3 endpoint.

Upload data to EDITO


All commands below are identical for personal, project, CloudFerro and external storage.

Only ALIAS and WORKING_DIRECTORY_PATH change.

💡 To check the storage used in your bucket you can use:

mc du <ALIAS>/<WORKING_DIRECTORY_PATH>

Upload one file

mc cp my_file.nc <ALIAS>/<WORKING_DIRECTORY_PATH>/target_folder/my_file.nc

Upload a directory recursively

mc cp --recursive my_folder/ <ALIAS>/<WORKING_DIRECTORY_PATH>/target_folder/

All files are stored under the destination prefix.

💡 You do not need to create target_folder first. S3 will create the corresponding object-key prefix when the objects are uploaded.

​Synchronize a local directory

For repeated transfers, use mc mirror:

mc mirror my_folder/ <ALIAS>/<WORKING_DIRECTORY_PATH>/target_folder/

💡 mc mirror compares the source and destination and transfers the required changes rather than blindly copying the complete directory again. If the transfer is interrupted, run the same command again.

⚠️ Review the mc mirror options before using deletion or overwrite-related flags in an automated workflow.

Track progress and resume

mc cp displays a progress indicator for transfers.

​Large files are uploaded using multipart transfer automatically; no additional multipart configuration is normally required.


Download data to your computer or cluster


List content

mc ls <ALIAS>/<WORKING_DIRECTORY_PATH>/target_folder/

Display a small text file

mc cat is useful for a small configuration or text object, or for piping its content into another tool:

mc cat <ALIAS>/<WORKING_DIRECTORY_PATH>/target_folder/my_file.txt

⚠️ Do not use mc cat to print a very large binary object to the terminal.

Download one object

mc cp <ALIAS>/<WORKING_DIRECTORY_PATH>/target_folder/my_file.nc ./my_file.nc

​Download a prefix recursively

mc cp --recursive <ALIAS>/<WORKING_DIRECTORY_PATH>/target_folder/ ./target_folder/

Synchronize EDITO storage to a local directory

mc mirror <ALIAS>/<WORKING_DIRECTORY_PATH>/target_folder/ ./target_folder/

Copy data between two S3 storages


mc can also transfer objects directly between two configured S3 endpoints.

This works regardless of whether the source and destination are hosted on EDITO MinIO, CloudFerro or another S3-compatible provider.

For example:

mc cp <SOURCE_ALIAS>/<SOURCE_WORKING_DIRECTORY_PATH>/path/to/my_file.nc <DESTINATION_ALIAS>/<DESTINATION_WORKING_DIRECTORY_PATH>/path/to/my_file.nc

For a complete prefix/folder:

mc cp --recursive <SOURCE_ALIAS>/<SOURCE_WORKING_DIRECTORY_PATH>/source_folder/ <DESTINATION_ALIAS>/<DESTINATION_WORKING_DIRECTORY_PATH>/destination_folder/

Or synchronize them with:

mc mirror <SOURCE_ALIAS>/<SOURCE_WORKING_DIRECTORY_PATH>/source_folder/ <DESTINATION_ALIAS>/<DESTINATION_WORKING_DIRECTORY_PATH>/destination_folder/

Both aliases must be configured with credentials that allow the required operation.

Manage objects with mc inside the same storage


Copy an object

mc cp <ALIAS>/<WORKING_DIRECTORY_PATH>/path/to/my_file.nc <ALIAS>/<WORKING_DIRECTORY_PATH>/path/to/my_file.nc

Copy a prefix

mc cp --recursive <ALIAS>/<WORKING_DIRECTORY_PATH>/source_prefix/ <ALIAS>/<WORKING_DIRECTORY_PATH>/destination_prefix/

Move or rename an object

mc mv <ALIAS>/<WORKING_DIRECTORY_PATH>/old_path/my_file.nc <ALIAS>/<WORKING_DIRECTORY_PATH>/new_path/my_file.nc

Move or rename a prefix

mc mv --recursive <ALIAS>/<WORKING_DIRECTORY_PATH>/old_prefix/ <ALIAS>/<WORKING_DIRECTORY_PATH>/new_prefix/

For large prefixes, remember that object storage may implement a move as a copy followed by deletion.

Delete one object

mc rm <ALIAS>/<WORKING_DIRECTORY_PATH>/path/to/my_file.nc

Delete all objects under a prefix

Preview the operation first:

mc rm --recursive --force --dry-run <ALIAS>/<WORKING_DIRECTORY_PATH>/path/to/prefix/

Then, if the target is correct:

mc rm --recursive --force <ALIAS>/<WORKING_DIRECTORY_PATH>/path/to/prefix/

⚠️ Recursive deletion is irreversible unless the bucket has an independent versioning or backup policy. Check the alias, bucket and prefix carefully.

Open scientific data without a complete download


Libraries such as s3fs, fsspec, xarray and Zarr can read supported formats directly from private S3 storage.

This can reduce data transfer when the format supports partial or chunked access and you only need a subset of a large dataset.

For the canonical authenticated xarray and s3fs examples, see Access EDITO storage from code, services and processes.


Transfer data from an HPC cluster or batch job


Because mc is entirely command-line based, the same commands can be used in SSH sessions, SLURM jobs or other automated workflows.

Before running a large transfer from compute nodes:

  • Confirm that the nodes can reach ENDPOINT;

  • Check proxy and firewall rules;

  • Avoid hard-coding credentials in a shared job script;

  • Use your cluster's secret-management mechanism when available;

  • Make sure temporary credentials will remain valid for the expected duration of the transfer.

Upload with Python and boto3


Use boto3 when the transfer is part of an existing Python pipeline.

boto3 does not provide a direct one-command equivalent of mc mirror for a whole local directory. To synchronize a directory, iterate through the local files, build each object key and call upload_file, or use a dedicated synchronization tool.

For in-memory uploads and additional Python examples, see Access EDITO storage from code, services and processes.


Good practices


  • Always copy the exact endpoint and working-directory path from My Account → Connect to storage, Project Settings → S3 Configurations, or your external provider.

  • Do not assume that a project name is also the bucket name.

  • Check the destination bucket's quota before a large upload.

  • Do not begin WORKING_DIRECTORY_PATH or an object key with /.

  • Use mc mirror for repeated synchronization rather than uploading unchanged files again.

  • Keep a transfer log for long automated jobs.

  • Verify object counts and sizes after a critical migration.

  • Use checksums or application-level validation when data integrity is essential.

  • Keep credentials outside source code and rotate them after exposure.

  • Prefer short-lived credentials for interactive transfers.

  • Restrict static credentials to the minimum bucket, prefix and operations.

  • Remember that temporary EDITO credentials expire after 24 hours.

💡 About folders and prefixes

You normally do not need to create a folder before uploading data.

For example:

mc cp my_file.nc <ALIAS>/<WORKING_DIRECTORY_PATH>/results/2026/my_file.nc

automatically creates an object whose key is:

results/2026/my_file.nc

File Explorer and mc will display results/2026/ as a folder-like hierarchy.

Troubleshooting


AccessDenied

Check that the credentials have permission to access the requested bucket and prefix. Credentials for one personal space, project or provider may not be valid for another.

Also check that <WORKING_DIRECTORY_PATH> points to the path accessible with those credentials.

InvalidToken or ExpiredToken

Obtain a new temporary credential set, including a new session token, then recreate the MC_HOST_<ALIAS> variable or Python client.


​NoSuchBucket​

Check the bucket name and whether the value shown in Project Settings is a bucket or a working-directory path inside a bucket.

Use the exact value supplied by the storage configuration rather than guessing it from the project name.

Connection or TLS error

Check <ENDPOINT>, including the URL scheme.

For the default EDITO MinIO storage: https://minio.dive.edito.eu

Also check local proxy, firewall, DNS and outbound-network rules.

HPC login nodes and compute nodes may have different network-access policies.

The object appears under an unexpected path

S3 object keys should not normally begin with /. Compare the source and destination paths carefully and remember that a trailing / changes how some recursive copy commands construct the destination keys.


What's next?


For operations performed inside an EDITO service, see:

For configuring another S3 provider in EDITO, see:

For project-specific storage, see:

If you have any questions, problems, or suggestions, please feel free to contact us via chat using the widget available at the bottom right of the page.

Did this answer your question?