gcp.colab.NotebookExecution

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

const myRuntimeTemplate = new gcp.colab.RuntimeTemplate("my_runtime_template", {
    name: "runtime-template-name",
    displayName: "Runtime template",
    location: "us-central1",
    machineSpec: {
        machineType: "e2-standard-4",
    },
    networkSpec: {
        enableInternetAccess: true,
    },
});
const outputBucket = new gcp.storage.Bucket("output_bucket", {
    name: "my_bucket",
    location: "US",
    forceDestroy: true,
    uniformBucketLevelAccess: true,
});
const notebook_execution = new gcp.colab.NotebookExecution("notebook-execution", {
    displayName: "Notebook execution basic",
    location: "us-central1",
    directNotebookSource: {
        content: std.base64encode({
            input: `    {
      \\"cells\\": [
        {
          \\"cell_type\\": \\"code\\",
          \\"execution_count\\": null,
          \\"metadata\\": {},
          \\"outputs\\": [],
          \\"source\\": [
            \\"print(\\\\\\"Hello, World!\\\\\\")\\"
          ]
        }
      ],
      \\"metadata\\": {
        \\"kernelspec\\": {
          \\"display_name\\": \\"Python 3\\",
          \\"language\\": \\"python\\",
          \\"name\\": \\"python3\\"
        },
        \\"language_info\\": {
          \\"codemirror_mode\\": {
            \\"name\\": \\"ipython\\",
            \\"version\\": 3
          },
          \\"file_extension\\": \\".py\\",
          \\"mimetype\\": \\"text/x-python\\",
          \\"name\\": \\"python\\",
          \\"nbconvert_exporter\\": \\"python\\",
          \\"pygments_lexer\\": \\"ipython3\\",
          \\"version\\": \\"3.8.5\\"
        }
      },
      \\"nbformat\\": 4,
      \\"nbformat_minor\\": 4
    }
`,
        }).then(invoke => invoke.result),
    },
    notebookRuntimeTemplateResourceName: pulumi.interpolate`projects/${myRuntimeTemplate.project}/locations/${myRuntimeTemplate.location}/notebookRuntimeTemplates/${myRuntimeTemplate.name}`,
    gcsOutputUri: pulumi.interpolate`gs://${outputBucket.name}`,
    serviceAccount: "my@service-account.com",
}, {
    dependsOn: [
        myRuntimeTemplate,
        outputBucket,
    ],
});

import pulumi
import pulumi_gcp as gcp
import pulumi_std as std

my_runtime_template = gcp.colab.RuntimeTemplate("my_runtime_template",
    name="runtime-template-name",
    display_name="Runtime template",
    location="us-central1",
    machine_spec={
        "machine_type": "e2-standard-4",
    },
    network_spec={
        "enable_internet_access": True,
    })
output_bucket = gcp.storage.Bucket("output_bucket",
    name="my_bucket",
    location="US",
    force_destroy=True,
    uniform_bucket_level_access=True)
notebook_execution = gcp.colab.NotebookExecution("notebook-execution",
    display_name="Notebook execution basic",
    location="us-central1",
    direct_notebook_source={
        "content": std.base64encode(input="""    {
      \"cells\": [
        {
          \"cell_type\": \"code\",
          \"execution_count\": null,
          \"metadata\": {},
          \"outputs\": [],
          \"source\": [
            \"print(\\\"Hello, World!\\\")\"
          ]
        }
      ],
      \"metadata\": {
        \"kernelspec\": {
          \"display_name\": \"Python 3\",
          \"language\": \"python\",
          \"name\": \"python3\"
        },
        \"language_info\": {
          \"codemirror_mode\": {
            \"name\": \"ipython\",
            \"version\": 3
          },
          \"file_extension\": \".py\",
          \"mimetype\": \"text/x-python\",
          \"name\": \"python\",
          \"nbconvert_exporter\": \"python\",
          \"pygments_lexer\": \"ipython3\",
          \"version\": \"3.8.5\"
        }
      },
      \"nbformat\": 4,
      \"nbformat_minor\": 4
    }
""").result,
    },
    notebook_runtime_template_resource_name=pulumi.Output.all(
        project=my_runtime_template.project,
        location=my_runtime_template.location,
        name=my_runtime_template.name
).apply(lambda resolved_outputs: f"projects/{resolved_outputs['project']}/locations/{resolved_outputs['location']}/notebookRuntimeTemplates/{resolved_outputs['name']}")
,
    gcs_output_uri=output_bucket.name.apply(lambda name: f"gs://{name}"),
    service_account="my@service-account.com",
    opts = pulumi.ResourceOptions(depends_on=[
            my_runtime_template,
            output_bucket,
        ]))

package main

