pulumi-gcp-kotlin/com.pulumi.gcp.appengine.kotlin/StandardAppVersionArgs

StandardAppVersionArgs

data class StandardAppVersionArgs(val appEngineApis: Output<Boolean>? = null, val automaticScaling: Output<StandardAppVersionAutomaticScalingArgs>? = null, val basicScaling: Output<StandardAppVersionBasicScalingArgs>? = null, val deleteServiceOnDestroy: Output<Boolean>? = null, val deployment: Output<StandardAppVersionDeploymentArgs>? = null, val entrypoint: Output<StandardAppVersionEntrypointArgs>? = null, val envVariables: Output<Map<String, String>>? = null, val handlers: Output<List<StandardAppVersionHandlerArgs>>? = null, val inboundServices: Output<List<String>>? = null, val instanceClass: Output<String>? = null, val libraries: Output<List<StandardAppVersionLibraryArgs>>? = null, val manualScaling: Output<StandardAppVersionManualScalingArgs>? = null, val noopOnDestroy: Output<Boolean>? = null, val project: Output<String>? = null, val runtime: Output<String>? = null, val runtimeApiVersion: Output<String>? = null, val service: Output<String>? = null, val serviceAccount: Output<String>? = null, val threadsafe: Output<Boolean>? = null, val versionId: Output<String>? = null, val vpcAccessConnector: Output<StandardAppVersionVpcAccessConnectorArgs>? = null) : ConvertibleToJava<StandardAppVersionArgs>

Standard App Version resource to create a new version of standard GAE Application. Learn about the differences between the standard environment and the flexible environment at https://cloud.google.com/appengine/docs/the-appengine-environments. Currently supporting Zip and File Containers. To get more information about StandardAppVersion, see:

Example Usage

App Engine Standard App Version

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const customServiceAccount = new gcp.serviceaccount.Account("custom_service_account", {
    accountId: "my-account",
    displayName: "Custom Service Account",
});
const gaeApi = new gcp.projects.IAMMember("gae_api", {
    project: customServiceAccount.project,
    role: "roles/compute.networkUser",
    member: pulumi.interpolate`serviceAccount:${customServiceAccount.email}`,
});
const storageViewer = new gcp.projects.IAMMember("storage_viewer", {
    project: customServiceAccount.project,
    role: "roles/storage.objectViewer",
    member: pulumi.interpolate`serviceAccount:${customServiceAccount.email}`,
});
const bucket = new gcp.storage.Bucket("bucket", {
    name: "appengine-static-content",
    location: "US",
});
const object = new gcp.storage.BucketObject("object", {
    name: "hello-world.zip",
    bucket: bucket.name,
    source: new pulumi.asset.FileAsset("./test-fixtures/hello-world.zip"),
});
const myappV1 = new gcp.appengine.StandardAppVersion("myapp_v1", {
    versionId: "v1",
    service: "myapp",
    runtime: "nodejs20",
    entrypoint: {
        shell: "node ./app.js",
    },
    deployment: {
        zip: {
            sourceUrl: pulumi.interpolate`https://storage.googleapis.com/${bucket.name}/${object.name}`,
        },
    },
    envVariables: {
        port: "8080",
    },
    automaticScaling: {
        maxConcurrentRequests: 10,
        minIdleInstances: 1,
        maxIdleInstances: 3,
        minPendingLatency: "1s",
        maxPendingLatency: "5s",
        standardSchedulerSettings: {
            targetCpuUtilization: 0.5,
            targetThroughputUtilization: 0.75,
            minInstances: 2,
            maxInstances: 10,
        },
    },
    deleteServiceOnDestroy: true,
    serviceAccount: customServiceAccount.email,
});
const myappV2 = new gcp.appengine.StandardAppVersion("myapp_v2", {
    versionId: "v2",
    service: "myapp",
    runtime: "nodejs20",
    appEngineApis: true,
    entrypoint: {
        shell: "node ./app.js",
    },
    deployment: {
        zip: {
            sourceUrl: pulumi.interpolate`https://storage.googleapis.com/${bucket.name}/${object.name}`,
        },
    },
    envVariables: {
        port: "8080",
    },
    basicScaling: {
        maxInstances: 5,
    },
    noopOnDestroy: true,
    serviceAccount: customServiceAccount.email,
});
Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
custom_service_account = gcp.serviceaccount.Account("custom_service_account",
    account_id="my-account",
    display_name="Custom Service Account")
