How to Deploy ClearML as a GCP Vertex AI Alternative

15 min readUpdated 24 September 2026

Google Vertex AI is Google Cloud's managed machine learning platform that provides experiment tracking, training jobs, pipelines, a model registry, and model serving as hosted services within the GCP ecosystem. It abstracts infrastructure management but ties teams to GCP-specific APIs, per-use compute billing, and Google's tooling.

ClearML is an open-source MLOps platform that delivers experiment management, distributed training coordination, pipeline orchestration, and model serving without requiring a cloud provider account. It deploys on any Docker host or Kubernetes cluster, captures training metrics automatically without code changes, and keeps all data within the team's own infrastructure.

This article explains how to deploy ClearML Server using Docker Compose with Traefik as a reverse proxy, configure agents for remote execution, and run machine learning workflows. It covers experiment tracking, pipeline creation, hyperparameter optimization, model serving with Triton, and migration strategies from Google Vertex AI.

Understanding ClearML Architecture

ClearML maps directly to Vertex AI components, providing equivalent functionality through a self-hosted, cloud-agnostic platform.

GCP Vertex AI	ClearML Equivalent	Description
Vertex AI Workbench	ClearML Web UI	Browser-based interface for experiment monitoring, configuration, and visualization
Vertex AI Experiments	ClearML Experiment Manager	Automatic tracking of hyperparameters, metrics, code versions, and artifacts
Vertex AI Training Job	ClearML Agent + Tasks	Agent-based execution where any machine becomes a remote worker
Vertex AI Pipelines	ClearML Pipelines	Python-native DAG orchestration with caching and dependency management
Vertex AI Model Registry	ClearML Model Repository	Versioned model storage with lineage tracking
Vertex AI Endpoints	ClearML Serving	Model deployment with Triton inference server
Cloud Monitoring + Cloud Logging	ClearML Scalars/Plots	Real-time metrics visualization and hardware monitoring

The ClearML architecture consists of:

ClearML Server: Central hub comprising the API server, web UI, and file server. Stores experiment metadata in MongoDB and Elasticsearch.
ClearML Agent: Worker daemon that pulls tasks from queues and executes them. Runs on any machine with Python and optionally GPU support.
ClearML SDK: Python library that instruments code for automatic logging and remote execution.
ClearML Serving: Model deployment stack using Triton inference server for production endpoints.

Prerequisites

Before you begin, you need to:

Have access to a Linux-based server as a non-root user with sudo privileges.
Install Docker and Docker Compose.
Configure DNS A records pointing to your server's IP address for the following subdomains: app.clearml.example.com (Web UI), api.clearml.example.com (API server), and files.clearml.example.com (file server).
(Optional) Install the NVIDIA Container Toolkit for GPU workloads with ClearML agents.

Note

The ClearML Server does not require a GPU instance. Deploy ClearML Agents on GPU-enabled instances to handle compute-intensive training tasks.

Deploy ClearML Server with Docker Compose

ClearML Server runs as a multi-container application with Elasticsearch for indexing, MongoDB for metadata, and Redis for caching. Traefik handles HTTPS termination and routes traffic to the appropriate service.

