Deploy GCP Notebook Runtimes

The gcp:notebooks/runtime:Runtime resource, part of the Pulumi GCP provider, provisions a Cloud AI Platform Notebook runtime: the VM, storage, access controls, and software environment for interactive data science work. This resource is deprecated; new projects should use gcp.workbench.Instance instead. This guide focuses on four capabilities: compute and storage sizing, GPU acceleration, container-based environments, and startup script automation.

Runtimes require a GCP project with the Notebooks API enabled and user accounts for access control. The examples are intentionally small. Combine them with your own network configuration, IAM policies, and cost controls.

Create a basic runtime with compute and storage

Most notebook deployments start by provisioning a VM with specified machine type and persistent disk for data science workflows.

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";

const runtime = new gcp.notebooks.Runtime("runtime", {
    name: "notebooks-runtime",
    location: "us-central1",
    accessConfig: {
        accessType: "SINGLE_USER",
        runtimeOwner: "admin@hashicorptest.com",
    },
    virtualMachine: {
        virtualMachineConfig: {
            machineType: "n1-standard-4",
            dataDisk: {
                initializeParams: {
                    diskSizeGb: 100,
                    diskType: "PD_STANDARD",
                },
            },
        },
    },
});

import pulumi
import pulumi_gcp as gcp

runtime = gcp.notebooks.Runtime("runtime",
    name="notebooks-runtime",
    location="us-central1",
    access_config={
        "access_type": "SINGLE_USER",
        "runtime_owner": "admin@hashicorptest.com",
    },
    virtual_machine={
        "virtual_machine_config": {
            "machine_type": "n1-standard-4",
            "data_disk": {
                "initialize_params": {
                    "disk_size_gb": 100,
                    "disk_type": "PD_STANDARD",
                },
            },
        },
    })

package main

