Getting started with Managed Service for MLflow: create your first cluster

MLflow helps to track and manage your machine learning experiments. With clusters for MLflow in Nebius AI Cloud, you can deploy MLflow in a cloud in just a couple of clicks and connect to it easily from machines that run your workloads. This guide covers how to set up your environment to work with Managed Service for MLflow, create your first cluster, run a simple experiment and access its artifacts in Object Storage.

Prerequisites

Web console
CLI
Go SDK
Python SDK
JavaScript SDK

Install the MLflow Python package that provides an API to run and manage experiments in your code:
pip install mlflow
Make sure you are in a group that has the admin role within your tenant or project; for example, the default admins group. You can check this in the Administration → IAM section of the web console.

Install the following tools:
- MLflow: Python package that provides an API to run and manage experiments in your code.
- Nebius AI Cloud CLI (How to install the CLI): To manage all Nebius AI Cloud resources.
Here are all the installation commands in a single copy-and-paste block:
pip install mlflow curl -sSL https://artifacts.nebius.cloud/cli/install.sh | bash nebius profile create
pip install mlflow curl -sSL https://artifacts.nebius.cloud/cli/install.sh | bash nebius profile create
The last command, nebius profile create, will guide you through several prompts. After you complete the prompts, your browser will open the Nebius AI Cloud web console sign-in screen. Sign in to the web console to complete the initialization. If you have access to multiple tenants, the CLI will prompt you to choose a tenant ID. After that, save your project ID in the CLI configuration. If the project ID hasn’t been configured during the nebius profile create flow, get the project ID and save it in the CLI configuration:
nebius config set parent-id <project_ID>
Make sure that you, or the service account that you use on your behalf, is in a group that has the admin role within your tenant; for example, the default admins group. You can check this in the Administration → IAM section of the web console.

Install the MLflow Python package that provides an API to run and manage experiments in your code:
pip install mlflow
Install and initialize the Nebius SDK for Go.
Make sure that you, or the service account that you use on your behalf, is in a group that has the admin role within your tenant; for example, the default admins group. You can check this in the Administration → IAM section of the web console.

Install the MLflow Python package that provides an API to run and manage experiments in your code:
pip install mlflow
Install and initialize the Nebius SDK for Python.
Make sure that you, or the service account that you use on your behalf, is in a group that has the admin role within your tenant; for example, the default admins group. You can check this in the Administration → IAM section of the web console.

Install the MLflow Python package that provides an API to run and manage experiments in your code:
pip install mlflow
Install and initialize the Nebius SDK for JavaScript.
Make sure that you, or the service account that you use on your behalf, is in a group that has the admin role within your tenant; for example, the default admins group. You can check this in the Administration → IAM section of the web console.

Steps

Create a cluster

Web console
CLI
Go SDK
Python SDK
JavaScript SDK

In the sidebar, go to MLflow.
Click Create cluster.
On the cluster creation page that opens, set the following parameters:
- Name: Enter a name for your cluster.
- Service account: Select the mlflow-sa service account. It was created for Managed MLflow by default after you signed up for Nebius AI Cloud.
- Access: Select the Public and private option. In this case, the cluster has both public and private tracking endpoints. You can access the public endpoint from the internet and the private endpoint from the network where the cluster is located (for example, via a virtual machine in this network).
- Cluster size: Select Medium.
- Admin credentials: Enter a username and a strong password.
Click Create cluster.

Create a password for administrator access to the cluster and save it to an environment variable:
export PASSWORD=<password>
The password must be between 8 and 64 characters long and must contain at least the following:
- One uppercase letter
- One lowercase letter
- One digit
- One special character from **-!@#$^&*_=+:;’”\|/?,.~\§\±()[]{}<>\`**.
Get the ID of the mlflow-sa service account. It was created by default after you signed up for Nebius AI Cloud. Save the ID to an environment variable:
export SA_ID=$(nebius iam service-account get-by-name \ --name mlflow-sa \ --format jsonpath='{.metadata.id}')

Get the ID of the default network and save it to an environment variable:

export NETWORK_ID=$(nebius vpc network get-by-name \
  --name default-network \
  --format jsonpath='{.metadata.id}')

Create a test cluster:

nebius msp mlflow v1alpha1 cluster create \
  --name mlflow-test-cluster \
  --service-account-id $SA_ID \
  --network-id $NETWORK_ID \
  --admin-username admin \
  --admin-password $PASSWORD \
  --public-access=true

Get the ID of the mlflow-sa service account. It was created by default after you signed up for Nebius AI Cloud:

