Vertexai workbench secure boot enabled remediation

​

A. Create a new Vertex AI Workbench notebook with Secure Boot enabled

1. Open Vertex AI Workbench
   • Go to Google Cloud Console.
   • In the left menu, navigate to:
     Vertex AI → Workbench.
2. Start creating a new notebook
   • Click + New notebook.
   • Choose the type (e.g., User-managed notebooks or Managed notebooks) and select an image / environment.
3. Open advanced VM configuration
   • After selecting the base image/config:
     • For Managed notebooks:
       • In the notebook creation panel, click Advanced options or Customize to show VM-level settings.
     • For User-managed notebooks:
       • After selecting the image, scroll down to the Machine configuration, then expand Advanced options or Security (wording may vary slightly by UI version).
4. Enable Shielded VM and Secure Boot
   • Look for a section named Security, Shielded VM, or Security and access.
   • Ensure Shielded VM is enabled (if it’s a separate checkbox).
   • Then check the box for Secure Boot (sometimes labeled as Turn on Secure Boot).
   • Optionally also enable:
     • vTPM (virtual TPM)
     • Integrity monitoring, if available (both part of Shielded VM).
5. Finish notebook creation
   • Complete any remaining fields (name, region/zone, machine type, disk, networking, etc.).
   • Click Create.
   • The resulting Vertex AI notebook VM will now have Secure Boot enabled.

​

B. Handling existing Vertex AI notebook instances

1. Identify the existing notebook
   • Go to Vertex AI → Workbench.
   • Find the notebook instance that does not have Secure Boot enabled.
2. Export / back up work
   • Open the notebook (JupyterLab/Jupyter).
   • Copy notebooks, scripts, and data to a durable location:
     • A Cloud Storage bucket, or
     • A Git repository, or
     • Another shared storage solution.
3. Recreate the notebook with Secure Boot
   • Stop the old instance if you wish (optional, for cost).
   • Follow Section A above to create a new notebook instance with the same:
     • Region/Zone
     • Machine type
     • Image / environment
     • Disk size
   • Ensure you enable Shielded VM + Secure Boot in the advanced/security settings.
4. Restore your work
   • Open the new notebook instance.
   • Pull your notebooks and data back from Cloud Storage / Git / other backup.
   • Validate the environment and dependencies (packages, libraries) match your prior setup.
5. Decommission the old instance
   • Once the new Secure-Boot-enabled notebook is working, return to Vertex AI → Workbench.
   • Select the old instance and click Delete (if no longer needed), or leave it stopped.

​

C. Verify Secure Boot is enabled (optional)

1. Go to Compute Engine → VM instances in the console.
2. Locate the VM created for your Vertex AI notebook (name will match or be similar).
3. Click the instance name.
4. In the Details tab, look at the Security or Shielded VM section.
5. Confirm that Secure Boot is shown as On / Enabled.

Note: Secure Boot is a Shielded VM feature. It can only be enabled on instances that support Shielded VM. For some existing instances, you may need to recreate them with Secure Boot enabled.

​

1. Identify your notebook instance

gcloud notebooks instances list

gcloud notebooks instances list --location=us-central1

• INSTANCE_ID
• REGION (e.g., us-central1)

​

2. Stop the notebook instance

gcloud notebooks instances stop INSTANCE_ID \
  --location=REGION

​

3. Enable Secure Boot on the instance (if supported)

gcloud notebooks instances update INSTANCE_ID \
  --location=REGION \
  --shielded-secure-boot

​

4. Verify Secure Boot is enabled

gcloud notebooks instances describe INSTANCE_ID \
  --location=REGION \
  --format="yaml|shieldedInstanceConfig"

​

5. If update fails: recreate the notebook with Secure Boot

1. Export the configuration (for reference):
   gcloud notebooks instances describe INSTANCE_ID \
     --location=REGION > old-notebook-config.yaml
   