gae_api = gcp.projects.IAMMember("gae_api",
    project=custom_service_account.project,
    role="roles/compute.networkUser",
    member=custom_service_account.email.apply(lambda email: f"serviceAccount:{email}"))
storage_viewer = gcp.projects.IAMMember("storage_viewer",
    project=custom_service_account.project,
    role="roles/storage.objectViewer",
    member=custom_service_account.email.apply(lambda email: f"serviceAccount:{email}"))
bucket = gcp.storage.Bucket("bucket",
    name="appengine-static-content",
    location="US")
object = gcp.storage.BucketObject("object",
    name="hello-world.zip",
    bucket=bucket.name,
    source=pulumi.FileAsset("./test-fixtures/hello-world.zip"))
myapp_v1 = gcp.appengine.StandardAppVersion("myapp_v1",
    version_id="v1",
    service="myapp",
    runtime="nodejs20",
    entrypoint={
        "shell": "node ./app.js",
    },
    deployment={
        "zip": {
            "source_url": pulumi.Output.all(
                bucketName=bucket.name,
                objectName=object.name
).apply(lambda resolved_outputs: f"https://storage.googleapis.com/{resolved_outputs['bucketName']}/{resolved_outputs['objectName']}")
,
        },
    },
    env_variables={
        "port": "8080",
    },
    automatic_scaling={
        "max_concurrent_requests": 10,
        "min_idle_instances": 1,
        "max_idle_instances": 3,
        "min_pending_latency": "1s",
        "max_pending_latency": "5s",
        "standard_scheduler_settings": {
            "target_cpu_utilization": 0.5,
            "target_throughput_utilization": 0.75,
            "min_instances": 2,
            "max_instances": 10,
        },
    },
    delete_service_on_destroy=True,
    service_account=custom_service_account.email)