serviceAccount, err := sdk.Services().IAM().V1().
    ServiceAccount().GetByName(
        ctx,
        &iam.GetServiceAccountByNameRequest{
            ParentId: "<project_ID>",
            Name: "mlflow-sa",
        },
    )
if err != nil {
    return fmt.Errorf("get service account by name: %w", err)
}
serviceAccountID := serviceAccount.GetMetadata().GetId()
fmt.Println(serviceAccountID)

In ParentId, specify the project ID. The code prints the service account ID.

Get the ID of the default network:

network, err := sdk.Services().VPC().V1().Network().
    GetByName(
        ctx,
        &vpc.GetNetworkByNameRequest{
            ParentId: "<project_ID>",
            Name: "default-network",
        },
    )
if err != nil {
    return fmt.Errorf("get network by name: %w", err)
}
networkID := network.GetMetadata().GetId()
fmt.Println(networkID)

The code prints the network ID.

Create a test cluster:

createService := sdk.Services().MSP().MLFlow().
    V1Alpha1().Cluster()
createOperation, err := createService.Create(
    ctx,
    &mlflow.CreateClusterRequest{
        Metadata: &common.ResourceMetadata{
            ParentId: "<project_ID>",
            Name: "mlflow-test-cluster",
        },
        Spec: &mlflow.ClusterSpec{
            NetworkId: "<network_ID>",
            ServiceAccountId: "<service_account_ID>",
            AdminUsername: "admin",
            AdminPassword: "<password>",
            PublicAccess: true,
        },
    },
)
if err != nil {
    return fmt.Errorf("create cluster: %w", err)
}
_, err = createOperation.Wait(ctx)
if err != nil {
    return fmt.Errorf("wait for cluster creation: %w", err)
}

The code creates the mlflow-test-cluster cluster with the admin administrator username and both public and private tracking endpoints. In the code, specify the following values:

Metadata.ParentId: Project ID.
Spec.NetworkId: Network ID that you got earlier.
Spec.ServiceAccountId: ID of the mlflow-sa service account that you got earlier.
Spec.AdminPassword: Strong password for the cluster administrator. The password must be between 8 and 64 characters long and must contain at least the following:
- One uppercase letter
- One lowercase letter
- One digit
- One special character from **-!@#$^&*_=+:;’”\|/?,.~\§\±()[]{}<>\`**.

Get the ID of the mlflow-sa service account. It was created by default after you signed up for Nebius AI Cloud:

service_account_service = ServiceAccountServiceClient(sdk)
service_account = await service_account_service.get_by_name(
    GetServiceAccountByNameRequest(
        parent_id="<project_ID>",
        name="mlflow-sa",
    ),
)
service_account_id = service_account.metadata.id
print(service_account_id)

In parent_id, specify the project ID. The code prints the service account ID.

Get the ID of the default network:

network_service = NetworkServiceClient(sdk)
network = await network_service.get_by_name(
    GetNetworkByNameRequest(
        parent_id="<project_ID>",
        name="default-network",
    ),
)
network_id = network.metadata.id
print(network_id)

The code prints the network ID.

Create a test cluster:

create_service = mlflow.ClusterServiceClient(sdk)
create_operation = await create_service.create(
    mlflow.CreateClusterRequest(
        metadata=ResourceMetadata(
            parent_id="<project_ID>",
            name="mlflow-test-cluster",
        ),
        spec=mlflow.ClusterSpec(
            network_id="<network_ID>",
            service_account_id="<service_account_ID>",
            admin_username="admin",
            admin_password="<password>",
            public_access=True,
        ),
    ),
)
await create_operation.wait()

The code creates the mlflow-test-cluster cluster with the admin administrator username and both public and private tracking endpoints. In the code, specify the following values:

metadata.parent_id: Project ID.
spec.network_id: Network ID that you got earlier.
spec.service_account_id: ID of the mlflow-sa service account that you got earlier.
spec.admin_password: Strong password for the cluster administrator. The password must be between 8 and 64 characters long and must contain at least the following:
- One uppercase letter
- One lowercase letter
- One digit
- One special character from **-!@#$^&*_=+:;’”\|/?,.~\§\±()[]{}<>\`**.

Get the ID of the mlflow-sa service account. It was created by default after you signed up for Nebius AI Cloud:

const serviceAccountService =
  new ServiceAccountService(sdk);
const serviceAccount = await serviceAccountService.getByName(
  GetServiceAccountByNameRequest.create({
    parentId: "<project_ID>",
    name: "mlflow-sa",
  }),
).result;
const serviceAccountId = serviceAccount.metadata.id;
console.log(serviceAccountId);

In parentId, specify the project ID. The code prints the service account ID.

