pulumi-aws-kotlin/com.pulumi.aws.rds.kotlin/Proxy

Proxy

class Proxy : KotlinCustomResource

Provides an RDS DB proxy resource. For additional information, see the RDS User Guide.

Example Usage

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const example = new aws.rds.Proxy("example", {
    name: "example",
    debugLogging: false,
    engineFamily: "MYSQL",
    idleClientTimeout: 1800,
    requireTls: true,
    roleArn: exampleAwsIamRole.arn,
    vpcSecurityGroupIds: [exampleAwsSecurityGroup&#46;id],
    vpcSubnetIds: [exampleAwsSubnet&#46;id],
    auths: [{
        authScheme: "SECRETS",
        description: "example",
        iamAuth: "DISABLED",
        secretArn: exampleAwsSecretsmanagerSecret.arn,
    }],
    tags: {
        Name: "example",
        Key: "value",
    },
});

import pulumi
import pulumi_aws as aws
example = aws.rds.Proxy("example",
    name="example",
    debug_logging=False,
    engine_family="MYSQL",
    idle_client_timeout=1800,
    require_tls=True,
    role_arn=example_aws_iam_role["arn"],
    vpc_security_group_ids=[example_aws_security_group["id"]],
    vpc_subnet_ids=[example_aws_subnet["id"]],
    auths=[aws.rds.ProxyAuthArgs(
        auth_scheme="SECRETS",
        description="example",
        iam_auth="DISABLED",
        secret_arn=example_aws_secretsmanager_secret["arn"],
    )],
    tags={
        "Name": "example",
        "Key": "value",
    })

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
    var example = new Aws.Rds.Proxy("example", new()
    {
        Name = "example",
        DebugLogging = false,
        EngineFamily = "MYSQL",
        IdleClientTimeout = 1800,
        RequireTls = true,
        RoleArn = exampleAwsIamRole.Arn,
        VpcSecurityGroupIds = new[]
        {
            exampleAwsSecurityGroup.Id,
        },
        VpcSubnetIds = new[]
        {
            exampleAwsSubnet.Id,
        },
        Auths = new[]
        {
            new Aws.Rds.Inputs.ProxyAuthArgs
            {
                AuthScheme = "SECRETS",
                Description = "example",
                IamAuth = "DISABLED",
                SecretArn = exampleAwsSecretsmanagerSecret.Arn,
            },
        },
        Tags =
        {
            { "Name", "example" },
            { "Key", "value" },
        },
    });
});

package main
import (
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/rds"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := rds.NewProxy(ctx, "example", &rds.ProxyArgs{
			Name:              pulumi.String("example"),
			DebugLogging:      pulumi.Bool(false),
			EngineFamily:      pulumi.String("MYSQL"),
			IdleClientTimeout: pulumi.Int(1800),
			RequireTls:        pulumi.Bool(true),
			RoleArn:           pulumi.Any(exampleAwsIamRole.Arn),
			VpcSecurityGroupIds: pulumi.StringArray{
				exampleAwsSecurityGroup.Id,
			},
			VpcSubnetIds: pulumi.StringArray{
				exampleAwsSubnet.Id,
			},
			Auths: rds.ProxyAuthArray{
				&rds.ProxyAuthArgs{
					AuthScheme:  pulumi.String("SECRETS"),
					Description: pulumi.String("example"),
					IamAuth:     pulumi.String("DISABLED"),
					SecretArn:   pulumi.Any(exampleAwsSecretsmanagerSecret.Arn),
				},
			},
			Tags: pulumi.StringMap{
				"Name": pulumi.String("example"),
				"Key":  pulumi.String("value"),
			},
		})
		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.aws.rds.Proxy;
import com.pulumi.aws.rds.ProxyArgs;
import com.pulumi.aws.rds.inputs.ProxyAuthArgs;
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 example = new Proxy("example", ProxyArgs.builder()
            .name("example")
            .debugLogging(false)
            .engineFamily("MYSQL")
            .idleClientTimeout(1800)
            .requireTls(true)
            .roleArn(exampleAwsIamRole.arn())
            .vpcSecurityGroupIds(exampleAwsSecurityGroup.id())
            .vpcSubnetIds(exampleAwsSubnet.id())
            .auths(ProxyAuthArgs.builder()
                .authScheme("SECRETS")
                .description("example")
                .iamAuth("DISABLED")
                .secretArn(exampleAwsSecretsmanagerSecret.arn())
                .build())
            .tags(Map.ofEntries(
                Map.entry("Name", "example"),
                Map.entry("Key", "value")
            ))
            .build());
    }
}

resources:
  example:
    type: aws:rds:Proxy
    properties:
      name: example
      debugLogging: false
      engineFamily: MYSQL
      idleClientTimeout: 1800
      requireTls: true
      roleArn: ${exampleAwsIamRole.arn}
      vpcSecurityGroupIds:
        - ${exampleAwsSecurityGroup.id}
      vpcSubnetIds:
        - ${exampleAwsSubnet.id}
      auths:
        - authScheme: SECRETS
          description: example
          iamAuth: DISABLED
          secretArn: ${exampleAwsSecretsmanagerSecret.arn}
      tags:
        Name: example
        Key: value

Import

Using pulumi import, import DB proxies using the name. For example:

$ pulumi import aws:rds/proxy:Proxy example example

Properties

arn

val arn: Output<String>

The Amazon Resource Name (ARN) for the proxy.

auths

val auths: Output<List<ProxyAuth>>

Configuration block(s) with authorization mechanisms to connect to the associated instances or clusters. Described below.

debugLogging

val debugLogging: Output<Boolean>?

Whether the proxy includes detailed information about SQL statements in its logs. This information helps you to debug issues involving SQL behavior or the performance and scalability of the proxy connections. The debug information includes the text of SQL statements that you submit through the proxy. Thus, only enable this setting when needed for debugging, and only when you have security measures in place to safeguard any sensitive information that appears in the logs.

endpoint

val endpoint: Output<String>

The endpoint that you can use to connect to the proxy. You include the endpoint value in the connection string for a database client application.

engineFamily

val engineFamily: Output<String>

The kinds of databases that the proxy can connect to. This value determines which database network protocol the proxy recognizes when it interprets network traffic to and from the database. For Aurora MySQL, RDS for MariaDB, and RDS for MySQL databases, specify MYSQL. For Aurora PostgreSQL and RDS for PostgreSQL databases, specify POSTGRESQL. For RDS for Microsoft SQL Server, specify SQLSERVER. Valid values are MYSQL, POSTGRESQL, and SQLSERVER.

val id: Output<String>

idleClientTimeout

val idleClientTimeout: Output<Int>

The number of seconds that a connection to the proxy can be inactive before the proxy disconnects it. You can set this value higher or lower than the connection timeout limit for the associated database.

name

val name: Output<String>

The identifier for the proxy. This name must be unique for all proxies owned by your AWS account in the specified AWS Region. An identifier must begin with a letter and must contain only ASCII letters, digits, and hyphens; it can't end with a hyphen or contain two consecutive hyphens.

pulumiChildResources

val pulumiChildResources: Set<KotlinResource>

pulumiResourceName

val pulumiResourceName: String

pulumiResourceType

val pulumiResourceType: String

requireTls

val requireTls: Output<Boolean>?

A Boolean parameter that specifies whether Transport Layer Security (TLS) encryption is required for connections to the proxy. By enabling this setting, you can enforce encrypted TLS connections to the proxy.

roleArn

val roleArn: Output<String>

The Amazon Resource Name (ARN) of the IAM role that the proxy uses to access secrets in AWS Secrets Manager.