tencentcloud.TseCngwRouteRateLimit

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

const config = new pulumi.Config();
const availabilityZone = config.get("availabilityZone") || "ap-guangzhou-4";
const vpc = new tencentcloud.Vpc("vpc", {cidrBlock: "10.0.0.0/16"});
const subnet = new tencentcloud.Subnet("subnet", {
    vpcId: vpc.vpcId,
    availabilityZone: availabilityZone,
    cidrBlock: "10.0.1.0/24",
});
const cngwGateway = new tencentcloud.TseCngwGateway("cngwGateway", {
    description: "terraform test1",
    enableCls: true,
    engineRegion: "ap-guangzhou",
    featureVersion: "STANDARD",
    gatewayVersion: "2.5.1",
    ingressClassName: "tse-nginx-ingress",
    internetMaxBandwidthOut: 0,
    tradeType: 0,
    type: "kong",
    nodeConfig: {
        number: 2,
        specification: "1c2g",
    },
    vpcConfig: {
        subnetId: subnet.subnetId,
        vpcId: vpc.vpcId,
    },
    tags: {
        createdBy: "terraform",
    },
});
const cngwService = new tencentcloud.TseCngwService("cngwService", {
    gatewayId: cngwGateway.tseCngwGatewayId,
    path: "/test",
    protocol: "http",
    retries: 5,
    timeout: 60000,
    upstreamType: "HostIP",
    upstreamInfo: {
        algorithm: "round-robin",
        autoScalingCvmPort: 0,
        host: "arunma.cn",
        port: 8012,
        slowStart: 0,
    },
});
const cngwRoute = new tencentcloud.TseCngwRoute("cngwRoute", {
    destinationPorts: [],
    forceHttps: false,
    gatewayId: cngwGateway.tseCngwGatewayId,
    hosts: ["192.168.0.1:9090"],
    httpsRedirectStatusCode: 426,
    paths: ["/user"],
    headers: [{
        key: "req",
        value: "terraform",
    }],
    preserveHost: false,
    protocols: [
        "http",
        "https",
    ],
    routeName: "terraform-route",
    serviceId: cngwService.serviceId,
    stripPath: true,
});
const cngwRouteRateLimit = new tencentcloud.TseCngwRouteRateLimit("cngwRouteRateLimit", {
    gatewayId: cngwGateway.tseCngwGatewayId,
    routeId: cngwRoute.routeId,
    limitDetail: {
        enabled: true,
        header: "req",
        hideClientHeaders: true,
        isDelay: true,
        limitBy: "header",
        lineUpTime: 10,
        policy: "redis",
        responseType: "default",
        qpsThresholds: [{
            max: 10,
            unit: "minute",
        }],
    },
});

import pulumi
import pulumi_tencentcloud as tencentcloud

config = pulumi.Config()
availability_zone = config.get("availabilityZone")
if availability_zone is None:
    availability_zone = "ap-guangzhou-4"
vpc = tencentcloud.Vpc("vpc", cidr_block="10.0.0.0/16")
subnet = tencentcloud.Subnet("subnet",
    vpc_id=vpc.vpc_id,
    availability_zone=availability_zone,
    cidr_block="10.0.1.0/24")
cngw_gateway = tencentcloud.TseCngwGateway("cngwGateway",
    description="terraform test1",
    enable_cls=True,
    engine_region="ap-guangzhou",
    feature_version="STANDARD",
    gateway_version="2.5.1",
    ingress_class_name="tse-nginx-ingress",
    internet_max_bandwidth_out=0,
    trade_type=0,
    type="kong",
    node_config={
        "number": 2,
        "specification": "1c2g",
    },
    vpc_config={
        "subnet_id": subnet.subnet_id,
        "vpc_id": vpc.vpc_id,
    },
    tags={
        "createdBy": "terraform",
    })
cngw_service = tencentcloud.TseCngwService("cngwService",
    gateway_id=cngw_gateway.tse_cngw_gateway_id,
    path="/test",
    protocol="http",
    retries=5,
    timeout=60000,
    upstream_type="HostIP",
    upstream_info={
        "algorithm": "round-robin",
        "auto_scaling_cvm_port": 0,
        "host": "arunma.cn",
        "port": 8012,
        "slow_start": 0,
    })
