snowflake.getSystemGetPrivateLinkConfig

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
import * as snowflake from "@pulumi/snowflake";

const snowflakePrivateLink = snowflake.getSystemGetPrivateLinkConfig({});
const snowflakePrivateLinkSecurityGroup = new aws.index.SecurityGroup("snowflake_private_link", {
    vpcId: vpcId,
    ingress: [
        {
            fromPort: 80,
            toPort: 80,
            cidrBlocks: vpcCidr,
            protocol: "tcp",
        },
        {
            fromPort: 443,
            toPort: 443,
            cidrBlocks: vpcCidr,
            protocol: "tcp",
        },
    ],
});
const snowflakePrivateLinkVpcEndpoint = new aws.index.VpcEndpoint("snowflake_private_link", {
    vpcId: vpcId,
    serviceName: snowflakePrivateLink.awsVpceId,
    vpcEndpointType: "Interface",
    securityGroupIds: [snowflakePrivateLinkSecurityGroup.id],
    subnetIds: subnetIds,
    privateDnsEnabled: false,
});
const snowflakePrivateLinkRoute53Zone = new aws.index.Route53Zone("snowflake_private_link", {
    name: "privatelink.snowflakecomputing.com",
    vpc: [{
        vpcId: vpcId,
    }],
});
const snowflakePrivateLinkUrl = new aws.index.Route53Record("snowflake_private_link_url", {
    zoneId: snowflakePrivateLinkRoute53Zone.zoneId,
    name: snowflakePrivateLink.accountUrl,
    type: "CNAME",
    ttl: "300",
    records: [snowflakePrivateLinkVpcEndpoint.dnsEntry[0].dns_name],
});
const snowflakePrivateLinkOcspUrl = new aws.index.Route53Record("snowflake_private_link_ocsp_url", {
    zoneId: snowflakePrivateLinkRoute53Zone.zoneId,
    name: snowflakePrivateLink.ocspUrl,
    type: "CNAME",
    ttl: "300",
    records: [snowflakePrivateLinkVpcEndpoint.dnsEntry[0].dns_name],
});

import pulumi
import pulumi_aws as aws
import pulumi_snowflake as snowflake

snowflake_private_link = snowflake.get_system_get_private_link_config()
snowflake_private_link_security_group = aws.SecurityGroup("snowflake_private_link",
    vpc_id=vpc_id,
    ingress=[
        {
            fromPort: 80,
            toPort: 80,
            cidrBlocks: vpc_cidr,
            protocol: tcp,
        },
        {
            fromPort: 443,
            toPort: 443,
            cidrBlocks: vpc_cidr,
            protocol: tcp,
        },
    ])
snowflake_private_link_vpc_endpoint = aws.VpcEndpoint("snowflake_private_link",
    vpc_id=vpc_id,
    service_name=snowflake_private_link.aws_vpce_id,
    vpc_endpoint_type=Interface,
    security_group_ids=[snowflake_private_link_security_group.id],
    subnet_ids=subnet_ids,
    private_dns_enabled=False)
snowflake_private_link_route53_zone = aws.Route53Zone("snowflake_private_link",
    name=privatelink.snowflakecomputing.com,
    vpc=[{
        vpcId: vpc_id,
    }])
snowflake_private_link_url = aws.Route53Record("snowflake_private_link_url",
    zone_id=snowflake_private_link_route53_zone.zone_id,
    name=snowflake_private_link.account_url,
    type=CNAME,
    ttl=300,
    records=[snowflake_private_link_vpc_endpoint.dns_entry[0].dns_name])
snowflake_private_link_ocsp_url = aws.Route53Record("snowflake_private_link_ocsp_url",
    zone_id=snowflake_private_link_route53_zone.zone_id,
    name=snowflake_private_link.ocsp_url,
    type=CNAME,
    ttl=300,
    records=[snowflake_private_link_vpc_endpoint.dns_entry[0].dns_name])