myapp_v2 = gcp.appengine.StandardAppVersion("myapp_v2",
    version_id="v2",
    service="myapp",
    runtime="nodejs20",
    app_engine_apis=True,
    entrypoint={
        "shell": "node ./app.js",
    },
    deployment={
        "zip": {
            "source_url": pulumi.Output.all(
                bucketName=bucket.name,
                objectName=object.name
).apply(lambda resolved_outputs: f"https://storage.googleapis.com/{resolved_outputs['bucketName']}/{resolved_outputs['objectName']}")
,
        },
    },
    env_variables={
        "port": "8080",
    },
    basic_scaling={
        "max_instances": 5,
    },
    noop_on_destroy=True,
    service_account=custom_service_account.email)
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var customServiceAccount = new Gcp.ServiceAccount.Account("custom_service_account", new()
    {
        AccountId = "my-account",
        DisplayName = "Custom Service Account",
    });
    var gaeApi = new Gcp.Projects.IAMMember("gae_api", new()
    {
        Project = customServiceAccount.Project,
        Role = "roles/compute.networkUser",
        Member = customServiceAccount.Email.Apply(email => $"serviceAccount:{email}"),
    });
    var storageViewer = new Gcp.Projects.IAMMember("storage_viewer", new()
    {
        Project = customServiceAccount.Project,
        Role = "roles/storage.objectViewer",
        Member = customServiceAccount.Email.Apply(email => $"serviceAccount:{email}"),
    });
    var bucket = new Gcp.Storage.Bucket("bucket", new()
    {
        Name = "appengine-static-content",
        Location = "US",
    });
    var @object = new Gcp.Storage.BucketObject("object", new()
    {
        Name = "hello-world.zip",
        Bucket = bucket.Name,
        Source = new FileAsset("./test-fixtures/hello-world.zip"),
    });
    var myappV1 = new Gcp.AppEngine.StandardAppVersion("myapp_v1", new()
    {
        VersionId = "v1",
        Service = "myapp",
        Runtime = "nodejs20",
        Entrypoint = new Gcp.AppEngine.Inputs.StandardAppVersionEntrypointArgs
        {
            Shell = "node ./app.js",
        },
        Deployment = new Gcp.AppEngine.Inputs.StandardAppVersionDeploymentArgs
        {
            Zip = new Gcp.AppEngine.Inputs.StandardAppVersionDeploymentZipArgs
            {
                SourceUrl = Output.Tuple(bucket.Name, @object.Name).Apply(values =>
                {
                    var bucketName = values.Item1;
                    var objectName = values.Item2;
                    return $"https://storage.googleapis.com/{bucketName}/{objectName}";
                }),
            },
        },
        EnvVariables =
        {
            { "port", "8080" },
        },
        AutomaticScaling = new Gcp.AppEngine.Inputs.StandardAppVersionAutomaticScalingArgs
        {
            MaxConcurrentRequests = 10,
            MinIdleInstances = 1,
            MaxIdleInstances = 3,
            MinPendingLatency = "1s",
            MaxPendingLatency = "5s",
            StandardSchedulerSettings = new Gcp.AppEngine.Inputs.StandardAppVersionAutomaticScalingStandardSchedulerSettingsArgs
            {
                TargetCpuUtilization = 0.5,
                TargetThroughputUtilization = 0.75,
                MinInstances = 2,
                MaxInstances = 10,
            },
        },
        DeleteServiceOnDestroy = true,
        ServiceAccount = customServiceAccount.Email,
    });
    var myappV2 = new Gcp.AppEngine.StandardAppVersion("myapp_v2", new()
    {
        VersionId = "v2",
        Service = "myapp",
        Runtime = "nodejs20",
        AppEngineApis = true,
        Entrypoint = new Gcp.AppEngine.Inputs.StandardAppVersionEntrypointArgs
        {
            Shell = "node ./app.js",
        },
        Deployment = new Gcp.AppEngine.Inputs.StandardAppVersionDeploymentArgs
        {
            Zip = new Gcp.AppEngine.Inputs.StandardAppVersionDeploymentZipArgs
            {
                SourceUrl = Output.Tuple(bucket.Name, @object.Name).Apply(values =>
                {
                    var bucketName = values.Item1;
                    var objectName = values.Item2;
                    return $"https://storage.googleapis.com/{bucketName}/{objectName}";
                }),
            },
        },
        EnvVariables =
        {
            { "port", "8080" },
        },
        BasicScaling = new Gcp.AppEngine.Inputs.StandardAppVersionBasicScalingArgs
        {
            MaxInstances = 5,
        },
        NoopOnDestroy = true,
        ServiceAccount = customServiceAccount.Email,
    });
});
Content copied to clipboard
package main
import (
	"fmt"
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/appengine"
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/projects"
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/serviceaccount"
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/storage"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		customServiceAccount, err := serviceaccount.NewAccount(ctx, "custom_service_account", &serviceaccount.AccountArgs{
			AccountId:   pulumi.String("my-account"),
			DisplayName: pulumi.String("Custom Service Account"),
		})
		if err != nil {
			return err
		}
		_, err = projects.NewIAMMember(ctx, "gae_api", &projects.IAMMemberArgs{
			Project: customServiceAccount.Project,
			Role:    pulumi.String("roles/compute.networkUser"),
			Member: customServiceAccount.Email.ApplyT(func(email string) (string, error) {
				return fmt.Sprintf("serviceAccount:%v", email), nil
			}).(pulumi.StringOutput),
		})
		if err != nil {
			return err
		}
		_, err = projects.NewIAMMember(ctx, "storage_viewer", &projects.IAMMemberArgs{
			Project: customServiceAccount.Project,
			Role:    pulumi.String("roles/storage.objectViewer"),
			Member: customServiceAccount.Email.ApplyT(func(email string) (string, error) {
				return fmt.Sprintf("serviceAccount:%v", email), nil
			}).(pulumi.StringOutput),
		})
		if err != nil {
			return err
		}
		bucket, err := storage.NewBucket(ctx, "bucket", &storage.BucketArgs{
			Name:     pulumi.String("appengine-static-content"),
			Location: pulumi.String("US"),
		})
		if err != nil {
			return err
		}
		object, err := storage.NewBucketObject(ctx, "object", &storage.BucketObjectArgs{
			Name:   pulumi.String("hello-world.zip"),
			Bucket: bucket.Name,
			Source: pulumi.NewFileAsset("./test-fixtures/hello-world.zip"),
		})
		if err != nil {
			return err
		}
		_, err = appengine.NewStandardAppVersion(ctx, "myapp_v1", &appengine.StandardAppVersionArgs{
			VersionId: pulumi.String("v1"),
			Service:   pulumi.String("myapp"),
			Runtime:   pulumi.String("nodejs20"),
			Entrypoint: &appengine.StandardAppVersionEntrypointArgs{
				Shell: pulumi.String("node ./app.js"),
			},
			Deployment: &appengine.StandardAppVersionDeploymentArgs{
				Zip: &appengine.StandardAppVersionDeploymentZipArgs{
					SourceUrl: pulumi.All(bucket.Name, object.Name).ApplyT(func(_args []interface{}) (string, error) {
						bucketName := _args[0].(string)
						objectName := _args[1].(string)
						return fmt.Sprintf("https://storage.googleapis.com/%v/%v", bucketName, objectName), nil
					}).(pulumi.StringOutput),
				},
			},
			EnvVariables: pulumi.StringMap{
				"port": pulumi.String("8080"),
			},
			AutomaticScaling: &appengine.StandardAppVersionAutomaticScalingArgs{
				MaxConcurrentRequests: pulumi.Int(10),
				MinIdleInstances:      pulumi.Int(1),
				MaxIdleInstances:      pulumi.Int(3),
				MinPendingLatency:     pulumi.String("1s"),
				MaxPendingLatency:     pulumi.String("5s"),
				StandardSchedulerSettings: &appengine.StandardAppVersionAutomaticScalingStandardSchedulerSettingsArgs{
					TargetCpuUtilization:        pulumi.Float64(0.5),
					TargetThroughputUtilization: pulumi.Float64(0.75),
					MinInstances:                pulumi.Int(2),
					MaxInstances:                pulumi.Int(10),
				},
			},
			DeleteServiceOnDestroy: pulumi.Bool(true),
			ServiceAccount:         customServiceAccount.Email,
		})
		if err != nil {
			return err
		}
		_, err = appengine.NewStandardAppVersion(ctx, "myapp_v2", &appengine.StandardAppVersionArgs{
			VersionId:     pulumi.String("v2"),
			Service:       pulumi.String("myapp"),
			Runtime:       pulumi.String("nodejs20"),
			AppEngineApis: pulumi.Bool(true),
			Entrypoint: &appengine.StandardAppVersionEntrypointArgs{
				Shell: pulumi.String("node ./app.js"),
			},
			Deployment: &appengine.StandardAppVersionDeploymentArgs{
				Zip: &appengine.StandardAppVersionDeploymentZipArgs{
					SourceUrl: pulumi.All(bucket.Name, object.Name).ApplyT(func(_args []interface{}) (string, error) {
						bucketName := _args[0].(string)
						objectName := _args[1].(string)
						return fmt.Sprintf("https://storage.googleapis.com/%v/%v", bucketName, objectName), nil
					}).(pulumi.StringOutput),
				},
			},
			EnvVariables: pulumi.StringMap{
				"port": pulumi.String("8080"),
			},
			BasicScaling: &appengine.StandardAppVersionBasicScalingArgs{
				MaxInstances: pulumi.Int(5),
			},
			NoopOnDestroy:  pulumi.Bool(true),
			ServiceAccount: customServiceAccount.Email,
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.serviceaccount.Account;
import com.pulumi.gcp.serviceaccount.AccountArgs;
import com.pulumi.gcp.projects.IAMMember;
import com.pulumi.gcp.projects.IAMMemberArgs;
import com.pulumi.gcp.storage.Bucket;
import com.pulumi.gcp.storage.BucketArgs;
import com.pulumi.gcp.storage.BucketObject;
import com.pulumi.gcp.storage.BucketObjectArgs;
import com.pulumi.gcp.appengine.StandardAppVersion;
import com.pulumi.gcp.appengine.StandardAppVersionArgs;
import com.pulumi.gcp.appengine.inputs.StandardAppVersionEntrypointArgs;
import com.pulumi.gcp.appengine.inputs.StandardAppVersionDeploymentArgs;
import com.pulumi.gcp.appengine.inputs.StandardAppVersionDeploymentZipArgs;
import com.pulumi.gcp.appengine.inputs.StandardAppVersionAutomaticScalingArgs;
import com.pulumi.gcp.appengine.inputs.StandardAppVersionAutomaticScalingStandardSchedulerSettingsArgs;
import com.pulumi.gcp.appengine.inputs.StandardAppVersionBasicScalingArgs;
import com.pulumi.asset.FileAsset;
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 customServiceAccount = new Account("customServiceAccount", AccountArgs.builder()
            .accountId("my-account")
            .displayName("Custom Service Account")
            .build());
        var gaeApi = new IAMMember("gaeApi", IAMMemberArgs.builder()
            .project(customServiceAccount.project())
            .role("roles/compute.networkUser")
            .member(customServiceAccount.email().applyValue(_email -> String.format("serviceAccount:%s", _email)))
            .build());
        var storageViewer = new IAMMember("storageViewer", IAMMemberArgs.builder()
            .project(customServiceAccount.project())
            .role("roles/storage.objectViewer")
            .member(customServiceAccount.email().applyValue(_email -> String.format("serviceAccount:%s", _email)))
            .build());
        var bucket = new Bucket("bucket", BucketArgs.builder()
            .name("appengine-static-content")
            .location("US")
            .build());
        var object = new BucketObject("object", BucketObjectArgs.builder()
            .name("hello-world.zip")
            .bucket(bucket.name())
            .source(new FileAsset("./test-fixtures/hello-world.zip"))
            .build());
        var myappV1 = new StandardAppVersion("myappV1", StandardAppVersionArgs.builder()
            .versionId("v1")
            .service("myapp")
            .runtime("nodejs20")
            .entrypoint(StandardAppVersionEntrypointArgs.builder()
                .shell("node ./app.js")
                .build())
            .deployment(StandardAppVersionDeploymentArgs.builder()
                .zip(StandardAppVersionDeploymentZipArgs.builder()
                    .sourceUrl(Output.tuple(bucket.name(), object.name()).applyValue(values -> {
                        var bucketName = values.t1;
                        var objectName = values.t2;
                        return String.format("https://storage.googleapis.com/%s/%s", bucketName,objectName);
                    }))
                    .build())
                .build())
            .envVariables(Map.of("port", "8080"))
            .automaticScaling(StandardAppVersionAutomaticScalingArgs.builder()
                .maxConcurrentRequests(10)
                .minIdleInstances(1)
                .maxIdleInstances(3)
                .minPendingLatency("1s")
                .maxPendingLatency("5s")
                .standardSchedulerSettings(StandardAppVersionAutomaticScalingStandardSchedulerSettingsArgs.builder()
                    .targetCpuUtilization(0.5)
                    .targetThroughputUtilization(0.75)
                    .minInstances(2)
                    .maxInstances(10)
                    .build())
                .build())
            .deleteServiceOnDestroy(true)
            .serviceAccount(customServiceAccount.email())
            .build());
        var myappV2 = new StandardAppVersion("myappV2", StandardAppVersionArgs.builder()
            .versionId("v2")
            .service("myapp")
            .runtime("nodejs20")
            .appEngineApis(true)
            .entrypoint(StandardAppVersionEntrypointArgs.builder()
                .shell("node ./app.js")
                .build())
            .deployment(StandardAppVersionDeploymentArgs.builder()
                .zip(StandardAppVersionDeploymentZipArgs.builder()
                    .sourceUrl(Output.tuple(bucket.name(), object.name()).applyValue(values -> {
                        var bucketName = values.t1;
                        var objectName = values.t2;
                        return String.format("https://storage.googleapis.com/%s/%s", bucketName,objectName);
                    }))
                    .build())
                .build())
            .envVariables(Map.of("port", "8080"))
            .basicScaling(StandardAppVersionBasicScalingArgs.builder()
                .maxInstances(5)
                .build())
            .noopOnDestroy(true)
            .serviceAccount(customServiceAccount.email())
            .build());
    }
}
Content copied to clipboard
resources:
  customServiceAccount:
    type: gcp:serviceaccount:Account
    name: custom_service_account
    properties:
      accountId: my-account
      displayName: Custom Service Account
  gaeApi:
    type: gcp:projects:IAMMember
    name: gae_api
    properties:
      project: ${customServiceAccount.project}
      role: roles/compute.networkUser
      member: serviceAccount:${customServiceAccount.email}
  storageViewer:
    type: gcp:projects:IAMMember
    name: storage_viewer
    properties:
      project: ${customServiceAccount.project}
      role: roles/storage.objectViewer
      member: serviceAccount:${customServiceAccount.email}
  myappV1:
    type: gcp:appengine:StandardAppVersion
    name: myapp_v1
    properties:
      versionId: v1
      service: myapp
      runtime: nodejs20
      entrypoint:
        shell: node ./app.js
      deployment:
        zip:
          sourceUrl: https://storage.googleapis.com/${bucket.name}/${object.name}
      envVariables:
        port: '8080'
      automaticScaling:
        maxConcurrentRequests: 10
        minIdleInstances: 1
        maxIdleInstances: 3
        minPendingLatency: 1s
        maxPendingLatency: 5s
        standardSchedulerSettings:
          targetCpuUtilization: 0.5
          targetThroughputUtilization: 0.75
          minInstances: 2
          maxInstances: 10
      deleteServiceOnDestroy: true
      serviceAccount: ${customServiceAccount.email}
  myappV2:
    type: gcp:appengine:StandardAppVersion
    name: myapp_v2
    properties:
      versionId: v2
      service: myapp
      runtime: nodejs20
      appEngineApis: true
      entrypoint:
        shell: node ./app.js
      deployment:
        zip:
          sourceUrl: https://storage.googleapis.com/${bucket.name}/${object.name}
      envVariables:
        port: '8080'
      basicScaling:
        maxInstances: 5
      noopOnDestroy: true
      serviceAccount: ${customServiceAccount.email}
  bucket:
    type: gcp:storage:Bucket
    properties:
      name: appengine-static-content
      location: US
  object:
    type: gcp:storage:BucketObject
    properties:
      name: hello-world.zip
      bucket: ${bucket.name}
      source:
        fn::FileAsset: ./test-fixtures/hello-world.zip