import (
	"fmt"

	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/colab"
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/storage"
	"github.com/pulumi/pulumi-std/sdk/go/std"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		myRuntimeTemplate, err := colab.NewRuntimeTemplate(ctx, "my_runtime_template", &colab.RuntimeTemplateArgs{
			Name:        pulumi.String("runtime-template-name"),
			DisplayName: pulumi.String("Runtime template"),
			Location:    pulumi.String("us-central1"),
			MachineSpec: &colab.RuntimeTemplateMachineSpecArgs{
				MachineType: pulumi.String("e2-standard-4"),
			},
			NetworkSpec: &colab.RuntimeTemplateNetworkSpecArgs{
				EnableInternetAccess: pulumi.Bool(true),
			},
		})
		if err != nil {
			return err
		}
		outputBucket, err := storage.NewBucket(ctx, "output_bucket", &storage.BucketArgs{
			Name:                     pulumi.String("my_bucket"),
			Location:                 pulumi.String("US"),
			ForceDestroy:             pulumi.Bool(true),
			UniformBucketLevelAccess: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		invokeBase64encode, err := std.Base64encode(ctx, &std.Base64encodeArgs{
			Input: `    {
      \"cells\": [
        {
          \"cell_type\": \"code\",
          \"execution_count\": null,
          \"metadata\": {},
          \"outputs\": [],
          \"source\": [
            \"print(\\\"Hello, World!\\\")\"
          ]
        }
      ],
      \"metadata\": {
        \"kernelspec\": {
          \"display_name\": \"Python 3\",
          \"language\": \"python\",
          \"name\": \"python3\"
        },
        \"language_info\": {
          \"codemirror_mode\": {
            \"name\": \"ipython\",
            \"version\": 3
          },
          \"file_extension\": \".py\",
          \"mimetype\": \"text/x-python\",
          \"name\": \"python\",
          \"nbconvert_exporter\": \"python\",
          \"pygments_lexer\": \"ipython3\",
          \"version\": \"3.8.5\"
        }
      },
      \"nbformat\": 4,
      \"nbformat_minor\": 4
    }
`,
		}, nil)
		if err != nil {
			return err
		}
		_, err = colab.NewNotebookExecution(ctx, "notebook-execution", &colab.NotebookExecutionArgs{
			DisplayName: pulumi.String("Notebook execution basic"),
			Location:    pulumi.String("us-central1"),
			DirectNotebookSource: &colab.NotebookExecutionDirectNotebookSourceArgs{
				Content: pulumi.String(invokeBase64encode.Result),
			},
			NotebookRuntimeTemplateResourceName: pulumi.All(myRuntimeTemplate.Project, myRuntimeTemplate.Location, myRuntimeTemplate.Name).ApplyT(func(_args []interface{}) (string, error) {
				project := _args[0].(string)
				location := _args[1].(string)
				name := _args[2].(string)
				return fmt.Sprintf("projects/%v/locations/%v/notebookRuntimeTemplates/%v", project, location, name), nil
			}).(pulumi.StringOutput),
			GcsOutputUri: outputBucket.Name.ApplyT(func(name string) (string, error) {
				return fmt.Sprintf("gs://%v", name), nil
			}).(pulumi.StringOutput),
			ServiceAccount: pulumi.String("my@service-account.com"),
		}, pulumi.DependsOn([]pulumi.Resource{
			myRuntimeTemplate,
			outputBucket,
		}))
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var myRuntimeTemplate = new Gcp.Colab.RuntimeTemplate("my_runtime_template", new()
    {
        Name = "runtime-template-name",
        DisplayName = "Runtime template",
        Location = "us-central1",
        MachineSpec = new Gcp.Colab.Inputs.RuntimeTemplateMachineSpecArgs
        {
            MachineType = "e2-standard-4",
        },
        NetworkSpec = new Gcp.Colab.Inputs.RuntimeTemplateNetworkSpecArgs
        {
            EnableInternetAccess = true,
        },
    });

    var outputBucket = new Gcp.Storage.Bucket("output_bucket", new()
    {
        Name = "my_bucket",
        Location = "US",
        ForceDestroy = true,
        UniformBucketLevelAccess = true,
    });

    var notebook_execution = new Gcp.Colab.NotebookExecution("notebook-execution", new()
    {
        DisplayName = "Notebook execution basic",
        Location = "us-central1",
        DirectNotebookSource = new Gcp.Colab.Inputs.NotebookExecutionDirectNotebookSourceArgs
        {
            Content = Std.Base64encode.Invoke(new()
            {
                Input = @"    {
      \""cells\"": [
        {
          \""cell_type\"": \""code\"",
          \""execution_count\"": null,
          \""metadata\"": {},
          \""outputs\"": [],
          \""source\"": [
            \""print(\\\""Hello, World!\\\"")\""
          ]
        }
      ],
      \""metadata\"": {
        \""kernelspec\"": {
          \""display_name\"": \""Python 3\"",
          \""language\"": \""python\"",
          \""name\"": \""python3\""
        },
        \""language_info\"": {
          \""codemirror_mode\"": {
            \""name\"": \""ipython\"",
            \""version\"": 3
          },
          \""file_extension\"": \"".py\"",
          \""mimetype\"": \""text/x-python\"",
          \""name\"": \""python\"",
          \""nbconvert_exporter\"": \""python\"",
          \""pygments_lexer\"": \""ipython3\"",
          \""version\"": \""3.8.5\""
        }
      },
      \""nbformat\"": 4,
      \""nbformat_minor\"": 4
    }
",
            }).Apply(invoke => invoke.Result),
        },
        NotebookRuntimeTemplateResourceName = Output.Tuple(myRuntimeTemplate.Project, myRuntimeTemplate.Location, myRuntimeTemplate.Name).Apply(values =>
        {
            var project = values.Item1;
            var location = values.Item2;
            var name = values.Item3;
            return $"projects/{project}/locations/{location}/notebookRuntimeTemplates/{name}";
        }),
        GcsOutputUri = outputBucket.Name.Apply(name => $"gs://{name}"),
        ServiceAccount = "my@service-account.com",
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            myRuntimeTemplate,
            outputBucket,
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.colab.RuntimeTemplate;
import com.pulumi.gcp.colab.RuntimeTemplateArgs;
import com.pulumi.gcp.colab.inputs.RuntimeTemplateMachineSpecArgs;
import com.pulumi.gcp.colab.inputs.RuntimeTemplateNetworkSpecArgs;
import com.pulumi.gcp.storage.Bucket;
import com.pulumi.gcp.storage.BucketArgs;
import com.pulumi.gcp.colab.NotebookExecution;
import com.pulumi.gcp.colab.NotebookExecutionArgs;
import com.pulumi.gcp.colab.inputs.NotebookExecutionDirectNotebookSourceArgs;
import com.pulumi.std.StdFunctions;
import com.pulumi.std.inputs.Base64encodeArgs;
import com.pulumi.resources.CustomResourceOptions;
import java.util.ArrayList;
import java.util.Arrays;
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 myRuntimeTemplate = new RuntimeTemplate("myRuntimeTemplate", RuntimeTemplateArgs.builder()
            .name("runtime-template-name")
            .displayName("Runtime template")
            .location("us-central1")
            .machineSpec(RuntimeTemplateMachineSpecArgs.builder()
                .machineType("e2-standard-4")
                .build())
            .networkSpec(RuntimeTemplateNetworkSpecArgs.builder()
                .enableInternetAccess(true)
                .build())
            .build());

        var outputBucket = new Bucket("outputBucket", BucketArgs.builder()
            .name("my_bucket")
            .location("US")
            .forceDestroy(true)
            .uniformBucketLevelAccess(true)
            .build());

        var notebook_execution = new NotebookExecution("notebook-execution", NotebookExecutionArgs.builder()
            .displayName("Notebook execution basic")
            .location("us-central1")
            .directNotebookSource(NotebookExecutionDirectNotebookSourceArgs.builder()
                .content(StdFunctions.base64encode(Base64encodeArgs.builder()
                    .input("""
    {
      \"cells\": [
        {
          \"cell_type\": \"code\",
          \"execution_count\": null,
          \"metadata\": {},
          \"outputs\": [],
          \"source\": [
            \"print(\\\"Hello, World!\\\")\"
          ]
        }
      ],
      \"metadata\": {
        \"kernelspec\": {
          \"display_name\": \"Python 3\",
          \"language\": \"python\",
          \"name\": \"python3\"
        },
        \"language_info\": {
          \"codemirror_mode\": {
            \"name\": \"ipython\",
            \"version\": 3
          },
          \"file_extension\": \".py\",
          \"mimetype\": \"text/x-python\",
          \"name\": \"python\",
          \"nbconvert_exporter\": \"python\",
          \"pygments_lexer\": \"ipython3\",
          \"version\": \"3.8.5\"
        }
      },
      \"nbformat\": 4,
      \"nbformat_minor\": 4
    }
                    """)
                    .build()).result())
                .build())
            .notebookRuntimeTemplateResourceName(Output.tuple(myRuntimeTemplate.project(), myRuntimeTemplate.location(), myRuntimeTemplate.name()).applyValue(values -> {
                var project = values.t1;
                var location = values.t2;
                var name = values.t3;
                return String.format("projects/%s/locations/%s/notebookRuntimeTemplates/%s", project,location,name);
            }))
            .gcsOutputUri(outputBucket.name().applyValue(_name -> String.format("gs://%s", _name)))
            .serviceAccount("my@service-account.com")
            .build(), CustomResourceOptions.builder()
                .dependsOn(                
                    myRuntimeTemplate,
                    outputBucket)
                .build());

    }
}

resources:
  myRuntimeTemplate:
    type: gcp:colab:RuntimeTemplate
    name: my_runtime_template
    properties:
      name: runtime-template-name
      displayName: Runtime template
      location: us-central1
      machineSpec:
        machineType: e2-standard-4
      networkSpec:
        enableInternetAccess: true
  outputBucket:
    type: gcp:storage:Bucket
    name: output_bucket
    properties:
      name: my_bucket
      location: US
      forceDestroy: true
      uniformBucketLevelAccess: true
  notebook-execution:
    type: gcp:colab:NotebookExecution
    properties:
      displayName: Notebook execution basic
      location: us-central1
      directNotebookSource:
        content:
          fn::invoke:
            function: std:base64encode
            arguments:
              input: |2
                    {
                      \"cells\": [
                        {
                          \"cell_type\": \"code\",
                          \"execution_count\": null,
                          \"metadata\": {},
                          \"outputs\": [],
                          \"source\": [
                            \"print(\\\"Hello, World!\\\")\"
                          ]
                        }
                      ],
                      \"metadata\": {
                        \"kernelspec\": {
                          \"display_name\": \"Python 3\",
                          \"language\": \"python\",
                          \"name\": \"python3\"
                        },
                        \"language_info\": {
                          \"codemirror_mode\": {
                            \"name\": \"ipython\",
                            \"version\": 3
                          },
                          \"file_extension\": \".py\",
                          \"mimetype\": \"text/x-python\",
                          \"name\": \"python\",
                          \"nbconvert_exporter\": \"python\",
                          \"pygments_lexer\": \"ipython3\",
                          \"version\": \"3.8.5\"
                        }
                      },
                      \"nbformat\": 4,
                      \"nbformat_minor\": 4
                    }
            return: result
      notebookRuntimeTemplateResourceName: projects/${myRuntimeTemplate.project}/locations/${myRuntimeTemplate.location}/notebookRuntimeTemplates/${myRuntimeTemplate.name}
      gcsOutputUri: gs://${outputBucket.name}
      serviceAccount: my@service-account.com
    options:
      dependsOn:
        - ${myRuntimeTemplate}
        - ${outputBucket}

