Notebook Environments for ML on GCP

Google Cloud provides several Jupyter-based notebook environments, each optimized for different workflows. Understanding the differences is critical for the MLE exam and for real-world architecture decisions.

Decision Matrix: When to Use Each Option

Colab Enterprise brings the familiar Google Colab experience into the Google Cloud console with enterprise-grade security, compliance, and data governance. Notebooks run on serverless infrastructure with no VM to manage.

Key Features

• Serverless & Zero-Config: No VMs to create, patch, or manage. Runtimes spin up on demand
• Real-Time Collaboration: Multiple users can edit the same notebook simultaneously, similar to Google Docs
• IAM Integration: Access controlled via Cloud IAM roles — roles/aiplatform.colabEnterpriseUser
• VPC Service Controls: Notebooks can be placed within a VPC-SC perimeter for data exfiltration prevention
• Org Policies: Admins can enforce notebook-level restrictions (e.g., no external network)
• BigQuery Integration: Native connectors for querying directly from notebook cells

Runtime types determine the compute available. You can select CPU-only, GPU-enabled (T4), or high-memory runtimes. Runtimes are ephemeral — when disconnected, local files are lost. Persist results to Cloud Storage or BigQuery.

# Colab Enterprise — query BigQuery directly
from google.cloud import bigquery

client = bigquery.Client(project="my-project")
query = """
    SELECT name, SUM(number) as total
    FROM `bigquery-public-data.usa_names.usa_1910_2013`
    GROUP BY name
    ORDER BY total DESC
    LIMIT 10
"""
df = client.query(query).to_dataframe()
df.head()

Vertex AI Workbench provides JupyterLab-based notebook instances backed by Compute Engine VMs. There are two variants: Managed Notebooks and User-Managed Notebooks.

Managed Notebooks

Managed notebooks are Google-maintained JupyterLab instances. Google handles kernel updates, security patches, and health monitoring. You choose the machine type, then get a JupyterLab URL that is authenticated via IAM.

# Create a managed notebook instance via gcloud
gcloud notebooks instances create my-managed-notebook \
  --location=us-central1-a \
  --machine-type=n1-standard-4 \
  --vm-image-project=deeplearning-platform-release \
  --vm-image-family=common-cpu-notebooks

Key properties: automatic idle shutdown, environment health checks, integration with Vertex AI services (training, pipelines, endpoints), and support for custom containers.

User-Managed Notebooks

User-managed notebooks give you a full Compute Engine VM with JupyterLab installed via Deep Learning VM images. You have root/sudo access, can install arbitrary packages at the OS level, configure networking, and attach multiple GPUs.

# Create a user-managed notebook with GPU
gcloud notebooks instances create my-gpu-notebook \
  --location=us-central1-a \
  --machine-type=n1-standard-8 \
  --accelerator-type=NVIDIA_TESLA_T4 \
  --accelerator-core-count=1 \
  --vm-image-project=deeplearning-platform-release \
  --vm-image-family=tf-latest-gpu \
  --boot-disk-size=200GB \
  --install-gpu-driver

Machine Types and Accelerators

Choosing the right machine type depends on your workload. For data exploration, a standard CPU machine is sufficient. For model training, you need GPU-accelerated instances.

Accelerator options:

• NVIDIA T4: Cost-effective for inference and light training (16GB VRAM)
• NVIDIA V100: Good for medium-scale training (16/32GB HBM2)
• NVIDIA A100: High-end training and large models (40/80GB HBM2e)
• TPU v2/v3: Best for TensorFlow/JAX workloads at scale

Idle Shutdown

Idle shutdown automatically stops a notebook instance after a period of inactivity. This is critical for cost management, especially with GPU instances.

# Set idle shutdown to 60 minutes on an existing instance
gcloud notebooks instances update my-notebook \
  --location=us-central1-a \
  --idle-shutdown-timeout=60m

# Disable idle shutdown (not recommended for GPU instances)
gcloud notebooks instances update my-notebook \
  --location=us-central1-a \
  --no-idle-shutdown

All Vertex AI notebook environments support Git integration for version-controlling your notebooks, scripts, and configuration files.

Workbench Git Integration

Vertex AI Workbench instances include a built-in Git UI in JupyterLab. You can clone repos, create branches, commit, and push directly from the sidebar. For Cloud Source Repositories or GitHub, configure SSH keys or use gcloud credential helpers.

# Clone a repo inside your notebook instance
git clone https://source.developers.google.com/p/my-project/r/my-repo

# Or use GitHub with SSH
git clone git@github.com:my-org/ml-notebooks.git

# Configure credential helper for Cloud Source Repos
git config --global credential.helper gcloud.sh

Colab Enterprise Git Support

In Colab Enterprise, notebooks are stored in Cloud Storage buckets by default. You can integrate with GitHub by connecting your repository and syncing notebooks. Changes are committed via the Colab Enterprise UI or programmatically.