Get the ID of the default network:

const networkService = new NetworkService(sdk);
const network = await networkService.getByName(
  GetNetworkByNameRequest.create({
    parentId: "<project_ID>",
    name: "default-network",
  }),
).result;
const networkId = network.metadata.id;
console.log(networkId);

The code prints the network ID.

Create a test cluster:
const createService = new mlflow.ClusterService(sdk); const createOperation = await createService.create( mlflow.CreateClusterRequest.create({ metadata: { parentId: "<project_ID>", name: "mlflow-test-cluster", }, spec: { networkId: "<network_ID>", serviceAccountId: "<service_account_ID>", adminUsername: "admin", adminPassword: "<password>", publicAccess: true, }, }), ).result; await createOperation.wait();
The code creates the mlflow-test-cluster cluster with the admin administrator username and both public and private tracking endpoints. In the code, specify the following values:
- metadata.parentId: Project ID.
- spec.networkId: Network ID that you got earlier.
- spec.serviceAccountId: ID of the mlflow-sa service account that you got earlier.
- spec.adminPassword: Strong password for the cluster administrator. The password must be between 8 and 64 characters long and must contain at least the following:
  - One uppercase letter
  - One lowercase letter
  - One digit
  - One special character from **-!@#$^&*_=+:;’”\|/?,.~\§\±()[]{}<>\`**.

Together with the cluster, Managed Service for MLflow creates a bucket in Object Storage to store the experiment logs and metrics. This bucket is not deleted automatically after you delete the cluster. You are still charged for the bucket until you delete it.

Configure connection to MLflow Tracking

Get the cluster tracking endpoint and save it to an environment variable:

Web console
CLI
Go SDK
Python SDK
JavaScript SDK

Go to the cluster page and copy the Public Tracking URI value. Prepend https:// to it and save the resulting URL to an environment variable:

export MLFLOW_TRACKING_URI=https://<public_tracking_URI>

Run the following command:

export MLFLOW_TRACKING_URI=https://$(nebius msp mlflow v1alpha1 cluster get-by-name \
  --name mlflow-test-cluster \
  --format jsonpath='{.status.tracking_endpoint}')

Get the tracking endpoint of the cluster:

trackingService := sdk.Services().MSP().MLFlow().
    V1Alpha1().Cluster()
trackingCluster, err := trackingService.GetByName(
    ctx,
    &mlflow.GetClusterByNameRequest{
        ParentId: "<project_ID>",
        Name: "mlflow-test-cluster",
    },
)
if err != nil {
    return fmt.Errorf("get cluster by name: %w", err)
}
mlflowTrackingURI := "https://" +
    trackingCluster.GetStatus().GetTrackingEndpoint()
if err := os.Setenv(
    "MLFLOW_TRACKING_URI", mlflowTrackingURI,
); err != nil {
    return fmt.Errorf("set tracking URI: %w", err)
}
fmt.Println(trackingCluster.GetStatus().GetTrackingEndpoint())

In ParentId, specify the project ID. The code sets the MLFLOW_TRACKING_URI environment variable for the process that runs it and prints the tracking endpoint. To use the endpoint in your terminal, run the code and save its output to an environment variable:

export MLFLOW_TRACKING_URI=https://$(<command_that_runs_your_code>)

In this command, set the command that runs your code, for example, go run .. The code must print only the tracking endpoint, otherwise the variable gets the whole output.

Get the tracking endpoint of the cluster:

tracking_service = mlflow.ClusterServiceClient(sdk)
tracking_cluster = await tracking_service.get_by_name(
    mlflow.GetClusterByNameRequest(
        parent_id="<project_ID>",
        name="mlflow-test-cluster",
    ),
)
os.environ["MLFLOW_TRACKING_URI"] = (
    "https://" + tracking_cluster.status.tracking_endpoint
)
print(tracking_cluster.status.tracking_endpoint)

In parent_id, specify the project ID. The code sets the MLFLOW_TRACKING_URI environment variable for the process that runs it and prints the tracking endpoint. To use the endpoint in your terminal, run the code and save its output to an environment variable:

export MLFLOW_TRACKING_URI=https://$(<command_that_runs_your_code>)

In this command, set the command that runs your code, for example, python3 main.py. The code must print only the tracking endpoint, otherwise the variable gets the whole output.

Get the tracking endpoint of the cluster:

const trackingService = new mlflow.ClusterService(sdk);
const trackingCluster = await trackingService.getByName(
  mlflow.GetClusterByNameRequest.create({
    parentId: "<project_ID>",
    name: "mlflow-test-cluster",
  }),
).result;
process.env.MLFLOW_TRACKING_URI =
  "https://" + (trackingCluster.status?.trackingEndpoint ?? "");
