All Downloads are FREE. Search and download functionalities are using the official Maven repository.

com.pulumi.azurenative.network.kotlin.inputs.InboundNatRuleArgs.kt Maven / Gradle / Ivy

Go to download

Build cloud applications and infrastructure by combining the safety and reliability of infrastructure as code with the power of the Kotlin programming language.

There is a newer version: 2.82.0.0
Show newest version
@file:Suppress("NAME_SHADOWING", "DEPRECATION")

package com.pulumi.azurenative.network.kotlin.inputs

import com.pulumi.azurenative.network.inputs.InboundNatRuleArgs.builder
import com.pulumi.azurenative.network.kotlin.enums.TransportProtocol
import com.pulumi.core.Either
import com.pulumi.core.Output
import com.pulumi.core.Output.of
import com.pulumi.kotlin.ConvertibleToJava
import com.pulumi.kotlin.PulumiTagMarker
import com.pulumi.kotlin.applySuspend
import kotlin.Boolean
import kotlin.Int
import kotlin.String
import kotlin.Suppress
import kotlin.Unit
import kotlin.jvm.JvmName

/**
 * Inbound NAT rule of the load balancer.
 * @property backendAddressPool A reference to backendAddressPool resource.
 * @property backendPort The port used for the internal endpoint. Acceptable values range from 1 to 65535.
 * @property enableFloatingIP Configures a virtual machine's endpoint for the floating IP capability required to configure a SQL AlwaysOn Availability Group. This setting is required when using the SQL AlwaysOn Availability Groups in SQL server. This setting can't be changed after you create the endpoint.
 * @property enableTcpReset Receive bidirectional TCP Reset on TCP flow idle timeout or unexpected connection termination. This element is only used when the protocol is set to TCP.
 * @property frontendIPConfiguration A reference to frontend IP addresses.
 * @property frontendPort The port for the external endpoint. Port numbers for each rule must be unique within the Load Balancer. Acceptable values range from 1 to 65534.
 * @property frontendPortRangeEnd The port range end for the external endpoint. This property is used together with BackendAddressPool and FrontendPortRangeStart. Individual inbound NAT rule port mappings will be created for each backend address from BackendAddressPool. Acceptable values range from 1 to 65534.
 * @property frontendPortRangeStart The port range start for the external endpoint. This property is used together with BackendAddressPool and FrontendPortRangeEnd. Individual inbound NAT rule port mappings will be created for each backend address from BackendAddressPool. Acceptable values range from 1 to 65534.
 * @property id Resource ID.
 * @property idleTimeoutInMinutes The timeout for the TCP idle connection. The value can be set between 4 and 30 minutes. The default value is 4 minutes. This element is only used when the protocol is set to TCP.
 * @property name The name of the resource that is unique within the set of inbound NAT rules used by the load balancer. This name can be used to access the resource.
 * @property protocol The reference to the transport protocol used by the load balancing rule.
 */
public data class InboundNatRuleArgs(
    public val backendAddressPool: Output? = null,
    public val backendPort: Output? = null,
    public val enableFloatingIP: Output? = null,
    public val enableTcpReset: Output? = null,
    public val frontendIPConfiguration: Output? = null,
    public val frontendPort: Output? = null,
    public val frontendPortRangeEnd: Output? = null,
    public val frontendPortRangeStart: Output? = null,
    public val id: Output? = null,
    public val idleTimeoutInMinutes: Output? = null,
    public val name: Output? = null,
    public val protocol: Output>? = null,
) : ConvertibleToJava {
    override fun toJava(): com.pulumi.azurenative.network.inputs.InboundNatRuleArgs =
        com.pulumi.azurenative.network.inputs.InboundNatRuleArgs.builder()
            .backendAddressPool(
                backendAddressPool?.applyValue({ args0 ->
                    args0.let({ args0 ->
                        args0.toJava()
                    })
                }),
            )
            .backendPort(backendPort?.applyValue({ args0 -> args0 }))
            .enableFloatingIP(enableFloatingIP?.applyValue({ args0 -> args0 }))
            .enableTcpReset(enableTcpReset?.applyValue({ args0 -> args0 }))
            .frontendIPConfiguration(
                frontendIPConfiguration?.applyValue({ args0 ->
                    args0.let({ args0 ->
                        args0.toJava()
                    })
                }),
            )
            .frontendPort(frontendPort?.applyValue({ args0 -> args0 }))
            .frontendPortRangeEnd(frontendPortRangeEnd?.applyValue({ args0 -> args0 }))
            .frontendPortRangeStart(frontendPortRangeStart?.applyValue({ args0 -> args0 }))
            .id(id?.applyValue({ args0 -> args0 }))
            .idleTimeoutInMinutes(idleTimeoutInMinutes?.applyValue({ args0 -> args0 }))
            .name(name?.applyValue({ args0 -> args0 }))
            .protocol(
                protocol?.applyValue({ args0 ->
                    args0.transform({ args0 -> args0 }, { args0 ->
                        args0.let({ args0 -> args0.toJava() })
                    })
                }),
            ).build()
}