pulumi {
  required_providers {
    gcp = {
      source = "pulumi/gcp"
    }
    std = {
      source = "pulumi/std"
    }
  }
}

resource "gcp_colab_runtimetemplate" "my_runtime_template" {
  name         = "runtime-template-name"
  display_name = "Runtime template"
  location     = "us-central1"
  machine_spec = {
    machine_type = "e2-standard-4"
  }
  network_spec = {
    enable_internet_access = true
  }
}
resource "gcp_storage_bucket" "output_bucket" {
  name                        = "my_bucket"
  location                    = "US"
  force_destroy               = true
  uniform_bucket_level_access = true
}
resource "gcp_colab_notebookexecution" "notebook-execution" {
  depends_on   = [gcp_colab_runtimetemplate.my_runtime_template, gcp_storage_bucket.output_bucket]
  display_name = "Notebook execution basic"
  location     = "us-central1"
  direct_notebook_source = {
    content = base64encode("    {\n      \\\"cells\\\": [\n        {\n          \\\"cell_type\\\": \\\"code\\\",\n          \\\"execution_count\\\": null,\n          \\\"metadata\\\": {},\n          \\\"outputs\\\": [],\n          \\\"source\\\": [\n            \\\"print(\\\\\\\"Hello, World!\\\\\\\")\\\"\n          ]\n        }\n      ],\n      \\\"metadata\\\": {\n        \\\"kernelspec\\\": {\n          \\\"display_name\\\": \\\"Python 3\\\",\n          \\\"language\\\": \\\"python\\\",\n          \\\"name\\\": \\\"python3\\\"\n        },\n        \\\"language_info\\\": {\n          \\\"codemirror_mode\\\": {\n            \\\"name\\\": \\\"ipython\\\",\n            \\\"version\\\": 3\n          },\n          \\\"file_extension\\\": \\\".py\\\",\n          \\\"mimetype\\\": \\\"text/x-python\\\",\n          \\\"name\\\": \\\"python\\\",\n          \\\"nbconvert_exporter\\\": \\\"python\\\",\n          \\\"pygments_lexer\\\": \\\"ipython3\\\",\n          \\\"version\\\": \\\"3.8.5\\\"\n        }\n      },\n      \\\"nbformat\\\": 4,\n      \\\"nbformat_minor\\\": 4\n    }\n")
  }
  notebook_runtime_template_resource_name ="projects/${gcp_colab_runtimetemplate.my_runtime_template.project}/locations/${gcp_colab_runtimetemplate.my_runtime_template.location}/notebookRuntimeTemplates/${gcp_colab_runtimetemplate.my_runtime_template.name}"
  gcs_output_uri                          ="gs://${gcp_storage_bucket.output_bucket.name}"
  service_account                         = "my@service-account.com"
}

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

