alicloud.fc.CustomDomain

import * as pulumi from "@pulumi/pulumi";
import * as alicloud from "@pulumi/alicloud";
import * as random from "@pulumi/random";

const defaultRandomInteger = new random.RandomInteger("defaultRandomInteger", {
    max: 99999,
    min: 10000,
});
const defaultProject = new alicloud.log.Project("defaultProject", {});
const defaultStore = new alicloud.log.Store("defaultStore", {project: defaultProject.name});
const defaultRole = new alicloud.ram.Role("defaultRole", {
    document: `  {
      "Statement": [
        {
          "Action": "sts:AssumeRole",
          "Effect": "Allow",
          "Principal": {
            "Service": [
              "fc.aliyuncs.com"
            ]
          }
        }
      ],
      "Version": "1"
  }
`,
    description: "this is a example",
    force: true,
});
const defaultRolePolicyAttachment = new alicloud.ram.RolePolicyAttachment("defaultRolePolicyAttachment", {
    roleName: defaultRole.name,
    policyName: "AliyunLogFullAccess",
    policyType: "System",
});
const defaultService = new alicloud.fc.Service("defaultService", {
    description: "example-value",
    role: defaultRole.arn,
    logConfig: {
        project: defaultProject.name,
        logstore: defaultStore.name,
        enableInstanceMetrics: true,
        enableRequestMetrics: true,
    },
});
const defaultBucket = new alicloud.oss.Bucket("defaultBucket", {bucket: pulumi.interpolate`terraform-example-${defaultRandomInteger.result}`});
// If you upload the function by OSS Bucket, you need to specify path can't upload by content.
const defaultBucketObject = new alicloud.oss.BucketObject("defaultBucketObject", {
    bucket: defaultBucket.id,
    key: "index.py",
    content: `import logging 
def handler(event, context): 
logger = logging.getLogger() 
logger.info('hello world') 
return 'hello world'`,
});
const defaultFunction = new alicloud.fc.Function("defaultFunction", {
    service: defaultService.name,
    description: "example",
    ossBucket: defaultBucket.id,
    ossKey: defaultBucketObject.key,
    memorySize: 512,
    runtime: "python2.7",
    handler: "hello.handler",
});
const defaultCustomDomain = new alicloud.fc.CustomDomain("defaultCustomDomain", {
    domainName: "terraform.functioncompute.com",
    protocol: "HTTP",
    routeConfigs: [{
        path: "/login/*",
        serviceName: defaultService.name,
        functionName: defaultFunction.name,
        qualifier: "?query",
        methods: [
            "GET",
            "POST",
        ],
    }],
    certConfig: {
        certName: "example",
        certificate: `-----BEGIN CERTIFICATE-----
MIICWD****-----END CERTIFICATE-----`,
        privateKey: `-----BEGIN RSA PRIVATE KEY-----
MIICX****n-----END RSA PRIVATE KEY-----`,
    },
});

import pulumi
import pulumi_alicloud as alicloud
import pulumi_random as random

default_random_integer = random.RandomInteger("defaultRandomInteger",
    max=99999,
    min=10000)
default_project = alicloud.log.Project("defaultProject")
default_store = alicloud.log.Store("defaultStore", project=default_project.name)
default_role = alicloud.ram.Role("defaultRole",
    document="""  {
      "Statement": [
        {
          "Action": "sts:AssumeRole",
          "Effect": "Allow",
          "Principal": {
            "Service": [
              "fc.aliyuncs.com"
            ]
          }
        }
      ],
      "Version": "1"
  }
""",
    description="this is a example",
    force=True)
default_role_policy_attachment = alicloud.ram.RolePolicyAttachment("defaultRolePolicyAttachment",
    role_name=default_role.name,
    policy_name="AliyunLogFullAccess",
    policy_type="System")
default_service = alicloud.fc.Service("defaultService",
    description="example-value",
    role=default_role.arn,
    log_config=alicloud.fc.ServiceLogConfigArgs(
        project=default_project.name,
        logstore=default_store.name,
        enable_instance_metrics=True,
        enable_request_metrics=True,
    ))