package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws"
	"github.com/pulumi/pulumi-snowflake/sdk/v2/go/snowflake"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		snowflakePrivateLink, err := snowflake.GetSystemGetPrivateLinkConfig(ctx, map[string]interface{}{}, nil)
		if err != nil {
			return err
		}
		snowflakePrivateLinkSecurityGroup, err := aws.NewSecurityGroup(ctx, "snowflake_private_link", &aws.SecurityGroupArgs{
			VpcId: vpcId,
			Ingress: []interface{}{
				map[string]interface{}{
					"fromPort":   80,
					"toPort":     80,
					"cidrBlocks": vpcCidr,
					"protocol":   "tcp",
				},
				map[string]interface{}{
					"fromPort":   443,
					"toPort":     443,
					"cidrBlocks": vpcCidr,
					"protocol":   "tcp",
				},
			},
		})
		if err != nil {
			return err
		}
		snowflakePrivateLinkVpcEndpoint, err := aws.NewVpcEndpoint(ctx, "snowflake_private_link", &aws.VpcEndpointArgs{
			VpcId:           vpcId,
			ServiceName:     snowflakePrivateLink.AwsVpceId,
			VpcEndpointType: "Interface",
			SecurityGroupIds: []interface{}{
				snowflakePrivateLinkSecurityGroup.Id,
			},
			SubnetIds:         subnetIds,
			PrivateDnsEnabled: false,
		})
		if err != nil {
			return err
		}
		snowflakePrivateLinkRoute53Zone, err := aws.NewRoute53Zone(ctx, "snowflake_private_link", &aws.Route53ZoneArgs{
			Name: "privatelink.snowflakecomputing.com",
			Vpc: []map[string]interface{}{
				map[string]interface{}{
					"vpcId": vpcId,
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = aws.NewRoute53Record(ctx, "snowflake_private_link_url", &aws.Route53RecordArgs{
			ZoneId: snowflakePrivateLinkRoute53Zone.ZoneId,
			Name:   snowflakePrivateLink.AccountUrl,
			Type:   "CNAME",
			Ttl:    "300",
			Records: []interface{}{
				snowflakePrivateLinkVpcEndpoint.DnsEntry[0].Dns_name,
			},
		})
		if err != nil {
			return err
		}
		_, err = aws.NewRoute53Record(ctx, "snowflake_private_link_ocsp_url", &aws.Route53RecordArgs{
			ZoneId: snowflakePrivateLinkRoute53Zone.ZoneId,
			Name:   snowflakePrivateLink.OcspUrl,
			Type:   "CNAME",
			Ttl:    "300",
			Records: []interface{}{
				snowflakePrivateLinkVpcEndpoint.DnsEntry[0].Dns_name,
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
using Snowflake = Pulumi.Snowflake;

return await Deployment.RunAsync(() => 
{
    var snowflakePrivateLink = Snowflake.GetSystemGetPrivateLinkConfig.Invoke();

    var snowflakePrivateLinkSecurityGroup = new Aws.SecurityGroup("snowflake_private_link", new()
    {
        VpcId = vpcId,
        Ingress = new[]
        {
            
            {
                { "fromPort", 80 },
                { "toPort", 80 },
                { "cidrBlocks", vpcCidr },
                { "protocol", "tcp" },
            },
            
            {
                { "fromPort", 443 },
                { "toPort", 443 },
                { "cidrBlocks", vpcCidr },
                { "protocol", "tcp" },
            },
        },
    });

    var snowflakePrivateLinkVpcEndpoint = new Aws.VpcEndpoint("snowflake_private_link", new()
    {
        VpcId = vpcId,
        ServiceName = snowflakePrivateLink.Apply(getSystemGetPrivateLinkConfigResult => getSystemGetPrivateLinkConfigResult.AwsVpceId),
        VpcEndpointType = "Interface",
        SecurityGroupIds = new[]
        {
            snowflakePrivateLinkSecurityGroup.Id,
        },
        SubnetIds = subnetIds,
        PrivateDnsEnabled = false,
    });

    var snowflakePrivateLinkRoute53Zone = new Aws.Route53Zone("snowflake_private_link", new()
    {
        Name = "privatelink.snowflakecomputing.com",
        Vpc = new[]
        {
            
            {
                { "vpcId", vpcId },
            },
        },
    });

    var snowflakePrivateLinkUrl = new Aws.Route53Record("snowflake_private_link_url", new()
    {
        ZoneId = snowflakePrivateLinkRoute53Zone.ZoneId,
        Name = snowflakePrivateLink.Apply(getSystemGetPrivateLinkConfigResult => getSystemGetPrivateLinkConfigResult.AccountUrl),
        Type = "CNAME",
        Ttl = "300",
        Records = new[]
        {
            snowflakePrivateLinkVpcEndpoint.DnsEntry[0].Dns_name,
        },
    });

    var snowflakePrivateLinkOcspUrl = new Aws.Route53Record("snowflake_private_link_ocsp_url", new()
    {
        ZoneId = snowflakePrivateLinkRoute53Zone.ZoneId,
        Name = snowflakePrivateLink.Apply(getSystemGetPrivateLinkConfigResult => getSystemGetPrivateLinkConfigResult.OcspUrl),
        Type = "CNAME",
        Ttl = "300",
        Records = new[]
        {
            snowflakePrivateLinkVpcEndpoint.DnsEntry[0].Dns_name,
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.snowflake.SnowflakeFunctions;
import com.pulumi.aws.SecurityGroup;
import com.pulumi.aws.SecurityGroupArgs;
import com.pulumi.aws.VpcEndpoint;
import com.pulumi.aws.VpcEndpointArgs;
import com.pulumi.aws.Route53Zone;
import com.pulumi.aws.Route53ZoneArgs;
import com.pulumi.aws.Route53Record;
import com.pulumi.aws.Route53RecordArgs;
import java.util.ArrayList;
import java.util.Arrays;
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 snowflakePrivateLink = SnowflakeFunctions.getSystemGetPrivateLinkConfig(%!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference);

        var snowflakePrivateLinkSecurityGroup = new SecurityGroup("snowflakePrivateLinkSecurityGroup", SecurityGroupArgs.builder()
            .vpcId(vpcId)
            .ingress(Arrays.asList(            
                Map.ofEntries(
                    Map.entry("fromPort", 80),
                    Map.entry("toPort", 80),
                    Map.entry("cidrBlocks", vpcCidr),
                    Map.entry("protocol", "tcp")
                ),
                Map.ofEntries(
                    Map.entry("fromPort", 443),
                    Map.entry("toPort", 443),
                    Map.entry("cidrBlocks", vpcCidr),
                    Map.entry("protocol", "tcp")
                )))
            .build());

        var snowflakePrivateLinkVpcEndpoint = new VpcEndpoint("snowflakePrivateLinkVpcEndpoint", VpcEndpointArgs.builder()
            .vpcId(vpcId)
            .serviceName(snowflakePrivateLink.awsVpceId())
            .vpcEndpointType("Interface")
            .securityGroupIds(Arrays.asList(snowflakePrivateLinkSecurityGroup.id()))
            .subnetIds(subnetIds)
            .privateDnsEnabled(false)
            .build());

        var snowflakePrivateLinkRoute53Zone = new Route53Zone("snowflakePrivateLinkRoute53Zone", Route53ZoneArgs.builder()
            .name("privatelink.snowflakecomputing.com")
            .vpc(Arrays.asList(Map.of("vpcId", vpcId)))
            .build());

        var snowflakePrivateLinkUrl = new Route53Record("snowflakePrivateLinkUrl", Route53RecordArgs.builder()
            .zoneId(snowflakePrivateLinkRoute53Zone.zoneId())
            .name(snowflakePrivateLink.accountUrl())
            .type("CNAME")
            .ttl("300")
            .records(Arrays.asList(snowflakePrivateLinkVpcEndpoint.dnsEntry()[0].dns_name()))
            .build());

        var snowflakePrivateLinkOcspUrl = new Route53Record("snowflakePrivateLinkOcspUrl", Route53RecordArgs.builder()
            .zoneId(snowflakePrivateLinkRoute53Zone.zoneId())
            .name(snowflakePrivateLink.ocspUrl())
            .type("CNAME")
            .ttl("300")
            .records(Arrays.asList(snowflakePrivateLinkVpcEndpoint.dnsEntry()[0].dns_name()))
            .build());

    }
}

resources:
  snowflakePrivateLinkSecurityGroup:
    type: aws:SecurityGroup
    name: snowflake_private_link
    properties:
      vpcId: ${vpcId}
      ingress:
        - fromPort: 80
          toPort: 80
          cidrBlocks: ${vpcCidr}
          protocol: tcp
        - fromPort: 443
          toPort: 443
          cidrBlocks: ${vpcCidr}
          protocol: tcp
  snowflakePrivateLinkVpcEndpoint:
    type: aws:VpcEndpoint
    name: snowflake_private_link
    properties:
      vpcId: ${vpcId}
      serviceName: ${snowflakePrivateLink.awsVpceId}
      vpcEndpointType: Interface
      securityGroupIds:
        - ${snowflakePrivateLinkSecurityGroup.id}
      subnetIds: ${subnetIds}
      privateDnsEnabled: false
  snowflakePrivateLinkRoute53Zone:
    type: aws:Route53Zone
    name: snowflake_private_link
    properties:
      name: privatelink.snowflakecomputing.com
      vpc:
        - vpcId: ${vpcId}
  snowflakePrivateLinkUrl:
    type: aws:Route53Record
    name: snowflake_private_link_url
    properties:
      zoneId: ${snowflakePrivateLinkRoute53Zone.zoneId}
      name: ${snowflakePrivateLink.accountUrl}
      type: CNAME
      ttl: '300'
      records:
        - ${snowflakePrivateLinkVpcEndpoint.dnsEntry[0]["dns_name"]}
  snowflakePrivateLinkOcspUrl:
    type: aws:Route53Record
    name: snowflake_private_link_ocsp_url
    properties:
      zoneId: ${snowflakePrivateLinkRoute53Zone.zoneId}
      name: ${snowflakePrivateLink.ocspUrl}
      type: CNAME
      ttl: '300'
      records:
        - ${snowflakePrivateLinkVpcEndpoint.dnsEntry[0]["dns_name"]}
variables:
  snowflakePrivateLink:
    fn::invoke:
      function: snowflake:getSystemGetPrivateLinkConfig
      arguments: {}

pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
    snowflake = {
      source = "pulumi/snowflake"
    }
  }
}

data "snowflake_getsystemgetprivatelinkconfig" "snowflakePrivateLink" {
}

resource "aws_securitygroup" "snowflake_private_link" {
  vpc_id = vpcId
  ingress = [{
    "fromPort"   = 80
    "toPort"     = 80
    "cidrBlocks" = vpcCidr
    "protocol"   = "tcp"
    }, {
    "fromPort"   = 443
    "toPort"     = 443
    "cidrBlocks" = vpcCidr
    "protocol"   = "tcp"
  }]
}
resource "aws_vpcendpoint" "snowflake_private_link" {
  vpc_id              = vpcId
  service_name        = data.snowflake_getsystemgetprivatelinkconfig.snowflakePrivateLink.aws_vpce_id
  vpc_endpoint_type   = "Interface"
  security_group_ids  = [aws_securitygroup.snowflake_private_link.id]
  subnet_ids          = subnetIds
  private_dns_enabled = false
}
resource "aws_route53zone" "snowflake_private_link" {
  name = "privatelink.snowflakecomputing.com"
  vpc = [{
    "vpcId" = vpcId
  }]
}
resource "aws_route53record" "snowflake_private_link_url" {
  zone_id = aws_route53zone.snowflake_private_link.zoneId
  name    = data.snowflake_getsystemgetprivatelinkconfig.snowflakePrivateLink.account_url
  type    = "CNAME"
  ttl     = "300"
  records = [aws_vpcendpoint.snowflake_private_link.dnsEntry[0]["dns_name"]]
}
resource "aws_route53record" "snowflake_private_link_ocsp_url" {
  zone_id = aws_route53zone.snowflake_private_link.zoneId
  name    = data.snowflake_getsystemgetprivatelinkconfig.snowflakePrivateLink.ocsp_url
  type    = "CNAME"
  ttl     = "300"
  records = [aws_vpcendpoint.snowflake_private_link.dnsEntry[0]["dns_name"]]
}

function getSystemGetPrivateLinkConfig(opts?: InvokeOptions): Promise<GetSystemGetPrivateLinkConfigResult>
function getSystemGetPrivateLinkConfigOutput(opts?: InvokeOptions): Output<GetSystemGetPrivateLinkConfigResult>

def get_system_get_private_link_config(opts: Optional[InvokeOptions] = None) -> GetSystemGetPrivateLinkConfigResult
def get_system_get_private_link_config_output(opts: Optional[InvokeOptions] = None) -> Output[GetSystemGetPrivateLinkConfigResult]

func GetSystemGetPrivateLinkConfig(ctx *Context, opts ...InvokeOption) (*GetSystemGetPrivateLinkConfigResult, error)
func GetSystemGetPrivateLinkConfigOutput(ctx *Context, opts ...InvokeOption) GetSystemGetPrivateLinkConfigResultOutput

public static class GetSystemGetPrivateLinkConfig 
{
    public static Task<GetSystemGetPrivateLinkConfigResult> InvokeAsync(InvokeOptions? opts = null)
    public static Output<GetSystemGetPrivateLinkConfigResult> Invoke(InvokeOptions? opts = null)
}

public static CompletableFuture<GetSystemGetPrivateLinkConfigResult> getSystemGetPrivateLinkConfig(InvokeOptions options)
public static Output<GetSystemGetPrivateLinkConfigResult> getSystemGetPrivateLinkConfig(InvokeOptions options)

fn::invoke:
  function: snowflake:index/getSystemGetPrivateLinkConfig:getSystemGetPrivateLinkConfig
  arguments:
    # arguments dictionary

data "snowflake_getsystemgetprivatelinkconfig" "name" {
    # arguments
}