pulumi-gcp-kotlin/com.pulumi.gcp.ml.kotlin/EngineModelArgs

EngineModelArgs

data class EngineModelArgs(val defaultVersion: Output<EngineModelDefaultVersionArgs>? = null, val description: Output<String>? = null, val labels: Output<Map<String, String>>? = null, val name: Output<String>? = null, val onlinePredictionConsoleLogging: Output<Boolean>? = null, val onlinePredictionLogging: Output<Boolean>? = null, val project: Output<String>? = null, val regions: Output<String>? = null) : ConvertibleToJava<EngineModelArgs>

Represents a machine learning solution. A model can have multiple versions, each of which is a deployed, trained model ready to receive prediction requests. The model itself is just a container. To get more information about Model, see:

API documentation
How-to Guides

Official Documentation

Example Usage

Ml Model Basic

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const _default = new gcp.ml.EngineModel("default", {
    name: "default",
    description: "My model",
    regions: "us-central1",
});

import pulumi
import pulumi_gcp as gcp
default = gcp.ml.EngineModel("default",
    name="default",
    description="My model",
    regions="us-central1")

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var @default = new Gcp.ML.EngineModel("default", new()
    {
        Name = "default",
        Description = "My model",
        Regions = "us-central1",
    });
});

package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/ml"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := ml.NewEngineModel(ctx, "default", &ml.EngineModelArgs{
			Name:        pulumi.String("default"),
			Description: pulumi.String("My model"),
			Regions:     pulumi.String("us-central1"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.ml.EngineModel;
import com.pulumi.gcp.ml.EngineModelArgs;
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 default_ = new EngineModel("default", EngineModelArgs.builder()
            .name("default")
            .description("My model")
            .regions("us-central1")
            .build());
    }
}

resources:
  default:
    type: gcp:ml:EngineModel
    properties:
      name: default
      description: My model
      regions: us-central1

Ml Model Full

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const _default = new gcp.ml.EngineModel("default", {
    name: "default",
    description: "My model",
    regions: "us-central1",
    labels: {
        my_model: "foo",
    },
    onlinePredictionLogging: true,
    onlinePredictionConsoleLogging: true,
});

import pulumi
import pulumi_gcp as gcp
default = gcp.ml.EngineModel("default",
    name="default",
    description="My model",
    regions="us-central1",
    labels={
        "my_model": "foo",
    },
    online_prediction_logging=True,
    online_prediction_console_logging=True)

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var @default = new Gcp.ML.EngineModel("default", new()
    {
        Name = "default",
        Description = "My model",
        Regions = "us-central1",
        Labels =
        {
            { "my_model", "foo" },
        },
        OnlinePredictionLogging = true,
        OnlinePredictionConsoleLogging = true,
    });
});

package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/ml"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := ml.NewEngineModel(ctx, "default", &ml.EngineModelArgs{
			Name:        pulumi.String("default"),
			Description: pulumi.String("My model"),
			Regions:     pulumi.String("us-central1"),
			Labels: pulumi.StringMap{
				"my_model": pulumi.String("foo"),
			},
			OnlinePredictionLogging:        pulumi.Bool(true),
			OnlinePredictionConsoleLogging: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.ml.EngineModel;
import com.pulumi.gcp.ml.EngineModelArgs;
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 default_ = new EngineModel("default", EngineModelArgs.builder()
            .name("default")
            .description("My model")
            .regions("us-central1")
            .labels(Map.of("my_model", "foo"))
            .onlinePredictionLogging(true)
            .onlinePredictionConsoleLogging(true)
            .build());
    }
}

resources:
  default:
    type: gcp:ml:EngineModel
    properties:
      name: default
      description: My model
      regions: us-central1
      labels:
        my_model: foo
      onlinePredictionLogging: true
      onlinePredictionConsoleLogging: true

Import

Model can be imported using any of these accepted formats:

projects/{{project}}/models/{{name}}
{{project}}/{{name}}
{{name}} When using the pulumi import command, Model can be imported using one of the formats above. For example:

$ pulumi import gcp:ml/engineModel:EngineModel default projects/{{project}}/models/{{name}}

$ pulumi import gcp:ml/engineModel:EngineModel default {{project}}/{{name}}

$ pulumi import gcp:ml/engineModel:EngineModel default {{name}}

Constructors

EngineModelArgs

constructor(defaultVersion: Output<EngineModelDefaultVersionArgs>? = null, description: Output<String>? = null, labels: Output<Map<String, String>>? = null, name: Output<String>? = null, onlinePredictionConsoleLogging: Output<Boolean>? = null, onlinePredictionLogging: Output<Boolean>? = null, project: Output<String>? = null, regions: Output<String>? = null)

Properties

defaultVersion

val defaultVersion: Output<EngineModelDefaultVersionArgs>? = null

The default version of the model. This version will be used to handle prediction requests that do not specify a version. Structure is documented below.

description

val description: Output<String>? = null

The description specified for the model when it was created.

labels

val labels: Output<Map<String, String>>? = null

One or more labels that you can add, to organize your models. Note: This field is non-authoritative, and will only manage the labels present in your configuration. Please refer to the field effective_labels for all of the labels present on the resource.

name

val name: Output<String>? = null

The name specified for the model.

onlinePredictionConsoleLogging

val onlinePredictionConsoleLogging: Output<Boolean>? = null

If true, online prediction nodes send stderr and stdout streams to Stackdriver Logging

onlinePredictionLogging

val onlinePredictionLogging: Output<Boolean>? = null

If true, online prediction access logs are sent to StackDriver Logging.

project

val project: Output<String>? = null

The ID of the project in which the resource belongs. If it is not provided, the provider project is used.