Deploy GCP Notebook Runtimes

The gcp:notebooks/runtime:Runtime resource, part of the Pulumi GCP provider, provisions a Cloud AI Platform Notebook runtime with its compute resources, storage, access controls, and software environment. This resource is deprecated; for new projects, use gcp.workbench.Instance instead. This guide focuses on three capabilities: machine type and disk configuration, GPU acceleration, and custom container images and kernels.

Runtimes require a GCP project with the Notebooks API enabled and appropriate IAM permissions. Custom images require Container Registry access. The examples are intentionally small. Combine them with your own network configuration and security policies.

Create a basic runtime with compute and storage

Most notebook deployments start by provisioning compute resources and persistent storage for interactive data science work.

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 accessConfig property controls who can access the runtime; SINGLE_USER restricts access to a specified email address. The virtualMachine block defines the compute environment: machineType sets CPU and memory, while dataDisk configures persistent storage size and type. The runtime provisions a managed Jupyter environment with these specifications.

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, specifying the GPU type and count. Setting installGpuDriver to true ensures the runtime installs CUDA drivers automatically. This configuration extends the basic runtime with GPU hardware for compute-intensive ML tasks.

Run custom container images for specialized environments

Teams often need specific Python libraries, frameworks, or system dependencies that aren’t available in default notebook 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 pre-built images from Container Registry. Each entry includes a repository path and tag. The runtime pulls these images at startup, providing custom dependencies without manual installation. You can specify multiple images for different notebook environments.

Configure custom Jupyter kernels

Data scientists working across multiple projects may need different kernel environments with isolated dependencies.

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

const runtimeContainer = new gcp.notebooks.Runtime("runtime_container", {
    name: "notebooks-runtime-kernel",
    location: "us-central1",
    accessConfig: {
        accessType: "SINGLE_USER",
        runtimeOwner: "admin@hashicorptest.com",
    },
    softwareConfig: {
        kernels: [{
            repository: "gcr.io/deeplearning-platform-release/base-cpu",
            tag: "latest",
        }],
    },
    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-kernel",
    location="us-central1",
    access_config={
        "access_type": "SINGLE_USER",
        "runtime_owner": "admin@hashicorptest.com",
    },
    software_config={
        "kernels": [{
            "repository": "gcr.io/deeplearning-platform-release/base-cpu",
            "tag": "latest",
        }],
    },
    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-kernel"),
			Location: pulumi.String("us-central1"),
			AccessConfig: &notebooks.RuntimeAccessConfigArgs{
				AccessType:   pulumi.String("SINGLE_USER"),
				RuntimeOwner: pulumi.String("admin@hashicorptest.com"),
			},
			SoftwareConfig: &notebooks.RuntimeSoftwareConfigArgs{
				Kernels: notebooks.RuntimeSoftwareConfigKernelArray{
					&notebooks.RuntimeSoftwareConfigKernelArgs{
						Repository: pulumi.String("gcr.io/deeplearning-platform-release/base-cpu"),
						Tag:        pulumi.String("latest"),
					},
				},
			},
			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-kernel",
        Location = "us-central1",
        AccessConfig = new Gcp.Notebooks.Inputs.RuntimeAccessConfigArgs
        {
            AccessType = "SINGLE_USER",
            RuntimeOwner = "admin@hashicorptest.com",
        },
        SoftwareConfig = new Gcp.Notebooks.Inputs.RuntimeSoftwareConfigArgs
        {
            Kernels = new[]
            {
                new Gcp.Notebooks.Inputs.RuntimeSoftwareConfigKernelArgs
                {
                    Repository = "gcr.io/deeplearning-platform-release/base-cpu",
                    Tag = "latest",
                },
            },
        },
        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-kernel")
            .location("us-central1")
            .accessConfig(RuntimeAccessConfigArgs.builder()
                .accessType("SINGLE_USER")
                .runtimeOwner("admin@hashicorptest.com")
                .build())
            .softwareConfig(RuntimeSoftwareConfigArgs.builder()
                .kernels(RuntimeSoftwareConfigKernelArgs.builder()
                    .repository("gcr.io/deeplearning-platform-release/base-cpu")
                    .tag("latest")
                    .build())
                .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-kernel
      location: us-central1
      accessConfig:
        accessType: SINGLE_USER
        runtimeOwner: admin@hashicorptest.com
      softwareConfig:
        kernels:
          - repository: gcr.io/deeplearning-platform-release/base-cpu
            tag: latest
      virtualMachine:
        virtualMachineConfig:
          machineType: n1-standard-4
          dataDisk:
            initializeParams:
              diskSizeGb: '100'
              diskType: PD_STANDARD
      labels:
        k: val

The kernels property in softwareConfig defines custom Jupyter kernel images. Each kernel runs in isolation with its own dependencies. The labels property adds metadata for organization and cost tracking.

Beyond these examples

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

The examples assume pre-existing infrastructure such as a GCP project with Notebooks API enabled, IAM permissions for runtime creation, and Container Registry access for custom images. They focus on configuring the runtime rather than provisioning surrounding infrastructure.

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

Network configuration (VPC, subnets, firewall rules)
Post-startup scripts and initialization (postStartupScriptBehavior)
Idle shutdown policies and cost controls
Encryption keys and security settings

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 this resource for new projects?

No, this resource is deprecated and will be removed in a future release. Use gcp.workbench.Instance instead for new notebook instances.

State Management & Drift

Why aren't my configuration changes being detected?

Due to API limitations, many fields don’t properly detect drift and won’t appear in state after import. Manual verification of changes may be needed.

What properties can't I change after creation?

The location, name, and project properties are immutable. Changing these requires replacing the entire runtime.

Why do my labels differ from what I configured?

The labels field is non-authoritative and only manages labels in your configuration. Use effectiveLabels to see all labels on the resource, including those set by other clients or services.

Configuration & Setup

What's required to configure runtime access?

Configure accessConfig with accessType (e.g., SINGLE_USER) and runtimeOwner (user email). All examples include this configuration.

How do I specify the machine type for my runtime?

Set virtualMachine.virtualMachineConfig.machineType to a Compute Engine machine type like n1-standard-4.

GPU & Advanced Features

How do I enable GPU support for my runtime?

Configure acceleratorConfig with coreCount and type (e.g., NVIDIA_TESLA_V100), and set softwareConfig.installGpuDriver to true.

What's the difference between containerImages and kernels?

Use containerImages in virtualMachineConfig for custom container environments, or use kernels in softwareConfig for custom kernel images. Both accept repository and tag specifications.

How do I run a script every time the runtime starts?

Set softwareConfig.postStartupScriptBehavior to RUN_EVERY_START.

Using a different cloud?

Explore compute guides for other cloud providers:

AWS Guides Azure Guides