alicloud.fc.CustomDomain

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

return await Deployment.RunAsync(() => 
{
    var config = new Config();
    var name = config.Get("name") ?? "tf-testaccalicloudfcservice";
    var defaultService = new AliCloud.FC.Service("defaultService", new()
    {
        Description = $"{name}-description",
    });

    var defaultBucket = new AliCloud.Oss.Bucket("defaultBucket", new()
    {
        BucketName = name,
    });

    var defaultBucketObject = new AliCloud.Oss.BucketObject("defaultBucketObject", new()
    {
        Bucket = defaultBucket.Id,
        Key = "fc/hello.zip",
        Content = @"		# -*- coding: utf-8 -*-
	def handler(event, context):
		print ""hello world""
		return 'hello world'
",
    });

    var defaultFunction = new AliCloud.FC.Function("defaultFunction", new()
    {
        Service = defaultService.Name,
        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 = "v1",
                Methods = new[]
                {
                    "GET",
                    "POST",
                },
            },
        },
        CertConfig = new AliCloud.FC.Inputs.CustomDomainCertConfigArgs
        {
            CertName = "your certificate name",
            PrivateKey = "your private key",
            Certificate = "your certificate data",
        },
    });

});

package main

import (
	"fmt"

	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/fc"
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/oss"
	"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 := "tf-testaccalicloudfcservice"
		if param := cfg.Get("name"); param != "" {
			name = param
		}
		defaultService, err := fc.NewService(ctx, "defaultService", &fc.ServiceArgs{
			Description: pulumi.String(fmt.Sprintf("%v-description", name)),
		})
		if err != nil {
			return err
		}
		defaultBucket, err := oss.NewBucket(ctx, "defaultBucket", &oss.BucketArgs{
			Bucket: pulumi.String(name),
		})
		if err != nil {
			return err
		}
		defaultBucketObject, err := oss.NewBucketObject(ctx, "defaultBucketObject", &oss.BucketObjectArgs{
			Bucket:  defaultBucket.ID(),
			Key:     pulumi.String("fc/hello.zip"),
			Content: pulumi.String(fmt.Sprintf("		# -*- coding: utf-8 -*-\n	def handler(event, context):\n		print \"hello world\"\n		return 'hello world'\n")),
		})
		if err != nil {
			return err
		}
		defaultFunction, err := fc.NewFunction(ctx, "defaultFunction", &fc.FunctionArgs{
			Service:    defaultService.Name,
			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("v1"),
					Methods: pulumi.StringArray{
						pulumi.String("GET"),
						pulumi.String("POST"),
					},
				},
			},
			CertConfig: &fc.CustomDomainCertConfigArgs{
				CertName:    pulumi.String("your certificate name"),
				PrivateKey:  pulumi.String("your private key"),
				Certificate: pulumi.String("your certificate data"),
			},
		})
		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.fc.Service;
import com.pulumi.alicloud.fc.ServiceArgs;
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) {
        final var config = ctx.config();
        final var name = config.get("name").orElse("tf-testaccalicloudfcservice");
        var defaultService = new Service("defaultService", ServiceArgs.builder()        
            .description(String.format("%s-description", name))
            .build());

        var defaultBucket = new Bucket("defaultBucket", BucketArgs.builder()        
            .bucket(name)
            .build());

        var defaultBucketObject = new BucketObject("defaultBucketObject", BucketObjectArgs.builder()        
            .bucket(defaultBucket.id())
            .key("fc/hello.zip")
            .content("""
		# -*- coding: utf-8 -*-
	def handler(event, context):
		print "hello world"
		return 'hello world'
            """)
            .build());

        var defaultFunction = new Function("defaultFunction", FunctionArgs.builder()        
            .service(defaultService.name())
            .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("v1")
                .methods(                
                    "GET",
                    "POST")
                .build())
            .certConfig(CustomDomainCertConfigArgs.builder()
                .certName("your certificate name")
                .privateKey("your private key")
                .certificate("your certificate data")
                .build())
            .build());

    }
}

import pulumi
import pulumi_alicloud as alicloud

config = pulumi.Config()
name = config.get("name")
if name is None:
    name = "tf-testaccalicloudfcservice"
default_service = alicloud.fc.Service("defaultService", description=f"{name}-description")
default_bucket = alicloud.oss.Bucket("defaultBucket", bucket=name)
default_bucket_object = alicloud.oss.BucketObject("defaultBucketObject",
    bucket=default_bucket.id,
    key="fc/hello.zip",
    content="""		# -*- coding: utf-8 -*-
	def handler(event, context):
		print "hello world"
		return 'hello world'
""")
default_function = alicloud.fc.Function("defaultFunction",
    service=default_service.name,
    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="v1",
        methods=[
            "GET",
            "POST",
        ],
    )],
    cert_config=alicloud.fc.CustomDomainCertConfigArgs(
        cert_name="your certificate name",
        private_key="your private key",
        certificate="your certificate data",
    ))

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

const config = new pulumi.Config();
const name = config.get("name") || "tf-testaccalicloudfcservice";
const defaultService = new alicloud.fc.Service("defaultService", {description: `${name}-description`});
const defaultBucket = new alicloud.oss.Bucket("defaultBucket", {bucket: name});
const defaultBucketObject = new alicloud.oss.BucketObject("defaultBucketObject", {
    bucket: defaultBucket.id,
    key: "fc/hello.zip",
    content: `		# -*- coding: utf-8 -*-
	def handler(event, context):
		print "hello world"
		return 'hello world'
`,
});
const defaultFunction = new alicloud.fc.Function("defaultFunction", {
    service: defaultService.name,
    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: "v1",
        methods: [
            "GET",
            "POST",
        ],
    }],
    certConfig: {
        certName: "your certificate name",
        privateKey: "your private key",
        certificate: "your certificate data",
    },
});

configuration:
  name:
    type: string
    default: tf-testaccalicloudfcservice
resources:
  defaultCustomDomain:
    type: alicloud:fc:CustomDomain
    properties:
      domainName: terraform.functioncompute.com
      protocol: HTTP
      routeConfigs:
        - path: /login/*
          serviceName: ${defaultService.name}
          functionName: ${defaultFunction.name}
          qualifier: v1
          methods:
            - GET
            - POST
      certConfig:
        certName: your certificate name
        privateKey: your private key
        certificate: your certificate data
  defaultService:
    type: alicloud:fc:Service
    properties:
      description: ${name}-description
  defaultBucket:
    type: alicloud:oss:Bucket
    properties:
      bucket: ${name}
  defaultBucketObject:
    type: alicloud:oss:BucketObject
    properties:
      bucket: ${defaultBucket.id}
      key: fc/hello.zip
      content: |
        		# -*- coding: utf-8 -*-
        	def handler(event, context):
        		print "hello world"
        		return 'hello world'        
  defaultFunction:
    type: alicloud:fc:Function
    properties:
      service: ${defaultService.name}
      ossBucket: ${defaultBucket.id}
      ossKey: ${defaultBucketObject.key}
      memorySize: 512
      runtime: python2.7
      handler: hello.handler