gcp.appengine.FlexibleAppVersion

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

const myProject = new gcp.organizations.Project("my_project", {
    name: "appeng-flex",
    projectId: "appeng-flex",
    orgId: "123456789",
    billingAccount: "000000-0000000-0000000-000000",
    deletionPolicy: "DELETE",
});
const app = new gcp.appengine.Application("app", {
    project: myProject.projectId,
    locationId: "us-central",
});
const service = new gcp.projects.Service("service", {
    project: myProject.projectId,
    service: "appengineflex.googleapis.com",
    disableDependentServices: false,
});
const customServiceAccount = new gcp.serviceaccount.Account("custom_service_account", {
    project: service.project,
    accountId: "my-account",
    displayName: "Custom Service Account",
});
const gaeApi = new gcp.projects.IAMMember("gae_api", {
    project: service.project,
    role: "roles/compute.networkUser",
    member: pulumi.interpolate`serviceAccount:${customServiceAccount.email}`,
});
const logsWriter = new gcp.projects.IAMMember("logs_writer", {
    project: service.project,
    role: "roles/logging.logWriter",
    member: pulumi.interpolate`serviceAccount:${customServiceAccount.email}`,
});
const storageViewer = new gcp.projects.IAMMember("storage_viewer", {
    project: service.project,
    role: "roles/storage.objectViewer",
    member: pulumi.interpolate`serviceAccount:${customServiceAccount.email}`,
});
const bucket = new gcp.storage.Bucket("bucket", {
    project: myProject.projectId,
    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.FlexibleAppVersion("myapp_v1", {
    versionId: "v1",
    project: gaeApi.project,
    service: "default",
    runtime: "nodejs",
    flexibleRuntimeSettings: {
        operatingSystem: "ubuntu22",
        runtimeVersion: "20",
    },
    entrypoint: {
        shell: "node ./app.js",
    },
    deployment: {
        zip: {
            sourceUrl: pulumi.interpolate`https://storage.googleapis.com/${bucket.name}/${object.name}`,
        },
    },
    livenessCheck: {
        path: "/",
    },
    readinessCheck: {
        path: "/",
    },
    envVariables: {
        port: "8080",
    },
    handlers: [{
        urlRegex: ".*\\/my-path\\/*",
        securityLevel: "SECURE_ALWAYS",
        login: "LOGIN_REQUIRED",
        authFailAction: "AUTH_FAIL_ACTION_REDIRECT",
        staticFiles: {
            path: "my-other-path",
            uploadPathRegex: ".*\\/my-path\\/*",
        },
    }],
    automaticScaling: {
        coolDownPeriod: "120s",
        cpuUtilization: {
            targetUtilization: 0.5,
        },
    },
    noopOnDestroy: true,
    serviceAccount: customServiceAccount.email,
});

import pulumi
import pulumi_gcp as gcp

my_project = gcp.organizations.Project("my_project",
    name="appeng-flex",
    project_id="appeng-flex",
    org_id="123456789",
    billing_account="000000-0000000-0000000-000000",
    deletion_policy="DELETE")
app = gcp.appengine.Application("app",
    project=my_project.project_id,
    location_id="us-central")
service = gcp.projects.Service("service",
    project=my_project.project_id,
    service="appengineflex.googleapis.com",
    disable_dependent_services=False)
custom_service_account = gcp.serviceaccount.Account("custom_service_account",
    project=service.project,
    account_id="my-account",
    display_name="Custom Service Account")
gae_api = gcp.projects.IAMMember("gae_api",
    project=service.project,
    role="roles/compute.networkUser",
    member=custom_service_account.email.apply(lambda email: f"serviceAccount:{email}"))
logs_writer = gcp.projects.IAMMember("logs_writer",
    project=service.project,
    role="roles/logging.logWriter",
    member=custom_service_account.email.apply(lambda email: f"serviceAccount:{email}"))
storage_viewer = gcp.projects.IAMMember("storage_viewer",
    project=service.project,
    role="roles/storage.objectViewer",
    member=custom_service_account.email.apply(lambda email: f"serviceAccount:{email}"))
bucket = gcp.storage.Bucket("bucket",
    project=my_project.project_id,
    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.FlexibleAppVersion("myapp_v1",
    version_id="v1",
    project=gae_api.project,
    service="default",
    runtime="nodejs",
    flexible_runtime_settings={
        "operating_system": "ubuntu22",
        "runtime_version": "20",
    },
    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']}")
,
        },
    },
    liveness_check={
        "path": "/",
    },
    readiness_check={
        "path": "/",
    },
    env_variables={
        "port": "8080",
    },
    handlers=[{
        "url_regex": ".*\\/my-path\\/*",
        "security_level": "SECURE_ALWAYS",
        "login": "LOGIN_REQUIRED",
        "auth_fail_action": "AUTH_FAIL_ACTION_REDIRECT",
        "static_files": {
            "path": "my-other-path",
            "upload_path_regex": ".*\\/my-path\\/*",
        },
    }],
    automatic_scaling={
        "cool_down_period": "120s",
        "cpu_utilization": {
            "target_utilization": 0.5,
        },
    },
    noop_on_destroy=True,
    service_account=custom_service_account.email)

package main

import (
	"fmt"

	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/appengine"
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/organizations"
	"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 {
		myProject, err := organizations.NewProject(ctx, "my_project", &organizations.ProjectArgs{
			Name:           pulumi.String("appeng-flex"),
			ProjectId:      pulumi.String("appeng-flex"),
			OrgId:          pulumi.String("123456789"),
			BillingAccount: pulumi.String("000000-0000000-0000000-000000"),
			DeletionPolicy: pulumi.String("DELETE"),
		})
		if err != nil {
			return err
		}
		_, err = appengine.NewApplication(ctx, "app", &appengine.ApplicationArgs{
			Project:    myProject.ProjectId,
			LocationId: pulumi.String("us-central"),
		})
		if err != nil {
			return err
		}
		service, err := projects.NewService(ctx, "service", &projects.ServiceArgs{
			Project:                  myProject.ProjectId,
			Service:                  pulumi.String("appengineflex.googleapis.com"),
			DisableDependentServices: pulumi.Bool(false),
		})
		if err != nil {
			return err
		}
		customServiceAccount, err := serviceaccount.NewAccount(ctx, "custom_service_account", &serviceaccount.AccountArgs{
			Project:     service.Project,
			AccountId:   pulumi.String("my-account"),
			DisplayName: pulumi.String("Custom Service Account"),
		})
		if err != nil {
			return err
		}
		gaeApi, err := projects.NewIAMMember(ctx, "gae_api", &projects.IAMMemberArgs{
			Project: service.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, "logs_writer", &projects.IAMMemberArgs{
			Project: service.Project,
			Role:    pulumi.String("roles/logging.logWriter"),
			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: service.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{
			Project:  myProject.ProjectId,
			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.NewFlexibleAppVersion(ctx, "myapp_v1", &appengine.FlexibleAppVersionArgs{
			VersionId: pulumi.String("v1"),
			Project:   gaeApi.Project,
			Service:   pulumi.String("default"),
			Runtime:   pulumi.String("nodejs"),
			FlexibleRuntimeSettings: &appengine.FlexibleAppVersionFlexibleRuntimeSettingsArgs{
				OperatingSystem: pulumi.String("ubuntu22"),
				RuntimeVersion:  pulumi.String("20"),
			},
			Entrypoint: &appengine.FlexibleAppVersionEntrypointArgs{
				Shell: pulumi.String("node ./app.js"),
			},
			Deployment: &appengine.FlexibleAppVersionDeploymentArgs{
				Zip: &appengine.FlexibleAppVersionDeploymentZipArgs{
					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),
				},
			},
			LivenessCheck: &appengine.FlexibleAppVersionLivenessCheckArgs{
				Path: pulumi.String("/"),
			},
			ReadinessCheck: &appengine.FlexibleAppVersionReadinessCheckArgs{
				Path: pulumi.String("/"),
			},
			EnvVariables: pulumi.StringMap{
				"port": pulumi.String("8080"),
			},
			Handlers: appengine.FlexibleAppVersionHandlerArray{
				&appengine.FlexibleAppVersionHandlerArgs{
					UrlRegex:       pulumi.String(".*\\/my-path\\/*"),
					SecurityLevel:  pulumi.String("SECURE_ALWAYS"),
					Login:          pulumi.String("LOGIN_REQUIRED"),
					AuthFailAction: pulumi.String("AUTH_FAIL_ACTION_REDIRECT"),
					StaticFiles: &appengine.FlexibleAppVersionHandlerStaticFilesArgs{
						Path:            pulumi.String("my-other-path"),
						UploadPathRegex: pulumi.String(".*\\/my-path\\/*"),
					},
				},
			},
			AutomaticScaling: &appengine.FlexibleAppVersionAutomaticScalingArgs{
				CoolDownPeriod: pulumi.String("120s"),
				CpuUtilization: &appengine.FlexibleAppVersionAutomaticScalingCpuUtilizationArgs{
					TargetUtilization: pulumi.Float64(0.5),
				},
			},
			NoopOnDestroy:  pulumi.Bool(true),
			ServiceAccount: customServiceAccount.Email,
		})
		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 myProject = new Gcp.Organizations.Project("my_project", new()
    {
        Name = "appeng-flex",
        ProjectId = "appeng-flex",
        OrgId = "123456789",
        BillingAccount = "000000-0000000-0000000-000000",
        DeletionPolicy = "DELETE",
    });

    var app = new Gcp.AppEngine.Application("app", new()
    {
        Project = myProject.ProjectId,
        LocationId = "us-central",
    });

    var service = new Gcp.Projects.Service("service", new()
    {
        Project = myProject.ProjectId,
        ServiceName = "appengineflex.googleapis.com",
        DisableDependentServices = false,
    });

    var customServiceAccount = new Gcp.ServiceAccount.Account("custom_service_account", new()
    {
        Project = service.Project,
        AccountId = "my-account",
        DisplayName = "Custom Service Account",
    });

    var gaeApi = new Gcp.Projects.IAMMember("gae_api", new()
    {
        Project = service.Project,
        Role = "roles/compute.networkUser",
        Member = customServiceAccount.Email.Apply(email => $"serviceAccount:{email}"),
    });

    var logsWriter = new Gcp.Projects.IAMMember("logs_writer", new()
    {
        Project = service.Project,
        Role = "roles/logging.logWriter",
        Member = customServiceAccount.Email.Apply(email => $"serviceAccount:{email}"),
    });

    var storageViewer = new Gcp.Projects.IAMMember("storage_viewer", new()
    {
        Project = service.Project,
        Role = "roles/storage.objectViewer",
        Member = customServiceAccount.Email.Apply(email => $"serviceAccount:{email}"),
    });

    var bucket = new Gcp.Storage.Bucket("bucket", new()
    {
        Project = myProject.ProjectId,
        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.FlexibleAppVersion("myapp_v1", new()
    {
        VersionId = "v1",
        Project = gaeApi.Project,
        Service = "default",
        Runtime = "nodejs",
        FlexibleRuntimeSettings = new Gcp.AppEngine.Inputs.FlexibleAppVersionFlexibleRuntimeSettingsArgs
        {
            OperatingSystem = "ubuntu22",
            RuntimeVersion = "20",
        },
        Entrypoint = new Gcp.AppEngine.Inputs.FlexibleAppVersionEntrypointArgs
        {
            Shell = "node ./app.js",
        },
        Deployment = new Gcp.AppEngine.Inputs.FlexibleAppVersionDeploymentArgs
        {
            Zip = new Gcp.AppEngine.Inputs.FlexibleAppVersionDeploymentZipArgs
            {
                SourceUrl = Output.Tuple(bucket.Name, @object.Name).Apply(values =>
                {
                    var bucketName = values.Item1;
                    var objectName = values.Item2;
                    return $"https://storage.googleapis.com/{bucketName}/{objectName}";
                }),
            },
        },
        LivenessCheck = new Gcp.AppEngine.Inputs.FlexibleAppVersionLivenessCheckArgs
        {
            Path = "/",
        },
        ReadinessCheck = new Gcp.AppEngine.Inputs.FlexibleAppVersionReadinessCheckArgs
        {
            Path = "/",
        },
        EnvVariables = 
        {
            { "port", "8080" },
        },
        Handlers = new[]
        {
            new Gcp.AppEngine.Inputs.FlexibleAppVersionHandlerArgs
            {
                UrlRegex = ".*\\/my-path\\/*",
                SecurityLevel = "SECURE_ALWAYS",
                Login = "LOGIN_REQUIRED",
                AuthFailAction = "AUTH_FAIL_ACTION_REDIRECT",
                StaticFiles = new Gcp.AppEngine.Inputs.FlexibleAppVersionHandlerStaticFilesArgs
                {
                    Path = "my-other-path",
                    UploadPathRegex = ".*\\/my-path\\/*",
                },
            },
        },
        AutomaticScaling = new Gcp.AppEngine.Inputs.FlexibleAppVersionAutomaticScalingArgs
        {
            CoolDownPeriod = "120s",
            CpuUtilization = new Gcp.AppEngine.Inputs.FlexibleAppVersionAutomaticScalingCpuUtilizationArgs
            {
                TargetUtilization = 0.5,
            },
        },
        NoopOnDestroy = true,
        ServiceAccount = customServiceAccount.Email,
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.organizations.Project;
import com.pulumi.gcp.organizations.ProjectArgs;
import com.pulumi.gcp.appengine.Application;
import com.pulumi.gcp.appengine.ApplicationArgs;
import com.pulumi.gcp.projects.Service;
import com.pulumi.gcp.projects.ServiceArgs;
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.FlexibleAppVersion;
import com.pulumi.gcp.appengine.FlexibleAppVersionArgs;
import com.pulumi.gcp.appengine.inputs.FlexibleAppVersionFlexibleRuntimeSettingsArgs;
import com.pulumi.gcp.appengine.inputs.FlexibleAppVersionEntrypointArgs;
import com.pulumi.gcp.appengine.inputs.FlexibleAppVersionDeploymentArgs;
import com.pulumi.gcp.appengine.inputs.FlexibleAppVersionDeploymentZipArgs;
import com.pulumi.gcp.appengine.inputs.FlexibleAppVersionLivenessCheckArgs;
import com.pulumi.gcp.appengine.inputs.FlexibleAppVersionReadinessCheckArgs;
import com.pulumi.gcp.appengine.inputs.FlexibleAppVersionHandlerArgs;
import com.pulumi.gcp.appengine.inputs.FlexibleAppVersionHandlerStaticFilesArgs;
import com.pulumi.gcp.appengine.inputs.FlexibleAppVersionAutomaticScalingArgs;
import com.pulumi.gcp.appengine.inputs.FlexibleAppVersionAutomaticScalingCpuUtilizationArgs;
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 myProject = new Project("myProject", ProjectArgs.builder()
            .name("appeng-flex")
            .projectId("appeng-flex")
            .orgId("123456789")
            .billingAccount("000000-0000000-0000000-000000")
            .deletionPolicy("DELETE")
            .build());

        var app = new Application("app", ApplicationArgs.builder()
            .project(myProject.projectId())
            .locationId("us-central")
            .build());

        var service = new Service("service", ServiceArgs.builder()
            .project(myProject.projectId())
            .service("appengineflex.googleapis.com")
            .disableDependentServices(false)
            .build());

        var customServiceAccount = new Account("customServiceAccount", AccountArgs.builder()
            .project(service.project())
            .accountId("my-account")
            .displayName("Custom Service Account")
            .build());

        var gaeApi = new IAMMember("gaeApi", IAMMemberArgs.builder()
            .project(service.project())
            .role("roles/compute.networkUser")
            .member(customServiceAccount.email().applyValue(email -> String.format("serviceAccount:%s", email)))
            .build());

        var logsWriter = new IAMMember("logsWriter", IAMMemberArgs.builder()
            .project(service.project())
            .role("roles/logging.logWriter")
            .member(customServiceAccount.email().applyValue(email -> String.format("serviceAccount:%s", email)))
            .build());

        var storageViewer = new IAMMember("storageViewer", IAMMemberArgs.builder()
            .project(service.project())
            .role("roles/storage.objectViewer")
            .member(customServiceAccount.email().applyValue(email -> String.format("serviceAccount:%s", email)))
            .build());

        var bucket = new Bucket("bucket", BucketArgs.builder()
            .project(myProject.projectId())
            .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 FlexibleAppVersion("myappV1", FlexibleAppVersionArgs.builder()
            .versionId("v1")
            .project(gaeApi.project())
            .service("default")
            .runtime("nodejs")
            .flexibleRuntimeSettings(FlexibleAppVersionFlexibleRuntimeSettingsArgs.builder()
                .operatingSystem("ubuntu22")
                .runtimeVersion("20")
                .build())
            .entrypoint(FlexibleAppVersionEntrypointArgs.builder()
                .shell("node ./app.js")
                .build())
            .deployment(FlexibleAppVersionDeploymentArgs.builder()
                .zip(FlexibleAppVersionDeploymentZipArgs.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())
            .livenessCheck(FlexibleAppVersionLivenessCheckArgs.builder()
                .path("/")
                .build())
            .readinessCheck(FlexibleAppVersionReadinessCheckArgs.builder()
                .path("/")
                .build())
            .envVariables(Map.of("port", "8080"))
            .handlers(FlexibleAppVersionHandlerArgs.builder()
                .urlRegex(".*\\/my-path\\/*")
                .securityLevel("SECURE_ALWAYS")
                .login("LOGIN_REQUIRED")
                .authFailAction("AUTH_FAIL_ACTION_REDIRECT")
                .staticFiles(FlexibleAppVersionHandlerStaticFilesArgs.builder()
                    .path("my-other-path")
                    .uploadPathRegex(".*\\/my-path\\/*")
                    .build())
                .build())
            .automaticScaling(FlexibleAppVersionAutomaticScalingArgs.builder()
                .coolDownPeriod("120s")
                .cpuUtilization(FlexibleAppVersionAutomaticScalingCpuUtilizationArgs.builder()
                    .targetUtilization(0.5)
                    .build())
                .build())
            .noopOnDestroy(true)
            .serviceAccount(customServiceAccount.email())
            .build());

    }
}

resources:
  myProject:
    type: gcp:organizations:Project
    name: my_project
    properties:
      name: appeng-flex
      projectId: appeng-flex
      orgId: '123456789'
      billingAccount: 000000-0000000-0000000-000000
      deletionPolicy: DELETE
  app:
    type: gcp:appengine:Application
    properties:
      project: ${myProject.projectId}
      locationId: us-central
  service:
    type: gcp:projects:Service
    properties:
      project: ${myProject.projectId}
      service: appengineflex.googleapis.com
      disableDependentServices: false
  customServiceAccount:
    type: gcp:serviceaccount:Account
    name: custom_service_account
    properties:
      project: ${service.project}
      accountId: my-account
      displayName: Custom Service Account
  gaeApi:
    type: gcp:projects:IAMMember
    name: gae_api
    properties:
      project: ${service.project}
      role: roles/compute.networkUser
      member: serviceAccount:${customServiceAccount.email}
  logsWriter:
    type: gcp:projects:IAMMember
    name: logs_writer
    properties:
      project: ${service.project}
      role: roles/logging.logWriter
      member: serviceAccount:${customServiceAccount.email}
  storageViewer:
    type: gcp:projects:IAMMember
    name: storage_viewer
    properties:
      project: ${service.project}
      role: roles/storage.objectViewer
      member: serviceAccount:${customServiceAccount.email}
  myappV1:
    type: gcp:appengine:FlexibleAppVersion
    name: myapp_v1
    properties:
      versionId: v1
      project: ${gaeApi.project}
      service: default
      runtime: nodejs
      flexibleRuntimeSettings:
        operatingSystem: ubuntu22
        runtimeVersion: '20'
      entrypoint:
        shell: node ./app.js
      deployment:
        zip:
          sourceUrl: https://storage.googleapis.com/${bucket.name}/${object.name}
      livenessCheck:
        path: /
      readinessCheck:
        path: /
      envVariables:
        port: '8080'
      handlers:
        - urlRegex: .*\/my-path\/*
          securityLevel: SECURE_ALWAYS
          login: LOGIN_REQUIRED
          authFailAction: AUTH_FAIL_ACTION_REDIRECT
          staticFiles:
            path: my-other-path
            uploadPathRegex: .*\/my-path\/*
      automaticScaling:
        coolDownPeriod: 120s
        cpuUtilization:
          targetUtilization: 0.5
      noopOnDestroy: true
      serviceAccount: ${customServiceAccount.email}
  bucket:
    type: gcp:storage:Bucket
    properties:
      project: ${myProject.projectId}
      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

var flexibleAppVersionResource = new Gcp.AppEngine.FlexibleAppVersion("flexibleAppVersionResource", new()
{
    LivenessCheck = new Gcp.AppEngine.Inputs.FlexibleAppVersionLivenessCheckArgs
    {
        Path = "string",
        CheckInterval = "string",
        FailureThreshold = 0,
        Host = "string",
        InitialDelay = "string",
        SuccessThreshold = 0,
        Timeout = "string",
    },
    Service = "string",
    Runtime = "string",
    ReadinessCheck = new Gcp.AppEngine.Inputs.FlexibleAppVersionReadinessCheckArgs
    {
        Path = "string",
        AppStartTimeout = "string",
        CheckInterval = "string",
        FailureThreshold = 0,
        Host = "string",
        SuccessThreshold = 0,
        Timeout = "string",
    },
    Entrypoint = new Gcp.AppEngine.Inputs.FlexibleAppVersionEntrypointArgs
    {
        Shell = "string",
    },
    NoopOnDestroy = false,
    EndpointsApiService = new Gcp.AppEngine.Inputs.FlexibleAppVersionEndpointsApiServiceArgs
    {
        Name = "string",
        ConfigId = "string",
        DisableTraceSampling = false,
        RolloutStrategy = "string",
    },
    ApiConfig = new Gcp.AppEngine.Inputs.FlexibleAppVersionApiConfigArgs
    {
        Script = "string",
        AuthFailAction = "string",
        Login = "string",
        SecurityLevel = "string",
        Url = "string",
    },
    EnvVariables = 
    {
        { "string", "string" },
    },
    FlexibleRuntimeSettings = new Gcp.AppEngine.Inputs.FlexibleAppVersionFlexibleRuntimeSettingsArgs
    {
        OperatingSystem = "string",
        RuntimeVersion = "string",
    },
    Handlers = new[]
    {
        new Gcp.AppEngine.Inputs.FlexibleAppVersionHandlerArgs
        {
            AuthFailAction = "string",
            Login = "string",
            RedirectHttpResponseCode = "string",
            Script = new Gcp.AppEngine.Inputs.FlexibleAppVersionHandlerScriptArgs
            {
                ScriptPath = "string",
            },
            SecurityLevel = "string",
            StaticFiles = new Gcp.AppEngine.Inputs.FlexibleAppVersionHandlerStaticFilesArgs
            {
                ApplicationReadable = false,
                Expiration = "string",
                HttpHeaders = 
                {
                    { "string", "string" },
                },
                MimeType = "string",
                Path = "string",
                RequireMatchingFile = false,
                UploadPathRegex = "string",
            },
            UrlRegex = "string",
        },
    },
    InboundServices = new[]
    {
        "string",
    },
    InstanceClass = "string",
    DeleteServiceOnDestroy = false,
    ManualScaling = new Gcp.AppEngine.Inputs.FlexibleAppVersionManualScalingArgs
    {
        Instances = 0,
    },
    Network = new Gcp.AppEngine.Inputs.FlexibleAppVersionNetworkArgs
    {
        Name = "string",
        ForwardedPorts = new[]
        {
            "string",
        },
        InstanceIpMode = "string",
        InstanceTag = "string",
        SessionAffinity = false,
        Subnetwork = "string",
    },
    NobuildFilesRegex = "string",
    Deployment = new Gcp.AppEngine.Inputs.FlexibleAppVersionDeploymentArgs
    {
        CloudBuildOptions = new Gcp.AppEngine.Inputs.FlexibleAppVersionDeploymentCloudBuildOptionsArgs
        {
            AppYamlPath = "string",
            CloudBuildTimeout = "string",
        },
        Container = new Gcp.AppEngine.Inputs.FlexibleAppVersionDeploymentContainerArgs
        {
            Image = "string",
        },
        Files = new[]
        {
            new Gcp.AppEngine.Inputs.FlexibleAppVersionDeploymentFileArgs
            {
                Name = "string",
                SourceUrl = "string",
                Sha1Sum = "string",
            },
        },
        Zip = new Gcp.AppEngine.Inputs.FlexibleAppVersionDeploymentZipArgs
        {
            SourceUrl = "string",
            FilesCount = 0,
        },
    },
    Project = "string",
    DefaultExpiration = "string",
    Resources = new Gcp.AppEngine.Inputs.FlexibleAppVersionResourcesArgs
    {
        Cpu = 0,
        DiskGb = 0,
        MemoryGb = 0,
        Volumes = new[]
        {
            new Gcp.AppEngine.Inputs.FlexibleAppVersionResourcesVolumeArgs
            {
                Name = "string",
                SizeGb = 0,
                VolumeType = "string",
            },
        },
    },
    BetaSettings = 
    {
        { "string", "string" },
    },
    RuntimeApiVersion = "string",
    RuntimeChannel = "string",
    RuntimeMainExecutablePath = "string",
    AutomaticScaling = new Gcp.AppEngine.Inputs.FlexibleAppVersionAutomaticScalingArgs
    {
        CpuUtilization = new Gcp.AppEngine.Inputs.FlexibleAppVersionAutomaticScalingCpuUtilizationArgs
        {
            TargetUtilization = 0,
            AggregationWindowLength = "string",
        },
        CoolDownPeriod = "string",
        DiskUtilization = new Gcp.AppEngine.Inputs.FlexibleAppVersionAutomaticScalingDiskUtilizationArgs
        {
            TargetReadBytesPerSecond = 0,
            TargetReadOpsPerSecond = 0,
            TargetWriteBytesPerSecond = 0,
            TargetWriteOpsPerSecond = 0,
        },
        MaxConcurrentRequests = 0,
        MaxIdleInstances = 0,
        MaxPendingLatency = "string",
        MaxTotalInstances = 0,
        MinIdleInstances = 0,
        MinPendingLatency = "string",
        MinTotalInstances = 0,
        NetworkUtilization = new Gcp.AppEngine.Inputs.FlexibleAppVersionAutomaticScalingNetworkUtilizationArgs
        {
            TargetReceivedBytesPerSecond = 0,
            TargetReceivedPacketsPerSecond = 0,
            TargetSentBytesPerSecond = 0,
            TargetSentPacketsPerSecond = 0,
        },
        RequestUtilization = new Gcp.AppEngine.Inputs.FlexibleAppVersionAutomaticScalingRequestUtilizationArgs
        {
            TargetConcurrentRequests = 0,
            TargetRequestCountPerSecond = "string",
        },
    },
    ServiceAccount = "string",
    ServingStatus = "string",
    VersionId = "string",
    VpcAccessConnector = new Gcp.AppEngine.Inputs.FlexibleAppVersionVpcAccessConnectorArgs
    {
        Name = "string",
    },
});

example, err := appengine.NewFlexibleAppVersion(ctx, "flexibleAppVersionResource", &appengine.FlexibleAppVersionArgs{
	LivenessCheck: &appengine.FlexibleAppVersionLivenessCheckArgs{
		Path:             pulumi.String("string"),
		CheckInterval:    pulumi.String("string"),
		FailureThreshold: pulumi.Float64(0),
		Host:             pulumi.String("string"),
		InitialDelay:     pulumi.String("string"),
		SuccessThreshold: pulumi.Float64(0),
		Timeout:          pulumi.String("string"),
	},
	Service: pulumi.String("string"),
	Runtime: pulumi.String("string"),
	ReadinessCheck: &appengine.FlexibleAppVersionReadinessCheckArgs{
		Path:             pulumi.String("string"),
		AppStartTimeout:  pulumi.String("string"),
		CheckInterval:    pulumi.String("string"),
		FailureThreshold: pulumi.Float64(0),
		Host:             pulumi.String("string"),
		SuccessThreshold: pulumi.Float64(0),
		Timeout:          pulumi.String("string"),
	},
	Entrypoint: &appengine.FlexibleAppVersionEntrypointArgs{
		Shell: pulumi.String("string"),
	},
	NoopOnDestroy: pulumi.Bool(false),
	EndpointsApiService: &appengine.FlexibleAppVersionEndpointsApiServiceArgs{
		Name:                 pulumi.String("string"),
		ConfigId:             pulumi.String("string"),
		DisableTraceSampling: pulumi.Bool(false),
		RolloutStrategy:      pulumi.String("string"),
	},
	ApiConfig: &appengine.FlexibleAppVersionApiConfigArgs{
		Script:         pulumi.String("string"),
		AuthFailAction: pulumi.String("string"),
		Login:          pulumi.String("string"),
		SecurityLevel:  pulumi.String("string"),
		Url:            pulumi.String("string"),
	},
	EnvVariables: pulumi.StringMap{
		"string": pulumi.String("string"),
	},
	FlexibleRuntimeSettings: &appengine.FlexibleAppVersionFlexibleRuntimeSettingsArgs{
		OperatingSystem: pulumi.String("string"),
		RuntimeVersion:  pulumi.String("string"),
	},
	Handlers: appengine.FlexibleAppVersionHandlerArray{
		&appengine.FlexibleAppVersionHandlerArgs{
			AuthFailAction:           pulumi.String("string"),
			Login:                    pulumi.String("string"),
			RedirectHttpResponseCode: pulumi.String("string"),
			Script: &appengine.FlexibleAppVersionHandlerScriptArgs{
				ScriptPath: pulumi.String("string"),
			},
			SecurityLevel: pulumi.String("string"),
			StaticFiles: &appengine.FlexibleAppVersionHandlerStaticFilesArgs{
				ApplicationReadable: pulumi.Bool(false),
				Expiration:          pulumi.String("string"),
				HttpHeaders: pulumi.StringMap{
					"string": pulumi.String("string"),
				},
				MimeType:            pulumi.String("string"),
				Path:                pulumi.String("string"),
				RequireMatchingFile: pulumi.Bool(false),
				UploadPathRegex:     pulumi.String("string"),
			},
			UrlRegex: pulumi.String("string"),
		},
	},
	InboundServices: pulumi.StringArray{
		pulumi.String("string"),
	},
	InstanceClass:          pulumi.String("string"),
	DeleteServiceOnDestroy: pulumi.Bool(false),
	ManualScaling: &appengine.FlexibleAppVersionManualScalingArgs{
		Instances: pulumi.Int(0),
	},
	Network: &appengine.FlexibleAppVersionNetworkArgs{
		Name: pulumi.String("string"),
		ForwardedPorts: pulumi.StringArray{
			pulumi.String("string"),
		},
		InstanceIpMode:  pulumi.String("string"),
		InstanceTag:     pulumi.String("string"),
		SessionAffinity: pulumi.Bool(false),
		Subnetwork:      pulumi.String("string"),
	},
	NobuildFilesRegex: pulumi.String("string"),
	Deployment: &appengine.FlexibleAppVersionDeploymentArgs{
		CloudBuildOptions: &appengine.FlexibleAppVersionDeploymentCloudBuildOptionsArgs{
			AppYamlPath:       pulumi.String("string"),
			CloudBuildTimeout: pulumi.String("string"),
		},
		Container: &appengine.FlexibleAppVersionDeploymentContainerArgs{
			Image: pulumi.String("string"),
		},
		Files: appengine.FlexibleAppVersionDeploymentFileArray{
			&appengine.FlexibleAppVersionDeploymentFileArgs{
				Name:      pulumi.String("string"),
				SourceUrl: pulumi.String("string"),
				Sha1Sum:   pulumi.String("string"),
			},
		},
		Zip: &appengine.FlexibleAppVersionDeploymentZipArgs{
			SourceUrl:  pulumi.String("string"),
			FilesCount: pulumi.Int(0),
		},
	},
	Project:           pulumi.String("string"),
	DefaultExpiration: pulumi.String("string"),
	Resources: &appengine.FlexibleAppVersionResourcesArgs{
		Cpu:      pulumi.Int(0),
		DiskGb:   pulumi.Int(0),
		MemoryGb: pulumi.Float64(0),
		Volumes: appengine.FlexibleAppVersionResourcesVolumeArray{
			&appengine.FlexibleAppVersionResourcesVolumeArgs{
				Name:       pulumi.String("string"),
				SizeGb:     pulumi.Int(0),
				VolumeType: pulumi.String("string"),
			},
		},
	},
	BetaSettings: pulumi.StringMap{
		"string": pulumi.String("string"),
	},
	RuntimeApiVersion:         pulumi.String("string"),
	RuntimeChannel:            pulumi.String("string"),
	RuntimeMainExecutablePath: pulumi.String("string"),
	AutomaticScaling: &appengine.FlexibleAppVersionAutomaticScalingArgs{
		CpuUtilization: &appengine.FlexibleAppVersionAutomaticScalingCpuUtilizationArgs{
			TargetUtilization:       pulumi.Float64(0),
			AggregationWindowLength: pulumi.String("string"),
		},
		CoolDownPeriod: pulumi.String("string"),
		DiskUtilization: &appengine.FlexibleAppVersionAutomaticScalingDiskUtilizationArgs{
			TargetReadBytesPerSecond:  pulumi.Int(0),
			TargetReadOpsPerSecond:    pulumi.Int(0),
			TargetWriteBytesPerSecond: pulumi.Int(0),
			TargetWriteOpsPerSecond:   pulumi.Int(0),
		},
		MaxConcurrentRequests: pulumi.Int(0),
		MaxIdleInstances:      pulumi.Int(0),
		MaxPendingLatency:     pulumi.String("string"),
		MaxTotalInstances:     pulumi.Int(0),
		MinIdleInstances:      pulumi.Int(0),
		MinPendingLatency:     pulumi.String("string"),
		MinTotalInstances:     pulumi.Int(0),
		NetworkUtilization: &appengine.FlexibleAppVersionAutomaticScalingNetworkUtilizationArgs{
			TargetReceivedBytesPerSecond:   pulumi.Int(0),
			TargetReceivedPacketsPerSecond: pulumi.Int(0),
			TargetSentBytesPerSecond:       pulumi.Int(0),
			TargetSentPacketsPerSecond:     pulumi.Int(0),
		},
		RequestUtilization: &appengine.FlexibleAppVersionAutomaticScalingRequestUtilizationArgs{
			TargetConcurrentRequests:    pulumi.Float64(0),
			TargetRequestCountPerSecond: pulumi.String("string"),
		},
	},
	ServiceAccount: pulumi.String("string"),
	ServingStatus:  pulumi.String("string"),
	VersionId:      pulumi.String("string"),
	VpcAccessConnector: &appengine.FlexibleAppVersionVpcAccessConnectorArgs{
		Name: pulumi.String("string"),
	},
})