const myNetwork = new gcp.compute.Network("my_network", {
    name: "colab-test-default",
    autoCreateSubnetworks: false,
});
const mySubnetwork = new gcp.compute.Subnetwork("my_subnetwork", {
    name: "colab-test-default",
    network: myNetwork.id,
    region: "us-central1",
    ipCidrRange: "10.0.1.0/24",
});
const outputBucket = new gcp.storage.Bucket("output_bucket", {
    name: "my_bucket",
    location: "US",
    forceDestroy: true,
    uniformBucketLevelAccess: true,
});
const notebook_execution = new gcp.colab.NotebookExecution("notebook-execution", {
    displayName: "Notebook execution basic",
    location: "us-central1",
    directNotebookSource: {
        content: std.base64encode({
            input: `    {
      \\"cells\\": [
        {
          \\"cell_type\\": \\"code\\",
          \\"execution_count\\": null,
          \\"metadata\\": {},
          \\"outputs\\": [],
          \\"source\\": [
            \\"print(\\\\\\"Hello, World!\\\\\\")\\"
          ]
        }
      ],
      \\"metadata\\": {
        \\"kernelspec\\": {
          \\"display_name\\": \\"Python 3\\",
          \\"language\\": \\"python\\",
          \\"name\\": \\"python3\\"
        },
        \\"language_info\\": {
          \\"codemirror_mode\\": {
            \\"name\\": \\"ipython\\",
            \\"version\\": 3
          },
          \\"file_extension\\": \\".py\\",
          \\"mimetype\\": \\"text/x-python\\",
          \\"name\\": \\"python\\",
          \\"nbconvert_exporter\\": \\"python\\",
          \\"pygments_lexer\\": \\"ipython3\\",
          \\"version\\": \\"3.8.5\\"
        }
      },
      \\"nbformat\\": 4,
      \\"nbformat_minor\\": 4
    }
`,
        }).then(invoke => invoke.result),
    },
    customEnvironmentSpec: {
        machineSpec: {
            machineType: "n1-standard-2",
            acceleratorType: "NVIDIA_TESLA_T4",
            acceleratorCount: 1,
        },
        persistentDiskSpec: {
            diskType: "pd-standard",
            diskSizeGb: "200",
        },
        networkSpec: {
            enableInternetAccess: true,
            network: myNetwork.id,
            subnetwork: mySubnetwork.id,
        },
        shieldedInstanceConfig: {
            enableIntegrityMonitoring: true,
            enableSecureBoot: true,
            enableVtpm: true,
        },
    },
    gcsOutputUri: pulumi.interpolate`gs://${outputBucket.name}`,
    serviceAccount: "my@service-account.com",
}, {
    dependsOn: [outputBucket],
});

