snowflake.ExternalVolume

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

// Basic - S3 storage location with required fields only
const s3Basic = new snowflake.ExternalVolume("s3_basic", {
    name: "my_external_volume",
    storageLocations: [{
        storageLocationName: "my-s3-location",
        storageProvider: "S3",
        storageBaseUrl: "s3://mybucket/",
        storageAwsRoleArn: "arn:aws:iam::123456789012:role/myrole",
    }],
});
// Complete - S3 with all optional fields
const s3Complete = new snowflake.ExternalVolume("s3_complete", {
    name: "my_external_volume_complete",
    comment: "my external volume",
    allowWrites: "true",
    storageLocations: [{
        storageLocationName: "my-s3-location",
        storageProvider: "S3",
        storageBaseUrl: "s3://mybucket/",
        storageAwsRoleArn: "arn:aws:iam::123456789012:role/myrole",
        storageAwsAccessPointArn: "arn:aws:s3:us-west-2:123456789012:accesspoint/my-access-point",
        usePrivatelinkEndpoint: "true",
        encryptionType: "AWS_SSE_KMS",
        encryptionKmsKeyId: "1234abcd-12ab-34cd-56ef-1234567890ab",
    }],
});
// Basic - GCS storage location with required fields only
const gcsBasic = new snowflake.ExternalVolume("gcs_basic", {
    name: "my_gcs_external_volume",
    storageLocations: [{
        storageLocationName: "my-gcs-location",
        storageProvider: "GCS",
        storageBaseUrl: "gcs://mybucket/",
    }],
});
// Complete - GCS with all optional fields
const gcsComplete = new snowflake.ExternalVolume("gcs_complete", {
    name: "my_gcs_external_volume_complete",
    storageLocations: [{
        storageLocationName: "my-gcs-location",
        storageProvider: "GCS",
        storageBaseUrl: "gcs://mybucket/",
        encryptionType: "GCS_SSE_KMS",
        encryptionKmsKeyId: "1234abcd-12ab-34cd-56ef-1234567890ab",
    }],
});
// Basic - Azure storage location with required fields only
const azureBasic = new snowflake.ExternalVolume("azure_basic", {
    name: "my_azure_external_volume",
    storageLocations: [{
        storageLocationName: "my-azure-location",
        storageProvider: "AZURE",
        storageBaseUrl: "azure://myaccount.blob.core.windows.net/mycontainer/",
        azureTenantId: "123e4567-e89b-12d3-a456-426614174000",
    }],
});
// Complete - Azure with all optional fields
const azureComplete = new snowflake.ExternalVolume("azure_complete", {
    name: "my_azure_external_volume_complete",
    comment: "my azure external volume",
    allowWrites: "true",
    storageLocations: [{
        storageLocationName: "my-azure-location",
        storageProvider: "AZURE",
        storageBaseUrl: "azure://myaccount.blob.core.windows.net/mycontainer/",
        azureTenantId: "123e4567-e89b-12d3-a456-426614174000",
        usePrivatelinkEndpoint: "true",
    }],
});
// S3-compatible storage location
const s3compat = new snowflake.ExternalVolume("s3compat", {
    name: "my_s3compat_external_volume",
    storageLocations: [{
        storageLocationName: "my-s3compat-location",
        storageProvider: "S3COMPAT",
        storageBaseUrl: "s3compat://mybucket/",
        storageEndpoint: "https://s3-compatible.example.com",
        storageAwsKeyId: awsKeyId,
        storageAwsSecretKey: awsSecretKey,
    }],
});

import pulumi
import pulumi_snowflake as snowflake

# Basic - S3 storage location with required fields only
s3_basic = snowflake.ExternalVolume("s3_basic",
    name="my_external_volume",
    storage_locations=[{
        "storage_location_name": "my-s3-location",
        "storage_provider": "S3",
        "storage_base_url": "s3://mybucket/",
        "storage_aws_role_arn": "arn:aws:iam::123456789012:role/myrole",
    }])