/**
 * Builder for [InboundNatRuleArgs].
 */
@PulumiTagMarker
public class InboundNatRuleArgsBuilder internal constructor() {
    private var backendAddressPool: Output? = null

    private var backendPort: Output? = null

    private var enableFloatingIP: Output? = null

    private var enableTcpReset: Output? = null

    private var frontendIPConfiguration: Output? = null

    private var frontendPort: Output? = null

    private var frontendPortRangeEnd: Output? = null

    private var frontendPortRangeStart: Output? = null

    private var id: Output? = null

    private var idleTimeoutInMinutes: Output? = null

    private var name: Output? = null

    private var protocol: Output>? = null

    /**
     * @param value A reference to backendAddressPool resource.
     */
    @JvmName("gryungwnixyqtdnd")
    public suspend fun backendAddressPool(`value`: Output) {
        this.backendAddressPool = value
    }

    /**
     * @param value The port used for the internal endpoint. Acceptable values range from 1 to 65535.
     */
    @JvmName("uaeqxtpiaxgynqsk")
    public suspend fun backendPort(`value`: Output) {
        this.backendPort = value
    }

    /**
     * @param value Configures a virtual machine's endpoint for the floating IP capability required to configure a SQL AlwaysOn Availability Group. This setting is required when using the SQL AlwaysOn Availability Groups in SQL server. This setting can't be changed after you create the endpoint.
     */
    @JvmName("rxoflkcojlakxnav")
    public suspend fun enableFloatingIP(`value`: Output) {
        this.enableFloatingIP = value
    }

    /**
     * @param value Receive bidirectional TCP Reset on TCP flow idle timeout or unexpected connection termination. This element is only used when the protocol is set to TCP.
     */
    @JvmName("tlautsfyafeshjlg")
    public suspend fun enableTcpReset(`value`: Output) {
        this.enableTcpReset = value
    }

    /**
     * @param value A reference to frontend IP addresses.
     */
    @JvmName("qudrtybgsfvsypkg")
    public suspend fun frontendIPConfiguration(`value`: Output) {
        this.frontendIPConfiguration = value
    }

    /**
     * @param value The port for the external endpoint. Port numbers for each rule must be unique within the Load Balancer. Acceptable values range from 1 to 65534.
     */
    @JvmName("rmifmtybcfnowikd")
    public suspend fun frontendPort(`value`: Output) {
        this.frontendPort = value
    }

    /**
     * @param value The port range end for the external endpoint. This property is used together with BackendAddressPool and FrontendPortRangeStart. Individual inbound NAT rule port mappings will be created for each backend address from BackendAddressPool. Acceptable values range from 1 to 65534.
     */
    @JvmName("awdyiojxohdntqbl")
    public suspend fun frontendPortRangeEnd(`value`: Output) {
        this.frontendPortRangeEnd = value
    }

    /**
     * @param value The port range start for the external endpoint. This property is used together with BackendAddressPool and FrontendPortRangeEnd. Individual inbound NAT rule port mappings will be created for each backend address from BackendAddressPool. Acceptable values range from 1 to 65534.
     */
    @JvmName("xjuumplsqopvfaie")
    public suspend fun frontendPortRangeStart(`value`: Output) {
        this.frontendPortRangeStart = value
    }

    /**
     * @param value Resource ID.
     */
    @JvmName("wleauheprqsqmtod")
    public suspend fun id(`value`: Output) {
        this.id = value
    }

    /**
     * @param value The timeout for the TCP idle connection. The value can be set between 4 and 30 minutes. The default value is 4 minutes. This element is only used when the protocol is set to TCP.
     */
    @JvmName("cyvljbcqpojisxxt")
    public suspend fun idleTimeoutInMinutes(`value`: Output) {
        this.idleTimeoutInMinutes = value
    }

    /**
     * @param value The name of the resource that is unique within the set of inbound NAT rules used by the load balancer. This name can be used to access the resource.
     */
    @JvmName("wvhhjhsattccbnng")
    public suspend fun name(`value`: Output) {
        this.name = value
    }

    /**
     * @param value The reference to the transport protocol used by the load balancing rule.
     */
    @JvmName("atnjijvbkdpsviut")
    public suspend fun protocol(`value`: Output>) {
        this.protocol = value
    }

    /**
     * @param value A reference to backendAddressPool resource.
     */
    @JvmName("utcwaiqsaekdkckm")
    public suspend fun backendAddressPool(`value`: SubResourceArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.backendAddressPool = mapped
    }

    /**
     * @param argument A reference to backendAddressPool resource.
     */
    @JvmName("uqeypwxwpsebrpxg")
    public suspend fun backendAddressPool(argument: suspend SubResourceArgsBuilder.() -> Unit) {
        val toBeMapped = SubResourceArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.backendAddressPool = mapped
    }