import pulumi
import pulumi_gcp as gcp
import pulumi_std as std

my_network = gcp.compute.Network("my_network",
    name="colab-test-default",
    auto_create_subnetworks=False)
my_subnetwork = gcp.compute.Subnetwork("my_subnetwork",
    name="colab-test-default",
    network=my_network.id,
    region="us-central1",
    ip_cidr_range="10.0.1.0/24")
output_bucket = gcp.storage.Bucket("output_bucket",
    name="my_bucket",
    location="US",
    force_destroy=True,
    uniform_bucket_level_access=True)
notebook_execution = gcp.colab.NotebookExecution("notebook-execution",
    display_name="Notebook execution basic",
    location="us-central1",
    direct_notebook_source={
        "content": std.base64encode(input="""    {
      \"cells\": [
        {
          \"cell_type\": \"code\",
          \"execution_count\": null,
          \"metadata\": {},
          \"outputs\": [],
          \"source\": [
            \"print(\\\"Hello, World!\\\")\"
          ]
        }
      ],
      \"metadata\": {
        \"kernelspec\": {
          \"display_name\": \"Python 3\",
          \"language\": \"python\",
          \"name\": \"python3\"
        },
        \"language_info\": {
          \"codemirror_mode\": {
            \"name\": \"ipython\",
            \"version\": 3
          },
          \"file_extension\": \".py\",
          \"mimetype\": \"text/x-python\",
          \"name\": \"python\",
          \"nbconvert_exporter\": \"python\",
          \"pygments_lexer\": \"ipython3\",
          \"version\": \"3.8.5\"
        }
      },
      \"nbformat\": 4,
      \"nbformat_minor\": 4
    }
""").result,
    },
    custom_environment_spec={
        "machine_spec": {
            "machine_type": "n1-standard-2",
            "accelerator_type": "NVIDIA_TESLA_T4",
            "accelerator_count": 1,
        },
        "persistent_disk_spec": {
            "disk_type": "pd-standard",
            "disk_size_gb": "200",
        },
        "network_spec": {
            "enable_internet_access": True,
            "network": my_network.id,
            "subnetwork": my_subnetwork.id,
        },
        "shielded_instance_config": {
            "enable_integrity_monitoring": True,
            "enable_secure_boot": True,
            "enable_vtpm": True,
        },
    },
    gcs_output_uri=output_bucket.name.apply(lambda name: f"gs://{name}"),
    service_account="my@service-account.com",
    opts = pulumi.ResourceOptions(depends_on=[output_bucket]))

package main