Content copied to clipboard

Import

StandardAppVersion can be imported using any of these accepted formats:

  • apps/{{project}}/services/{{service}}/versions/{{version_id}}

  • {{project}}/{{service}}/{{version_id}}

  • {{service}}/{{version_id}} When using the pulumi import command, StandardAppVersion can be imported using one of the formats above. For example:

$ pulumi import gcp:appengine/standardAppVersion:StandardAppVersion default apps/{{project}}/services/{{service}}/versions/{{version_id}}
Content copied to clipboard
$ pulumi import gcp:appengine/standardAppVersion:StandardAppVersion default {{project}}/{{service}}/{{version_id}}
Content copied to clipboard
$ pulumi import gcp:appengine/standardAppVersion:StandardAppVersion default {{service}}/{{version_id}}
Content copied to clipboard

Constructors

Link copied to clipboard
constructor(appEngineApis: Output<Boolean>? = null, automaticScaling: Output<StandardAppVersionAutomaticScalingArgs>? = null, basicScaling: Output<StandardAppVersionBasicScalingArgs>? = null, deleteServiceOnDestroy: Output<Boolean>? = null, deployment: Output<StandardAppVersionDeploymentArgs>? = null, entrypoint: Output<StandardAppVersionEntrypointArgs>? = null, envVariables: Output<Map<String, String>>? = null, handlers: Output<List<StandardAppVersionHandlerArgs>>? = null, inboundServices: Output<List<String>>? = null, instanceClass: Output<String>? = null, libraries: Output<List<StandardAppVersionLibraryArgs>>? = null, manualScaling: Output<StandardAppVersionManualScalingArgs>? = null, noopOnDestroy: Output<Boolean>? = null, project: Output<String>? = null, runtime: Output<String>? = null, runtimeApiVersion: Output<String>? = null, service: Output<String>? = null, serviceAccount: Output<String>? = null, threadsafe: Output<Boolean>? = null, versionId: Output<String>? = null, vpcAccessConnector: Output<StandardAppVersionVpcAccessConnectorArgs>? = null)