console.log(trackingCluster.status?.trackingEndpoint ?? "");

In parentId, specify the project ID. The code sets the MLFLOW_TRACKING_URI environment variable for the process that runs it and prints the tracking endpoint. To use the endpoint in your terminal, run the code and save its output to an environment variable:

export MLFLOW_TRACKING_URI=https://$(<command_that_runs_your_code>)

In this command, set the command that runs your code, for example, node main.mjs. The code must print only the tracking endpoint, otherwise the variable gets the whole output.

Set up other environment variables used by MLflow Tracking:

export MLFLOW_TRACKING_USERNAME=<admin_username>
export MLFLOW_TRACKING_PASSWORD=<admin_password>
export MLFLOW_EXPERIMENT_NAME=<default_experiment_name>

For more details on secure connection to the tracking server, see MLflow documentation.

Run an experiment and check its results

Run an experiment:

Create a Python script, nebius_mlflow_test.py, that trains a linear regression model on a simple, randomly populated dataset and uses MLflow autologging to log the training:

import mlflow
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression

np.random.seed(42)
X = np.random.rand(100, 1)
y = 3.5 * X.squeeze() + np.random.randn(100) * 0.5
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42)

mlflow.autolog()

model = LinearRegression()
model.fit(X_train, y_train)

Run the script:
python3 nebius_mlflow_test.py

Check the experiment artifacts:

Web console
CLI
Go SDK
Python SDK
JavaScript SDK

Go to the cluster page and click Go to web UI.
Enter the admin credentials you specified when creating the cluster.
In the MLflow UI, select the experiment you just ran and review its results.

Get the public tracking endpoint URL of the cluster:

nebius msp mlflow v1alpha1 cluster get-by-name \
  --name mlflow-test-cluster \
  --format jsonpath='{.status.tracking_endpoint}'

Open the URL in your browser and enter the admin credentials you specified when creating the cluster.
In the MLflow UI, select the experiment you just ran and review its results.

Get the public tracking endpoint URL of the cluster:

publicTrackingService := sdk.Services().MSP().MLFlow().
    V1Alpha1().Cluster()
publicTrackingCluster, err := publicTrackingService.GetByName(
    ctx,
    &mlflow.GetClusterByNameRequest{
        ParentId: "<project_ID>",
        Name: "mlflow-test-cluster",
    },
)
if err != nil {
    return fmt.Errorf("get cluster by name: %w", err)
}
fmt.Println(publicTrackingCluster.GetStatus().GetTrackingEndpoint())

In ParentId, specify the project ID.

Open the printed URL in your browser and enter the admin credentials you specified when creating the cluster.
In the MLflow UI, select the experiment you just ran and review its results.

Get the public tracking endpoint URL of the cluster:

public_tracking_service = mlflow.ClusterServiceClient(sdk)
public_tracking_cluster = await public_tracking_service.get_by_name(
    mlflow.GetClusterByNameRequest(
        parent_id="<project_ID>",
        name="mlflow-test-cluster",
    ),
)
print(public_tracking_cluster.status.tracking_endpoint)

In parent_id, specify the project ID.

Open the printed URL in your browser and enter the admin credentials you specified when creating the cluster.
In the MLflow UI, select the experiment you just ran and review its results.

Get the public tracking endpoint URL of the cluster:

const publicTrackingService =
  new mlflow.ClusterService(sdk);
const publicTrackingCluster = await publicTrackingService.getByName(
  mlflow.GetClusterByNameRequest.create({
    parentId: "<project_ID>",
    name: "mlflow-test-cluster",
  }),
).result;
console.log(publicTrackingCluster.status?.trackingEndpoint ?? "");

In parentId, specify the project ID.

Open the printed URL in your browser and enter the admin credentials you specified when creating the cluster.
In the MLflow UI, select the experiment you just ran and review its results.

If the client where you work requires a certificate, use the certificate provided by your operating system. For example, check the /etc/ssl/ folder on macOS.

AI services in Nebius AI Cloud

Serverless AI

Managed Service for MLflow

Applications in Nebius AI Cloud

Tutorials

Third-party integrations

Getting started with Managed Service for MLflow: create your first cluster

Prerequisites

Steps

Create a cluster

Configure connection to MLflow Tracking

Run an experiment and check its results

​Prerequisites

​Steps

​Create a cluster

​Configure connection to MLflow Tracking

​Run an experiment and check its results

Prerequisites

Steps

Create a cluster

Configure connection to MLflow Tracking

Run an experiment and check its results