Increase the virtual memory limit for Elasticsearch.
CONSOLE
$ echo "vm.max_map_count=524288" | sudo tee /etc/sysctl.d/99-clearml.conf
Powered by Vultr AgentBeta
Apply the sysctl configuration.
CONSOLE
$ sudo sysctl --system
Powered by Vultr AgentBeta
Restart the Docker service to apply memory changes.
CONSOLE
$ sudo systemctl restart docker
Powered by Vultr AgentBeta
Create the directory structure for persistent storage.
CONSOLE
$ sudo mkdir -p /opt/clearml/{data/elastic_7,data/mongo_4/db,data/mongo_4/configdb,data/redis,data/fileserver,logs,config}
Powered by Vultr AgentBeta
- data/elastic_7: Elasticsearch index storage
- data/mongo_4: MongoDB database files
- data/redis: Redis cache persistence
- data/fileserver: Uploaded artifacts and models
- logs: Service log files
- config: Configuration files
Set ownership to match the container user IDs.
CONSOLE
$ sudo chown -R 1000:1000 /opt/clearml
Powered by Vultr AgentBeta
Create the project directory.
CONSOLE
$ mkdir -p ~/clearml
Powered by Vultr AgentBeta
Navigate to the project directory.
CONSOLE
$ cd ~/clearml
Powered by Vultr AgentBeta
Download the official ClearML Docker Compose file.
CONSOLE
$ curl -fsSL https://raw.githubusercontent.com/clearml/clearml-server/master/docker/docker-compose.yml -o docker-compose.yml
Powered by Vultr AgentBeta
Open the Docker Compose file to modify port mappings and network configuration.
CONSOLE
$ nano docker-compose.yml
Powered by Vultr AgentBeta
Locate each ports: block under the apiserver, webserver, and fileserver services and comment them out by adding # at the beginning of each line. Traefik handles external routing, so direct port exposure is not needed.
Locate the networks block at the bottom of the file and update it to use named bridge networks:
YAML
networks: backend: name: clearml_backend driver: bridge frontend: name: clearml_frontend driver: bridge
Powered by Vultr AgentBeta
Save and close the file.
Create the environment file for ClearML service URLs. Replace clearml.example.com with your domain.
CONSOLE
$ nano .env
Powered by Vultr AgentBeta
Add the following configuration:
INI
CLEARML_WEB_HOST=https://app.clearml.example.com CLEARML_API_HOST=https://api.clearml.example.com CLEARML_FILES_HOST=https://files.clearml.example.com
Powered by Vultr AgentBeta
Save and close the file.
Start the ClearML services.
CONSOLE
$ docker compose up -d
Powered by Vultr AgentBeta
Verify all containers are running.
CONSOLE
$ docker compose ps
Powered by Vultr AgentBeta
The output displays containers for clearml-webserver, clearml-apiserver, clearml-fileserver, clearml-mongo, clearml-elastic, and clearml-redis.
Check the logs for startup errors.
CONSOLE
$ docker compose logs --tail 50
Powered by Vultr AgentBeta
For more information on managing Docker Compose stacks, see the How To Use Docker Compose article.

Configure Traefik Reverse Proxy

Traefik routes HTTPS traffic to ClearML services using subdomain-based routing. Each ClearML component receives a dedicated subdomain with automatic Let's Encrypt certificate management.

Create the Traefik directory.
CONSOLE
$ mkdir -p ~/clearml/traefik
Powered by Vultr AgentBeta
Navigate to the Traefik directory.
CONSOLE
$ cd ~/clearml/traefik
Powered by Vultr AgentBeta
Create the Let's Encrypt storage directory.
CONSOLE
$ mkdir -p letsencrypt
Powered by Vultr AgentBeta
Create the certificate storage file.
CONSOLE
$ touch letsencrypt/acme.json
Powered by Vultr AgentBeta
Restrict the file permissions so only the owner can read and write it. Let's Encrypt requires this permission level before it writes any certificate data.
CONSOLE
$ chmod 600 letsencrypt/acme.json
Powered by Vultr AgentBeta
Create the Traefik environment file. Replace admin@example.com with your email address for Let's Encrypt notifications.
CONSOLE
$ nano .env
Powered by Vultr AgentBeta
Add the following configuration:
INI
LETSENCRYPT_EMAIL=admin@example.com
Powered by Vultr AgentBeta
Save and close the file.

Create the Traefik Docker Compose file.

CONSOLE

$ nano docker-compose.yml

Add the following configuration:

YAML
services:
  traefik:
    image: traefik:v3.6
    container_name: traefik
    command:
      - "--log.level=INFO"
      - "--providers.file.filename=/etc/traefik/dynamic_conf.yml"
      - "--entryPoints.web.address=:80"
      - "--entryPoints.websecure.address=:443"
      - "--entryPoints.web.http.redirections.entrypoint.to=websecure"
      - "--certificatesResolvers.le.acme.httpChallenge.entryPoint=web"
      - "--certificatesResolvers.le.acme.email=${LETSENCRYPT_EMAIL}"
      - "--certificatesResolvers.le.acme.storage=/letsencrypt/acme.json"
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - "./letsencrypt:/letsencrypt"
      - "./dynamic_conf.yml:/etc/traefik/dynamic_conf.yml:ro"
    networks:
      - clearml-frontend
    restart: unless-stopped