Properties

Link copied to clipboard
val appEngineApis: Output<Boolean>? = null

Allows App Engine second generation runtimes to access the legacy bundled services.

Link copied to clipboard
val automaticScaling: Output<StandardAppVersionAutomaticScalingArgs>? = null

Automatic scaling is based on request rate, response latencies, and other application metrics.

Link copied to clipboard
val basicScaling: Output<StandardAppVersionBasicScalingArgs>? = null

Basic scaling creates instances when your application receives requests. Each instance will be shut down when the application becomes idle. Basic scaling is ideal for work that is intermittent or driven by user activity.

Link copied to clipboard
val deleteServiceOnDestroy: Output<Boolean>? = null

If set to 'true', the service will be deleted if it is the last version.

Link copied to clipboard
val deployment: Output<StandardAppVersionDeploymentArgs>? = null

Code and application artifacts that make up this version. Structure is documented below.

Link copied to clipboard
val entrypoint: Output<StandardAppVersionEntrypointArgs>? = null

The entrypoint for the application. Structure is documented below.

Link copied to clipboard
val envVariables: Output<Map<String, String>>? = null

Environment variables available to the application.

Link copied to clipboard
val handlers: Output<List<StandardAppVersionHandlerArgs>>? = null

An ordered list of URL-matching patterns that should be applied to incoming requests. The first matching URL handles the request and other request handlers are not attempted.