2. (Optional) Back up important data (e.g., copy notebooks to a GCS bucket):
   gsutil -m cp -r /path/to/notebooks gs://YOUR_BUCKET/path/
   
3. Delete the old instance (if acceptable):
   gcloud notebooks instances delete INSTANCE_ID \
     --location=REGION
   
4. Recreate with Secure Boot enabled (adjust flags to match your previous config: machine type, image family, etc.):
   gcloud notebooks instances create NEW_INSTANCE_ID \
     --location=REGION \
     --vm-image-project=deeplearning-platform-release \
     --vm-image-family=tf-latest-gpu \
     --machine-type=n1-standard-4 \
     --shielded-secure-boot
   
5. Restore your notebooks/data from backup if needed.

Important: For Shielded VM options (including Secure Boot), the instance must be stopped before updating.

​

1. Prerequisites

1. Install the Notebooks client library

pip install google-cloud-notebooks

2. Authenticate

• roles/notebooks.admin (or equivalent permissions)
• roles/compute.instanceAdmin.v1 (for Shielded VM config on underlying VM)

gcloud auth application-default login

​

2. Python script to enable Secure Boot

1. Stops the notebook instance (if needed).
2. Updates the Shielded VM configuration to enable Secure Boot.
3. Restarts the instance.

from google.cloud import notebooks_v1
from google.protobuf import field_mask_pb2
import time

PROJECT_ID = "YOUR_PROJECT_ID"
LOCATION = "YOUR_REGION"          # e.g. "us-central1-b" or "us-central1"
INSTANCE_ID = "YOUR_NOTEBOOK_NAME"

def wait_for_operation(client, operation):
    """Waits for a long‑running operation to complete."""
    name = operation.name
    while not operation.done:
        time.sleep(5)
        operation = client.get_operation(name=name)
    if operation.error.code != 0:
        raise RuntimeError(f"Operation failed: {operation.error.message}")
    return operation

def main():
    client = notebooks_v1.NotebookServiceClient()
    operations_client = client.transport.operations_client

    instance_name = client.instance_path(PROJECT_ID, LOCATION, INSTANCE_ID)

    # 1. Get current instance
    instance = client.get_instance(name=instance_name)

    # 2. Stop instance if it is running
    if instance.state == notebooks_v1.Instance.State.ACTIVE:
        print("Stopping instance...")
        op = client.stop_instance(name=instance_name)
        wait_for_operation(operations_client, op)
        print("Instance stopped.")

    # 3. Enable Secure Boot in Shielded VM config
    #    (preserve other existing shielded settings if present)
    current_shielded = instance.shielded_instance_config
    if current_shielded is None:
        current_shielded = notebooks_v1.Instance.ShieldedInstanceConfig()

    current_shielded.enable_secure_boot = True

    updated_instance = notebooks_v1.Instance(
        name=instance_name,
        shielded_instance_config=current_shielded,
    )

    update_mask = field_mask_pb2.FieldMask(
        paths=["shielded_instance_config.enable_secure_boot"]
    )

    print("Updating instance to enable Secure Boot...")
    op = client.update_instance(
        instance=updated_instance,
        update_mask=update_mask,
    )
    wait_for_operation(operations_client, op)
    print("Secure Boot enabled.")

    # 4. Start the instance again (optional)
    print("Starting instance...")
    op = client.start_instance(name=instance_name)
    wait_for_operation(operations_client, op)
    print("Instance started with Secure Boot enabled.")

if __name__ == "__main__":
    main()

​

3. Notes / Variations

• New instances: To enforce Secure Boot for all new user-managed notebook instances, always set shielded_instance_config.enable_secure_boot = True in your creation code.
• Managed notebooks: Fully managed Vertex AI Workbench notebooks may not expose Shielded VM settings directly; in that case, you must enforce Secure Boot at the project / organization policy level for Shielded VMs or use user‑managed notebooks where this option is configurable.