Repository: kubernetes-sigs/aws-ebs-csi-driver
Pull request #2467 (2025-05-07 19:59:34)

Remove Snow Device Support
#### What type of PR is this?

<!--
Add one of the following kinds:
/kind bug
/kind cleanup
/kind documentation
/kind feature
-->

/kind feature

#### What is this PR about? / Why do we need it?

Deprecate Snow Device Support. See #2365 

#### How was this change tested?

Local & CI

#### Does this PR introduce a user-facing change?
<!--
If no, just write "NONE" in the release-note block below.
If yes, enter your extended release note in the block below.
-->
```release-note
Remove support for Snow Devices. See https://github.com/kubernetes-sigs/aws-ebs-csi-driver/issues/2365
```


k8s-ci-robot: [APPROVALNOTIFIER] This PR is **NOT APPROVED**

This pull-request has been approved by:
**Once this PR has been reviewed and has the lgtm label**, please assign [torredil](https://github.com/torredil) for approval. For more information see [the Code Review Process](https://git.k8s.io/community/contributors/guide/owners.md#the-code-review-process).

The full list of commands accepted by this bot can be found [here](https://go.k8s.io/bot-commands?repo=kubernetes-sigs%2Faws-ebs-csi-driver).

<details open>
Needs approval from an approver in each of these files:

- **[OWNERS](https://github.com/kubernetes-sigs/aws-ebs-csi-driver/blob/master/OWNERS)**

Approvers can indicate their approval by writing `/approve` in a comment
Approvers can cancel approval by writing `/approve cancel` in a comment
</details>
<!-- META={"approvers":["torredil"]} -->
k8s-ci-robot: PR needs rebase.

<details>

Instructions for interacting with me using PR comments are available [here](https://git.k8s.io/community/contributors/guide/pull-requests.md).  If you have questions or suggestions related to my behavior, please file an issue against the [kubernetes-sigs/prow](https://github.com/kubernetes-sigs/prow/issues/new?title=Prow%20issue:) repository.
</details>
k8s-ci-robot: @AndrewSirenko: The following tests **failed**, say `/retest` to rerun all failed tests or `/retest-required` to rerun all mandatory failed tests:

Test name | Commit | Details | Required | Rerun command
--- | --- | --- | --- | ---
pull-aws-ebs-csi-driver-external-test-arm64 | fcd31e071467716616d1480eb84440fb32c515f7 | [link](https://prow.k8s.io/view/gs/kubernetes-ci-logs/pr-logs/pull/kubernetes-sigs_aws-ebs-csi-driver/2467/pull-aws-ebs-csi-driver-external-test-arm64/1920206904185851904) | false | `/test pull-aws-ebs-csi-driver-external-test-arm64`
pull-aws-ebs-csi-driver-e2e-single-az | fcd31e071467716616d1480eb84440fb32c515f7 | [link](https://prow.k8s.io/view/gs/kubernetes-ci-logs/pr-logs/pull/kubernetes-sigs_aws-ebs-csi-driver/2467/pull-aws-ebs-csi-driver-e2e-single-az/1920206903837724672) | true | `/test pull-aws-ebs-csi-driver-e2e-single-az`
pull-aws-ebs-csi-driver-e2e-multi-az | fcd31e071467716616d1480eb84440fb32c515f7 | [link](https://prow.k8s.io/view/gs/kubernetes-ci-logs/pr-logs/pull/kubernetes-sigs_aws-ebs-csi-driver/2467/pull-aws-ebs-csi-driver-e2e-multi-az/1920206903913222144) | true | `/test pull-aws-ebs-csi-driver-e2e-multi-az`
pull-aws-ebs-csi-driver-unit | fcd31e071467716616d1480eb84440fb32c515f7 | [link](https://prow.k8s.io/view/gs/kubernetes-ci-logs/pr-logs/pull/kubernetes-sigs_aws-ebs-csi-driver/2467/pull-aws-ebs-csi-driver-unit/1920206903766421504) | true | `/test pull-aws-ebs-csi-driver-unit`
pull-aws-ebs-csi-driver-test-e2e-external-eks-windows | fcd31e071467716616d1480eb84440fb32c515f7 | [link](https://prow.k8s.io/view/gs/kubernetes-ci-logs/pr-logs/pull/kubernetes-sigs_aws-ebs-csi-driver/2467/pull-aws-ebs-csi-driver-test-e2e-external-eks-windows/1920206903493791744) | true | `/test pull-aws-ebs-csi-driver-test-e2e-external-eks-windows`
pull-aws-ebs-csi-driver-external-test | fcd31e071467716616d1480eb84440fb32c515f7 | [link](https://prow.k8s.io/view/gs/kubernetes-ci-logs/pr-logs/pull/kubernetes-sigs_aws-ebs-csi-driver/2467/pull-aws-ebs-csi-driver-external-test/1920206904001302528) | true | `/test pull-aws-ebs-csi-driver-external-test`
pull-aws-ebs-csi-driver-external-test-eks | fcd31e071467716616d1480eb84440fb32c515f7 | [link](https://prow.k8s.io/view/gs/kubernetes-ci-logs/pr-logs/pull/kubernetes-sigs_aws-ebs-csi-driver/2467/pull-aws-ebs-csi-driver-external-test-eks/1920206904097771520) | true | `/test pull-aws-ebs-csi-driver-external-test-eks`
pull-aws-ebs-csi-driver-verify | fcd31e071467716616d1480eb84440fb32c515f7 | [link](https://prow.k8s.io/view/gs/kubernetes-ci-logs/pr-logs/pull/kubernetes-sigs_aws-ebs-csi-driver/2467/pull-aws-ebs-csi-driver-verify/1920206903665758208) | true | `/test pull-aws-ebs-csi-driver-verify`
pull-aws-ebs-csi-driver-test-helm-chart | fcd31e071467716616d1480eb84440fb32c515f7 | [link](https://prow.k8s.io/view/gs/kubernetes-ci-logs/pr-logs/pull/kubernetes-sigs_aws-ebs-csi-driver/2467/pull-aws-ebs-csi-driver-test-helm-chart/1920206903577677824) | true | `/test pull-aws-ebs-csi-driver-test-helm-chart`

[Full PR test history](https://prow.k8s.io/pr-history?org=kubernetes-sigs&repo=aws-ebs-csi-driver&pr=2467). [Your PR dashboard](https://prow.k8s.io/pr?query=is%3Apr%20state%3Aopen%20author%3AAndrewSirenko). Please help us cut down on flakes by [linking to](https://git.k8s.io/community/contributors/devel/sig-testing/flaky-tests.md#filing-issues-for-flaky-tests) an [open issue](https://github.com/kubernetes-sigs/aws-ebs-csi-driver/issues?q=is:issue+is:open) when you hit one in your PR.

<details>

Instructions for interacting with me using PR comments are available [here](https://git.k8s.io/community/contributors/guide/pull-requests.md).  If you have questions or suggestions related to my behavior, please file an issue against the [kubernetes-sigs/prow](https://github.com/kubernetes-sigs/prow/issues/new?title=Prow%20issue:) repository. I understand the commands that are listed [here](https://go.k8s.io/bot-commands).
</details>
<!-- test report -->

Patch:
diff --git a/docs/parameters.md b/docs/parameters.md
index bc930499..660eeeba 100644
--- a/docs/parameters.md
+++ b/docs/parameters.md
@@ -5,23 +5,23 @@ There are several optional parameters that may be passed into `CreateVolumeReque
 
 The AWS EBS CSI Driver supports [tagging](tagging.md) through `StorageClass.parameters` (in v1.6.0 and later). 
 
-| Parameters                   | Values                                            | Default | Description                                                                                                                                                                                                                                                                                                                                                                                   |
-|------------------------------|---------------------------------------------------|---------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| "csi.storage.k8s.io/fstype"  | xfs, ext3, ext4                              | ext4    | File system type that will be formatted during volume creation. This parameter is case sensitive!                                                                                                                                                                                                                                                                                             |
-| "type"                       | io1, io2, gp2, gp3, sc1, st1, standard, sbp1, sbg1 | gp3*    | EBS volume type.                                                                                                                                                                                                                                                                                                                                                                              |
-| "iopsPerGB"                  |                                                   |         | I/O operations per second per GiB. Can be specified for IO1, IO2, and GP3 volumes.                                                                                                                                                                                                                                                                                                            |
-| "allowAutoIOPSPerGBIncrease" | true, false                                       | false   | When `"true"`, the CSI driver increases IOPS for a volume when `iopsPerGB * <volume size>` is too low to fit into IOPS range supported by AWS. This allows dynamic provisioning to always succeed, even when user specifies too small PVC capacity or `iopsPerGB` value. On the other hand, it may introduce additional costs, as such volumes have higher IOPS than requested in `iopsPerGB`. |
-| "iops"                       |                                                   |         | I/O operations per second. Can be specified for IO1, IO2, and GP3 volumes.                                                                                                                                                                                                                                                                                                                    |
-| "throughput"                 |                                                   | 125     | Throughput in MiB/s. Only effective when gp3 volume type is specified. If empty, it will set to 125MiB/s as documented [here](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-volume-types.html).                                                                                                                                                                                     |
-| "encrypted"                  | true, false                                       | false   | Whether the volume should be encrypted or not. Valid values are "true" or "false".                                                                                                                                                                                                                                                                                                            |
-| "blockExpress"               | true, false                                       | false   | Enables the creation of [io2 Block Express volumes](https://aws.amazon.com/ebs/provisioned-iops/#Introducing_io2_Block_Express) by increasing the IOPS limit for io2 volumes to 256000. Volumes created with more than 64000 IOPS will fail to mount on instances that do not support io2 Block Express.                                                                                      |
-| "kmsKeyId"                   |                                                   |         | The full ARN of the key to use when encrypting the volume. If not specified, AWS will use the default KMS key for the region the volume is in. This will be an auto-generated key called `/aws/ebs` if not changed.                                                                                                                                                                           |
-| "blockSize"                  |                                                   |         | The block size to use when formatting the underlying filesystem. Only supported on linux nodes and with fstype `ext3`, `ext4`, or `xfs`.                                                                                                                                                                                                                                               |
-| "inodeSize"                  |                                                   |         | The inode size to use when formatting the underlying filesystem. Only supported on linux nodes and with fstype `ext3`, `ext4`, or `xfs`.                                                                                                                                                                                                                                              |
-| "bytesPerInode"              |                                                   |         | The `bytes-per-inode` to use when formatting the underlying filesystem. Only supported on linux nodes and with fstype `ext3`, `ext4`.                                                                                                                                                                                                                                                 |
-| "numberOfInodes"             |                                                   |         | The `number-of-inodes` to use when formatting the underlying filesystem. Only supported on linux nodes and with fstype `ext3`, `ext4`.                                                                                                                                                                                                                                                |
-| "ext4BigAlloc"               | true, false                                       | false   | Changes the `ext4` filesystem to use clustered block allocation by enabling the `bigalloc` formatting option. Warning: `bigalloc` may not be fully supported with your node's Linux kernel. Please see our [FAQ](/docs/faq.md).                                                                                                                                                               |
-| "ext4ClusterSize"            |                                                   |         | The cluster size to use when formatting an `ext4` filesystem when the `bigalloc` feature is enabled. Note: The `ext4BigAlloc` parameter must be set to true. See our [FAQ](/docs/faq.md).                                                                                                                                                                                                     |
+| Parameters                   | Values                                          | Default | Description                                                                                                                                                                                                                                                                                                                                                                                   |
+|------------------------------|-------------------------------------------------|---------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| "csi.storage.k8s.io/fstype"  | xfs, ext3, ext4                            | ext4    | File system type that will be formatted during volume creation. This parameter is case sensitive!                                                                                                                                                                                                                                                                                             |
+| "type"                       | io1, io2, gp2, gp3, sc1, st1, standard | gp3*    | EBS volume type.                                                                                                                                                                                                                                                                                                                                                                              |
+| "iopsPerGB"                  |                                                 |         | I/O operations per second per GiB. Can be specified for IO1, IO2, and GP3 volumes.                                                                                                                                                                                                                                                                                                            |
+| "allowAutoIOPSPerGBIncrease" | true, false                                     | false   | When `"true"`, the CSI driver increases IOPS for a volume when `iopsPerGB * <volume size>` is too low to fit into IOPS range supported by AWS. This allows dynamic provisioning to always succeed, even when user specifies too small PVC capacity or `iopsPerGB` value. On the other hand, it may introduce additional costs, as such volumes have higher IOPS than requested in `iopsPerGB`. |
+| "iops"                       |                                                 |         | I/O operations per second. Can be specified for IO1, IO2, and GP3 volumes.                                                                                                                                                                                                                                                                                                                    |
+| "throughput"                 |                                                 | 125     | Throughput in MiB/s. Only effective when gp3 volume type is specified. If empty, it will set to 125MiB/s as documented [here](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-volume-types.html).                                                                                                                                                                                     |
+| "encrypted"                  | true, false                                     | false   | Whether the volume should be encrypted or not. Valid values are "true" or "false".                                                                                                                                                                                                                                                                                                            |
+| "blockExpress"               | true, false                                     | false   | Enables the creation of [io2 Block Express volumes](https://aws.amazon.com/ebs/provisioned-iops/#Introducing_io2_Block_Express) by increasing the IOPS limit for io2 volumes to 256000. Volumes created with more than 64000 IOPS will fail to mount on instances that do not support io2 Block Express.                                                                                      |
+| "kmsKeyId"                   |                                                 |         | The full ARN of the key to use when encrypting the volume. If not specified, AWS will use the default KMS key for the region the volume is in. This will be an auto-generated key called `/aws/ebs` if not changed.                                                                                                                                                                           |
+| "blockSize"                  |                                                 |         | The block size to use when formatting the underlying filesystem. Only supported on linux nodes and with fstype `ext3`, `ext4`, or `xfs`.                                                                                                                                                                                                                                               |
+| "inodeSize"                  |                                                 |         | The inode size to use when formatting the underlying filesystem. Only supported on linux nodes and with fstype `ext3`, `ext4`, or `xfs`.                                                                                                                                                                                                                                              |
+| "bytesPerInode"              |                                                 |         | The `bytes-per-inode` to use when formatting the underlying filesystem. Only supported on linux nodes and with fstype `ext3`, `ext4`.                                                                                                                                                                                                                                                 |
+| "numberOfInodes"             |                                                 |         | The `number-of-inodes` to use when formatting the underlying filesystem. Only supported on linux nodes and with fstype `ext3`, `ext4`.                                                                                                                                                                                                                                                |
+| "ext4BigAlloc"               | true, false                                     | false   | Changes the `ext4` filesystem to use clustered block allocation by enabling the `bigalloc` formatting option. Warning: `bigalloc` may not be fully supported with your node's Linux kernel. Please see our [FAQ](/docs/faq.md).                                                                                                                                                               |
+| "ext4ClusterSize"            |                                                 |         | The cluster size to use when formatting an `ext4` filesystem when the `bigalloc` feature is enabled. Note: The `ext4BigAlloc` parameter must be set to true. See our [FAQ](/docs/faq.md).                                                                                                                                                                                                     |
 | "volumeInitializationRate"   | integer                                           |         |  When creating a volume from a snapshot, this parameter can be used to request a provisioned initialization rate, in MiB/s.                             |
 
 ## Restrictions
diff --git a/pkg/cloud/cloud.go b/pkg/cloud/cloud.go
index 36998fc0..b7204e16 100644
--- a/pkg/cloud/cloud.go
+++ b/pkg/cloud/cloud.go
@@ -56,10 +56,6 @@ const (
 	VolumeTypeSC1 = "sc1"
 	// VolumeTypeST1 represents a throughput-optimized HDD type of volume.
 	VolumeTypeST1 = "st1"
-	// VolumeTypeSBG1 represents a capacity-optimized HDD type of volume. Only for SBE devices.
-	VolumeTypeSBG1 = "sbg1"
-	// VolumeTypeSBP1 represents a performance-optimized SSD type of volume. Only for SBE devices.
-	VolumeTypeSBP1 = "sbp1"
 	// VolumeTypeStandard represents a previous type of  volume.
 	VolumeTypeStandard = "standard"
 )
@@ -547,7 +543,7 @@ func (c *cloud) CreateDisk(ctx context.Context, volumeName string, diskOptions *
 	}
 
 	switch createType {
-	case VolumeTypeGP2, VolumeTypeSC1, VolumeTypeST1, VolumeTypeSBG1, VolumeTypeSBP1, VolumeTypeStandard:
+	case VolumeTypeGP2, VolumeTypeSC1, VolumeTypeST1, VolumeTypeStandard:
 	case VolumeTypeIO1:
 		maxIops = io1MaxTotalIOPS
 		minIops = io1MinTotalIOPS
@@ -624,10 +620,7 @@ func (c *cloud) CreateDisk(ctx context.Context, volumeName string, diskOptions *
 		VolumeType:         types.VolumeType(createType),
 		Encrypted:          aws.Bool(diskOptions.Encrypted),
 		MultiAttachEnabled: aws.Bool(diskOptions.MultiAttachEnabled),
-	}
-
-	if !util.IsSBE(zone) {
-		requestInput.TagSpecifications = []types.TagSpecification{tagSpec}
+		TagSpecifications:  []types.TagSpecification{tagSpec},
 	}
 
 	// EBS doesn't handle empty outpost arn, so we have to include it only when it's non-empty
@@ -685,26 +678,7 @@ func (c *cloud) CreateDisk(ctx context.Context, volumeName string, diskOptions *
 		return nil, fmt.Errorf("timed out waiting for volume to create: %w", err)
 	}
 
-	outpostArn := aws.ToString(response.OutpostArn)
-	var resources []string
-	if util.IsSBE(zone) {
-		requestTagsInput := &ec2.CreateTagsInput{
-			Resources: append(resources, volumeID),
-			Tags:      tags,
-		}
-		_, err := c.ec2.CreateTags(ctx, requestTagsInput)
-		if err != nil {
-			// To avoid leaking volume, we should delete the volume just created
-			// TODO: Need to figure out how to handle DeleteDisk failed scenario instead of just log the error
-			if _, deleteDiskErr := c.DeleteDisk(ctx, volumeID); deleteDiskErr != nil {
-				klog.ErrorS(deleteDiskErr, "failed to be deleted, this may cause volume leak", "volumeID", volumeID)
-			} else {
-				klog.V(5).InfoS("volume is deleted because there was an error while attaching the tags", "volumeID", volumeID)
-			}
-			return nil, fmt.Errorf("could not attach tags to volume: %v. %w", volumeID, err)
-		}
-	}
-	return &Disk{CapacityGiB: size, VolumeID: volumeID, AvailabilityZone: zone, SnapshotID: snapshotID, OutpostArn: outpostArn}, nil
+	return &Disk{CapacityGiB: size, VolumeID: volumeID, AvailabilityZone: zone, SnapshotID: snapshotID, OutpostArn: aws.ToString(response.OutpostArn)}, nil
 }
 
 // execBatchDescribeVolumesModifications executes a batched DescribeVolumesModifications API call.
diff --git a/pkg/cloud/metadata/ec2.go b/pkg/cloud/metadata/ec2.go
index c1c8d927..886e2773 100644
--- a/pkg/cloud/metadata/ec2.go
+++ b/pkg/cloud/metadata/ec2.go
@@ -50,7 +50,7 @@ var DefaultEC2MetadataClient = func() (EC2Metadata, error) {
 	return svc, nil
 }
 
-func EC2MetadataInstanceInfo(svc EC2Metadata, regionFromSession string) (*Metadata, error) {
+func EC2MetadataInstanceInfo(svc EC2Metadata) (*Metadata, error) {
 	docOutput, err := svc.GetInstanceIdentityDocument(context.Background(), &imds.GetInstanceIdentityDocumentInput{})
 	if err != nil {
 		return nil, fmt.Errorf("could not get EC2 instance identity metadata: %w", err)
@@ -66,19 +66,11 @@ func EC2MetadataInstanceInfo(svc EC2Metadata, regionFromSession string) (*Metada
 	}
 
 	if len(doc.Region) == 0 {
-		if len(regionFromSession) != 0 && util.IsSBE(regionFromSession) {
-			doc.Region = regionFromSession
-		} else {
-			return nil, errors.New("could not get valid EC2 region")
-		}
+		return nil, errors.New("could not get valid EC2 region")
 	}
 
 	if len(doc.AvailabilityZone) == 0 {
-		if len(regionFromSession) != 0 && util.IsSBE(regionFromSession) {
-			doc.AvailabilityZone = regionFromSession
-		} else {
-			return nil, errors.New("could not get valid EC2 availability zone")
-		}
+		return nil, errors.New("could not get valid EC2 availability zone")
 	}
 
 	attachedENIs, err := getAttachedENIs(svc)
@@ -86,18 +78,15 @@ func EC2MetadataInstanceInfo(svc EC2Metadata, regionFromSession string) (*Metada
 		return nil, err
 	}
 
-	blockDevMappings := 0
-	if !util.IsSBE(doc.Region) {
-		mappingsOutput, mappingsOutputErr := svc.GetMetadata(context.Background(), &imds.GetMetadataInput{Path: BlockDevicesEndpoint})
-		if mappingsOutputErr != nil {
-			return nil, fmt.Errorf("could not get metadata for block device mappings: %w", mappingsOutputErr)
-		}
-		mappings, mappingsErr := io.ReadAll(mappingsOutput.Content)
-		if mappingsErr != nil {
-			return nil, fmt.Errorf("could not read block device mappings metadata content: %w", mappingsErr)
-		}
-		blockDevMappings = strings.Count(string(mappings), "ebs")
+	mappingsOutput, mappingsOutputErr := svc.GetMetadata(context.Background(), &imds.GetMetadataInput{Path: BlockDevicesEndpoint})
+	if mappingsOutputErr != nil {
+		return nil, fmt.Errorf("could not get metadata for block device mappings: %w", mappingsOutputErr)
+	}
+	mappings, mappingsErr := io.ReadAll(mappingsOutput.Content)
+	if mappingsErr != nil {
+		return nil, fmt.Errorf("could not read block device mappings metadata content: %w", mappingsErr)
 	}
+	blockDevMappings := strings.Count(string(mappings), "ebs")
 
 	instanceInfo := Metadata{
 		InstanceID:             doc.InstanceID,
diff --git a/pkg/cloud/metadata/metadata.go b/pkg/cloud/metadata/metadata.go
index 6a29255b..77b5a3dd 100644
--- a/pkg/cloud/metadata/metadata.go
+++ b/pkg/cloud/metadata/metadata.go
@@ -52,7 +52,7 @@ func NewMetadataService(cfg MetadataServiceConfig, region string) (MetadataServi
 		klog.V(2).InfoS("Environment variable AWS_EC2_METADATA_DISABLED set to 'true'. Will not rely on IMDS for instance metadata")
 	} else {
 		klog.V(2).InfoS("Attempting to retrieve instance metadata from IMDS")
-		metadata, err := retrieveEC2Metadata(cfg.EC2MetadataClient, region)
+		metadata, err := retrieveEC2Metadata(cfg.EC2MetadataClient)
 		if err == nil {
 			klog.V(2).InfoS("Retrieved metadata from IMDS")
 			return metadata.overrideRegion(region), nil
@@ -88,13 +88,13 @@ func (m *Metadata) UpdateMetadata() error {
 	return nil
 }
 
-func retrieveEC2Metadata(ec2MetadataClient EC2MetadataClient, region string) (*Metadata, error) {
+func retrieveEC2Metadata(ec2MetadataClient EC2MetadataClient) (*Metadata, error) {
 	svc, err := ec2MetadataClient()
 	if err != nil {
 		klog.ErrorS(err, "failed to initialize EC2 Metadata client")
 		return nil, err
 	}
-	return EC2MetadataInstanceInfo(svc, region)
+	return EC2MetadataInstanceInfo(svc)
 }
 
 func retrieveK8sMetadata(k8sAPIClient KubernetesAPIClient) (*Metadata, error) {
diff --git a/pkg/driver/node.go b/pkg/driver/node.go
index 176be66e..9cbf7e04 100644
--- a/pkg/driver/node.go
+++ b/pkg/driver/node.go
@@ -49,9 +49,6 @@ const (
 
 	// VolumeOperationAlreadyExists is message fmt returned to CO when there is another in-flight call on the given volumeID.
 	VolumeOperationAlreadyExists = "An operation with the given volume=%q is already in progress"
-
-	// sbeDeviceVolumeAttachmentLimit refers to the maximum number of volumes that can be attached to an instance on snow.
-	sbeDeviceVolumeAttachmentLimit = 10
 )
 
 var (
@@ -773,9 +770,6 @@ func (d *NodeService) getVolumesLimit() int64 {
 		klog.V(4).InfoS("getVolumesLimit: VolumeAttachLimit manually set to", d.options.VolumeAttachLimit, "overriding the default value")
 		return d.options.VolumeAttachLimit
 	}
-	if util.IsSBE(d.metadata.GetRegion()) {
-		return sbeDeviceVolumeAttachmentLimit
-	}
 
 	instanceType := d.metadata.GetInstanceType()
 	klog.V(4).InfoS("getVolumesLimit:", "instanceType", instanceType)
diff --git a/pkg/mounter/mount_linux.go b/pkg/mounter/mount_linux.go
index 051e6a19..c55cd70e 100644
--- a/pkg/mounter/mount_linux.go
+++ b/pkg/mounter/mount_linux.go
@@ -28,7 +28,6 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/kubernetes-sigs/aws-ebs-csi-driver/pkg/util"
 	"golang.org/x/sys/unix"
 	"k8s.io/klog/v2"
 	mountutils "k8s.io/mount-utils"
@@ -113,15 +112,6 @@ func (m *NodeMounter) FindDevicePath(devicePath, volumeID, partition, region str
 		klog.V(5).InfoS("[Debug] error searching for nvme path", "nvmeName", nvmeName, "err", err)
 	}
 
-	if util.IsSBE(region) {
-		klog.V(5).InfoS("[Debug] Falling back to snow volume lookup", "devicePath", devicePath)
-		// Snow completely ignores the requested device path and mounts volumes starting at /dev/vda .. /dev/vdb .. etc
-		// Morph the device path to the snow form by chopping off the last letter and prefixing with /dev/vd
-		// VMs on snow devices are currently limited to 10 block devices each - if that ever exceeds 26 this will need
-		// to be adapted
-		canonicalDevicePath = "/dev/vd" + devicePath[len(devicePath)-1:]
-	}
-
 	if canonicalDevicePath == "" {
 		return "", fmt.Errorf("no device path for device %q volume %q found", devicePath, volumeID)
 	}
diff --git a/pkg/util/util.go b/pkg/util/util.go
index 346dde5d..ad4bb452 100644
--- a/pkg/util/util.go
+++ b/pkg/util/util.go
@@ -132,10 +132,6 @@ func GetAccessModes(caps []*csi.VolumeCapability) *[]string {
 	return &modes
 }
 
-func IsSBE(region string) bool {
-	return region == "snow"
-}
-
 // StringIsAlphanumeric returns true if a given string contains only English letters or numbers.
 func StringIsAlphanumeric(s string) bool {
 	return isAlphanumericRegex(s)


Test patch:
diff --git a/pkg/cloud/cloud_test.go b/pkg/cloud/cloud_test.go
index d9435fc8..4d1ff280 100644
--- a/pkg/cloud/cloud_test.go
+++ b/pkg/cloud/cloud_test.go
@@ -42,7 +42,6 @@ import (
 const (
 	defaultZone     = "test-az"
 	expZone         = "us-west-2b"
-	snowZone        = "snow"
 	defaultVolumeID = "vol-test-1234"
 	defaultNodeID   = "node-1234"
 	defaultPath     = "/dev/xvdaa"
@@ -1263,41 +1262,6 @@ func TestCreateDisk(t *testing.T) {
 			},
 			expErr: nil,
 		},
-		{
-			name:       "success: create volume when zone is snow and add tags",
-			volumeName: "vol-test-name",
-			diskOptions: &DiskOptions{
-				CapacityBytes:    util.GiBToBytes(1),
-				Tags:             map[string]string{VolumeNameTagKey: "vol-test", AwsEbsDriverTagKey: "true"},
-				AvailabilityZone: snowZone,
-				VolumeType:       "sbp1",
-			},
-			expCreateVolumeInput: &ec2.CreateVolumeInput{},
-			expDisk: &Disk{
-				VolumeID:         "vol-test",
-				CapacityGiB:      1,
-				AvailabilityZone: snowZone,
-			},
-			expErr: nil,
-		},
-		{
-			name:       "fail: zone is snow and add tags throws error",
-			volumeName: "vol-test-name",
-			diskOptions: &DiskOptions{
-				CapacityBytes:    util.GiBToBytes(1),
-				Tags:             map[string]string{VolumeNameTagKey: "vol-test", AwsEbsDriverTagKey: "true"},
-				AvailabilityZone: snowZone,
-				VolumeType:       "sbg1",
-			},
-			expCreateVolumeInput: &ec2.CreateVolumeInput{},
-			expCreateTagsErr:     errors.New("CreateTags generic error"),
-			expDisk: &Disk{
-				VolumeID:         "vol-test",
-				CapacityGiB:      1,
-				AvailabilityZone: snowZone,
-			},
-			expErr: errors.New("could not attach tags to volume: vol-test. CreateTags generic error"),
-		},
 		{
 			name:       "success: create default volume with throughput",
 			volumeName: "vol-test-name",
@@ -1439,10 +1403,6 @@ func TestCreateDisk(t *testing.T) {
 						},
 					},
 				}, tc.expDescVolumeErr).AnyTimes()
-				if tc.diskOptions.AvailabilityZone == "snow" {
-					mockEC2.EXPECT().CreateTags(gomock.Any(), gomock.Any()).Return(&ec2.CreateTagsOutput{}, tc.expCreateTagsErr)
-					mockEC2.EXPECT().DeleteVolume(gomock.Any(), gomock.Any(), gomock.Any()).Return(&ec2.DeleteVolumeOutput{}, nil).AnyTimes()
-				}
 				if len(tc.diskOptions.SnapshotID) > 0 {
 					mockEC2.EXPECT().DescribeSnapshots(gomock.Any(), gomock.Any()).Return(&ec2.DescribeSnapshotsOutput{Snapshots: []types.Snapshot{snapshot}}, nil).AnyTimes()
 				}
diff --git a/pkg/cloud/metadata/metadata_test.go b/pkg/cloud/metadata/metadata_test.go
index fa5e3e65..aa1ffd43 100644
--- a/pkg/cloud/metadata/metadata_test.go
+++ b/pkg/cloud/metadata/metadata_test.go
@@ -169,11 +169,10 @@ func TestEC2MetadataInstanceInfo(t *testing.T) {
 	defer ctrl.Finish()
 
 	testCases := []struct {
-		name              string
-		regionFromSession string
-		mockEC2Metadata   func(m *MockEC2Metadata)
-		expectedMetadata  *Metadata
-		expectedError     error
+		name             string
+		mockEC2Metadata  func(m *MockEC2Metadata)
+		expectedMetadata *Metadata
+		expectedError    error
 	}{
 		{
 			name: "TestEC2MetadataInstanceInfo: Error getting instance identity document",
@@ -368,33 +367,6 @@ func TestEC2MetadataInstanceInfo(t *testing.T) {
 				OutpostArn:             arn.ARN{},
 			},
 		},
-		{
-			name:              "TestEC2MetadataInstanceInfo: Valid metadata retrieving snow region/AZ from session",
-			regionFromSession: "snow",
-			mockEC2Metadata: func(m *MockEC2Metadata) {
-				m.EXPECT().GetInstanceIdentityDocument(gomock.Any(), &imds.GetInstanceIdentityDocumentInput{}).Return(&imds.GetInstanceIdentityDocumentOutput{
-					InstanceIdentityDocument: imds.InstanceIdentityDocument{
-						InstanceID:       "i-1234567890abcdef0",
-						InstanceType:     "c5.xlarge",
-						Region:           "",
-						AvailabilityZone: "",
-					},
-				}, nil)
-				m.EXPECT().GetMetadata(gomock.Any(), &imds.GetMetadataInput{Path: EnisEndpoint}).Return(&imds.GetMetadataOutput{
-					Content: io.NopCloser(strings.NewReader("01:23:45:67:89:ab\n02:23:45:67:89:ab")),
-				}, nil)
-				m.EXPECT().GetMetadata(gomock.Any(), &imds.GetMetadataInput{Path: OutpostArnEndpoint}).Return(nil, errors.New("404 - Not Found"))
-			},
-			expectedMetadata: &Metadata{
-				InstanceID:             "i-1234567890abcdef0",
-				InstanceType:           "c5.xlarge",
-				Region:                 "snow",
-				AvailabilityZone:       "snow",
-				NumAttachedENIs:        2,
-				NumBlockDeviceMappings: 0,
-				OutpostArn:             arn.ARN{},
-			},
-		},
 	}
 
 	for _, tc := range testCases {
@@ -405,7 +377,7 @@ func TestEC2MetadataInstanceInfo(t *testing.T) {
 			mockEC2Metadata := NewMockEC2Metadata(mockCtrl)
 			tc.mockEC2Metadata(mockEC2Metadata)
 
-			metadata, err := EC2MetadataInstanceInfo(mockEC2Metadata, tc.regionFromSession)
+			metadata, err := EC2MetadataInstanceInfo(mockEC2Metadata)
 
 			if tc.expectedError != nil {
 				require.EqualError(t, err, tc.expectedError.Error())
diff --git a/pkg/driver/node_test.go b/pkg/driver/node_test.go
index 6e54367b..6e3e8563 100644
--- a/pkg/driver/node_test.go
+++ b/pkg/driver/node_test.go
@@ -1057,18 +1057,6 @@ func TestGetVolumesLimit(t *testing.T) {
 			},
 			expectedVal: 10,
 		},
-		{
-			name: "sbeDeviceVolumeAttachmentLimit",
-			options: &Options{
-				VolumeAttachLimit: -1,
-			},
-			expectedVal: sbeDeviceVolumeAttachmentLimit,
-			metadataMock: func(ctrl *gomock.Controller) *metadata.MockMetadataService {
-				m := metadata.NewMockMetadataService(ctrl)
-				m.EXPECT().GetRegion().Return("snow")
-				return m
-			},
-		},
 		{
 			name: "t2.medium_volume_attach_limit",
 			options: &Options{
@@ -1078,7 +1066,6 @@ func TestGetVolumesLimit(t *testing.T) {
 			expectedVal: 38,
 			metadataMock: func(ctrl *gomock.Controller) *metadata.MockMetadataService {
 				m := metadata.NewMockMetadataService(ctrl)
-				m.EXPECT().GetRegion().Return("us-west-2")
 				m.EXPECT().GetNumBlockDeviceMappings().Return(0)
 				m.EXPECT().GetInstanceType().Return("t2.medium")
 				return m
@@ -1093,7 +1080,6 @@ func TestGetVolumesLimit(t *testing.T) {
 			expectedVal: 36,
 			metadataMock: func(ctrl *gomock.Controller) *metadata.MockMetadataService {
 				m := metadata.NewMockMetadataService(ctrl)
-				m.EXPECT().GetRegion().Return("us-west-2")
 				m.EXPECT().GetInstanceType().Return("t2.medium")
 				return m
 			},
@@ -1107,7 +1093,6 @@ func TestGetVolumesLimit(t *testing.T) {
 			expectedVal: 23,
 			metadataMock: func(ctrl *gomock.Controller) *metadata.MockMetadataService {
 				m := metadata.NewMockMetadataService(ctrl)
-				m.EXPECT().GetRegion().Return("us-west-2")
 				m.EXPECT().GetInstanceType().Return("m5d.large")
 				m.EXPECT().GetNumBlockDeviceMappings().Return(0)
 				m.EXPECT().GetNumAttachedENIs().Return(3)
@@ -1123,7 +1108,6 @@ func TestGetVolumesLimit(t *testing.T) {
 			expectedVal: 1,
 			metadataMock: func(ctrl *gomock.Controller) *metadata.MockMetadataService {
 				m := metadata.NewMockMetadataService(ctrl)
-				m.EXPECT().GetRegion().Return("us-west-2")
 				m.EXPECT().GetInstanceType().Return("d3en.12xlarge")
 				m.EXPECT().GetNumBlockDeviceMappings().Return(0)
 				m.EXPECT().GetNumAttachedENIs().Return(1)
@@ -1139,7 +1123,6 @@ func TestGetVolumesLimit(t *testing.T) {
 			expectedVal: 1,
 			metadataMock: func(ctrl *gomock.Controller) *metadata.MockMetadataService {
 				m := metadata.NewMockMetadataService(ctrl)
-				m.EXPECT().GetRegion().Return("us-west-2")
 				m.EXPECT().GetInstanceType().Return("d3.8xlarge")
 				m.EXPECT().GetNumBlockDeviceMappings().Return(0)
 				m.EXPECT().GetNumAttachedENIs().Return(1)
@@ -1155,7 +1138,6 @@ func TestGetVolumesLimit(t *testing.T) {
 			expectedVal: 127,
 			metadataMock: func(ctrl *gomock.Controller) *metadata.MockMetadataService {
 				m := metadata.NewMockMetadataService(ctrl)
-				m.EXPECT().GetRegion().Return("us-west-2")
 				m.EXPECT().GetInstanceType().Return("m7i.48xlarge")
 				m.EXPECT().GetNumBlockDeviceMappings().Return(0)
 				return m
@@ -1169,7 +1151,6 @@ func TestGetVolumesLimit(t *testing.T) {
 			expectedVal: 1,
 			metadataMock: func(ctrl *gomock.Controller) *metadata.MockMetadataService {
 				m := metadata.NewMockMetadataService(ctrl)
-				m.EXPECT().GetRegion().Return("us-west-2")
 				m.EXPECT().GetInstanceType().Return("t3.xlarge")
 				m.EXPECT().GetNumAttachedENIs().Return(40)
 				return m
@@ -1184,7 +1165,6 @@ func TestGetVolumesLimit(t *testing.T) {
 			expectedVal: 15,
 			metadataMock: func(ctrl *gomock.Controller) *metadata.MockMetadataService {
 				m := metadata.NewMockMetadataService(ctrl)
-				m.EXPECT().GetRegion().Return("us-west-2")
 				m.EXPECT().GetInstanceType().Return("mac1.metal")
 				m.EXPECT().GetNumBlockDeviceMappings().Return(0)
 				m.EXPECT().GetNumAttachedENIs().Return(1)
@@ -1200,7 +1180,6 @@ func TestGetVolumesLimit(t *testing.T) {
 			expectedVal: 18,
 			metadataMock: func(ctrl *gomock.Controller) *metadata.MockMetadataService {
 				m := metadata.NewMockMetadataService(ctrl)
-				m.EXPECT().GetRegion().Return("us-west-2")
 				m.EXPECT().GetInstanceType().Return("u-12tb1.metal")
 				m.EXPECT().GetNumBlockDeviceMappings().Return(0)
 				m.EXPECT().GetNumAttachedENIs().Return(1)
@@ -1216,7 +1195,6 @@ func TestGetVolumesLimit(t *testing.T) {
 			expectedVal: 24,
 			metadataMock: func(ctrl *gomock.Controller) *metadata.MockMetadataService {
 				m := metadata.NewMockMetadataService(ctrl)
-				m.EXPECT().GetRegion().Return("us-west-2")
 				m.EXPECT().GetInstanceType().Return("g4dn.xlarge")
 				m.EXPECT().GetNumBlockDeviceMappings().Return(0)
 				m.EXPECT().GetNumAttachedENIs().Return(1)
@@ -1232,7 +1210,6 @@ func TestGetVolumesLimit(t *testing.T) {
 			expectedVal: 24,
 			metadataMock: func(ctrl *gomock.Controller) *metadata.MockMetadataService {
 				m := metadata.NewMockMetadataService(ctrl)
-				m.EXPECT().GetRegion().Return("us-west-2")
 				m.EXPECT().GetInstanceType().Return("g4ad.xlarge")
 				m.EXPECT().GetNumBlockDeviceMappings().Return(0)
 				m.EXPECT().GetNumAttachedENIs().Return(1)
@@ -1248,7 +1225,6 @@ func TestGetVolumesLimit(t *testing.T) {
 			expectedVal: 21,
 			metadataMock: func(ctrl *gomock.Controller) *metadata.MockMetadataService {
 				m := metadata.NewMockMetadataService(ctrl)
-				m.EXPECT().GetRegion().Return("us-west-2")
 				m.EXPECT().GetInstanceType().Return("g4dn.12xlarge")
 				m.EXPECT().GetNumBlockDeviceMappings().Return(0)
 				m.EXPECT().GetNumAttachedENIs().Return(1)
@@ -1264,7 +1240,6 @@ func TestGetVolumesLimit(t *testing.T) {
 			expectedVal: 14,
 			metadataMock: func(ctrl *gomock.Controller) *metadata.MockMetadataService {
 				m := metadata.NewMockMetadataService(ctrl)
-				m.EXPECT().GetRegion().Return("us-west-2")
 				m.EXPECT().GetInstanceType().Return("dl1.24xlarge")
 				m.EXPECT().GetNumBlockDeviceMappings().Return(0)
 				m.EXPECT().GetNumAttachedENIs().Return(1)
@@ -1281,7 +1256,6 @@ func TestGetVolumesLimit(t *testing.T) {
 			expectedVal: 8,
 			metadataMock: func(ctrl *gomock.Controller) *metadata.MockMetadataService {
 				m := metadata.NewMockMetadataService(ctrl)
-				m.EXPECT().GetRegion().Return("us-west-2")
 				m.EXPECT().GetInstanceType().Return("g5.48xlarge")
 				m.EXPECT().GetNumBlockDeviceMappings().Return(0)
 				m.EXPECT().GetNumAttachedENIs().Return(1)
@@ -1298,7 +1272,6 @@ func TestGetVolumesLimit(t *testing.T) {
 			expectedVal: 25,
 			metadataMock: func(ctrl *gomock.Controller) *metadata.MockMetadataService {
 				m := metadata.NewMockMetadataService(ctrl)
-				m.EXPECT().GetRegion().Return("us-west-2")
 				m.EXPECT().GetInstanceType().Return("inf1.xlarge")
 				m.EXPECT().GetNumBlockDeviceMappings().Return(0)
 				m.EXPECT().GetNumAttachedENIs().Return(1)
@@ -1315,7 +1288,6 @@ func TestGetVolumesLimit(t *testing.T) {
 			expectedVal: 25,
 			metadataMock: func(ctrl *gomock.Controller) *metadata.MockMetadataService {
 				m := metadata.NewMockMetadataService(ctrl)
-				m.EXPECT().GetRegion().Return("us-west-2")
 				m.EXPECT().GetInstanceType().Return("inf1.2xlarge")
 				m.EXPECT().GetNumBlockDeviceMappings().Return(0)
 				m.EXPECT().GetNumAttachedENIs().Return(1)
@@ -1332,7 +1304,6 @@ func TestGetVolumesLimit(t *testing.T) {
 			expectedVal: 22,
 			metadataMock: func(ctrl *gomock.Controller) *metadata.MockMetadataService {
 				m := metadata.NewMockMetadataService(ctrl)
-				m.EXPECT().GetRegion().Return("us-west-2")
 				m.EXPECT().GetInstanceType().Return("inf1.6xlarge")
 				m.EXPECT().GetNumBlockDeviceMappings().Return(0)
 				m.EXPECT().GetNumAttachedENIs().Return(1)
@@ -1349,7 +1320,6 @@ func TestGetVolumesLimit(t *testing.T) {
 			expectedVal: 10,
 			metadataMock: func(ctrl *gomock.Controller) *metadata.MockMetadataService {
 				m := metadata.NewMockMetadataService(ctrl)
-				m.EXPECT().GetRegion().Return("us-west-2")
 				m.EXPECT().GetInstanceType().Return("inf1.24xlarge")
 				m.EXPECT().GetNumBlockDeviceMappings().Return(0)
 				m.EXPECT().GetNumAttachedENIs().Return(1)
diff --git a/pkg/mounter/mount_linux_test.go b/pkg/mounter/mount_linux_test.go
index 0f44eb74..b8665f38 100644
--- a/pkg/mounter/mount_linux_test.go
+++ b/pkg/mounter/mount_linux_test.go
@@ -219,18 +219,6 @@ func TestFindDevicePath(t *testing.T) {
 			cmdOutputFsType: "ext4",
 			expectedErr:     fmt.Errorf("no device path for device %q volume %q found", "/temp/vol-1234567890abcdef0", "vol-1234567890abcdef0"),
 		},
-		{
-			name:            "SBE region fallback",
-			volumeID:        "vol-1234567890abcdef0",
-			partition:       "1",
-			region:          "snow",
-			createTempDir:   false,
-			symlink:         false,
-			verifyErr:       nil,
-			deviceSize:      "1024",
-			cmdOutputFsType: "ext4",
-			expectedErr:     nil,
-		},
 	}
 
 	for _, tc := range testCases {
@@ -287,10 +275,6 @@ func TestFindDevicePath(t *testing.T) {
 
 			result, err := fakeMounter.FindDevicePath(devicePath, tc.volumeID, tc.partition, tc.region)
 
-			if tc.region == "snow" {
-				expectedResult = "/dev/vd" + tc.volumeID[len(tc.volumeID)-1:] + tc.partition
-			}
-
 			if tc.expectedErr == nil {
 				assert.Equal(t, expectedResult, result)
 				assert.NoError(t, err)