import (
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/notebooks"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := notebooks.NewRuntime(ctx, "runtime", &notebooks.RuntimeArgs{
			Name:     pulumi.String("notebooks-runtime"),
			Location: pulumi.String("us-central1"),
			AccessConfig: &notebooks.RuntimeAccessConfigArgs{
				AccessType:   pulumi.String("SINGLE_USER"),
				RuntimeOwner: pulumi.String("admin@hashicorptest.com"),
			},
			VirtualMachine: &notebooks.RuntimeVirtualMachineArgs{
				VirtualMachineConfig: &notebooks.RuntimeVirtualMachineVirtualMachineConfigArgs{
					MachineType: pulumi.String("n1-standard-4"),
					DataDisk: &notebooks.RuntimeVirtualMachineVirtualMachineConfigDataDiskArgs{
						InitializeParams: &notebooks.RuntimeVirtualMachineVirtualMachineConfigDataDiskInitializeParamsArgs{
							DiskSizeGb: pulumi.Int(100),
							DiskType:   pulumi.String("PD_STANDARD"),
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;

return await Deployment.RunAsync(() => 
{
    var runtime = new Gcp.Notebooks.Runtime("runtime", new()
    {
        Name = "notebooks-runtime",
        Location = "us-central1",
        AccessConfig = new Gcp.Notebooks.Inputs.RuntimeAccessConfigArgs
        {
            AccessType = "SINGLE_USER",
            RuntimeOwner = "admin@hashicorptest.com",
        },
        VirtualMachine = new Gcp.Notebooks.Inputs.RuntimeVirtualMachineArgs
        {
            VirtualMachineConfig = new Gcp.Notebooks.Inputs.RuntimeVirtualMachineVirtualMachineConfigArgs
            {
                MachineType = "n1-standard-4",
                DataDisk = new Gcp.Notebooks.Inputs.RuntimeVirtualMachineVirtualMachineConfigDataDiskArgs
                {
                    InitializeParams = new Gcp.Notebooks.Inputs.RuntimeVirtualMachineVirtualMachineConfigDataDiskInitializeParamsArgs
                    {
                        DiskSizeGb = 100,
                        DiskType = "PD_STANDARD",
                    },
                },
            },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.notebooks.Runtime;
import com.pulumi.gcp.notebooks.RuntimeArgs;
import com.pulumi.gcp.notebooks.inputs.RuntimeAccessConfigArgs;
import com.pulumi.gcp.notebooks.inputs.RuntimeVirtualMachineArgs;
import com.pulumi.gcp.notebooks.inputs.RuntimeVirtualMachineVirtualMachineConfigArgs;
import com.pulumi.gcp.notebooks.inputs.RuntimeVirtualMachineVirtualMachineConfigDataDiskArgs;
import com.pulumi.gcp.notebooks.inputs.RuntimeVirtualMachineVirtualMachineConfigDataDiskInitializeParamsArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var runtime = new Runtime("runtime", RuntimeArgs.builder()
            .name("notebooks-runtime")
            .location("us-central1")
            .accessConfig(RuntimeAccessConfigArgs.builder()
                .accessType("SINGLE_USER")
                .runtimeOwner("admin@hashicorptest.com")
                .build())
            .virtualMachine(RuntimeVirtualMachineArgs.builder()
                .virtualMachineConfig(RuntimeVirtualMachineVirtualMachineConfigArgs.builder()
                    .machineType("n1-standard-4")
                    .dataDisk(RuntimeVirtualMachineVirtualMachineConfigDataDiskArgs.builder()
                        .initializeParams(RuntimeVirtualMachineVirtualMachineConfigDataDiskInitializeParamsArgs.builder()
                            .diskSizeGb(100)
                            .diskType("PD_STANDARD")
                            .build())
                        .build())
                    .build())
                .build())
            .build());

    }
}

resources:
  runtime:
    type: gcp:notebooks:Runtime
    properties:
      name: notebooks-runtime
      location: us-central1
      accessConfig:
        accessType: SINGLE_USER
        runtimeOwner: admin@hashicorptest.com
      virtualMachine:
        virtualMachineConfig:
          machineType: n1-standard-4
          dataDisk:
            initializeParams:
              diskSizeGb: '100'
              diskType: PD_STANDARD

The virtualMachine block defines the compute environment. The machineType property sets CPU and memory capacity; dataDisk configures persistent storage size and type. The accessConfig block controls who can access the runtime, using SINGLE_USER for individual data scientists or SHARED for team environments.

Add GPU acceleration for ML workloads

Machine learning training and inference often require GPU acceleration to process large datasets efficiently.

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";

const runtimeGpu = new gcp.notebooks.Runtime("runtime_gpu", {
    name: "notebooks-runtime-gpu",
    location: "us-central1",
    accessConfig: {
        accessType: "SINGLE_USER",
        runtimeOwner: "admin@hashicorptest.com",
    },
    softwareConfig: {
        installGpuDriver: true,
    },
    virtualMachine: {
        virtualMachineConfig: {
            machineType: "n1-standard-4",
            dataDisk: {
                initializeParams: {
                    diskSizeGb: 100,
                    diskType: "PD_STANDARD",
                },
            },
            acceleratorConfig: {
                coreCount: 1,
                type: "NVIDIA_TESLA_V100",
            },
        },
    },
});

import pulumi
import pulumi_gcp as gcp

runtime_gpu = gcp.notebooks.Runtime("runtime_gpu",
    name="notebooks-runtime-gpu",
    location="us-central1",
    access_config={
        "access_type": "SINGLE_USER",
        "runtime_owner": "admin@hashicorptest.com",
    },
    software_config={
        "install_gpu_driver": True,
    },
    virtual_machine={
        "virtual_machine_config": {
            "machine_type": "n1-standard-4",
            "data_disk": {
                "initialize_params": {
                    "disk_size_gb": 100,
                    "disk_type": "PD_STANDARD",
                },
            },
            "accelerator_config": {
                "core_count": 1,
                "type": "NVIDIA_TESLA_V100",
            },
        },
    })

package main

import (
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/notebooks"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := notebooks.NewRuntime(ctx, "runtime_gpu", &notebooks.RuntimeArgs{
			Name:     pulumi.String("notebooks-runtime-gpu"),
			Location: pulumi.String("us-central1"),
			AccessConfig: &notebooks.RuntimeAccessConfigArgs{
				AccessType:   pulumi.String("SINGLE_USER"),
				RuntimeOwner: pulumi.String("admin@hashicorptest.com"),
			},
			SoftwareConfig: &notebooks.RuntimeSoftwareConfigArgs{
				InstallGpuDriver: pulumi.Bool(true),
			},
			VirtualMachine: &notebooks.RuntimeVirtualMachineArgs{
				VirtualMachineConfig: &notebooks.RuntimeVirtualMachineVirtualMachineConfigArgs{
					MachineType: pulumi.String("n1-standard-4"),
					DataDisk: &notebooks.RuntimeVirtualMachineVirtualMachineConfigDataDiskArgs{
						InitializeParams: &notebooks.RuntimeVirtualMachineVirtualMachineConfigDataDiskInitializeParamsArgs{
							DiskSizeGb: pulumi.Int(100),
							DiskType:   pulumi.String("PD_STANDARD"),
						},
					},
					AcceleratorConfig: &notebooks.RuntimeVirtualMachineVirtualMachineConfigAcceleratorConfigArgs{
						CoreCount: pulumi.Int(1),
						Type:      pulumi.String("NVIDIA_TESLA_V100"),
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;

return await Deployment.RunAsync(() => 
{
    var runtimeGpu = new Gcp.Notebooks.Runtime("runtime_gpu", new()
    {
        Name = "notebooks-runtime-gpu",
        Location = "us-central1",
        AccessConfig = new Gcp.Notebooks.Inputs.RuntimeAccessConfigArgs
        {
            AccessType = "SINGLE_USER",
            RuntimeOwner = "admin@hashicorptest.com",
        },
        SoftwareConfig = new Gcp.Notebooks.Inputs.RuntimeSoftwareConfigArgs
        {
            InstallGpuDriver = true,
        },
        VirtualMachine = new Gcp.Notebooks.Inputs.RuntimeVirtualMachineArgs
        {
            VirtualMachineConfig = new Gcp.Notebooks.Inputs.RuntimeVirtualMachineVirtualMachineConfigArgs
            {
                MachineType = "n1-standard-4",
                DataDisk = new Gcp.Notebooks.Inputs.RuntimeVirtualMachineVirtualMachineConfigDataDiskArgs
                {
                    InitializeParams = new Gcp.Notebooks.Inputs.RuntimeVirtualMachineVirtualMachineConfigDataDiskInitializeParamsArgs
                    {
                        DiskSizeGb = 100,
                        DiskType = "PD_STANDARD",
                    },
                },
                AcceleratorConfig = new Gcp.Notebooks.Inputs.RuntimeVirtualMachineVirtualMachineConfigAcceleratorConfigArgs
                {
                    CoreCount = 1,
                    Type = "NVIDIA_TESLA_V100",
                },
            },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.notebooks.Runtime;
import com.pulumi.gcp.notebooks.RuntimeArgs;
import com.pulumi.gcp.notebooks.inputs.RuntimeAccessConfigArgs;
import com.pulumi.gcp.notebooks.inputs.RuntimeSoftwareConfigArgs;
import com.pulumi.gcp.notebooks.inputs.RuntimeVirtualMachineArgs;
import com.pulumi.gcp.notebooks.inputs.RuntimeVirtualMachineVirtualMachineConfigArgs;
import com.pulumi.gcp.notebooks.inputs.RuntimeVirtualMachineVirtualMachineConfigDataDiskArgs;
import com.pulumi.gcp.notebooks.inputs.RuntimeVirtualMachineVirtualMachineConfigDataDiskInitializeParamsArgs;
import com.pulumi.gcp.notebooks.inputs.RuntimeVirtualMachineVirtualMachineConfigAcceleratorConfigArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var runtimeGpu = new Runtime("runtimeGpu", RuntimeArgs.builder()
            .name("notebooks-runtime-gpu")
            .location("us-central1")
            .accessConfig(RuntimeAccessConfigArgs.builder()
                .accessType("SINGLE_USER")
                .runtimeOwner("admin@hashicorptest.com")
                .build())
            .softwareConfig(RuntimeSoftwareConfigArgs.builder()
                .installGpuDriver(true)
                .build())
            .virtualMachine(RuntimeVirtualMachineArgs.builder()
                .virtualMachineConfig(RuntimeVirtualMachineVirtualMachineConfigArgs.builder()
                    .machineType("n1-standard-4")
                    .dataDisk(RuntimeVirtualMachineVirtualMachineConfigDataDiskArgs.builder()
                        .initializeParams(RuntimeVirtualMachineVirtualMachineConfigDataDiskInitializeParamsArgs.builder()
                            .diskSizeGb(100)
                            .diskType("PD_STANDARD")
                            .build())
                        .build())
                    .acceleratorConfig(RuntimeVirtualMachineVirtualMachineConfigAcceleratorConfigArgs.builder()
                        .coreCount(1)
                        .type("NVIDIA_TESLA_V100")
                        .build())
                    .build())
                .build())
            .build());

    }
}

resources:
  runtimeGpu:
    type: gcp:notebooks:Runtime
    name: runtime_gpu
    properties:
      name: notebooks-runtime-gpu
      location: us-central1
      accessConfig:
        accessType: SINGLE_USER
        runtimeOwner: admin@hashicorptest.com
      softwareConfig:
        installGpuDriver: true
      virtualMachine:
        virtualMachineConfig:
          machineType: n1-standard-4
          dataDisk:
            initializeParams:
              diskSizeGb: '100'
              diskType: PD_STANDARD
          acceleratorConfig:
            coreCount: '1'
            type: NVIDIA_TESLA_V100

The acceleratorConfig property attaches NVIDIA GPUs to the runtime. The type specifies the GPU model (e.g., NVIDIA_TESLA_V100); coreCount sets how many GPUs to attach. Setting installGpuDriver to true automatically installs CUDA drivers, eliminating manual setup. This extends the basic runtime configuration with GPU-specific properties.

Run custom container images for specialized environments

Teams often package dependencies and tools into container images for reproducible environments that aren’t available in default images.

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";

const runtimeContainer = new gcp.notebooks.Runtime("runtime_container", {
    name: "notebooks-runtime-container",
    location: "us-central1",
    accessConfig: {
        accessType: "SINGLE_USER",
        runtimeOwner: "admin@hashicorptest.com",
    },
    virtualMachine: {
        virtualMachineConfig: {
            machineType: "n1-standard-4",
            dataDisk: {
                initializeParams: {
                    diskSizeGb: 100,
                    diskType: "PD_STANDARD",
                },
            },
            containerImages: [
                {
                    repository: "gcr.io/deeplearning-platform-release/base-cpu",
                    tag: "latest",
                },
                {
                    repository: "gcr.io/deeplearning-platform-release/beam-notebooks",
                    tag: "latest",
                },
            ],
        },
    },
});

import pulumi
import pulumi_gcp as gcp

runtime_container = gcp.notebooks.Runtime("runtime_container",
    name="notebooks-runtime-container",
    location="us-central1",
    access_config={
        "access_type": "SINGLE_USER",
        "runtime_owner": "admin@hashicorptest.com",
    },
    virtual_machine={
        "virtual_machine_config": {
            "machine_type": "n1-standard-4",
            "data_disk": {
                "initialize_params": {
                    "disk_size_gb": 100,
                    "disk_type": "PD_STANDARD",
                },
            },
            "container_images": [
                {
                    "repository": "gcr.io/deeplearning-platform-release/base-cpu",
                    "tag": "latest",
                },
                {
                    "repository": "gcr.io/deeplearning-platform-release/beam-notebooks",
                    "tag": "latest",
                },
            ],
        },
    })

package main

import (
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/notebooks"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := notebooks.NewRuntime(ctx, "runtime_container", &notebooks.RuntimeArgs{
			Name:     pulumi.String("notebooks-runtime-container"),
			Location: pulumi.String("us-central1"),
			AccessConfig: &notebooks.RuntimeAccessConfigArgs{
				AccessType:   pulumi.String("SINGLE_USER"),
				RuntimeOwner: pulumi.String("admin@hashicorptest.com"),
			},
			VirtualMachine: &notebooks.RuntimeVirtualMachineArgs{
				VirtualMachineConfig: &notebooks.RuntimeVirtualMachineVirtualMachineConfigArgs{
					MachineType: pulumi.String("n1-standard-4"),
					DataDisk: &notebooks.RuntimeVirtualMachineVirtualMachineConfigDataDiskArgs{
						InitializeParams: &notebooks.RuntimeVirtualMachineVirtualMachineConfigDataDiskInitializeParamsArgs{
							DiskSizeGb: pulumi.Int(100),
							DiskType:   pulumi.String("PD_STANDARD"),
						},
					},
					ContainerImages: notebooks.RuntimeVirtualMachineVirtualMachineConfigContainerImageArray{
						&notebooks.RuntimeVirtualMachineVirtualMachineConfigContainerImageArgs{
							Repository: pulumi.String("gcr.io/deeplearning-platform-release/base-cpu"),
							Tag:        pulumi.String("latest"),
						},
						&notebooks.RuntimeVirtualMachineVirtualMachineConfigContainerImageArgs{
							Repository: pulumi.String("gcr.io/deeplearning-platform-release/beam-notebooks"),
							Tag:        pulumi.String("latest"),
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;

return await Deployment.RunAsync(() => 
{
    var runtimeContainer = new Gcp.Notebooks.Runtime("runtime_container", new()
    {
        Name = "notebooks-runtime-container",
        Location = "us-central1",
        AccessConfig = new Gcp.Notebooks.Inputs.RuntimeAccessConfigArgs
        {
            AccessType = "SINGLE_USER",
            RuntimeOwner = "admin@hashicorptest.com",
        },
        VirtualMachine = new Gcp.Notebooks.Inputs.RuntimeVirtualMachineArgs
        {
            VirtualMachineConfig = new Gcp.Notebooks.Inputs.RuntimeVirtualMachineVirtualMachineConfigArgs
            {
                MachineType = "n1-standard-4",
                DataDisk = new Gcp.Notebooks.Inputs.RuntimeVirtualMachineVirtualMachineConfigDataDiskArgs
                {
                    InitializeParams = new Gcp.Notebooks.Inputs.RuntimeVirtualMachineVirtualMachineConfigDataDiskInitializeParamsArgs
                    {
                        DiskSizeGb = 100,
                        DiskType = "PD_STANDARD",
                    },
                },
                ContainerImages = new[]
                {
                    new Gcp.Notebooks.Inputs.RuntimeVirtualMachineVirtualMachineConfigContainerImageArgs
                    {
                        Repository = "gcr.io/deeplearning-platform-release/base-cpu",
                        Tag = "latest",
                    },
                    new Gcp.Notebooks.Inputs.RuntimeVirtualMachineVirtualMachineConfigContainerImageArgs
                    {
                        Repository = "gcr.io/deeplearning-platform-release/beam-notebooks",
                        Tag = "latest",
                    },
                },
            },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.notebooks.Runtime;
import com.pulumi.gcp.notebooks.RuntimeArgs;
import com.pulumi.gcp.notebooks.inputs.RuntimeAccessConfigArgs;
import com.pulumi.gcp.notebooks.inputs.RuntimeVirtualMachineArgs;
import com.pulumi.gcp.notebooks.inputs.RuntimeVirtualMachineVirtualMachineConfigArgs;
import com.pulumi.gcp.notebooks.inputs.RuntimeVirtualMachineVirtualMachineConfigDataDiskArgs;
import com.pulumi.gcp.notebooks.inputs.RuntimeVirtualMachineVirtualMachineConfigDataDiskInitializeParamsArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var runtimeContainer = new Runtime("runtimeContainer", RuntimeArgs.builder()
            .name("notebooks-runtime-container")
            .location("us-central1")
            .accessConfig(RuntimeAccessConfigArgs.builder()
                .accessType("SINGLE_USER")
                .runtimeOwner("admin@hashicorptest.com")
                .build())
            .virtualMachine(RuntimeVirtualMachineArgs.builder()
                .virtualMachineConfig(RuntimeVirtualMachineVirtualMachineConfigArgs.builder()
                    .machineType("n1-standard-4")
                    .dataDisk(RuntimeVirtualMachineVirtualMachineConfigDataDiskArgs.builder()
                        .initializeParams(RuntimeVirtualMachineVirtualMachineConfigDataDiskInitializeParamsArgs.builder()
                            .diskSizeGb(100)
                            .diskType("PD_STANDARD")
                            .build())
                        .build())
                    .containerImages(                    
                        RuntimeVirtualMachineVirtualMachineConfigContainerImageArgs.builder()
                            .repository("gcr.io/deeplearning-platform-release/base-cpu")
                            .tag("latest")
                            .build(),
                        RuntimeVirtualMachineVirtualMachineConfigContainerImageArgs.builder()
                            .repository("gcr.io/deeplearning-platform-release/beam-notebooks")
                            .tag("latest")
                            .build())
                    .build())
                .build())
            .build());

    }
}

resources:
  runtimeContainer:
    type: gcp:notebooks:Runtime
    name: runtime_container
    properties:
      name: notebooks-runtime-container
      location: us-central1
      accessConfig:
        accessType: SINGLE_USER
        runtimeOwner: admin@hashicorptest.com
      virtualMachine:
        virtualMachineConfig:
          machineType: n1-standard-4
          dataDisk:
            initializeParams:
              diskSizeGb: '100'
              diskType: PD_STANDARD
          containerImages:
            - repository: gcr.io/deeplearning-platform-release/base-cpu
              tag: latest
            - repository: gcr.io/deeplearning-platform-release/beam-notebooks
              tag: latest

The containerImages array specifies one or more container images to run in the runtime. Each entry includes a repository (typically GCR) and tag. The runtime pulls these images at startup, providing your custom software stack. This is an alternative to the basic example, replacing default images with your own containers.

Execute startup scripts on runtime initialization

Production workflows often require environment setup or package installation that runs automatically when the runtime starts.

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";

const runtimeContainer = new gcp.notebooks.Runtime("runtime_container", {
    name: "notebooks-runtime-script",
    location: "us-central1",
    accessConfig: {
        accessType: "SINGLE_USER",
        runtimeOwner: "admin@hashicorptest.com",
    },
    softwareConfig: {
        postStartupScriptBehavior: "RUN_EVERY_START",
    },
    virtualMachine: {
        virtualMachineConfig: {
            machineType: "n1-standard-4",
            dataDisk: {
                initializeParams: {
                    diskSizeGb: 100,
                    diskType: "PD_STANDARD",
                },
            },
        },
    },
    labels: {
        k: "val",
    },
});

import pulumi
import pulumi_gcp as gcp

runtime_container = gcp.notebooks.Runtime("runtime_container",
    name="notebooks-runtime-script",
    location="us-central1",
    access_config={
        "access_type": "SINGLE_USER",
        "runtime_owner": "admin@hashicorptest.com",
    },
    software_config={
        "post_startup_script_behavior": "RUN_EVERY_START",
    },
    virtual_machine={
        "virtual_machine_config": {
            "machine_type": "n1-standard-4",
            "data_disk": {
                "initialize_params": {
                    "disk_size_gb": 100,
                    "disk_type": "PD_STANDARD",
                },
            },
        },
    },
    labels={
        "k": "val",
    })

package main

import (
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/notebooks"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := notebooks.NewRuntime(ctx, "runtime_container", &notebooks.RuntimeArgs{
			Name:     pulumi.String("notebooks-runtime-script"),
			Location: pulumi.String("us-central1"),
			AccessConfig: &notebooks.RuntimeAccessConfigArgs{
				AccessType:   pulumi.String("SINGLE_USER"),
				RuntimeOwner: pulumi.String("admin@hashicorptest.com"),
			},
			SoftwareConfig: &notebooks.RuntimeSoftwareConfigArgs{
				PostStartupScriptBehavior: pulumi.String("RUN_EVERY_START"),
			},
			VirtualMachine: &notebooks.RuntimeVirtualMachineArgs{
				VirtualMachineConfig: &notebooks.RuntimeVirtualMachineVirtualMachineConfigArgs{
					MachineType: pulumi.String("n1-standard-4"),
					DataDisk: &notebooks.RuntimeVirtualMachineVirtualMachineConfigDataDiskArgs{
						InitializeParams: &notebooks.RuntimeVirtualMachineVirtualMachineConfigDataDiskInitializeParamsArgs{
							DiskSizeGb: pulumi.Int(100),
							DiskType:   pulumi.String("PD_STANDARD"),
						},
					},
				},
			},
			Labels: pulumi.StringMap{
				"k": pulumi.String("val"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;

return await Deployment.RunAsync(() => 
{
    var runtimeContainer = new Gcp.Notebooks.Runtime("runtime_container", new()
    {
        Name = "notebooks-runtime-script",
        Location = "us-central1",
        AccessConfig = new Gcp.Notebooks.Inputs.RuntimeAccessConfigArgs
        {
            AccessType = "SINGLE_USER",
            RuntimeOwner = "admin@hashicorptest.com",
        },
        SoftwareConfig = new Gcp.Notebooks.Inputs.RuntimeSoftwareConfigArgs
        {
            PostStartupScriptBehavior = "RUN_EVERY_START",
        },
        VirtualMachine = new Gcp.Notebooks.Inputs.RuntimeVirtualMachineArgs
        {
            VirtualMachineConfig = new Gcp.Notebooks.Inputs.RuntimeVirtualMachineVirtualMachineConfigArgs
            {
                MachineType = "n1-standard-4",
                DataDisk = new Gcp.Notebooks.Inputs.RuntimeVirtualMachineVirtualMachineConfigDataDiskArgs
                {
                    InitializeParams = new Gcp.Notebooks.Inputs.RuntimeVirtualMachineVirtualMachineConfigDataDiskInitializeParamsArgs
                    {
                        DiskSizeGb = 100,
                        DiskType = "PD_STANDARD",
                    },
                },
            },
        },
        Labels = 
        {
            { "k", "val" },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.notebooks.Runtime;
import com.pulumi.gcp.notebooks.RuntimeArgs;
import com.pulumi.gcp.notebooks.inputs.RuntimeAccessConfigArgs;
import com.pulumi.gcp.notebooks.inputs.RuntimeSoftwareConfigArgs;
import com.pulumi.gcp.notebooks.inputs.RuntimeVirtualMachineArgs;
import com.pulumi.gcp.notebooks.inputs.RuntimeVirtualMachineVirtualMachineConfigArgs;
import com.pulumi.gcp.notebooks.inputs.RuntimeVirtualMachineVirtualMachineConfigDataDiskArgs;
import com.pulumi.gcp.notebooks.inputs.RuntimeVirtualMachineVirtualMachineConfigDataDiskInitializeParamsArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var runtimeContainer = new Runtime("runtimeContainer", RuntimeArgs.builder()
            .name("notebooks-runtime-script")
            .location("us-central1")
            .accessConfig(RuntimeAccessConfigArgs.builder()
                .accessType("SINGLE_USER")
                .runtimeOwner("admin@hashicorptest.com")
                .build())
            .softwareConfig(RuntimeSoftwareConfigArgs.builder()
                .postStartupScriptBehavior("RUN_EVERY_START")
                .build())
            .virtualMachine(RuntimeVirtualMachineArgs.builder()
                .virtualMachineConfig(RuntimeVirtualMachineVirtualMachineConfigArgs.builder()
                    .machineType("n1-standard-4")
                    .dataDisk(RuntimeVirtualMachineVirtualMachineConfigDataDiskArgs.builder()
                        .initializeParams(RuntimeVirtualMachineVirtualMachineConfigDataDiskInitializeParamsArgs.builder()
                            .diskSizeGb(100)
                            .diskType("PD_STANDARD")
                            .build())
                        .build())
                    .build())
                .build())
            .labels(Map.of("k", "val"))
            .build());

    }
}

resources:
  runtimeContainer:
    type: gcp:notebooks:Runtime
    name: runtime_container
    properties:
      name: notebooks-runtime-script
      location: us-central1
      accessConfig:
        accessType: SINGLE_USER
        runtimeOwner: admin@hashicorptest.com
      softwareConfig:
        postStartupScriptBehavior: RUN_EVERY_START
      virtualMachine:
        virtualMachineConfig:
          machineType: n1-standard-4
          dataDisk:
            initializeParams:
              diskSizeGb: '100'
              diskType: PD_STANDARD
      labels:
        k: val

The postStartupScriptBehavior property controls when startup scripts execute. Setting it to RUN_EVERY_START ensures scripts run each time the runtime starts, not just on first boot. The actual script location and contents are configured separately through the runtime’s metadata or Cloud Storage references.

Beyond these examples

These snippets focus on specific runtime-level features: compute and storage configuration, GPU acceleration and driver installation, and container images and startup scripts. They’re intentionally minimal rather than full notebook deployments.

The examples may reference pre-existing infrastructure such as GCP projects with Notebooks API enabled, user accounts for runtime access (runtimeOwner email), and container registries (GCR) for custom images. They focus on configuring the runtime rather than provisioning everything around it.

To keep things focused, common runtime patterns are omitted, including:

  • Network configuration (VPC, subnets, firewall rules)
  • IAM permissions and service accounts
  • Custom kernel configurations beyond basic repository/tag
  • Idle shutdown policies and cost controls

These omissions are intentional: the goal is to illustrate how each runtime feature is wired, not provide drop-in notebook modules. See the Notebooks Runtime resource reference for all available configuration options.

Let's deploy GCP Notebook Runtimes

Get started with Pulumi Cloud, then follow our quick setup guide to deploy this infrastructure.

Try Pulumi Cloud for FREE

Frequently Asked Questions

Migration & Deprecation
Should I still use gcp.notebooks.Runtime?
No, gcp.notebooks.Runtime is deprecated and will be removed in a future major release. Use gcp.workbench.Instance instead.
State Management & Drift
Why aren't my configuration changes showing up in Pulumi state?
Many fields in this resource don’t properly detect drift due to Notebooks Runtime API limitations. These fields won’t appear in state once imported.
Configuration & Setup
How do I configure access to my runtime?
Set accessConfig with accessType (e.g., SINGLE_USER) and runtimeOwner (email address), as shown in all examples.
How do I add GPU support to my runtime?
Configure softwareConfig.installGpuDriver to true and add acceleratorConfig with coreCount and type (e.g., NVIDIA_TESLA_V100) in virtualMachine.virtualMachineConfig.
Can I use custom container images?
Yes, specify containerImages in virtualMachine.virtualMachineConfig with repository and tag for each image.
How do I configure custom kernels?
Add kernels to softwareConfig with repository and tag for each kernel.
Can I run scripts when my runtime starts?
Yes, configure softwareConfig.postStartupScriptBehavior (e.g., RUN_EVERY_START) to control script execution.
Immutability & Updates
What properties can't I change after creating a runtime?
The location, name, and project properties are immutable and require resource replacement if changed.
Labels & Metadata
What are the constraints for runtime labels?
Label keys must be 1-63 characters and conform to RFC 1035. Label values may be empty or 1-63 characters (also RFC 1035). Maximum 32 labels per runtime. The labels field is non-authoritative; use effectiveLabels to see all labels.
Why do I see labels I didn't configure?
The labels field is non-authoritative and only manages labels in your configuration. Use effectiveLabels to see all labels present on the resource, including those added by other clients or services.

Using a different cloud?

Explore compute guides for other cloud providers:

AWS Guides Azure Guides