Notebooks on GCP can connect to multiple data sources. The three most common patterns for ML workflows are BigQuery, Cloud Storage, and Vertex AI Feature Store.

BigQuery Integration

BigQuery is the primary data warehouse for ML on GCP. You can query data directly from notebooks using the google-cloud-bigquery client library or BigQuery cell magic.

# Method 1: Python client
from google.cloud import bigquery
client = bigquery.Client()
df = client.query("SELECT * FROM `project.dataset.table` LIMIT 1000").to_dataframe()

# Method 2: BigQuery cell magic (in Colab / Workbench)
%%bigquery df
SELECT *
FROM `bigquery-public-data.ml_datasets.penguins`
WHERE body_mass_g IS NOT NULL
LIMIT 100

Cloud Storage Access

# Read a CSV from Cloud Storage
from google.cloud import storage
import pandas as pd

# Direct pandas read via gcsfs (installed by default)
df = pd.read_csv("gs://my-bucket/data/training.csv")

# Or use the storage client for binary files
client = storage.Client()
bucket = client.get_bucket("my-bucket")
blob = bucket.blob("models/saved_model.pb")
blob.download_to_filename("local_model.pb")

Vertex AI Feature Store

# Read features from Vertex AI Feature Store
from google.cloud import aiplatform

aiplatform.init(project="my-project", location="us-central1")

feature_store = aiplatform.Featurestore(featurestore_name="my_featurestore")

# Batch read features for training
df = feature_store.batch_serve_to_df(
    serving_feature_ids={
        "users": ["age", "tenure", "spending_score"],
        "products": ["category", "price"]
    },
    read_instances_df=entity_df
)

IAM Roles for Notebooks

Access to notebook instances is controlled via IAM. Key roles include:

Service Accounts

Notebook instances run code using a service account. By default, the Compute Engine default service account is used. For production, always create a dedicated service account with least-privilege permissions.

# Create a dedicated service account for notebooks
gcloud iam service-accounts create notebook-sa \
  --display-name="Notebook Service Account"

# Grant only needed roles
gcloud projects add-iam-policy-binding my-project \
  --member="serviceAccount:notebook-sa@my-project.iam.gserviceaccount.com" \
  --role="roles/bigquery.dataViewer"

gcloud projects add-iam-policy-binding my-project \
  --member="serviceAccount:notebook-sa@my-project.iam.gserviceaccount.com" \
  --role="roles/storage.objectViewer"

# Create notebook with custom service account
gcloud notebooks instances create secure-notebook \
  --location=us-central1-a \
  --machine-type=n1-standard-4 \
  --service-account=notebook-sa@my-project.iam.gserviceaccount.com \
  --vm-image-project=deeplearning-platform-release \
  --vm-image-family=common-cpu-notebooks

VPC Service Controls (VPC-SC)

VPC-SC creates a security perimeter around your GCP resources to prevent data exfiltration. Notebook instances within a VPC-SC perimeter can only access resources within the same perimeter.

• Perimeter setup: Include Vertex AI API (notebooks) and BigQuery API in the same service perimeter
• Ingress rules: Define who can access the notebook from outside the perimeter
• Egress rules: Control what data can leave the perimeter (e.g., no external API calls)

Customer-Managed Encryption Keys (CMEK)

By default, Google encrypts data at rest. With CMEK, you control the encryption key via Cloud KMS. This is required for many compliance frameworks (HIPAA, PCI-DSS).

# Create a notebook with CMEK
gcloud notebooks instances create cmek-notebook \
  --location=us-central1-a \
  --machine-type=n1-standard-4 \
  --kms-key=projects/my-project/locations/us-central1/keyRings/my-ring/cryptoKeys/my-key \
  --vm-image-project=deeplearning-platform-release \
  --vm-image-family=common-cpu-notebooks

Production Notebooks vs Exploration

Parameterized Notebook Execution

Papermill allows you to parameterize and execute notebooks programmatically. This is the bridge between exploration and production.

# Execute a notebook with parameters via papermill
import papermill as pm

pm.execute_notebook(
    "template_notebook.ipynb",
    "output/run_2024_01.ipynb",
    parameters={
        "start_date": "2024-01-01",
        "end_date": "2024-01-31",
        "model_type": "xgboost",
        "learning_rate": 0.01
    }
)

Scenario Selection Guide

Key Exam Takeaways

• Colab Enterprise = serverless, collaborative, no GPU customization, IAM-native
• Workbench Managed = Google-maintained, auto-patching, scheduled runs, good for teams
• Workbench User-Managed = full control, sudo access, custom envs, multi-GPU
• All notebook types support BigQuery and Cloud Storage access
• VPC-SC and CMEK are supported on Workbench instances for compliance
• Always configure idle shutdown for GPU instances to control costs
• Use dedicated service accounts (not default) for production notebooks