EdgeContainerAppRecord

import * as pulumi from "@pulumi/pulumi";
import * as alicloud from "@pulumi/alicloud";
const config = new pulumi.Config();
const name = config.get("name") || "terraform.com";
const _default = alicloud.esa.getSites({
    planSubscribeType: "enterpriseplan",
});
const resourceSiteOriginPoolTest = new alicloud.esa.Site("resource_Site_OriginPool_test", {
    siteName: name,
    instanceId: _default.then(_default => _default.sites?.[0]?.instanceId),
    coverage: "overseas",
    accessType: "NS",
});
const defaultEdgeContainerApp = new alicloud.esa.EdgeContainerApp("default", {
    healthCheckHost: "example.com",
    healthCheckType: "l7",
    servicePort: 80,
    healthCheckInterval: 5,
    edgeContainerAppName: "terraform-app",
    healthCheckHttpCode: "http_2xx",
    healthCheckUri: "/",
    healthCheckTimeout: 3,
    healthCheckSuccTimes: 2,
    remarks: name,
    healthCheckMethod: "HEAD",
    healthCheckPort: 80,
    healthCheckFailTimes: 5,
    targetPort: 3000,
});
const defaultEdgeContainerAppRecord = new alicloud.esa.EdgeContainerAppRecord("default", {
    recordName: "tf.terraform.com",
    siteId: resourceSiteOriginPoolTest.id,
    appId: defaultEdgeContainerApp.id,
});

import pulumi
import pulumi_alicloud as alicloud
config = pulumi.Config()
name = config.get("name")
if name is None:
    name = "terraform.com"
default = alicloud.esa.get_sites(plan_subscribe_type="enterpriseplan")
resource_site_origin_pool_test = alicloud.esa.Site("resource_Site_OriginPool_test",
    site_name=name,
    instance_id=default.sites[0].instance_id,
    coverage="overseas",
    access_type="NS")
default_edge_container_app = alicloud.esa.EdgeContainerApp("default",
    health_check_host="example.com",
    health_check_type="l7",
    service_port=80,
    health_check_interval=5,
    edge_container_app_name="terraform-app",
    health_check_http_code="http_2xx",
    health_check_uri="/",
    health_check_timeout=3,
    health_check_succ_times=2,
    remarks=name,
    health_check_method="HEAD",
    health_check_port=80,
    health_check_fail_times=5,
    target_port=3000)
default_edge_container_app_record = alicloud.esa.EdgeContainerAppRecord("default",
    record_name="tf.terraform.com",
    site_id=resource_site_origin_pool_test.id,
    app_id=default_edge_container_app.id)

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AliCloud = Pulumi.AliCloud;
return await Deployment.RunAsync(() =>
{
    var config = new Config();
    var name = config.Get("name") ?? "terraform.com";
    var @default = AliCloud.Esa.GetSites.Invoke(new()
    {
        PlanSubscribeType = "enterpriseplan",
    });
    var resourceSiteOriginPoolTest = new AliCloud.Esa.Site("resource_Site_OriginPool_test", new()
    {
        SiteName = name,
        InstanceId = @default.Apply(@default => @default.Apply(getSitesResult => getSitesResult.Sites[0]?.InstanceId)),
        Coverage = "overseas",
        AccessType = "NS",
    });
    var defaultEdgeContainerApp = new AliCloud.Esa.EdgeContainerApp("default", new()
    {
        HealthCheckHost = "example.com",
        HealthCheckType = "l7",
        ServicePort = 80,
        HealthCheckInterval = 5,
        EdgeContainerAppName = "terraform-app",
        HealthCheckHttpCode = "http_2xx",
        HealthCheckUri = "/",
        HealthCheckTimeout = 3,
        HealthCheckSuccTimes = 2,
        Remarks = name,
        HealthCheckMethod = "HEAD",
        HealthCheckPort = 80,
        HealthCheckFailTimes = 5,
        TargetPort = 3000,
    });
    var defaultEdgeContainerAppRecord = new AliCloud.Esa.EdgeContainerAppRecord("default", new()
    {
        RecordName = "tf.terraform.com",
        SiteId = resourceSiteOriginPoolTest.Id,
        AppId = defaultEdgeContainerApp.Id,
    });
});