default_bucket = alicloud.oss.Bucket("defaultBucket", bucket=default_random_integer.result.apply(lambda result: f"terraform-example-{result}"))
# If you upload the function by OSS Bucket, you need to specify path can't upload by content.
default_bucket_object = alicloud.oss.BucketObject("defaultBucketObject",
    bucket=default_bucket.id,
    key="index.py",
    content="""import logging 
def handler(event, context): 
logger = logging.getLogger() 
logger.info('hello world') 
return 'hello world'""")
default_function = alicloud.fc.Function("defaultFunction",
    service=default_service.name,
    description="example",
    oss_bucket=default_bucket.id,
    oss_key=default_bucket_object.key,
    memory_size=512,
    runtime="python2.7",
    handler="hello.handler")
default_custom_domain = alicloud.fc.CustomDomain("defaultCustomDomain",
    domain_name="terraform.functioncompute.com",
    protocol="HTTP",
    route_configs=[alicloud.fc.CustomDomainRouteConfigArgs(
        path="/login/*",
        service_name=default_service.name,
        function_name=default_function.name,
        qualifier="?query",
        methods=[
            "GET",
            "POST",
        ],
    )],
    cert_config=alicloud.fc.CustomDomainCertConfigArgs(
        cert_name="example",
        certificate="""-----BEGIN CERTIFICATE-----
MIICWD****-----END CERTIFICATE-----""",
        private_key="""-----BEGIN RSA PRIVATE KEY-----
MIICX****n-----END RSA PRIVATE KEY-----""",
    ))

package main