networks:
  clearml-frontend:
    name: clearml_frontend
    external: true
Powered by Vultr AgentBeta

Save and close the file.

Create the Traefik dynamic configuration file. Replace clearml.example.com with your domain.

CONSOLE

$ nano dynamic_conf.yml

Add the following routing rules:

YAML
http:
  routers:
    clearml-web:
      rule: "Host(`app.clearml.example.com`)"
      entryPoints:
        - websecure
      service: clearml-web
      tls:
        certResolver: le

    clearml-api:
      rule: "Host(`api.clearml.example.com`)"
      entryPoints:
        - websecure
      service: clearml-api
      tls:
        certResolver: le

    clearml-files:
      rule: "Host(`files.clearml.example.com`)"
      entryPoints:
        - websecure
      service: clearml-files
      tls:
        certResolver: le

  services:
    clearml-web:
      loadBalancer:
        servers:
          - url: "http://clearml-webserver:80"

    clearml-api:
      loadBalancer:
        servers:
          - url: "http://clearml-apiserver:8008"

    clearml-files:
      loadBalancer:
        servers:
          - url: "http://clearml-fileserver:8081"
Powered by Vultr AgentBeta

Save and close the file.

Start Traefik.
CONSOLE
$ docker compose up -d
Powered by Vultr AgentBeta
Verify Traefik obtained the SSL certificates.
CONSOLE
$ docker logs traefik 2>&1 | grep -i certificate
Powered by Vultr AgentBeta
The output indicates certificate generation for each subdomain.

Configure ClearML Server

The ClearML Web UI provides initial setup and ongoing configuration management through a browser-based interface.