Link copied to clipboard
val inboundServices: Output<List<String>>? = null

A list of the types of messages that this application is able to receive. Possible values: "INBOUND_SERVICE_MAIL", "INBOUND_SERVICE_MAIL_BOUNCE", "INBOUND_SERVICE_XMPP_ERROR", "INBOUND_SERVICE_XMPP_MESSAGE", "INBOUND_SERVICE_XMPP_SUBSCRIBE", "INBOUND_SERVICE_XMPP_PRESENCE", "INBOUND_SERVICE_CHANNEL_PRESENCE", "INBOUND_SERVICE_WARMUP"

Link copied to clipboard
val instanceClass: Output<String>? = null

Instance class that is used to run this version. Valid values are AutomaticScaling: F1, F2, F4, F4_1G BasicScaling or ManualScaling: B1, B2, B4, B4_1G, B8 Defaults to F1 for AutomaticScaling and B2 for ManualScaling and BasicScaling. If no scaling is specified, AutomaticScaling is chosen.

Link copied to clipboard
val libraries: Output<List<StandardAppVersionLibraryArgs>>? = null

Configuration for third-party Python runtime libraries that are required by the application.

Link copied to clipboard
val manualScaling: Output<StandardAppVersionManualScalingArgs>? = null

A service with manual scaling runs continuously, allowing you to perform complex initialization and rely on the state of its memory over time.