import (
	"fmt"

	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/fc"
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/log"
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/oss"
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/ram"
	"github.com/pulumi/pulumi-random/sdk/v4/go/random"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		defaultRandomInteger, err := random.NewRandomInteger(ctx, "defaultRandomInteger", &random.RandomIntegerArgs{
			Max: pulumi.Int(99999),
			Min: pulumi.Int(10000),
		})
		if err != nil {
			return err
		}
		defaultProject, err := log.NewProject(ctx, "defaultProject", nil)
		if err != nil {
			return err
		}
		defaultStore, err := log.NewStore(ctx, "defaultStore", &log.StoreArgs{
			Project: defaultProject.Name,
		})
		if err != nil {
			return err
		}
		defaultRole, err := ram.NewRole(ctx, "defaultRole", &ram.RoleArgs{
			Document: pulumi.String(`  {
      "Statement": [
        {
          "Action": "sts:AssumeRole",
          "Effect": "Allow",
          "Principal": {
            "Service": [
              "fc.aliyuncs.com"
            ]
          }
        }
      ],
      "Version": "1"
  }
`),
			Description: pulumi.String("this is a example"),
			Force:       pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		_, err = ram.NewRolePolicyAttachment(ctx, "defaultRolePolicyAttachment", &ram.RolePolicyAttachmentArgs{
			RoleName:   defaultRole.Name,
			PolicyName: pulumi.String("AliyunLogFullAccess"),
			PolicyType: pulumi.String("System"),
		})
		if err != nil {
			return err
		}
		defaultService, err := fc.NewService(ctx, "defaultService", &fc.ServiceArgs{
			Description: pulumi.String("example-value"),
			Role:        defaultRole.Arn,
			LogConfig: &fc.ServiceLogConfigArgs{
				Project:               defaultProject.Name,
				Logstore:              defaultStore.Name,
				EnableInstanceMetrics: pulumi.Bool(true),
				EnableRequestMetrics:  pulumi.Bool(true),
			},
		})
		if err != nil {
			return err
		}
		defaultBucket, err := oss.NewBucket(ctx, "defaultBucket", &oss.BucketArgs{
			Bucket: defaultRandomInteger.Result.ApplyT(func(result int) (string, error) {
				return fmt.Sprintf("terraform-example-%v", result), nil
			}).(pulumi.StringOutput),
		})
		if err != nil {
			return err
		}
		// If you upload the function by OSS Bucket, you need to specify path can't upload by content.
		defaultBucketObject, err := oss.NewBucketObject(ctx, "defaultBucketObject", &oss.BucketObjectArgs{
			Bucket:  defaultBucket.ID(),
			Key:     pulumi.String("index.py"),
			Content: pulumi.String("import logging \ndef handler(event, context): \nlogger = logging.getLogger() \nlogger.info('hello world') \nreturn 'hello world'"),
		})
		if err != nil {
			return err
		}
		defaultFunction, err := fc.NewFunction(ctx, "defaultFunction", &fc.FunctionArgs{
			Service:     defaultService.Name,
			Description: pulumi.String("example"),
			OssBucket:   defaultBucket.ID(),
			OssKey:      defaultBucketObject.Key,
			MemorySize:  pulumi.Int(512),
			Runtime:     pulumi.String("python2.7"),
			Handler:     pulumi.String("hello.handler"),
		})
		if err != nil {
			return err
		}
		_, err = fc.NewCustomDomain(ctx, "defaultCustomDomain", &fc.CustomDomainArgs{
			DomainName: pulumi.String("terraform.functioncompute.com"),
			Protocol:   pulumi.String("HTTP"),
			RouteConfigs: fc.CustomDomainRouteConfigArray{
				&fc.CustomDomainRouteConfigArgs{
					Path:         pulumi.String("/login/*"),
					ServiceName:  defaultService.Name,
					FunctionName: defaultFunction.Name,
					Qualifier:    pulumi.String("?query"),
					Methods: pulumi.StringArray{
						pulumi.String("GET"),
						pulumi.String("POST"),
					},
				},
			},
			CertConfig: &fc.CustomDomainCertConfigArgs{
				CertName:    pulumi.String("example"),
				Certificate: pulumi.String("-----BEGIN CERTIFICATE-----\nMIICWD****-----END CERTIFICATE-----"),
				PrivateKey:  pulumi.String("-----BEGIN RSA PRIVATE KEY-----\nMIICX****n-----END RSA PRIVATE KEY-----"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AliCloud = Pulumi.AliCloud;
using Random = Pulumi.Random;

return await Deployment.RunAsync(() => 
{
    var defaultRandomInteger = new Random.RandomInteger("defaultRandomInteger", new()
    {
        Max = 99999,
        Min = 10000,
    });

    var defaultProject = new AliCloud.Log.Project("defaultProject");

    var defaultStore = new AliCloud.Log.Store("defaultStore", new()
    {
        Project = defaultProject.Name,
    });

    var defaultRole = new AliCloud.Ram.Role("defaultRole", new()
    {
        Document = @"  {
      ""Statement"": [
        {
          ""Action"": ""sts:AssumeRole"",
          ""Effect"": ""Allow"",
          ""Principal"": {
            ""Service"": [
              ""fc.aliyuncs.com""
            ]
          }
        }
      ],
      ""Version"": ""1""
  }
",
        Description = "this is a example",
        Force = true,
    });

    var defaultRolePolicyAttachment = new AliCloud.Ram.RolePolicyAttachment("defaultRolePolicyAttachment", new()
    {
        RoleName = defaultRole.Name,
        PolicyName = "AliyunLogFullAccess",
        PolicyType = "System",
    });

    var defaultService = new AliCloud.FC.Service("defaultService", new()
    {
        Description = "example-value",
        Role = defaultRole.Arn,
        LogConfig = new AliCloud.FC.Inputs.ServiceLogConfigArgs
        {
            Project = defaultProject.Name,
            Logstore = defaultStore.Name,
            EnableInstanceMetrics = true,
            EnableRequestMetrics = true,
        },
    });

    var defaultBucket = new AliCloud.Oss.Bucket("defaultBucket", new()
    {
        BucketName = defaultRandomInteger.Result.Apply(result => $"terraform-example-{result}"),
    });

    // If you upload the function by OSS Bucket, you need to specify path can't upload by content.
    var defaultBucketObject = new AliCloud.Oss.BucketObject("defaultBucketObject", new()
    {
        Bucket = defaultBucket.Id,
        Key = "index.py",
        Content = @"import logging 
def handler(event, context): 
logger = logging.getLogger() 
logger.info('hello world') 
return 'hello world'",
    });

    var defaultFunction = new AliCloud.FC.Function("defaultFunction", new()
    {
        Service = defaultService.Name,
        Description = "example",
        OssBucket = defaultBucket.Id,
        OssKey = defaultBucketObject.Key,
        MemorySize = 512,
        Runtime = "python2.7",
        Handler = "hello.handler",
    });

    var defaultCustomDomain = new AliCloud.FC.CustomDomain("defaultCustomDomain", new()
    {
        DomainName = "terraform.functioncompute.com",
        Protocol = "HTTP",
        RouteConfigs = new[]
        {
            new AliCloud.FC.Inputs.CustomDomainRouteConfigArgs
            {
                Path = "/login/*",
                ServiceName = defaultService.Name,
                FunctionName = defaultFunction.Name,
                Qualifier = "?query",
                Methods = new[]
                {
                    "GET",
                    "POST",
                },
            },
        },
        CertConfig = new AliCloud.FC.Inputs.CustomDomainCertConfigArgs
        {
            CertName = "example",
            Certificate = @"-----BEGIN CERTIFICATE-----
MIICWD****-----END CERTIFICATE-----",
            PrivateKey = @"-----BEGIN RSA PRIVATE KEY-----
MIICX****n-----END RSA PRIVATE KEY-----",
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.random.RandomInteger;
import com.pulumi.random.RandomIntegerArgs;
import com.pulumi.alicloud.log.Project;
import com.pulumi.alicloud.log.Store;
import com.pulumi.alicloud.log.StoreArgs;
import com.pulumi.alicloud.ram.Role;
import com.pulumi.alicloud.ram.RoleArgs;
import com.pulumi.alicloud.ram.RolePolicyAttachment;
import com.pulumi.alicloud.ram.RolePolicyAttachmentArgs;
import com.pulumi.alicloud.fc.Service;
import com.pulumi.alicloud.fc.ServiceArgs;
import com.pulumi.alicloud.fc.inputs.ServiceLogConfigArgs;
import com.pulumi.alicloud.oss.Bucket;
import com.pulumi.alicloud.oss.BucketArgs;
import com.pulumi.alicloud.oss.BucketObject;
import com.pulumi.alicloud.oss.BucketObjectArgs;
import com.pulumi.alicloud.fc.Function;
import com.pulumi.alicloud.fc.FunctionArgs;
import com.pulumi.alicloud.fc.CustomDomain;
import com.pulumi.alicloud.fc.CustomDomainArgs;
import com.pulumi.alicloud.fc.inputs.CustomDomainRouteConfigArgs;
import com.pulumi.alicloud.fc.inputs.CustomDomainCertConfigArgs;
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 defaultRandomInteger = new RandomInteger("defaultRandomInteger", RandomIntegerArgs.builder()        
            .max(99999)
            .min(10000)
            .build());

        var defaultProject = new Project("defaultProject");

        var defaultStore = new Store("defaultStore", StoreArgs.builder()        
            .project(defaultProject.name())
            .build());

        var defaultRole = new Role("defaultRole", RoleArgs.builder()        
            .document("""
  {
      "Statement": [
        {
          "Action": "sts:AssumeRole",
          "Effect": "Allow",
          "Principal": {
            "Service": [
              "fc.aliyuncs.com"
            ]
          }
        }
      ],
      "Version": "1"
  }
            """)
            .description("this is a example")
            .force(true)
            .build());

        var defaultRolePolicyAttachment = new RolePolicyAttachment("defaultRolePolicyAttachment", RolePolicyAttachmentArgs.builder()        
            .roleName(defaultRole.name())
            .policyName("AliyunLogFullAccess")
            .policyType("System")
            .build());

        var defaultService = new Service("defaultService", ServiceArgs.builder()        
            .description("example-value")
            .role(defaultRole.arn())
            .logConfig(ServiceLogConfigArgs.builder()
                .project(defaultProject.name())
                .logstore(defaultStore.name())
                .enableInstanceMetrics(true)
                .enableRequestMetrics(true)
                .build())
            .build());

        var defaultBucket = new Bucket("defaultBucket", BucketArgs.builder()        
            .bucket(defaultRandomInteger.result().applyValue(result -> String.format("terraform-example-%s", result)))
            .build());

        // If you upload the function by OSS Bucket, you need to specify path can't upload by content.
        var defaultBucketObject = new BucketObject("defaultBucketObject", BucketObjectArgs.builder()        
            .bucket(defaultBucket.id())
            .key("index.py")
            .content("""
import logging 
def handler(event, context): 
logger = logging.getLogger() 
logger.info('hello world') 
return 'hello world'            """)
            .build());

        var defaultFunction = new Function("defaultFunction", FunctionArgs.builder()        
            .service(defaultService.name())
            .description("example")
            .ossBucket(defaultBucket.id())
            .ossKey(defaultBucketObject.key())
            .memorySize("512")
            .runtime("python2.7")
            .handler("hello.handler")
            .build());

        var defaultCustomDomain = new CustomDomain("defaultCustomDomain", CustomDomainArgs.builder()        
            .domainName("terraform.functioncompute.com")
            .protocol("HTTP")
            .routeConfigs(CustomDomainRouteConfigArgs.builder()
                .path("/login/*")
                .serviceName(defaultService.name())
                .functionName(defaultFunction.name())
                .qualifier("?query")
                .methods(                
                    "GET",
                    "POST")
                .build())
            .certConfig(CustomDomainCertConfigArgs.builder()
                .certName("example")
                .certificate("""
-----BEGIN CERTIFICATE-----
MIICWD****-----END CERTIFICATE-----                """)
                .privateKey("""
-----BEGIN RSA PRIVATE KEY-----
MIICX****n-----END RSA PRIVATE KEY-----                """)
                .build())
            .build());

    }
}

resources:
  defaultRandomInteger:
    type: random:RandomInteger
    properties:
      max: 99999
      min: 10000
  defaultProject:
    type: alicloud:log:Project
  defaultStore:
    type: alicloud:log:Store
    properties:
      project: ${defaultProject.name}
  defaultRole:
    type: alicloud:ram:Role
    properties:
      document: |2
          {
              "Statement": [
                {
                  "Action": "sts:AssumeRole",
                  "Effect": "Allow",
                  "Principal": {
                    "Service": [
                      "fc.aliyuncs.com"
                    ]
                  }
                }
              ],
              "Version": "1"
          }
      description: this is a example
      force: true
  defaultRolePolicyAttachment:
    type: alicloud:ram:RolePolicyAttachment
    properties:
      roleName: ${defaultRole.name}
      policyName: AliyunLogFullAccess
      policyType: System
  defaultService:
    type: alicloud:fc:Service
    properties:
      description: example-value
      role: ${defaultRole.arn}
      logConfig:
        project: ${defaultProject.name}
        logstore: ${defaultStore.name}
        enableInstanceMetrics: true
        enableRequestMetrics: true
  defaultBucket:
    type: alicloud:oss:Bucket
    properties:
      bucket: terraform-example-${defaultRandomInteger.result}
  # If you upload the function by OSS Bucket, you need to specify path can't upload by content.
  defaultBucketObject:
    type: alicloud:oss:BucketObject
    properties:
      bucket: ${defaultBucket.id}
      key: index.py
      content: "import logging \ndef handler(event, context): \nlogger = logging.getLogger() \nlogger.info('hello world') \nreturn 'hello world'"
  defaultFunction:
    type: alicloud:fc:Function
    properties:
      service: ${defaultService.name}
      description: example
      ossBucket: ${defaultBucket.id}
      ossKey: ${defaultBucketObject.key}
      memorySize: '512'
      runtime: python2.7
      handler: hello.handler
  defaultCustomDomain:
    type: alicloud:fc:CustomDomain
    properties:
      domainName: terraform.functioncompute.com
      protocol: HTTP
      routeConfigs:
        - path: /login/*
          serviceName: ${defaultService.name}
          functionName: ${defaultFunction.name}
          qualifier: ?query
          methods:
            - GET
            - POST
      certConfig:
        certName: example
        certificate: |-
          -----BEGIN CERTIFICATE-----
          MIICWD****-----END CERTIFICATE-----          
        privateKey: |-
          -----BEGIN RSA PRIVATE KEY-----
          MIICX****n-----END RSA PRIVATE KEY-----          

var customDomainResource = new AliCloud.FC.CustomDomain("customDomainResource", new()
{
    DomainName = "string",
    Protocol = "string",
    CertConfig = new AliCloud.FC.Inputs.CustomDomainCertConfigArgs
    {
        CertName = "string",
        Certificate = "string",
        PrivateKey = "string",
    },
    RouteConfigs = new[]
    {
        new AliCloud.FC.Inputs.CustomDomainRouteConfigArgs
        {
            FunctionName = "string",
            Path = "string",
            ServiceName = "string",
            Methods = new[]
            {
                "string",
            },
            Qualifier = "string",
        },
    },
});

example, err := fc.NewCustomDomain(ctx, "customDomainResource", &fc.CustomDomainArgs{
	DomainName: pulumi.String("string"),
	Protocol:   pulumi.String("string"),
	CertConfig: &fc.CustomDomainCertConfigArgs{
		CertName:    pulumi.String("string"),
		Certificate: pulumi.String("string"),
		PrivateKey:  pulumi.String("string"),
	},
	RouteConfigs: fc.CustomDomainRouteConfigArray{
		&fc.CustomDomainRouteConfigArgs{
			FunctionName: pulumi.String("string"),
			Path:         pulumi.String("string"),
			ServiceName:  pulumi.String("string"),
			Methods: pulumi.StringArray{
				pulumi.String("string"),
			},
			Qualifier: pulumi.String("string"),
		},
	},
})

var customDomainResource = new CustomDomain("customDomainResource", CustomDomainArgs.builder()        
    .domainName("string")
    .protocol("string")
    .certConfig(CustomDomainCertConfigArgs.builder()
        .certName("string")
        .certificate("string")
        .privateKey("string")
        .build())
    .routeConfigs(CustomDomainRouteConfigArgs.builder()
        .functionName("string")
        .path("string")
        .serviceName("string")
        .methods("string")
        .qualifier("string")
        .build())
    .build());

custom_domain_resource = alicloud.fc.CustomDomain("customDomainResource",
    domain_name="string",
    protocol="string",
    cert_config=alicloud.fc.CustomDomainCertConfigArgs(
        cert_name="string",
        certificate="string",
        private_key="string",
    ),
    route_configs=[alicloud.fc.CustomDomainRouteConfigArgs(
        function_name="string",
        path="string",
        service_name="string",
        methods=["string"],
        qualifier="string",
    )])

const customDomainResource = new alicloud.fc.CustomDomain("customDomainResource", {
    domainName: "string",
    protocol: "string",
    certConfig: {
        certName: "string",
        certificate: "string",
        privateKey: "string",
    },
    routeConfigs: [{
        functionName: "string",
        path: "string",
        serviceName: "string",
        methods: ["string"],
        qualifier: "string",
    }],
});

type: alicloud:fc:CustomDomain
properties:
    certConfig:
        certName: string
        certificate: string
        privateKey: string
    domainName: string
    protocol: string
    routeConfigs:
        - functionName: string
          methods:
            - string
          path: string
          qualifier: string
          serviceName: string