import (
	"fmt"

	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/colab"
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/compute"
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/storage"
	"github.com/pulumi/pulumi-std/sdk/go/std"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		myNetwork, err := compute.NewNetwork(ctx, "my_network", &compute.NetworkArgs{
			Name:                  pulumi.String("colab-test-default"),
			AutoCreateSubnetworks: pulumi.Bool(false),
		})
		if err != nil {
			return err
		}
		mySubnetwork, err := compute.NewSubnetwork(ctx, "my_subnetwork", &compute.SubnetworkArgs{
			Name:        pulumi.String("colab-test-default"),
			Network:     myNetwork.ID().ToIDOutput().ToStringOutput(),
			Region:      pulumi.String("us-central1"),
			IpCidrRange: pulumi.String("10.0.1.0/24"),
		})
		if err != nil {
			return err
		}
		outputBucket, err := storage.NewBucket(ctx, "output_bucket", &storage.BucketArgs{
			Name:                     pulumi.String("my_bucket"),
			Location:                 pulumi.String("US"),
			ForceDestroy:             pulumi.Bool(true),
			UniformBucketLevelAccess: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		invokeBase64encode, err := std.Base64encode(ctx, &std.Base64encodeArgs{
			Input: `    {
      \"cells\": [
        {
          \"cell_type\": \"code\",
          \"execution_count\": null,
          \"metadata\": {},
          \"outputs\": [],
          \"source\": [
            \"print(\\\"Hello, World!\\\")\"
          ]
        }
      ],
      \"metadata\": {
        \"kernelspec\": {
          \"display_name\": \"Python 3\",
          \"language\": \"python\",
          \"name\": \"python3\"
        },
        \"language_info\": {
          \"codemirror_mode\": {
            \"name\": \"ipython\",
            \"version\": 3
          },
          \"file_extension\": \".py\",
          \"mimetype\": \"text/x-python\",
          \"name\": \"python\",
          \"nbconvert_exporter\": \"python\",
          \"pygments_lexer\": \"ipython3\",
          \"version\": \"3.8.5\"
        }
      },
      \"nbformat\": 4,
      \"nbformat_minor\": 4
    }
`,
		}, nil)
		if err != nil {
			return err
		}
		_, err = colab.NewNotebookExecution(ctx, "notebook-execution", &colab.NotebookExecutionArgs{
			DisplayName: pulumi.String("Notebook execution basic"),
			Location:    pulumi.String("us-central1"),
			DirectNotebookSource: &colab.NotebookExecutionDirectNotebookSourceArgs{
				Content: pulumi.String(invokeBase64encode.Result),
			},
			CustomEnvironmentSpec: &colab.NotebookExecutionCustomEnvironmentSpecArgs{
				MachineSpec: &colab.NotebookExecutionCustomEnvironmentSpecMachineSpecArgs{
					MachineType:      pulumi.String("n1-standard-2"),
					AcceleratorType:  pulumi.String("NVIDIA_TESLA_T4"),
					AcceleratorCount: pulumi.Int(1),
				},
				PersistentDiskSpec: &colab.NotebookExecutionCustomEnvironmentSpecPersistentDiskSpecArgs{
					DiskType:   pulumi.String("pd-standard"),
					DiskSizeGb: pulumi.String("200"),
				},
				NetworkSpec: &colab.NotebookExecutionCustomEnvironmentSpecNetworkSpecArgs{
					EnableInternetAccess: pulumi.Bool(true),
					Network:              myNetwork.ID().ToIDOutput().ToStringOutput(),
					Subnetwork:           mySubnetwork.ID().ToIDOutput().ToStringOutput(),
				},
				ShieldedInstanceConfig: &colab.NotebookExecutionCustomEnvironmentSpecShieldedInstanceConfigArgs{
					EnableIntegrityMonitoring: pulumi.Bool(true),
					EnableSecureBoot:          pulumi.Bool(true),
					EnableVtpm:                pulumi.Bool(true),
				},
			},
			GcsOutputUri: outputBucket.Name.ApplyT(func(name string) (string, error) {
				return fmt.Sprintf("gs://%v", name), nil
			}).(pulumi.StringOutput),
			ServiceAccount: pulumi.String("my@service-account.com"),
		}, pulumi.DependsOn([]pulumi.Resource{
			outputBucket,
		}))
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var myNetwork = new Gcp.Compute.Network("my_network", new()
    {
        Name = "colab-test-default",
        AutoCreateSubnetworks = false,
    });

    var mySubnetwork = new Gcp.Compute.Subnetwork("my_subnetwork", new()
    {
        Name = "colab-test-default",
        Network = myNetwork.Id,
        Region = "us-central1",
        IpCidrRange = "10.0.1.0/24",
    });

    var outputBucket = new Gcp.Storage.Bucket("output_bucket", new()
    {
        Name = "my_bucket",
        Location = "US",
        ForceDestroy = true,
        UniformBucketLevelAccess = true,
    });

    var notebook_execution = new Gcp.Colab.NotebookExecution("notebook-execution", new()
    {
        DisplayName = "Notebook execution basic",
        Location = "us-central1",
        DirectNotebookSource = new Gcp.Colab.Inputs.NotebookExecutionDirectNotebookSourceArgs
        {
            Content = Std.Base64encode.Invoke(new()
            {
                Input = @"    {
      \""cells\"": [
        {
          \""cell_type\"": \""code\"",
          \""execution_count\"": null,
          \""metadata\"": {},
          \""outputs\"": [],
          \""source\"": [
            \""print(\\\""Hello, World!\\\"")\""
          ]
        }
      ],
      \""metadata\"": {
        \""kernelspec\"": {
          \""display_name\"": \""Python 3\"",
          \""language\"": \""python\"",
          \""name\"": \""python3\""
        },
        \""language_info\"": {
          \""codemirror_mode\"": {
            \""name\"": \""ipython\"",
            \""version\"": 3
          },
          \""file_extension\"": \"".py\"",
          \""mimetype\"": \""text/x-python\"",
          \""name\"": \""python\"",
          \""nbconvert_exporter\"": \""python\"",
          \""pygments_lexer\"": \""ipython3\"",
          \""version\"": \""3.8.5\""
        }
      },
      \""nbformat\"": 4,
      \""nbformat_minor\"": 4
    }
",
            }).Apply(invoke => invoke.Result),
        },
        CustomEnvironmentSpec = new Gcp.Colab.Inputs.NotebookExecutionCustomEnvironmentSpecArgs
        {
            MachineSpec = new Gcp.Colab.Inputs.NotebookExecutionCustomEnvironmentSpecMachineSpecArgs
            {
                MachineType = "n1-standard-2",
                AcceleratorType = "NVIDIA_TESLA_T4",
                AcceleratorCount = 1,
            },
            PersistentDiskSpec = new Gcp.Colab.Inputs.NotebookExecutionCustomEnvironmentSpecPersistentDiskSpecArgs
            {
                DiskType = "pd-standard",
                DiskSizeGb = "200",
            },
            NetworkSpec = new Gcp.Colab.Inputs.NotebookExecutionCustomEnvironmentSpecNetworkSpecArgs
            {
                EnableInternetAccess = true,
                Network = myNetwork.Id,
                Subnetwork = mySubnetwork.Id,
            },
            ShieldedInstanceConfig = new Gcp.Colab.Inputs.NotebookExecutionCustomEnvironmentSpecShieldedInstanceConfigArgs
            {
                EnableIntegrityMonitoring = true,
                EnableSecureBoot = true,
                EnableVtpm = true,
            },
        },
        GcsOutputUri = outputBucket.Name.Apply(name => $"gs://{name}"),
        ServiceAccount = "my@service-account.com",
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            outputBucket,
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.compute.Network;
import com.pulumi.gcp.compute.NetworkArgs;
import com.pulumi.gcp.compute.Subnetwork;
import com.pulumi.gcp.compute.SubnetworkArgs;
import com.pulumi.gcp.storage.Bucket;
import com.pulumi.gcp.storage.BucketArgs;
import com.pulumi.gcp.colab.NotebookExecution;
import com.pulumi.gcp.colab.NotebookExecutionArgs;
import com.pulumi.gcp.colab.inputs.NotebookExecutionDirectNotebookSourceArgs;
import com.pulumi.gcp.colab.inputs.NotebookExecutionCustomEnvironmentSpecArgs;
import com.pulumi.gcp.colab.inputs.NotebookExecutionCustomEnvironmentSpecMachineSpecArgs;
import com.pulumi.gcp.colab.inputs.NotebookExecutionCustomEnvironmentSpecPersistentDiskSpecArgs;
import com.pulumi.gcp.colab.inputs.NotebookExecutionCustomEnvironmentSpecNetworkSpecArgs;
import com.pulumi.gcp.colab.inputs.NotebookExecutionCustomEnvironmentSpecShieldedInstanceConfigArgs;
import com.pulumi.std.StdFunctions;
import com.pulumi.std.inputs.Base64encodeArgs;
import com.pulumi.resources.CustomResourceOptions;
import java.util.ArrayList;
import java.util.Arrays;
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 myNetwork = new Network("myNetwork", NetworkArgs.builder()
            .name("colab-test-default")
            .autoCreateSubnetworks(false)
            .build());

        var mySubnetwork = new Subnetwork("mySubnetwork", SubnetworkArgs.builder()
            .name("colab-test-default")
            .network(myNetwork.id())
            .region("us-central1")
            .ipCidrRange("10.0.1.0/24")
            .build());

        var outputBucket = new Bucket("outputBucket", BucketArgs.builder()
            .name("my_bucket")
            .location("US")
            .forceDestroy(true)
            .uniformBucketLevelAccess(true)
            .build());

        var notebook_execution = new NotebookExecution("notebook-execution", NotebookExecutionArgs.builder()
            .displayName("Notebook execution basic")
            .location("us-central1")
            .directNotebookSource(NotebookExecutionDirectNotebookSourceArgs.builder()
                .content(StdFunctions.base64encode(Base64encodeArgs.builder()
                    .input("""
    {
      \"cells\": [
        {
          \"cell_type\": \"code\",
          \"execution_count\": null,
          \"metadata\": {},
          \"outputs\": [],
          \"source\": [
            \"print(\\\"Hello, World!\\\")\"
          ]
        }
      ],
      \"metadata\": {
        \"kernelspec\": {
          \"display_name\": \"Python 3\",
          \"language\": \"python\",
          \"name\": \"python3\"
        },
        \"language_info\": {
          \"codemirror_mode\": {
            \"name\": \"ipython\",
            \"version\": 3
          },
          \"file_extension\": \".py\",
          \"mimetype\": \"text/x-python\",
          \"name\": \"python\",
          \"nbconvert_exporter\": \"python\",
          \"pygments_lexer\": \"ipython3\",
          \"version\": \"3.8.5\"
        }
      },
      \"nbformat\": 4,
      \"nbformat_minor\": 4
    }
                    """)
                    .build()).result())
                .build())
            .customEnvironmentSpec(NotebookExecutionCustomEnvironmentSpecArgs.builder()
                .machineSpec(NotebookExecutionCustomEnvironmentSpecMachineSpecArgs.builder()
                    .machineType("n1-standard-2")
                    .acceleratorType("NVIDIA_TESLA_T4")
                    .acceleratorCount(1)
                    .build())
                .persistentDiskSpec(NotebookExecutionCustomEnvironmentSpecPersistentDiskSpecArgs.builder()
                    .diskType("pd-standard")
                    .diskSizeGb("200")
                    .build())
                .networkSpec(NotebookExecutionCustomEnvironmentSpecNetworkSpecArgs.builder()
                    .enableInternetAccess(true)
                    .network(myNetwork.id())
                    .subnetwork(mySubnetwork.id())
                    .build())
                .shieldedInstanceConfig(NotebookExecutionCustomEnvironmentSpecShieldedInstanceConfigArgs.builder()
                    .enableIntegrityMonitoring(true)
                    .enableSecureBoot(true)
                    .enableVtpm(true)
                    .build())
                .build())
            .gcsOutputUri(outputBucket.name().applyValue(_name -> String.format("gs://%s", _name)))
            .serviceAccount("my@service-account.com")
            .build(), CustomResourceOptions.builder()
                .dependsOn(outputBucket)
                .build());

    }
}

resources:
  myNetwork:
    type: gcp:compute:Network
    name: my_network
    properties:
      name: colab-test-default
      autoCreateSubnetworks: false
  mySubnetwork:
    type: gcp:compute:Subnetwork
    name: my_subnetwork
    properties:
      name: colab-test-default
      network: ${myNetwork.id}
      region: us-central1
      ipCidrRange: 10.0.1.0/24
  outputBucket:
    type: gcp:storage:Bucket
    name: output_bucket
    properties:
      name: my_bucket
      location: US
      forceDestroy: true
      uniformBucketLevelAccess: true
  notebook-execution:
    type: gcp:colab:NotebookExecution
    properties:
      displayName: Notebook execution basic
      location: us-central1
      directNotebookSource:
        content:
          fn::invoke:
            function: std:base64encode
            arguments:
              input: |2
                    {
                      \"cells\": [
                        {
                          \"cell_type\": \"code\",
                          \"execution_count\": null,
                          \"metadata\": {},
                          \"outputs\": [],
                          \"source\": [
                            \"print(\\\"Hello, World!\\\")\"
                          ]
                        }
                      ],
                      \"metadata\": {
                        \"kernelspec\": {
                          \"display_name\": \"Python 3\",
                          \"language\": \"python\",
                          \"name\": \"python3\"
                        },
                        \"language_info\": {
                          \"codemirror_mode\": {
                            \"name\": \"ipython\",
                            \"version\": 3
                          },
                          \"file_extension\": \".py\",
                          \"mimetype\": \"text/x-python\",
                          \"name\": \"python\",
                          \"nbconvert_exporter\": \"python\",
                          \"pygments_lexer\": \"ipython3\",
                          \"version\": \"3.8.5\"
                        }
                      },
                      \"nbformat\": 4,
                      \"nbformat_minor\": 4
                    }
            return: result
      customEnvironmentSpec:
        machineSpec:
          machineType: n1-standard-2
          acceleratorType: NVIDIA_TESLA_T4
          acceleratorCount: '1'
        persistentDiskSpec:
          diskType: pd-standard
          diskSizeGb: 200
        networkSpec:
          enableInternetAccess: true
          network: ${myNetwork.id}
          subnetwork: ${mySubnetwork.id}
        shieldedInstanceConfig:
          enableIntegrityMonitoring: true
          enableSecureBoot: true
          enableVtpm: true
      gcsOutputUri: gs://${outputBucket.name}
      serviceAccount: my@service-account.com
    options:
      dependsOn:
        - ${outputBucket}