Link copied to clipboard
val noopOnDestroy: Output<Boolean>? = null

If set to 'true', the application version will not be deleted.

Link copied to clipboard
val project: Output<String>? = null
Link copied to clipboard
val runtime: Output<String>? = null

Desired runtime. Example python27.

Link copied to clipboard
val runtimeApiVersion: Output<String>? = null

The version of the API in the given runtime environment. Please see the app.yaml reference for valid values at 'https://cloud.google.com/appengine/docs/standard//config/appref'\ Substitute '' with 'python', 'java', 'php', 'ruby', 'go' or 'nodejs'.

Link copied to clipboard
val service: Output<String>? = null

AppEngine service resource

Link copied to clipboard
val serviceAccount: Output<String>? = null

The identity that the deployed version will run as. Admin API will use the App Engine Appspot service account as default if this field is neither provided in app.yaml file nor through CLI flag.

Link copied to clipboard
val threadsafe: Output<Boolean>? = null

Whether multiple requests can be dispatched to this version at once.

Link copied to clipboard
val versionId: Output<String>? = null

Relative name of the version within the service. For example, 'v1'. Version names can contain only lowercase letters, numbers, or hyphens. Reserved names,"default", "latest", and any name with the prefix "ah-".

Link copied to clipboard
val vpcAccessConnector: Output<StandardAppVersionVpcAccessConnectorArgs>? = null

Enables VPC connectivity for standard apps.

Functions

Link copied to clipboard
open override fun toJava(): StandardAppVersionArgs