package main
import (
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/esa"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi/config"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		cfg := config.New(ctx, "")
		name := "terraform.com"
		if param := cfg.Get("name"); param != "" {
			name = param
		}
		_default, err := esa.GetSites(ctx, &esa.GetSitesArgs{
			PlanSubscribeType: pulumi.StringRef("enterpriseplan"),
		}, nil)
		if err != nil {
			return err
		}
		resourceSiteOriginPoolTest, err := esa.NewSite(ctx, "resource_Site_OriginPool_test", &esa.SiteArgs{
			SiteName:   pulumi.String(name),
			InstanceId: pulumi.String(_default.Sites[0].InstanceId),
			Coverage:   pulumi.String("overseas"),
			AccessType: pulumi.String("NS"),
		})
		if err != nil {
			return err
		}
		defaultEdgeContainerApp, err := esa.NewEdgeContainerApp(ctx, "default", &esa.EdgeContainerAppArgs{
			HealthCheckHost:      pulumi.String("example.com"),
			HealthCheckType:      pulumi.String("l7"),
			ServicePort:          pulumi.Int(80),
			HealthCheckInterval:  pulumi.Int(5),
			EdgeContainerAppName: pulumi.String("terraform-app"),
			HealthCheckHttpCode:  pulumi.String("http_2xx"),
			HealthCheckUri:       pulumi.String("/"),
			HealthCheckTimeout:   pulumi.Int(3),
			HealthCheckSuccTimes: pulumi.Int(2),
			Remarks:              pulumi.String(name),
			HealthCheckMethod:    pulumi.String("HEAD"),
			HealthCheckPort:      pulumi.Int(80),
			HealthCheckFailTimes: pulumi.Int(5),
			TargetPort:           pulumi.Int(3000),
		})
		if err != nil {
			return err
		}
		_, err = esa.NewEdgeContainerAppRecord(ctx, "default", &esa.EdgeContainerAppRecordArgs{
			RecordName: pulumi.String("tf.terraform.com"),
			SiteId:     resourceSiteOriginPoolTest.ID(),
			AppId:      defaultEdgeContainerApp.ID(),
		})
		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.alicloud.esa.EsaFunctions;
import com.pulumi.alicloud.esa.inputs.GetSitesArgs;
import com.pulumi.alicloud.esa.Site;
import com.pulumi.alicloud.esa.SiteArgs;
import com.pulumi.alicloud.esa.EdgeContainerApp;
import com.pulumi.alicloud.esa.EdgeContainerAppArgs;
import com.pulumi.alicloud.esa.EdgeContainerAppRecord;
import com.pulumi.alicloud.esa.EdgeContainerAppRecordArgs;
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) {
        final var config = ctx.config();
        final var name = config.get("name").orElse("terraform.com");
        final var default = EsaFunctions.getSites(GetSitesArgs.builder()
            .planSubscribeType("enterpriseplan")
            .build());
        var resourceSiteOriginPoolTest = new Site("resourceSiteOriginPoolTest", SiteArgs.builder()
            .siteName(name)
            .instanceId(default_.sites()[0].instanceId())
            .coverage("overseas")
            .accessType("NS")
            .build());
        var defaultEdgeContainerApp = new EdgeContainerApp("defaultEdgeContainerApp", EdgeContainerAppArgs.builder()
            .healthCheckHost("example.com")
            .healthCheckType("l7")
            .servicePort("80")
            .healthCheckInterval("5")
            .edgeContainerAppName("terraform-app")
            .healthCheckHttpCode("http_2xx")
            .healthCheckUri("/")
            .healthCheckTimeout("3")
            .healthCheckSuccTimes("2")
            .remarks(name)
            .healthCheckMethod("HEAD")
            .healthCheckPort("80")
            .healthCheckFailTimes("5")
            .targetPort("3000")
            .build());
        var defaultEdgeContainerAppRecord = new EdgeContainerAppRecord("defaultEdgeContainerAppRecord", EdgeContainerAppRecordArgs.builder()
            .recordName("tf.terraform.com")
            .siteId(resourceSiteOriginPoolTest.id())
            .appId(defaultEdgeContainerApp.id())
            .build());
    }
}

configuration:
  name:
    type: string
    default: terraform.com
resources:
  resourceSiteOriginPoolTest:
    type: alicloud:esa:Site
    name: resource_Site_OriginPool_test
    properties:
      siteName: ${name}
      instanceId: ${default.sites[0].instanceId}
      coverage: overseas
      accessType: NS
  defaultEdgeContainerApp:
    type: alicloud:esa:EdgeContainerApp
    name: default
    properties:
      healthCheckHost: example.com
      healthCheckType: l7
      servicePort: '80'
      healthCheckInterval: '5'
      edgeContainerAppName: terraform-app
      healthCheckHttpCode: http_2xx
      healthCheckUri: /
      healthCheckTimeout: '3'
      healthCheckSuccTimes: '2'
      remarks: ${name}
      healthCheckMethod: HEAD
      healthCheckPort: '80'
      healthCheckFailTimes: '5'
      targetPort: '3000'
  defaultEdgeContainerAppRecord:
    type: alicloud:esa:EdgeContainerAppRecord
    name: default
    properties:
      recordName: tf.terraform.com
      siteId: ${resourceSiteOriginPoolTest.id}
      appId: ${defaultEdgeContainerApp.id}
variables:
  default:
    fn::invoke:
      function: alicloud:esa:getSites
      arguments:
        planSubscribeType: enterpriseplan

$ pulumi import alicloud:esa/edgeContainerAppRecord:EdgeContainerAppRecord example <site_id>:<app_id>:<record_name>