# Complete - S3 with all optional fields
s3_complete = snowflake.ExternalVolume("s3_complete",
    name="my_external_volume_complete",
    comment="my external volume",
    allow_writes="true",
    storage_locations=[{
        "storage_location_name": "my-s3-location",
        "storage_provider": "S3",
        "storage_base_url": "s3://mybucket/",
        "storage_aws_role_arn": "arn:aws:iam::123456789012:role/myrole",
        "storage_aws_access_point_arn": "arn:aws:s3:us-west-2:123456789012:accesspoint/my-access-point",
        "use_privatelink_endpoint": "true",
        "encryption_type": "AWS_SSE_KMS",
        "encryption_kms_key_id": "1234abcd-12ab-34cd-56ef-1234567890ab",
    }])
# Basic - GCS storage location with required fields only
gcs_basic = snowflake.ExternalVolume("gcs_basic",
    name="my_gcs_external_volume",
    storage_locations=[{
        "storage_location_name": "my-gcs-location",
        "storage_provider": "GCS",
        "storage_base_url": "gcs://mybucket/",
    }])
# Complete - GCS with all optional fields
gcs_complete = snowflake.ExternalVolume("gcs_complete",
    name="my_gcs_external_volume_complete",
    storage_locations=[{
        "storage_location_name": "my-gcs-location",
        "storage_provider": "GCS",
        "storage_base_url": "gcs://mybucket/",
        "encryption_type": "GCS_SSE_KMS",
        "encryption_kms_key_id": "1234abcd-12ab-34cd-56ef-1234567890ab",
    }])
# Basic - Azure storage location with required fields only
azure_basic = snowflake.ExternalVolume("azure_basic",
    name="my_azure_external_volume",
    storage_locations=[{
        "storage_location_name": "my-azure-location",
        "storage_provider": "AZURE",
        "storage_base_url": "azure://myaccount.blob.core.windows.net/mycontainer/",
        "azure_tenant_id": "123e4567-e89b-12d3-a456-426614174000",
    }])
# Complete - Azure with all optional fields
azure_complete = snowflake.ExternalVolume("azure_complete",
    name="my_azure_external_volume_complete",
    comment="my azure external volume",
    allow_writes="true",
    storage_locations=[{
        "storage_location_name": "my-azure-location",
        "storage_provider": "AZURE",
        "storage_base_url": "azure://myaccount.blob.core.windows.net/mycontainer/",
        "azure_tenant_id": "123e4567-e89b-12d3-a456-426614174000",
        "use_privatelink_endpoint": "true",
    }])
# S3-compatible storage location
s3compat = snowflake.ExternalVolume("s3compat",
    name="my_s3compat_external_volume",
    storage_locations=[{
        "storage_location_name": "my-s3compat-location",
        "storage_provider": "S3COMPAT",
        "storage_base_url": "s3compat://mybucket/",
        "storage_endpoint": "https://s3-compatible.example.com",
        "storage_aws_key_id": aws_key_id,
        "storage_aws_secret_key": aws_secret_key,
    }])

package main

