aiven.AzurePrivatelinkConnectionApproval

import * as pulumi from "@pulumi/pulumi";
import * as aiven from "@pulumi/aiven";
import * as azurerm from "@pulumi/azurerm";

const staticIps: aiven.StaticIp[] = [];
for (const range = {value: 0}; range.value < 2; range.value++) {
    staticIps.push(new aiven.StaticIp(`static_ips-${range.value}`, {
        project: projectId,
        cloudName: region,
    }));
}
const _default = new aiven.Pg("default", {
    serviceName: "postgres",
    project: aivenProjectId,
    projectVpcId: aivenProjectVpcId,
    cloudName: region,
    plan: plan,
    staticIps: staticIps.map(sip => (sip.staticIpAddressId)),
    pgUserConfig: {
        pgVersion: "13",
        staticIps: true,
        privatelinkAccess: {
            pg: true,
            pgbouncer: true,
        },
    },
});
const privatelink = new aiven.AzurePrivatelink("privatelink", {
    project: aivenProjectId,
    serviceName: _default.name,
    userSubscriptionIds: [azureSubscriptionId],
});
const endpoint = new azurerm.index.PrivateEndpoint("endpoint", {
    name: "postgres-endpoint",
    location: region,
    resourceGroupName: azureResourceGroup.name,
    subnetId: azureSubnetId,
    privateServiceConnection: [{
        name: _default.name,
        privateConnectionResourceId: privatelink.azureServiceId,
        isManualConnection: true,
        requestMessage: _default.name,
    }],
}, {
    dependsOn: [privatelink],
});
const approval = new aiven.AzurePrivatelinkConnectionApproval("approval", {
    project: aivenProjectId,
    serviceName: _default.serviceName,
    endpointIpAddress: endpoint.privateServiceConnection[0].privateIpAddress,
});

import pulumi
import pulumi_aiven as aiven
import pulumi_azurerm as azurerm

static_ips = []
for range in [{"value": i} for i in range(0, 2)]:
    static_ips.append(aiven.StaticIp(f"static_ips-{range['value']}",
        project=project_id,
        cloud_name=region))
default = aiven.Pg("default",
    service_name="postgres",
    project=aiven_project_id,
    project_vpc_id=aiven_project_vpc_id,
    cloud_name=region,
    plan=plan,
    static_ips=[sip.static_ip_address_id for sip in static_ips],
    pg_user_config=aiven.PgPgUserConfigArgs(
        pg_version="13",
        static_ips=True,
        privatelink_access=aiven.PgPgUserConfigPrivatelinkAccessArgs(
            pg=True,
            pgbouncer=True,
        ),
    ))
privatelink = aiven.AzurePrivatelink("privatelink",
    project=aiven_project_id,
    service_name=default.name,
    user_subscription_ids=[azure_subscription_id])
endpoint = azurerm.index.PrivateEndpoint("endpoint",
    name=postgres-endpoint,
    location=region,
    resource_group_name=azure_resource_group.name,
    subnet_id=azure_subnet_id,
    private_service_connection=[{
        name: default.name,
        privateConnectionResourceId: privatelink.azure_service_id,
        isManualConnection: True,
        requestMessage: default.name,
    }],
    opts=pulumi.ResourceOptions(depends_on=[privatelink]))
approval = aiven.AzurePrivatelinkConnectionApproval("approval",
    project=aiven_project_id,
    service_name=default.service_name,
    endpoint_ip_address=endpoint["privateServiceConnection"][0]["privateIpAddress"])

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aiven = Pulumi.Aiven;
using Azurerm = Pulumi.Azurerm;

return await Deployment.RunAsync(() => 
{
    var staticIps = new List<Aiven.StaticIp>();
    for (var rangeIndex = 0; rangeIndex < 2; rangeIndex++)
    {
        var range = new { Value = rangeIndex };
        staticIps.Add(new Aiven.StaticIp($"static_ips-{range.Value}", new()
        {
            Project = projectId,
            CloudName = region,
        }));
    }
    var @default = new Aiven.Pg("default", new()
    {
        ServiceName = "postgres",
        Project = aivenProjectId,
        ProjectVpcId = aivenProjectVpcId,
        CloudName = region,
        Plan = plan,
        StaticIps = staticIps.Select(sip => 
        {
            return sip.StaticIpAddressId;
        }).ToList(),
        PgUserConfig = new Aiven.Inputs.PgPgUserConfigArgs
        {
            PgVersion = "13",
            StaticIps = true,
            PrivatelinkAccess = new Aiven.Inputs.PgPgUserConfigPrivatelinkAccessArgs
            {
                Pg = true,
                Pgbouncer = true,
            },
        },
    });

    var privatelink = new Aiven.AzurePrivatelink("privatelink", new()
    {
        Project = aivenProjectId,
        ServiceName = @default.Name,
        UserSubscriptionIds = new[]
        {
            azureSubscriptionId,
        },
    });

    var endpoint = new Azurerm.Index.PrivateEndpoint("endpoint", new()
    {
        Name = "postgres-endpoint",
        Location = region,
        ResourceGroupName = azureResourceGroup.Name,
        SubnetId = azureSubnetId,
        PrivateServiceConnection = new[]
        {
            
            {
                { "name", @default.Name },
                { "privateConnectionResourceId", privatelink.AzureServiceId },
                { "isManualConnection", true },
                { "requestMessage", @default.Name },
            },
        },
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            privatelink,
        },
    });

    var approval = new Aiven.AzurePrivatelinkConnectionApproval("approval", new()
    {
        Project = aivenProjectId,
        ServiceName = @default.ServiceName,
        EndpointIpAddress = endpoint.PrivateServiceConnection[0].PrivateIpAddress,
    });

});

var azurePrivatelinkConnectionApprovalResource = new Aiven.AzurePrivatelinkConnectionApproval("azurePrivatelinkConnectionApprovalResource", new()
{
    Project = "string",
    ServiceName = "string",
    EndpointIpAddress = "string",
});

example, err := aiven.NewAzurePrivatelinkConnectionApproval(ctx, "azurePrivatelinkConnectionApprovalResource", &aiven.AzurePrivatelinkConnectionApprovalArgs{
	Project:           pulumi.String("string"),
	ServiceName:       pulumi.String("string"),
	EndpointIpAddress: pulumi.String("string"),
})

var azurePrivatelinkConnectionApprovalResource = new AzurePrivatelinkConnectionApproval("azurePrivatelinkConnectionApprovalResource", AzurePrivatelinkConnectionApprovalArgs.builder()
    .project("string")
    .serviceName("string")
    .endpointIpAddress("string")
    .build());

azure_privatelink_connection_approval_resource = aiven.AzurePrivatelinkConnectionApproval("azurePrivatelinkConnectionApprovalResource",
    project="string",
    service_name="string",
    endpoint_ip_address="string")

const azurePrivatelinkConnectionApprovalResource = new aiven.AzurePrivatelinkConnectionApproval("azurePrivatelinkConnectionApprovalResource", {
    project: "string",
    serviceName: "string",
    endpointIpAddress: "string",
});

type: aiven:AzurePrivatelinkConnectionApproval
properties:
    endpointIpAddress: string
    project: string
    serviceName: string