Open a web browser and navigate to the ClearML Web UI at https://app.clearml.example.com.
Create the administrator account on first access:
- Enter a username (for example, admin).
- Enter your company name.
- Click Create Account.
Navigate to Settings in the left sidebar.
Click Workspace to view the workspace configuration.
Click Create new credentials to generate API credentials.
Copy and save the credentials block. This contains the API access key and secret key required for agent and SDK configuration.
The credentials block follows this format:
INI
api { web_server: https://app.clearml.example.com api_server: https://api.clearml.example.com files_server: https://files.clearml.example.com credentials { "access_key" = "YOUR_ACCESS_KEY" "secret_key" = "YOUR_SECRET_KEY" } }
Powered by Vultr AgentBeta

Deploy ClearML Agents for Remote Execution

ClearML Agent transforms any machine into a remote worker that pulls tasks from queues and executes them with full environment reproducibility. The agent manages virtual environments, GPU allocation, and code versioning automatically.

Note

You can run the ClearML Agent on the same server as the ClearML Server or on a dedicated machine. For GPU workloads, deploy agents on GPU-enabled instances.

Create the agent directory.
CONSOLE
$ mkdir -p ~/clearml-agent
Powered by Vultr AgentBeta
Navigate to the agent directory.
CONSOLE
$ cd ~/clearml-agent
Powered by Vultr AgentBeta
Install the Python virtual environment package.
CONSOLE
$ sudo apt install python3.12-venv -y
Powered by Vultr AgentBeta
Create and activate a virtual environment.
CONSOLE
$ python3 -m venv clearml_venv $ source clearml_venv/bin/activate
Powered by Vultr AgentBeta
Install the ClearML Agent package.
CONSOLE
$ pip install clearml-agent
Powered by Vultr AgentBeta
Initialize the agent configuration.
CONSOLE
$ clearml-agent init
Powered by Vultr AgentBeta
The command starts an interactive setup. When prompted:
1. Paste the credentials block copied from the ClearML Web UI.
2. Press Enter to accept the default output URI.
3. Press Enter to skip Git username (uses SSH key authentication).
4. Press Enter to skip additional artifact repository.
The agent saves the configuration to ~/clearml.conf.
Start the agent in daemon mode on the default queue.
CONSOLE
$ clearml-agent daemon --queue default --detached
Powered by Vultr AgentBeta
For GPU workloads, specify GPU indices:
CONSOLE
$ clearml-agent daemon --gpus 0,1 --queue default --detached
Powered by Vultr AgentBeta
Verify the agent registered in the ClearML Web UI by navigating to Workers & Queues and selecting the Workers tab.

Install ClearML SDK

The ClearML SDK instruments Python scripts for automatic experiment tracking, logging hyperparameters, metrics, code versions, and model artifacts without code changes.

Ensure the virtual environment is active.
CONSOLE
$ source ~/clearml-agent/clearml_venv/bin/activate
Powered by Vultr AgentBeta
Install the ClearML SDK and common data science dependencies.
CONSOLE
$ pip install clearml scikit-learn joblib pandas
Powered by Vultr AgentBeta
Configure the SDK connection to your ClearML Server.
CONSOLE
$ clearml-init
Powered by Vultr AgentBeta
Paste the credentials block from the ClearML Web UI when prompted. The configuration saves to ~/clearml.conf.

Create First ClearML Experiment

ClearML tracks every script execution as a task, automatically logging hyperparameters, metrics, code changes, and artifacts. The following experiment trains a Random Forest classifier to verify the server connection and demonstrate the tracking workflow.

Create a directory for experiments.
CONSOLE
$ mkdir -p ~/clearml/experiments
Powered by Vultr AgentBeta
Navigate to the experiments directory.
CONSOLE
$ cd ~/clearml/experiments
Powered by Vultr AgentBeta

Create the experiment script.

CONSOLE

$ nano 01_first_experiment.py

Add the following code:

PYTHON
import joblib
from clearml import Task
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, classification_report

# Initialize the ClearML task. This registers the run in the project and
# begins capturing code, environment, and hyperparameter information.
task = Task.init(
    project_name='ClearML Tutorial',
    task_name='01_First_Experiment',
    tags=['tutorial', 'random-forest']
)

# Define hyperparameters and connect them to the task so they appear in
# the Configuration tab and can be overridden for remote execution.
hyperparams = {
    'n_estimators': 100,
    'max_depth': 5,
    'random_state': 42
}
task.connect(hyperparams)
print(f"Training with hyperparameters: {hyperparams}")

# Load and split the Iris dataset
iris = load_iris()
X_train, X_test, y_train, y_test = train_test_split(
    iris.data, iris.target, test_size=0.2, random_state=42
)

# Train the model using the connected hyperparameters
clf = RandomForestClassifier(
    n_estimators=hyperparams['n_estimators'],
    max_depth=hyperparams['max_depth'],
    random_state=hyperparams['random_state']
)
clf.fit(X_train, y_train)

# Evaluate and report metrics to the ClearML Scalars tab
y_pred = clf.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
report = classification_report(y_test, y_pred, target_names=iris.target_names, output_dict=True)
print(f"Model Accuracy: {accuracy:.4f}")

logger = task.get_logger()
logger.report_scalar(title='Performance', series='Accuracy', value=accuracy, iteration=1)

for label, metrics in report.items():
    if isinstance(metrics, dict):
        for metric_name, value in metrics.items():
            logger.report_scalar(title=f'Class: {label}', series=metric_name, value=value, iteration=1)

# Save the model locally and upload it as a tracked artifact
model_path = 'iris_rf_model.pkl'
joblib.dump(clf, model_path)
task.upload_artifact(name='trained_model', artifact_object=model_path)
print(f"Model saved and uploaded: {model_path}")

task.close()
print("Experiment completed.")
Powered by Vultr AgentBeta

Save and close the file.

Run the experiment.
CONSOLE
$ python3 01_first_experiment.py
Powered by Vultr AgentBeta
The output displays a task URL. Open the URL to view the experiment in the ClearML Web UI.
Open the ClearML Web UI and navigate to the ClearML Tutorial project to view the experiment details.
The web interface organizes experiment data into tabs:
- Execution: Source code, Git commit, installed packages, and uncommitted changes.
- Configuration: Hyperparameters, command-line arguments, and environment variables.
- Artifacts: Uploaded model files and datasets with metadata.
- Console: Real-time stdout and stderr logs.
- Scalars: Interactive charts for numerical metrics over iterations.
- Plots: Visualizations like confusion matrices and ROC curves.

Build ClearML Pipeline

ClearML Pipelines chain tasks into a Directed Acyclic Graph (DAG) where step outputs feed into downstream inputs. The pipeline controller manages execution order, caching, and data flow between steps.

Navigate to the experiments directory.
CONSOLE
$ cd ~/clearml/experiments
Powered by Vultr AgentBeta

Create the pipeline script.

CONSOLE

$ nano 02_pipeline.py

Add the following code:

PYTHON
from clearml import PipelineController


# Step 1: Download and load the Iris dataset into a pandas DataFrame.
# Imports inside the function body are required when running steps remotely
# via an agent, as each step runs in its own isolated environment.
def step_one(pickle_data_url):
    import pickle
    import pandas as pd
    from clearml import StorageManager

    pickle_data_url = pickle_data_url or 'https://github.com/allegroai/events/raw/master/odsc20-east/generic/iris_dataset.pkl'
    local_iris_pkl = StorageManager.get_local_copy(remote_url=pickle_data_url)

    with open(local_iris_pkl, 'rb') as f:
        iris = pickle.load(f)

    data_frame = pd.DataFrame(iris['data'], columns=iris['feature_names'])
    data_frame['target'] = iris['target']
    return data_frame


# Step 2: Split the DataFrame into training and testing sets
def step_two(data_frame, test_size=0.2, random_state=42):
    from sklearn.model_selection import train_test_split

    y = data_frame['target']
    X = data_frame.drop(columns=['target'])
    X_train, X_test, y_train, y_test = train_test_split(
        X, y, test_size=test_size, random_state=random_state)
    return X_train, X_test, y_train, y_test


# Step 3: Train a Logistic Regression model on the processed data
def step_three(data):
    from sklearn.linear_model import LogisticRegression

    X_train, X_test, y_train, y_test = data
    model = LogisticRegression(solver='lbfgs', max_iter=1000)
    model.fit(X_train, y_train)
    return model


if __name__ == '__main__':
    # Initialize the pipeline controller with a version for reproducibility
    pipe = PipelineController(
        project='ClearML Tutorial',
        name='02_Pipeline_Experiment',
        version='1.0',
        add_pipeline_tags=True,
    )

    # Define a pipeline-level parameter that steps can reference
    pipe.add_parameter(
        name='url',
        description='URL to the dataset',
        default='https://github.com/allegroai/events/raw/master/odsc20-east/generic/iris_dataset.pkl'
    )

    # Wire each step into the pipeline. ClearML infers execution order
    # from input/output dependencies declared in function_kwargs.
    pipe.add_function_step(
        name='step_one',
        function=step_one,
        function_kwargs=dict(pickle_data_url='${pipeline.url}'),
        function_return=['data_frame'],
        cache_executed_step=True,  # Reuse result if inputs are unchanged
    )

    pipe.add_function_step(
        name='step_two',
        function=step_two,
        function_kwargs=dict(data_frame='${step_one.data_frame}'),
        function_return=['processed_data'],
        cache_executed_step=True,
    )

    pipe.add_function_step(
        name='step_three',
        function=step_three,
        function_kwargs=dict(data='${step_two.processed_data}'),
        function_return=['model'],
        cache_executed_step=True,
    )

    pipe.start_locally(run_pipeline_steps_locally=True)
    print('Pipeline completed.')
Powered by Vultr AgentBeta

Save and close the file.

Run the pipeline.
CONSOLE
$ python3 02_pipeline.py
Powered by Vultr AgentBeta
View the pipeline execution graph in the ClearML Web UI under the ClearML Tutorial project.

Set Up Hyperparameter Optimization

Hyperparameter Optimization (HPO) automates the search for optimal model parameters by spawning experiment variations. ClearML clones a baseline experiment, modifies parameters according to defined search ranges, and tracks each trial independently.

Navigate to the experiments directory.
CONSOLE
$ cd ~/clearml/experiments
Powered by Vultr AgentBeta

Create the HPO script.

CONSOLE

$ nano 03_hpo.py

Add the following code:

PYTHON
from clearml import Task
from clearml.automation import (
    HyperParameterOptimizer,
    DiscreteParameterRange,
    UniformIntegerParameterRange,
    RandomSearch
)

print("Searching for base experiment '01_First_Experiment'...")
tasks = Task.get_tasks(
    project_name='ClearML Tutorial',
    task_filter={'status': ['completed', 'published']},
    task_name='01_First_Experiment'
)

if not tasks:
    raise ValueError("Base experiment not found. Run 01_first_experiment.py first.")

base_task_id = tasks[-1].id
print(f"Found base task ID: {base_task_id}")

Task.init(
    project_name='ClearML Tutorial',
    task_name='03_Hyperparameter_Optimization',
    task_type=Task.TaskTypes.optimizer
)

optimizer = HyperParameterOptimizer(
    base_task_id=base_task_id,
    hyper_parameters=[
        UniformIntegerParameterRange('General/n_estimators', min_value=10, max_value=200, step_size=20),
        DiscreteParameterRange('General/max_depth', values=[3, 5, 7, 10])
    ],
    objective_metric_title='Performance',
    objective_metric_series='Accuracy',
    objective_metric_sign='max',
    optimizer_class=RandomSearch,
    max_number_of_concurrent_tasks=2,
    total_max_jobs=6
)

print("Starting optimization...")
optimizer.start()
optimizer.wait()

print("Optimization completed.")
top_exp = optimizer.get_top_experiments(1)
if top_exp:
    print(f"Best Experiment ID: {top_exp[0].id}")
    params = top_exp[0].get_parameters_as_dict().get('General', {})
    print(f"Best Hyperparameters: {params}")
Powered by Vultr AgentBeta

Save and close the file.

Run the optimization.
CONSOLE
$ python3 03_hpo.py
Powered by Vultr AgentBeta
Monitor the optimization progress in the ClearML Web UI under ClearML Tutorial.

Deploy Models with ClearML Serving

ClearML Serving provides model deployment with Triton inference server support. It enables production endpoints with versioning, monitoring, and automatic model updates.

Navigate to the project directory.
CONSOLE
$ cd ~/clearml
Powered by Vultr AgentBeta
Clone the ClearML Serving repository.
CONSOLE
$ git clone https://github.com/clearml/clearml-serving.git
Powered by Vultr AgentBeta
Install the ClearML Serving package.
CONSOLE
$ pip install clearml-serving
Powered by Vultr AgentBeta
Create a serving service.
CONSOLE
$ clearml-serving create --name "serving-example"
Powered by Vultr AgentBeta
Copy the Serving Service ID from the output for use in subsequent steps.
Open the serving environment file.
CONSOLE
$ nano clearml-serving/docker/.env
Powered by Vultr AgentBeta
Update the configuration with your ClearML server details. Replace the placeholders with your actual values.
INI
CLEARML_WEB_HOST="https://app.clearml.example.com" CLEARML_API_HOST="https://api.clearml.example.com" CLEARML_FILES_HOST="https://files.clearml.example.com" CLEARML_API_ACCESS_KEY="YOUR_ACCESS_KEY" CLEARML_API_SECRET_KEY="YOUR_SECRET_KEY" CLEARML_SERVING_TASK_ID="SERVING_SERVICE_ID"
Powered by Vultr AgentBeta
Replace:
- clearml.example.com with your domain.
- YOUR_ACCESS_KEY with your ClearML API access key.
- YOUR_SECRET_KEY with your ClearML API secret key.
- SERVING_SERVICE_ID with the ID from the previous step.
Save and close the file.
Start the serving stack.
CONSOLE
$ cd ~/clearml/clearml-serving/docker $ docker compose --env-file .env -f docker-compose-triton.yml up -d
Powered by Vultr AgentBeta
Install the PyTorch example dependencies.
CONSOLE
$ pip install -r ~/clearml/clearml-serving/examples/pytorch/requirements.txt
Powered by Vultr AgentBeta
Train and register a sample model.
CONSOLE
$ python3 ~/clearml/clearml-serving/examples/pytorch/train_pytorch_mnist.py
Powered by Vultr AgentBeta
Navigate to the task's Artifacts tab in the ClearML Web UI and copy the Model ID.

Add the model endpoint to the serving service. Replace SERVING_SERVICE_ID and MODEL_ID with your actual values.

CONSOLE
$ clearml-serving --id SERVING_SERVICE_ID model add \
    --engine triton \
    --endpoint "test_model_pytorch" \
    --preprocess "clearml-serving/examples/pytorch/preprocess.py" \
    --model-id MODEL_ID \
    --input-size 1 28 28 \
    --input-name "INPUT__0" \
    --input-type float32 \
    --output-size 10 \
    --output-name "OUTPUT__0" \
    --output-type float32
Powered by Vultr AgentBeta

Restart the serving containers to load the new endpoint.
CONSOLE
$ docker compose --env-file .env -f docker-compose-triton.yml restart
Powered by Vultr AgentBeta
Test the inference endpoint. Replace SERVER-IP with your server's IP address.
CONSOLE
$ curl -X POST "http://SERVER-IP:8080/serve/test_model_pytorch" \ -H "Content-Type: application/json" \ -d '{"url": "https://raw.githubusercontent.com/clearml/clearml-serving/main/examples/pytorch/5.jpg"}'
Powered by Vultr AgentBeta

Verify the Deployment

Validate the complete ClearML deployment by testing each component's functionality.

Navigate to https://app.clearml.example.com and verify you can log in and view projects.
Verify the API server responds.
CONSOLE
$ curl -s https://api.clearml.example.com/debug.ping | head -c 100
Powered by Vultr AgentBeta
Confirm the file server is accessible.
CONSOLE
$ curl -s -o /dev/null -w "%{http_code}" https://files.clearml.example.com/
Powered by Vultr AgentBeta
Navigate to Workers & Queues in the Web UI and confirm the agent appears under the Workers tab.
Confirm the first experiment appears in the ClearML Tutorial project with metrics, artifacts, and execution details.
Clone an experiment in the Web UI, modify a hyperparameter, and enqueue it. Verify the agent picks up and executes the task.

Migrate from Vertex AI to ClearML

Migrating from Vertex AI to ClearML shifts workflows from a managed cloud service to a self-hosted, infrastructure-agnostic platform.

Experiment Tracking Migration

Vertex AI experiments use the google.cloud.aiplatform SDK with experiment tracking and metadata logging.

Migration: Replace google.cloud.aiplatform experiment tracking with clearml.Task.
Benefit: ClearML automatically captures Git state, uncommitted changes, and environment dependencies without explicit logging calls.

Training Job Migration

Vertex AI uses Custom Training Jobs via the google.cloud.aiplatform SDK to launch managed training workloads.

Migration: Replace google.cloud.aiplatform.CustomJob with clearml.Task.
Workflow: Run scripts locally to verify them, then use task.execute_remotely() or enqueue through the Web UI. Agents running on any infrastructure pick up and execute tasks.

Notebook Migration

Vertex AI Workbench provides managed Jupyter notebook environments integrated with Vertex AI services.

Migration: Use standard Jupyter or JupyterHub. ClearML's Task.init() works identically from notebooks and automatically tracks cells, metrics, and outputs.

Pipeline Migration

Vertex AI pipelines are built on Kubeflow Pipelines and use a DSL defined in Python.

Migration: Convert to ClearML PipelineController or the @pipeline decorator.
Benefit: Python-native pipelines support standard control flow (if/else, loops) and avoid the additional compilation step required by Vertex AI pipelines, making them simpler to debug and iterate on.

Hyperparameter Tuning Migration

Vertex AI uses Vizier for hyperparameter tuning, integrated with training job submissions.

Migration: Replace Vertex AI Vizier with ClearML HyperParameterOptimizer.
Benefit: ClearML HPO runs on your own agents, clones experiments automatically, and reports optimization results in the Experiment Manager with full trial history.

Model Registry Migration

Vertex AI Model Registry serves as a central repository to manage the lifecycle of your machine learning models.

Migration: Use ClearML OutputModel for automatic model tracking.
Benefit: ClearML links models to source experiments with full lineage including code, hyperparameters, and training metrics.

Endpoint Migration

Vertex AI Endpoints is the managed service within Google Cloud's Vertex AI platform designed for hosting and serving machine learning models.

Migration: Deploy with ClearML Serving and Triton inference server for real-time inference.
Batch Prediction: Vertex AI Batch Prediction Jobs (async, large-scale dataset scoring) have no direct ClearML Serving equivalent. Migrate batch scoring workloads to standard ClearML Tasks that process datasets and write outputs to object storage.
Flexibility: Run on any infrastructure with support for canary deployments and A/B testing.

Data Storage Considerations

Vertex AI integrates with Google Cloud Storage for data access and uses datasets and metadata tracking via the google.cloud.aiplatform SDK.

Google Cloud Storage (GCS): ClearML works with GCS paths directly. Continue using existing buckets or migrate to any object storage.
Dataset Versioning: ClearML Data provides explicit dataset versioning with automatic caching on agents.

Things to Consider During Migration

SDK Differences: Replace google-cloud-aiplatform and related Vertex AI SDK usage with the clearml package. ClearML offers a simpler, more unified API with less boilerplate.
Authentication: Vertex AI uses Google Cloud IAM with Service Accounts and ADC (Application Default Credentials). ClearML uses API keys configured via clearml.conf or environment variables (CLEARML_API_ACCESS_KEY, CLEARML_API_SECRET_KEY).
Container Adaptation: Vertex AI relies on containerized workloads with injected environment variables (such as AIP_*) and conventions for inputs/outputs in custom jobs and predictions. ClearML agents work with standard Python environments and any Docker container without requiring Vertex-specific environment variables or conventions.
Cost Model: Vertex AI charges for managed services, training, and prediction resources. ClearML is open-source; you pay only for underlying compute and infrastructure.
Monitoring: Replace Google Cloud monitoring (via Cloud Logging and Cloud Monitoring) with ClearML’s built-in Scalars, Plots, and hardware monitoring dashboards.
Compute Targets to Queues: Vertex AI training specifies compute resources at job submission. ClearML uses agent queues, requiring you to deploy agents on target hardware and submit tasks to the matching queue instead of using a compute resource name.
Environment Management: Vertex AI manages Python environments through container specs in custom job definitions. ClearML agents auto-capture requirements.txt from the task environment; Docker base images can be set per task under the execution settings.
MLflow Compatibility: If existing code uses MLflow tracking, ClearML provides an MLflow backend compatibility layer. The mlflow.log_* calls route to ClearML without requiring a full SDK rewrite.

Conclusion

You have successfully deployed ClearML Server with Traefik reverse proxy, configured agents for remote execution, and executed machine learning workflows including experiment tracking, pipelines, hyperparameter optimization, and model serving. For more information, visit the official ClearML documentation.

Tags:Open Source ClearML ML tooling AI & Machine Learning

Understanding ClearML Architecture

Prerequisites

Note

Deploy ClearML Server with Docker Compose

Configure Traefik Reverse Proxy

Configure ClearML Server

Deploy ClearML Agents for Remote Execution

Note

Install ClearML SDK

Create First ClearML Experiment

Build ClearML Pipeline

Set Up Hyperparameter Optimization

Deploy Models with ClearML Serving

Verify the Deployment

Migrate from Vertex AI to ClearML

Experiment Tracking Migration

Training Job Migration

Notebook Migration

Pipeline Migration

Hyperparameter Tuning Migration

Model Registry Migration

Endpoint Migration

Data Storage Considerations

Things to Consider During Migration

Conclusion

About the Author

Shivang Shandilya

More to Explore

Tech Talk: Running a Self-Improving AI Agent with Hermes on Vultr

Tech Talk: Implementing Fine-Grained Access Control with Vultr IAM

Tech Talk: Getting Started with Vultr IAM

Tech Talk: Simplifying Zero-Trust Networking with NetBird on Vultr Marketplace

0 Comments

Understanding ClearML Architecture

Prerequisites

Note

Deploy ClearML Server with Docker Compose

Configure Traefik Reverse Proxy

Configure ClearML Server

Deploy ClearML Agents for Remote Execution

Note

Install ClearML SDK

Create First ClearML Experiment

Build ClearML Pipeline

Set Up Hyperparameter Optimization

Deploy Models with ClearML Serving

Verify the Deployment

Migrate from Vertex AI to ClearML

Experiment Tracking Migration

Training Job Migration

Notebook Migration

Pipeline Migration

Hyperparameter Tuning Migration

Model Registry Migration

Endpoint Migration

Data Storage Considerations

Things to Consider During Migration

Conclusion

About the Author

Shivang Shandilya

More to Explore

Tech Talk: Running a Self-Improving AI Agent with Hermes on Vultr

Tech Talk: Implementing Fine-Grained Access Control with Vultr IAM

Tech Talk: Getting Started with Vultr IAM

Tech Talk: Simplifying Zero-Trust Networking with NetBird on Vultr Marketplace

0 Comments