    /**
     * @param value The port used for the internal endpoint. Acceptable values range from 1 to 65535.
     */
    @JvmName("hrkfoywmhxnsryvr")
    public suspend fun backendPort(`value`: Int?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.backendPort = mapped
    }

    /**
     * @param value Configures a virtual machine's endpoint for the floating IP capability required to configure a SQL AlwaysOn Availability Group. This setting is required when using the SQL AlwaysOn Availability Groups in SQL server. This setting can't be changed after you create the endpoint.
     */
    @JvmName("arjxviqiwcwudnxs")
    public suspend fun enableFloatingIP(`value`: Boolean?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.enableFloatingIP = mapped
    }

    /**
     * @param value Receive bidirectional TCP Reset on TCP flow idle timeout or unexpected connection termination. This element is only used when the protocol is set to TCP.
     */
    @JvmName("fawwclkdjgkkydho")
    public suspend fun enableTcpReset(`value`: Boolean?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.enableTcpReset = mapped
    }

    /**
     * @param value A reference to frontend IP addresses.
     */
    @JvmName("kahyebnvhgqrdbvi")
    public suspend fun frontendIPConfiguration(`value`: SubResourceArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.frontendIPConfiguration = mapped
    }

    /**
     * @param argument A reference to frontend IP addresses.
     */
    @JvmName("wivpjpepnjfsacyr")
    public suspend fun frontendIPConfiguration(argument: suspend SubResourceArgsBuilder.() -> Unit) {
        val toBeMapped = SubResourceArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.frontendIPConfiguration = mapped
    }

    /**
     * @param value The port for the external endpoint. Port numbers for each rule must be unique within the Load Balancer. Acceptable values range from 1 to 65534.
     */
    @JvmName("fcjfpdulsjqisxpm")
    public suspend fun frontendPort(`value`: Int?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.frontendPort = mapped
    }

    /**
     * @param value The port range end for the external endpoint. This property is used together with BackendAddressPool and FrontendPortRangeStart. Individual inbound NAT rule port mappings will be created for each backend address from BackendAddressPool. Acceptable values range from 1 to 65534.
     */
    @JvmName("slfriasjsmggspqy")
    public suspend fun frontendPortRangeEnd(`value`: Int?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.frontendPortRangeEnd = mapped
    }

    /**
     * @param value The port range start for the external endpoint. This property is used together with BackendAddressPool and FrontendPortRangeEnd. Individual inbound NAT rule port mappings will be created for each backend address from BackendAddressPool. Acceptable values range from 1 to 65534.
     */
    @JvmName("stuatcopbibnmmwg")
    public suspend fun frontendPortRangeStart(`value`: Int?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.frontendPortRangeStart = mapped
    }

    /**
     * @param value Resource ID.
     */
    @JvmName("lrborrdipvxfvttf")
    public suspend fun id(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.id = mapped
    }

    /**
     * @param value The timeout for the TCP idle connection. The value can be set between 4 and 30 minutes. The default value is 4 minutes. This element is only used when the protocol is set to TCP.
     */
    @JvmName("vhahvlrqkpmbgboo")
    public suspend fun idleTimeoutInMinutes(`value`: Int?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.idleTimeoutInMinutes = mapped
    }

    /**
     * @param value The name of the resource that is unique within the set of inbound NAT rules used by the load balancer. This name can be used to access the resource.
     */
    @JvmName("fyywvvlytithuphn")
    public suspend fun name(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.name = mapped
    }

    /**
     * @param value The reference to the transport protocol used by the load balancing rule.
     */
    @JvmName("tlnlqjemavakbeje")
    public suspend fun protocol(`value`: Either?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.protocol = mapped
    }

    /**
     * @param value The reference to the transport protocol used by the load balancing rule.
     */
    @JvmName("aaslsbnthlxpsarm")
    public fun protocol(`value`: String) {
        val toBeMapped = Either.ofLeft(value)
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.protocol = mapped
    }

    /**
     * @param value The reference to the transport protocol used by the load balancing rule.
     */
    @JvmName("ddauosqbdynggwng")
    public fun protocol(`value`: TransportProtocol) {
        val toBeMapped = Either.ofRight(value)
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.protocol = mapped
    }

    internal fun build(): InboundNatRuleArgs = InboundNatRuleArgs(
        backendAddressPool = backendAddressPool,
        backendPort = backendPort,
        enableFloatingIP = enableFloatingIP,
        enableTcpReset = enableTcpReset,
        frontendIPConfiguration = frontendIPConfiguration,
        frontendPort = frontendPort,
        frontendPortRangeEnd = frontendPortRangeEnd,
        frontendPortRangeStart = frontendPortRangeStart,
        id = id,
        idleTimeoutInMinutes = idleTimeoutInMinutes,
        name = name,
        protocol = protocol,
    )
}




© 2015 - 2025 Weber Informatics LLC | Privacy Policy