import (
	"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 {
		// Basic - S3 storage location with required fields only
		_, err := snowflake.NewExternalVolume(ctx, "s3_basic", &snowflake.ExternalVolumeArgs{
			Name: pulumi.String("my_external_volume"),
			StorageLocations: snowflake.ExternalVolumeStorageLocationArray{
				&snowflake.ExternalVolumeStorageLocationArgs{
					StorageLocationName: pulumi.String("my-s3-location"),
					StorageProvider:     pulumi.String("S3"),
					StorageBaseUrl:      pulumi.String("s3://mybucket/"),
					StorageAwsRoleArn:   pulumi.String("arn:aws:iam::123456789012:role/myrole"),
				},
			},
		})
		if err != nil {
			return err
		}
		// Complete - S3 with all optional fields
		_, err = snowflake.NewExternalVolume(ctx, "s3_complete", &snowflake.ExternalVolumeArgs{
			Name:        pulumi.String("my_external_volume_complete"),
			Comment:     pulumi.String("my external volume"),
			AllowWrites: pulumi.String("true"),
			StorageLocations: snowflake.ExternalVolumeStorageLocationArray{
				&snowflake.ExternalVolumeStorageLocationArgs{
					StorageLocationName:      pulumi.String("my-s3-location"),
					StorageProvider:          pulumi.String("S3"),
					StorageBaseUrl:           pulumi.String("s3://mybucket/"),
					StorageAwsRoleArn:        pulumi.String("arn:aws:iam::123456789012:role/myrole"),
					StorageAwsAccessPointArn: pulumi.String("arn:aws:s3:us-west-2:123456789012:accesspoint/my-access-point"),
					UsePrivatelinkEndpoint:   pulumi.String("true"),
					EncryptionType:           pulumi.String("AWS_SSE_KMS"),
					EncryptionKmsKeyId:       pulumi.String("1234abcd-12ab-34cd-56ef-1234567890ab"),
				},
			},
		})
		if err != nil {
			return err
		}
		// Basic - GCS storage location with required fields only
		_, err = snowflake.NewExternalVolume(ctx, "gcs_basic", &snowflake.ExternalVolumeArgs{
			Name: pulumi.String("my_gcs_external_volume"),
			StorageLocations: snowflake.ExternalVolumeStorageLocationArray{
				&snowflake.ExternalVolumeStorageLocationArgs{
					StorageLocationName: pulumi.String("my-gcs-location"),
					StorageProvider:     pulumi.String("GCS"),
					StorageBaseUrl:      pulumi.String("gcs://mybucket/"),
				},
			},
		})
		if err != nil {
			return err
		}
		// Complete - GCS with all optional fields
		_, err = snowflake.NewExternalVolume(ctx, "gcs_complete", &snowflake.ExternalVolumeArgs{
			Name: pulumi.String("my_gcs_external_volume_complete"),
			StorageLocations: snowflake.ExternalVolumeStorageLocationArray{
				&snowflake.ExternalVolumeStorageLocationArgs{
					StorageLocationName: pulumi.String("my-gcs-location"),
					StorageProvider:     pulumi.String("GCS"),
					StorageBaseUrl:      pulumi.String("gcs://mybucket/"),
					EncryptionType:      pulumi.String("GCS_SSE_KMS"),
					EncryptionKmsKeyId:  pulumi.String("1234abcd-12ab-34cd-56ef-1234567890ab"),
				},
			},
		})
		if err != nil {
			return err
		}
		// Basic - Azure storage location with required fields only
		_, err = snowflake.NewExternalVolume(ctx, "azure_basic", &snowflake.ExternalVolumeArgs{
			Name: pulumi.String("my_azure_external_volume"),
			StorageLocations: snowflake.ExternalVolumeStorageLocationArray{
				&snowflake.ExternalVolumeStorageLocationArgs{
					StorageLocationName: pulumi.String("my-azure-location"),
					StorageProvider:     pulumi.String("AZURE"),
					StorageBaseUrl:      pulumi.String("azure://myaccount.blob.core.windows.net/mycontainer/"),
					AzureTenantId:       pulumi.String("123e4567-e89b-12d3-a456-426614174000"),
				},
			},
		})
		if err != nil {
			return err
		}
		// Complete - Azure with all optional fields
		_, err = snowflake.NewExternalVolume(ctx, "azure_complete", &snowflake.ExternalVolumeArgs{
			Name:        pulumi.String("my_azure_external_volume_complete"),
			Comment:     pulumi.String("my azure external volume"),
			AllowWrites: pulumi.String("true"),
			StorageLocations: snowflake.ExternalVolumeStorageLocationArray{
				&snowflake.ExternalVolumeStorageLocationArgs{
					StorageLocationName:    pulumi.String("my-azure-location"),
					StorageProvider:        pulumi.String("AZURE"),
					StorageBaseUrl:         pulumi.String("azure://myaccount.blob.core.windows.net/mycontainer/"),
					AzureTenantId:          pulumi.String("123e4567-e89b-12d3-a456-426614174000"),
					UsePrivatelinkEndpoint: pulumi.String("true"),
				},
			},
		})
		if err != nil {
			return err
		}
		// S3-compatible storage location
		_, err = snowflake.NewExternalVolume(ctx, "s3compat", &snowflake.ExternalVolumeArgs{
			Name: pulumi.String("my_s3compat_external_volume"),
			StorageLocations: snowflake.ExternalVolumeStorageLocationArray{
				&snowflake.ExternalVolumeStorageLocationArgs{
					StorageLocationName: pulumi.String("my-s3compat-location"),
					StorageProvider:     pulumi.String("S3COMPAT"),
					StorageBaseUrl:      pulumi.String("s3compat://mybucket/"),
					StorageEndpoint:     pulumi.String("https://s3-compatible.example.com"),
					StorageAwsKeyId:     pulumi.Any(awsKeyId),
					StorageAwsSecretKey: pulumi.Any(awsSecretKey),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    // Basic - S3 storage location with required fields only
    var s3Basic = new Snowflake.ExternalVolume("s3_basic", new()
    {
        Name = "my_external_volume",
        StorageLocations = new[]
        {
            new Snowflake.Inputs.ExternalVolumeStorageLocationArgs
            {
                StorageLocationName = "my-s3-location",
                StorageProvider = "S3",
                StorageBaseUrl = "s3://mybucket/",
                StorageAwsRoleArn = "arn:aws:iam::123456789012:role/myrole",
            },
        },
    });

    // Complete - S3 with all optional fields
    var s3Complete = new Snowflake.ExternalVolume("s3_complete", new()
    {
        Name = "my_external_volume_complete",
        Comment = "my external volume",
        AllowWrites = "true",
        StorageLocations = new[]
        {
            new Snowflake.Inputs.ExternalVolumeStorageLocationArgs
            {
                StorageLocationName = "my-s3-location",
                StorageProvider = "S3",
                StorageBaseUrl = "s3://mybucket/",
                StorageAwsRoleArn = "arn:aws:iam::123456789012:role/myrole",
                StorageAwsAccessPointArn = "arn:aws:s3:us-west-2:123456789012:accesspoint/my-access-point",
                UsePrivatelinkEndpoint = "true",
                EncryptionType = "AWS_SSE_KMS",
                EncryptionKmsKeyId = "1234abcd-12ab-34cd-56ef-1234567890ab",
            },
        },
    });

    // Basic - GCS storage location with required fields only
    var gcsBasic = new Snowflake.ExternalVolume("gcs_basic", new()
    {
        Name = "my_gcs_external_volume",
        StorageLocations = new[]
        {
            new Snowflake.Inputs.ExternalVolumeStorageLocationArgs
            {
                StorageLocationName = "my-gcs-location",
                StorageProvider = "GCS",
                StorageBaseUrl = "gcs://mybucket/",
            },
        },
    });

    // Complete - GCS with all optional fields
    var gcsComplete = new Snowflake.ExternalVolume("gcs_complete", new()
    {
        Name = "my_gcs_external_volume_complete",
        StorageLocations = new[]
        {
            new Snowflake.Inputs.ExternalVolumeStorageLocationArgs
            {
                StorageLocationName = "my-gcs-location",
                StorageProvider = "GCS",
                StorageBaseUrl = "gcs://mybucket/",
                EncryptionType = "GCS_SSE_KMS",
                EncryptionKmsKeyId = "1234abcd-12ab-34cd-56ef-1234567890ab",
            },
        },
    });

    // Basic - Azure storage location with required fields only
    var azureBasic = new Snowflake.ExternalVolume("azure_basic", new()
    {
        Name = "my_azure_external_volume",
        StorageLocations = new[]
        {
            new Snowflake.Inputs.ExternalVolumeStorageLocationArgs
            {
                StorageLocationName = "my-azure-location",
                StorageProvider = "AZURE",
                StorageBaseUrl = "azure://myaccount.blob.core.windows.net/mycontainer/",
                AzureTenantId = "123e4567-e89b-12d3-a456-426614174000",
            },
        },
    });

    // Complete - Azure with all optional fields
    var azureComplete = new Snowflake.ExternalVolume("azure_complete", new()
    {
        Name = "my_azure_external_volume_complete",
        Comment = "my azure external volume",
        AllowWrites = "true",
        StorageLocations = new[]
        {
            new Snowflake.Inputs.ExternalVolumeStorageLocationArgs
            {
                StorageLocationName = "my-azure-location",
                StorageProvider = "AZURE",
                StorageBaseUrl = "azure://myaccount.blob.core.windows.net/mycontainer/",
                AzureTenantId = "123e4567-e89b-12d3-a456-426614174000",
                UsePrivatelinkEndpoint = "true",
            },
        },
    });

    // S3-compatible storage location
    var s3compat = new Snowflake.ExternalVolume("s3compat", new()
    {
        Name = "my_s3compat_external_volume",
        StorageLocations = new[]
        {
            new Snowflake.Inputs.ExternalVolumeStorageLocationArgs
            {
                StorageLocationName = "my-s3compat-location",
                StorageProvider = "S3COMPAT",
                StorageBaseUrl = "s3compat://mybucket/",
                StorageEndpoint = "https://s3-compatible.example.com",
                StorageAwsKeyId = awsKeyId,
                StorageAwsSecretKey = awsSecretKey,
            },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.snowflake.ExternalVolume;
import com.pulumi.snowflake.ExternalVolumeArgs;
import com.pulumi.snowflake.inputs.ExternalVolumeStorageLocationArgs;
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) {
        // Basic - S3 storage location with required fields only
        var s3Basic = new ExternalVolume("s3Basic", ExternalVolumeArgs.builder()
            .name("my_external_volume")
            .storageLocations(ExternalVolumeStorageLocationArgs.builder()
                .storageLocationName("my-s3-location")
                .storageProvider("S3")
                .storageBaseUrl("s3://mybucket/")
                .storageAwsRoleArn("arn:aws:iam::123456789012:role/myrole")
                .build())
            .build());

        // Complete - S3 with all optional fields
        var s3Complete = new ExternalVolume("s3Complete", ExternalVolumeArgs.builder()
            .name("my_external_volume_complete")
            .comment("my external volume")
            .allowWrites("true")
            .storageLocations(ExternalVolumeStorageLocationArgs.builder()
                .storageLocationName("my-s3-location")
                .storageProvider("S3")
                .storageBaseUrl("s3://mybucket/")
                .storageAwsRoleArn("arn:aws:iam::123456789012:role/myrole")
                .storageAwsAccessPointArn("arn:aws:s3:us-west-2:123456789012:accesspoint/my-access-point")
                .usePrivatelinkEndpoint("true")
                .encryptionType("AWS_SSE_KMS")
                .encryptionKmsKeyId("1234abcd-12ab-34cd-56ef-1234567890ab")
                .build())
            .build());

        // Basic - GCS storage location with required fields only
        var gcsBasic = new ExternalVolume("gcsBasic", ExternalVolumeArgs.builder()
            .name("my_gcs_external_volume")
            .storageLocations(ExternalVolumeStorageLocationArgs.builder()
                .storageLocationName("my-gcs-location")
                .storageProvider("GCS")
                .storageBaseUrl("gcs://mybucket/")
                .build())
            .build());

        // Complete - GCS with all optional fields
        var gcsComplete = new ExternalVolume("gcsComplete", ExternalVolumeArgs.builder()
            .name("my_gcs_external_volume_complete")
            .storageLocations(ExternalVolumeStorageLocationArgs.builder()
                .storageLocationName("my-gcs-location")
                .storageProvider("GCS")
                .storageBaseUrl("gcs://mybucket/")
                .encryptionType("GCS_SSE_KMS")
                .encryptionKmsKeyId("1234abcd-12ab-34cd-56ef-1234567890ab")
                .build())
            .build());

        // Basic - Azure storage location with required fields only
        var azureBasic = new ExternalVolume("azureBasic", ExternalVolumeArgs.builder()
            .name("my_azure_external_volume")
            .storageLocations(ExternalVolumeStorageLocationArgs.builder()
                .storageLocationName("my-azure-location")
                .storageProvider("AZURE")
                .storageBaseUrl("azure://myaccount.blob.core.windows.net/mycontainer/")
                .azureTenantId("123e4567-e89b-12d3-a456-426614174000")
                .build())
            .build());

        // Complete - Azure with all optional fields
        var azureComplete = new ExternalVolume("azureComplete", ExternalVolumeArgs.builder()
            .name("my_azure_external_volume_complete")
            .comment("my azure external volume")
            .allowWrites("true")
            .storageLocations(ExternalVolumeStorageLocationArgs.builder()
                .storageLocationName("my-azure-location")
                .storageProvider("AZURE")
                .storageBaseUrl("azure://myaccount.blob.core.windows.net/mycontainer/")
                .azureTenantId("123e4567-e89b-12d3-a456-426614174000")
                .usePrivatelinkEndpoint("true")
                .build())
            .build());

        // S3-compatible storage location
        var s3compat = new ExternalVolume("s3compat", ExternalVolumeArgs.builder()
            .name("my_s3compat_external_volume")
            .storageLocations(ExternalVolumeStorageLocationArgs.builder()
                .storageLocationName("my-s3compat-location")
                .storageProvider("S3COMPAT")
                .storageBaseUrl("s3compat://mybucket/")
                .storageEndpoint("https://s3-compatible.example.com")
                .storageAwsKeyId(awsKeyId)
                .storageAwsSecretKey(awsSecretKey)
                .build())
            .build());

    }
}

resources:
  # Basic - S3 storage location with required fields only
  s3Basic:
    type: snowflake:ExternalVolume
    name: s3_basic
    properties:
      name: my_external_volume
      storageLocations:
        - storageLocationName: my-s3-location
          storageProvider: S3
          storageBaseUrl: s3://mybucket/
          storageAwsRoleArn: arn:aws:iam::123456789012:role/myrole
  # Complete - S3 with all optional fields
  s3Complete:
    type: snowflake:ExternalVolume
    name: s3_complete
    properties:
      name: my_external_volume_complete
      comment: my external volume
      allowWrites: 'true'
      storageLocations:
        - storageLocationName: my-s3-location
          storageProvider: S3
          storageBaseUrl: s3://mybucket/
          storageAwsRoleArn: arn:aws:iam::123456789012:role/myrole
          storageAwsAccessPointArn: arn:aws:s3:us-west-2:123456789012:accesspoint/my-access-point
          usePrivatelinkEndpoint: 'true'
          encryptionType: AWS_SSE_KMS
          encryptionKmsKeyId: 1234abcd-12ab-34cd-56ef-1234567890ab
  # Basic - GCS storage location with required fields only
  gcsBasic:
    type: snowflake:ExternalVolume
    name: gcs_basic
    properties:
      name: my_gcs_external_volume
      storageLocations:
        - storageLocationName: my-gcs-location
          storageProvider: GCS
          storageBaseUrl: gcs://mybucket/
  # Complete - GCS with all optional fields
  gcsComplete:
    type: snowflake:ExternalVolume
    name: gcs_complete
    properties:
      name: my_gcs_external_volume_complete
      storageLocations:
        - storageLocationName: my-gcs-location
          storageProvider: GCS
          storageBaseUrl: gcs://mybucket/
          encryptionType: GCS_SSE_KMS
          encryptionKmsKeyId: 1234abcd-12ab-34cd-56ef-1234567890ab
  # Basic - Azure storage location with required fields only
  azureBasic:
    type: snowflake:ExternalVolume
    name: azure_basic
    properties:
      name: my_azure_external_volume
      storageLocations:
        - storageLocationName: my-azure-location
          storageProvider: AZURE
          storageBaseUrl: azure://myaccount.blob.core.windows.net/mycontainer/
          azureTenantId: 123e4567-e89b-12d3-a456-426614174000
  # Complete - Azure with all optional fields
  azureComplete:
    type: snowflake:ExternalVolume
    name: azure_complete
    properties:
      name: my_azure_external_volume_complete
      comment: my azure external volume
      allowWrites: 'true'
      storageLocations:
        - storageLocationName: my-azure-location
          storageProvider: AZURE
          storageBaseUrl: azure://myaccount.blob.core.windows.net/mycontainer/
          azureTenantId: 123e4567-e89b-12d3-a456-426614174000
          usePrivatelinkEndpoint: 'true'
  # S3-compatible storage location
  s3compat:
    type: snowflake:ExternalVolume
    properties:
      name: my_s3compat_external_volume
      storageLocations:
        - storageLocationName: my-s3compat-location
          storageProvider: S3COMPAT
          storageBaseUrl: s3compat://mybucket/
          storageEndpoint: https://s3-compatible.example.com
          storageAwsKeyId: ${awsKeyId}
          storageAwsSecretKey: ${awsSecretKey}

var externalVolumeResource = new Snowflake.ExternalVolume("externalVolumeResource", new()
{
    StorageLocations = new[]
    {
        new Snowflake.Inputs.ExternalVolumeStorageLocationArgs
        {
            StorageBaseUrl = "string",
            StorageProvider = "string",
            StorageLocationName = "string",
            StorageAwsRoleArn = "string",
            StorageAwsExternalId = "string",
            StorageAwsKeyId = "string",
            AzureTenantId = "string",
            StorageAwsSecretKey = "string",
            StorageAwsAccessPointArn = "string",
            StorageEndpoint = "string",
            EncryptionType = "string",
            EncryptionKmsKeyId = "string",
            UsePrivatelinkEndpoint = "string",
        },
    },
    AllowWrites = "string",
    Comment = "string",
    Name = "string",
});

example, err := snowflake.NewExternalVolume(ctx, "externalVolumeResource", &snowflake.ExternalVolumeArgs{
	StorageLocations: snowflake.ExternalVolumeStorageLocationArray{
		&snowflake.ExternalVolumeStorageLocationArgs{
			StorageBaseUrl:           pulumi.String("string"),
			StorageProvider:          pulumi.String("string"),
			StorageLocationName:      pulumi.String("string"),
			StorageAwsRoleArn:        pulumi.String("string"),
			StorageAwsExternalId:     pulumi.String("string"),
			StorageAwsKeyId:          pulumi.String("string"),
			AzureTenantId:            pulumi.String("string"),
			StorageAwsSecretKey:      pulumi.String("string"),
			StorageAwsAccessPointArn: pulumi.String("string"),
			StorageEndpoint:          pulumi.String("string"),
			EncryptionType:           pulumi.String("string"),
			EncryptionKmsKeyId:       pulumi.String("string"),
			UsePrivatelinkEndpoint:   pulumi.String("string"),
		},
	},
	AllowWrites: pulumi.String("string"),
	Comment:     pulumi.String("string"),
	Name:        pulumi.String("string"),
})

resource "snowflake_externalvolume" "externalVolumeResource" {
  storage_locations {
    storage_base_url             = "string"
    storage_provider             = "string"
    storage_location_name        = "string"
    storage_aws_role_arn         = "string"
    storage_aws_external_id      = "string"
    storage_aws_key_id           = "string"
    azure_tenant_id              = "string"
    storage_aws_secret_key       = "string"
    storage_aws_access_point_arn = "string"
    storage_endpoint             = "string"
    encryption_type              = "string"
    encryption_kms_key_id        = "string"
    use_privatelink_endpoint     = "string"
  }
  allow_writes = "string"
  comment      = "string"
  name         = "string"
}

var externalVolumeResource = new ExternalVolume("externalVolumeResource", ExternalVolumeArgs.builder()
    .storageLocations(ExternalVolumeStorageLocationArgs.builder()
        .storageBaseUrl("string")
        .storageProvider("string")
        .storageLocationName("string")
        .storageAwsRoleArn("string")
        .storageAwsExternalId("string")
        .storageAwsKeyId("string")
        .azureTenantId("string")
        .storageAwsSecretKey("string")
        .storageAwsAccessPointArn("string")
        .storageEndpoint("string")
        .encryptionType("string")
        .encryptionKmsKeyId("string")
        .usePrivatelinkEndpoint("string")
        .build())
    .allowWrites("string")
    .comment("string")
    .name("string")
    .build());

external_volume_resource = snowflake.ExternalVolume("externalVolumeResource",
    storage_locations=[{
        "storage_base_url": "string",
        "storage_provider": "string",
        "storage_location_name": "string",
        "storage_aws_role_arn": "string",
        "storage_aws_external_id": "string",
        "storage_aws_key_id": "string",
        "azure_tenant_id": "string",
        "storage_aws_secret_key": "string",
        "storage_aws_access_point_arn": "string",
        "storage_endpoint": "string",
        "encryption_type": "string",
        "encryption_kms_key_id": "string",
        "use_privatelink_endpoint": "string",
    }],
    allow_writes="string",
    comment="string",
    name="string")

const externalVolumeResource = new snowflake.ExternalVolume("externalVolumeResource", {
    storageLocations: [{
        storageBaseUrl: "string",
        storageProvider: "string",
        storageLocationName: "string",
        storageAwsRoleArn: "string",
        storageAwsExternalId: "string",
        storageAwsKeyId: "string",
        azureTenantId: "string",
        storageAwsSecretKey: "string",
        storageAwsAccessPointArn: "string",
        storageEndpoint: "string",
        encryptionType: "string",
        encryptionKmsKeyId: "string",
        usePrivatelinkEndpoint: "string",
    }],
    allowWrites: "string",
    comment: "string",
    name: "string",
});

type: snowflake:ExternalVolume
properties:
    allowWrites: string
    comment: string
    name: string
    storageLocations:
        - azureTenantId: string
          encryptionKmsKeyId: string
          encryptionType: string
          storageAwsAccessPointArn: string
          storageAwsExternalId: string
          storageAwsKeyId: string
          storageAwsRoleArn: string
          storageAwsSecretKey: string
          storageBaseUrl: string
          storageEndpoint: string
          storageLocationName: string
          storageProvider: string
          usePrivatelinkEndpoint: string