pulumi {
  required_providers {
    gcp = {
      source = "pulumi/gcp"
    }
    std = {
      source = "pulumi/std"
    }
  }
}

resource "gcp_compute_network" "my_network" {
  name                    = "colab-test-default"
  auto_create_subnetworks = false
}
resource "gcp_compute_subnetwork" "my_subnetwork" {
  name          = "colab-test-default"
  network       = gcp_compute_network.my_network.id
  region        = "us-central1"
  ip_cidr_range = "10.0.1.0/24"
}
resource "gcp_storage_bucket" "output_bucket" {
  name                        = "my_bucket"
  location                    = "US"
  force_destroy               = true
  uniform_bucket_level_access = true
}
resource "gcp_colab_notebookexecution" "notebook-execution" {
  depends_on   = [gcp_storage_bucket.output_bucket]
  display_name = "Notebook execution basic"
  location     = "us-central1"
  direct_notebook_source = {
    content = base64encode("    {\n      \\\"cells\\\": [\n        {\n          \\\"cell_type\\\": \\\"code\\\",\n          \\\"execution_count\\\": null,\n          \\\"metadata\\\": {},\n          \\\"outputs\\\": [],\n          \\\"source\\\": [\n            \\\"print(\\\\\\\"Hello, World!\\\\\\\")\\\"\n          ]\n        }\n      ],\n      \\\"metadata\\\": {\n        \\\"kernelspec\\\": {\n          \\\"display_name\\\": \\\"Python 3\\\",\n          \\\"language\\\": \\\"python\\\",\n          \\\"name\\\": \\\"python3\\\"\n        },\n        \\\"language_info\\\": {\n          \\\"codemirror_mode\\\": {\n            \\\"name\\\": \\\"ipython\\\",\n            \\\"version\\\": 3\n          },\n          \\\"file_extension\\\": \\\".py\\\",\n          \\\"mimetype\\\": \\\"text/x-python\\\",\n          \\\"name\\\": \\\"python\\\",\n          \\\"nbconvert_exporter\\\": \\\"python\\\",\n          \\\"pygments_lexer\\\": \\\"ipython3\\\",\n          \\\"version\\\": \\\"3.8.5\\\"\n        }\n      },\n      \\\"nbformat\\\": 4,\n      \\\"nbformat_minor\\\": 4\n    }\n")
  }
  custom_environment_spec = {
    machine_spec = {
      machine_type      = "n1-standard-2"
      accelerator_type  = "NVIDIA_TESLA_T4"
      accelerator_count = "1"
    }
    persistent_disk_spec = {
      disk_type    = "pd-standard"
      disk_size_gb = 200
    }
    network_spec = {
      enable_internet_access = true
      network                = gcp_compute_network.my_network.id
      subnetwork             = gcp_compute_subnetwork.my_subnetwork.id
    }
    shielded_instance_config = {
      enable_integrity_monitoring = true
      enable_secure_boot          = true
      enable_vtpm                 = true
    }
  }
  gcs_output_uri  ="gs://${gcp_storage_bucket.output_bucket.name}"
  service_account = "my@service-account.com"
}