cngw_route = tencentcloud.TseCngwRoute("cngwRoute",
    destination_ports=[],
    force_https=False,
    gateway_id=cngw_gateway.tse_cngw_gateway_id,
    hosts=["192.168.0.1:9090"],
    https_redirect_status_code=426,
    paths=["/user"],
    headers=[{
        "key": "req",
        "value": "terraform",
    }],
    preserve_host=False,
    protocols=[
        "http",
        "https",
    ],
    route_name="terraform-route",
    service_id=cngw_service.service_id,
    strip_path=True)
cngw_route_rate_limit = tencentcloud.TseCngwRouteRateLimit("cngwRouteRateLimit",
    gateway_id=cngw_gateway.tse_cngw_gateway_id,
    route_id=cngw_route.route_id,
    limit_detail={
        "enabled": True,
        "header": "req",
        "hide_client_headers": True,
        "is_delay": True,
        "limit_by": "header",
        "line_up_time": 10,
        "policy": "redis",
        "response_type": "default",
        "qps_thresholds": [{
            "max": 10,
            "unit": "minute",
        }],
    })

package main

import (
	"github.com/pulumi/pulumi-terraform-provider/sdks/go/tencentcloud/tencentcloud"
	"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, "")
		availabilityZone := "ap-guangzhou-4"
		if param := cfg.Get("availabilityZone"); param != "" {
			availabilityZone = param
		}
		vpc, err := tencentcloud.NewVpc(ctx, "vpc", &tencentcloud.VpcArgs{
			CidrBlock: pulumi.String("10.0.0.0/16"),
		})
		if err != nil {
			return err
		}
		subnet, err := tencentcloud.NewSubnet(ctx, "subnet", &tencentcloud.SubnetArgs{
			VpcId:            vpc.VpcId,
			AvailabilityZone: pulumi.String(availabilityZone),
			CidrBlock:        pulumi.String("10.0.1.0/24"),
		})
		if err != nil {
			return err
		}
		cngwGateway, err := tencentcloud.NewTseCngwGateway(ctx, "cngwGateway", &tencentcloud.TseCngwGatewayArgs{
			Description:             pulumi.String("terraform test1"),
			EnableCls:               pulumi.Bool(true),
			EngineRegion:            pulumi.String("ap-guangzhou"),
			FeatureVersion:          pulumi.String("STANDARD"),
			GatewayVersion:          pulumi.String("2.5.1"),
			IngressClassName:        pulumi.String("tse-nginx-ingress"),
			InternetMaxBandwidthOut: pulumi.Float64(0),
			TradeType:               pulumi.Float64(0),
			Type:                    pulumi.String("kong"),
			NodeConfig: &tencentcloud.TseCngwGatewayNodeConfigArgs{
				Number:        pulumi.Float64(2),
				Specification: pulumi.String("1c2g"),
			},
			VpcConfig: &tencentcloud.TseCngwGatewayVpcConfigArgs{
				SubnetId: subnet.SubnetId,
				VpcId:    vpc.VpcId,
			},
			Tags: pulumi.StringMap{
				"createdBy": pulumi.String("terraform"),
			},
		})
		if err != nil {
			return err
		}
		cngwService, err := tencentcloud.NewTseCngwService(ctx, "cngwService", &tencentcloud.TseCngwServiceArgs{
			GatewayId:    cngwGateway.TseCngwGatewayId,
			Path:         pulumi.String("/test"),
			Protocol:     pulumi.String("http"),
			Retries:      pulumi.Float64(5),
			Timeout:      pulumi.Float64(60000),
			UpstreamType: pulumi.String("HostIP"),
			UpstreamInfo: &tencentcloud.TseCngwServiceUpstreamInfoArgs{
				Algorithm:          pulumi.String("round-robin"),
				AutoScalingCvmPort: pulumi.Float64(0),
				Host:               pulumi.String("arunma.cn"),
				Port:               pulumi.Float64(8012),
				SlowStart:          pulumi.Float64(0),
			},
		})
		if err != nil {
			return err
		}
		cngwRoute, err := tencentcloud.NewTseCngwRoute(ctx, "cngwRoute", &tencentcloud.TseCngwRouteArgs{
			DestinationPorts: pulumi.Float64Array{},
			ForceHttps:       pulumi.Bool(false),
			GatewayId:        cngwGateway.TseCngwGatewayId,
			Hosts: pulumi.StringArray{
				pulumi.String("192.168.0.1:9090"),
			},
			HttpsRedirectStatusCode: pulumi.Float64(426),
			Paths: pulumi.StringArray{
				pulumi.String("/user"),
			},
			Headers: tencentcloud.TseCngwRouteHeaderArray{
				&tencentcloud.TseCngwRouteHeaderArgs{
					Key:   pulumi.String("req"),
					Value: pulumi.String("terraform"),
				},
			},
			PreserveHost: pulumi.Bool(false),
			Protocols: pulumi.StringArray{
				pulumi.String("http"),
				pulumi.String("https"),
			},
			RouteName: pulumi.String("terraform-route"),
			ServiceId: cngwService.ServiceId,
			StripPath: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		_, err = tencentcloud.NewTseCngwRouteRateLimit(ctx, "cngwRouteRateLimit", &tencentcloud.TseCngwRouteRateLimitArgs{
			GatewayId: cngwGateway.TseCngwGatewayId,
			RouteId:   cngwRoute.RouteId,
			LimitDetail: &tencentcloud.TseCngwRouteRateLimitLimitDetailArgs{
				Enabled:           pulumi.Bool(true),
				Header:            pulumi.String("req"),
				HideClientHeaders: pulumi.Bool(true),
				IsDelay:           pulumi.Bool(true),
				LimitBy:           pulumi.String("header"),
				LineUpTime:        pulumi.Float64(10),
				Policy:            pulumi.String("redis"),
				ResponseType:      pulumi.String("default"),
				QpsThresholds: tencentcloud.TseCngwRouteRateLimitLimitDetailQpsThresholdArray{
					&tencentcloud.TseCngwRouteRateLimitLimitDetailQpsThresholdArgs{
						Max:  pulumi.Float64(10),
						Unit: pulumi.String("minute"),
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Tencentcloud = Pulumi.Tencentcloud;

return await Deployment.RunAsync(() => 
{
    var config = new Config();
    var availabilityZone = config.Get("availabilityZone") ?? "ap-guangzhou-4";
    var vpc = new Tencentcloud.Vpc("vpc", new()
    {
        CidrBlock = "10.0.0.0/16",
    });

    var subnet = new Tencentcloud.Subnet("subnet", new()
    {
        VpcId = vpc.VpcId,
        AvailabilityZone = availabilityZone,
        CidrBlock = "10.0.1.0/24",
    });

    var cngwGateway = new Tencentcloud.TseCngwGateway("cngwGateway", new()
    {
        Description = "terraform test1",
        EnableCls = true,
        EngineRegion = "ap-guangzhou",
        FeatureVersion = "STANDARD",
        GatewayVersion = "2.5.1",
        IngressClassName = "tse-nginx-ingress",
        InternetMaxBandwidthOut = 0,
        TradeType = 0,
        Type = "kong",
        NodeConfig = new Tencentcloud.Inputs.TseCngwGatewayNodeConfigArgs
        {
            Number = 2,
            Specification = "1c2g",
        },
        VpcConfig = new Tencentcloud.Inputs.TseCngwGatewayVpcConfigArgs
        {
            SubnetId = subnet.SubnetId,
            VpcId = vpc.VpcId,
        },
        Tags = 
        {
            { "createdBy", "terraform" },
        },
    });

    var cngwService = new Tencentcloud.TseCngwService("cngwService", new()
    {
        GatewayId = cngwGateway.TseCngwGatewayId,
        Path = "/test",
        Protocol = "http",
        Retries = 5,
        Timeout = 60000,
        UpstreamType = "HostIP",
        UpstreamInfo = new Tencentcloud.Inputs.TseCngwServiceUpstreamInfoArgs
        {
            Algorithm = "round-robin",
            AutoScalingCvmPort = 0,
            Host = "arunma.cn",
            Port = 8012,
            SlowStart = 0,
        },
    });

    var cngwRoute = new Tencentcloud.TseCngwRoute("cngwRoute", new()
    {
        DestinationPorts = new[] {},
        ForceHttps = false,
        GatewayId = cngwGateway.TseCngwGatewayId,
        Hosts = new[]
        {
            "192.168.0.1:9090",
        },
        HttpsRedirectStatusCode = 426,
        Paths = new[]
        {
            "/user",
        },
        Headers = new[]
        {
            new Tencentcloud.Inputs.TseCngwRouteHeaderArgs
            {
                Key = "req",
                Value = "terraform",
            },
        },
        PreserveHost = false,
        Protocols = new[]
        {
            "http",
            "https",
        },
        RouteName = "terraform-route",
        ServiceId = cngwService.ServiceId,
        StripPath = true,
    });

    var cngwRouteRateLimit = new Tencentcloud.TseCngwRouteRateLimit("cngwRouteRateLimit", new()
    {
        GatewayId = cngwGateway.TseCngwGatewayId,
        RouteId = cngwRoute.RouteId,
        LimitDetail = new Tencentcloud.Inputs.TseCngwRouteRateLimitLimitDetailArgs
        {
            Enabled = true,
            Header = "req",
            HideClientHeaders = true,
            IsDelay = true,
            LimitBy = "header",
            LineUpTime = 10,
            Policy = "redis",
            ResponseType = "default",
            QpsThresholds = new[]
            {
                new Tencentcloud.Inputs.TseCngwRouteRateLimitLimitDetailQpsThresholdArgs
                {
                    Max = 10,
                    Unit = "minute",
                },
            },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.tencentcloud.Vpc;
import com.pulumi.tencentcloud.VpcArgs;
import com.pulumi.tencentcloud.Subnet;
import com.pulumi.tencentcloud.SubnetArgs;
import com.pulumi.tencentcloud.TseCngwGateway;
import com.pulumi.tencentcloud.TseCngwGatewayArgs;
import com.pulumi.tencentcloud.inputs.TseCngwGatewayNodeConfigArgs;
import com.pulumi.tencentcloud.inputs.TseCngwGatewayVpcConfigArgs;
import com.pulumi.tencentcloud.TseCngwService;
import com.pulumi.tencentcloud.TseCngwServiceArgs;
import com.pulumi.tencentcloud.inputs.TseCngwServiceUpstreamInfoArgs;
import com.pulumi.tencentcloud.TseCngwRoute;
import com.pulumi.tencentcloud.TseCngwRouteArgs;
import com.pulumi.tencentcloud.inputs.TseCngwRouteHeaderArgs;
import com.pulumi.tencentcloud.TseCngwRouteRateLimit;
import com.pulumi.tencentcloud.TseCngwRouteRateLimitArgs;
import com.pulumi.tencentcloud.inputs.TseCngwRouteRateLimitLimitDetailArgs;
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 availabilityZone = config.get("availabilityZone").orElse("ap-guangzhou-4");
        var vpc = new Vpc("vpc", VpcArgs.builder()
            .cidrBlock("10.0.0.0/16")
            .build());

        var subnet = new Subnet("subnet", SubnetArgs.builder()
            .vpcId(vpc.vpcId())
            .availabilityZone(availabilityZone)
            .cidrBlock("10.0.1.0/24")
            .build());

        var cngwGateway = new TseCngwGateway("cngwGateway", TseCngwGatewayArgs.builder()
            .description("terraform test1")
            .enableCls(true)
            .engineRegion("ap-guangzhou")
            .featureVersion("STANDARD")
            .gatewayVersion("2.5.1")
            .ingressClassName("tse-nginx-ingress")
            .internetMaxBandwidthOut(0)
            .tradeType(0)
            .type("kong")
            .nodeConfig(TseCngwGatewayNodeConfigArgs.builder()
                .number(2)
                .specification("1c2g")
                .build())
            .vpcConfig(TseCngwGatewayVpcConfigArgs.builder()
                .subnetId(subnet.subnetId())
                .vpcId(vpc.vpcId())
                .build())
            .tags(Map.of("createdBy", "terraform"))
            .build());

        var cngwService = new TseCngwService("cngwService", TseCngwServiceArgs.builder()
            .gatewayId(cngwGateway.tseCngwGatewayId())
            .path("/test")
            .protocol("http")
            .retries(5)
            .timeout(60000)
            .upstreamType("HostIP")
            .upstreamInfo(TseCngwServiceUpstreamInfoArgs.builder()
                .algorithm("round-robin")
                .autoScalingCvmPort(0)
                .host("arunma.cn")
                .port(8012)
                .slowStart(0)
                .build())
            .build());

        var cngwRoute = new TseCngwRoute("cngwRoute", TseCngwRouteArgs.builder()
            .destinationPorts()
            .forceHttps(false)
            .gatewayId(cngwGateway.tseCngwGatewayId())
            .hosts("192.168.0.1:9090")
            .httpsRedirectStatusCode(426)
            .paths("/user")
            .headers(TseCngwRouteHeaderArgs.builder()
                .key("req")
                .value("terraform")
                .build())
            .preserveHost(false)
            .protocols(            
                "http",
                "https")
            .routeName("terraform-route")
            .serviceId(cngwService.serviceId())
            .stripPath(true)
            .build());

        var cngwRouteRateLimit = new TseCngwRouteRateLimit("cngwRouteRateLimit", TseCngwRouteRateLimitArgs.builder()
            .gatewayId(cngwGateway.tseCngwGatewayId())
            .routeId(cngwRoute.routeId())
            .limitDetail(TseCngwRouteRateLimitLimitDetailArgs.builder()
                .enabled(true)
                .header("req")
                .hideClientHeaders(true)
                .isDelay(true)
                .limitBy("header")
                .lineUpTime(10)
                .policy("redis")
                .responseType("default")
                .qpsThresholds(TseCngwRouteRateLimitLimitDetailQpsThresholdArgs.builder()
                    .max(10)
                    .unit("minute")
                    .build())
                .build())
            .build());

    }
}

configuration:
  availabilityZone:
    type: string
    default: ap-guangzhou-4
resources:
  vpc:
    type: tencentcloud:Vpc
    properties:
      cidrBlock: 10.0.0.0/16
  subnet:
    type: tencentcloud:Subnet
    properties:
      vpcId: ${vpc.vpcId}
      availabilityZone: ${availabilityZone}
      cidrBlock: 10.0.1.0/24
  cngwGateway:
    type: tencentcloud:TseCngwGateway
    properties:
      description: terraform test1
      enableCls: true
      engineRegion: ap-guangzhou
      featureVersion: STANDARD
      gatewayVersion: 2.5.1
      ingressClassName: tse-nginx-ingress
      internetMaxBandwidthOut: 0
      tradeType: 0
      type: kong
      nodeConfig:
        number: 2
        specification: 1c2g
      vpcConfig:
        subnetId: ${subnet.subnetId}
        vpcId: ${vpc.vpcId}
      tags:
        createdBy: terraform
  cngwService:
    type: tencentcloud:TseCngwService
    properties:
      gatewayId: ${cngwGateway.tseCngwGatewayId}
      path: /test
      protocol: http
      retries: 5
      timeout: 60000
      upstreamType: HostIP
      upstreamInfo:
        algorithm: round-robin
        autoScalingCvmPort: 0
        host: arunma.cn
        port: 8012
        slowStart: 0
  cngwRoute:
    type: tencentcloud:TseCngwRoute
    properties:
      destinationPorts: []
      forceHttps: false
      gatewayId: ${cngwGateway.tseCngwGatewayId}
      hosts:
        - 192.168.0.1:9090
      httpsRedirectStatusCode: 426
      paths:
        - /user
      headers:
        - key: req
          value: terraform
      preserveHost: false
      protocols:
        - http
        - https
      routeName: terraform-route
      serviceId: ${cngwService.serviceId}
      stripPath: true
  cngwRouteRateLimit:
    type: tencentcloud:TseCngwRouteRateLimit
    properties:
      gatewayId: ${cngwGateway.tseCngwGatewayId}
      routeId: ${cngwRoute.routeId}
      limitDetail:
        enabled: true
        header: req
        hideClientHeaders: true
        isDelay: true
        limitBy: header
        lineUpTime: 10
        policy: redis
        responseType: default
        qpsThresholds:
          - max: 10
            unit: minute