[CSI][i-cat] use DNS for ICAT datacenters

Author: Abby Deng

Dockerfile

@@ -23,14 +23,17 @@ RUN make cross
 ################################################################
 
 # Dockerfile.goreleaser should be kept roughly in sync
-FROM alpine:3.20.3
+FROM ubuntu:24.04
 
 # Need to get these updates for k8s mount-utils library to work properly
-RUN apk update && \
-    apk add --no-cache e2fsprogs-extra~=1.47.0 && \
-    apk add --no-cache blkid~=2.40.1 && \
-    apk add --no-cache xfsprogs-extra~=6.8.0 && \
-    rm -rf /var/cache/apk/*
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends \
+        ca-certificates \
+        e2fsprogs \
+        nfs-common \
+        util-linux \
+        xfsprogs && \
+    rm -rf /var/lib/apt/lists/*
 
 COPY --from=builder /build/dist/crusoe-csi-driver /usr/local/go/bin/crusoe-csi-driver
 

Dockerfile.goreleaser

@@ -1,14 +1,17 @@
 ################################################################
 # STEP 2: build a small image and run crusoe-csi-driver binary #
 ################################################################
-FROM alpine:3.20.3
+FROM ubuntu:24.04
 
 # Need to get these updates for k8s mount-utils library to work properly
-RUN apk update && \
-    apk add --no-cache e2fsprogs-extra~=1.47.0 && \
-    apk add --no-cache blkid~=2.40.1 && \
-    apk add --no-cache xfsprogs-extra~=6.8.0 && \
-    rm -rf /var/cache/apk/*
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends \
+        ca-certificates \
+        e2fsprogs \
+        nfs-common \
+        util-linux \
+        xfsprogs && \
+    rm -rf /var/lib/apt/lists/*
 
 COPY crusoe-csi-driver /usr/local/go/bin/crusoe-csi-driver
 

internal/crusoe/nfs_flag.go

@@ -7,31 +7,38 @@ import (
 	"fmt"
 	"io"
 	"net/http"
+
+	"k8s.io/klog/v2"
 )
 
-const nfsFlagRouteTemplate = "%s/projects/%s/storage/nfs/is-using-nfs"
+const (
+	nfsFlagRouteTemplate                     = "%s/projects/%s/storage/nfs/is-using-nfs"
+	vastUseSecondaryClusterFlagRouteTemplate = "%s/projects/%s/storage/nfs/vast-use-secondary-cluster"
+	DEBUG                                    = 8
+)
 
 var (
-	errCreateNfsFlagRequest = errors.New("failed to create NFS flag request")
-	errGetNfsFlag           = errors.New("failed to get NFS flag")
-	errReadNfsResponse      = errors.New("failed to read NFS flag response")
-	errUnmarshalNfsFlag     = errors.New("failed to unmarshal NFS flag response")
+	errCreateFlagRequest = errors.New("failed to create flag request")
+	errGetFlag           = errors.New("failed to get flag")
+	errReadFlagResponse  = errors.New("failed to read flag response")
+	errUnmarshalFlag     = errors.New("failed to unmarshal flag response")
 )
 
 type NfsFlagResponse struct {
 	Status bool `json:"status"`
 }
 
-// GetNFSFlag returns true if the project has NFS enabled.
-func GetNFSFlag(ctx context.Context, crusoeHTTPClient *http.Client, apiEndpoint, projectID string) (bool, error) {
-	nfsFlagRoute := fmt.Sprintf(nfsFlagRouteTemplate, apiEndpoint, projectID)
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, nfsFlagRoute, http.NoBody)
+// getFlag is a helper function to fetch a boolean flag from the API.
+func getFlag(ctx context.Context, crusoeHTTPClient *http.Client, flagRoute string) (bool, error) {
+	klog.Infof("Fetching flag from URL: %s", flagRoute)
+
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, flagRoute, http.NoBody)
 	if err != nil {
-		return false, fmt.Errorf("%w: %w", errCreateNfsFlagRequest, err)
+		return false, fmt.Errorf("%w: %w", errCreateFlagRequest, err)
 	}
 	resp, err := crusoeHTTPClient.Do(req)
 	if err != nil {
-		return false, fmt.Errorf("%w: %w", errGetNfsFlag, err)
+		return false, fmt.Errorf("%w: %w", errGetFlag, err)
 	}
 
 	if resp != nil && resp.Body != nil {
@@ -40,15 +47,42 @@ func GetNFSFlag(ctx context.Context, crusoeHTTPClient *http.Client, apiEndpoint,
 
 	bodyBytes, err := io.ReadAll(resp.Body)
 	if err != nil {
-		return false, fmt.Errorf("%w: %w", errReadNfsResponse, err)
+		return false, fmt.Errorf("%w: %w", errReadFlagResponse, err)
+	}
+
+	klog.Infof("Flag API response - Status: %d, Content-Type: %s, Body length: %d bytes",
+		resp.StatusCode, resp.Header.Get("Content-Type"), len(bodyBytes))
+	klog.V(DEBUG).Infof("Flag API raw response body: %q", string(bodyBytes))
+
+	// Check HTTP status code before unmarshaling
+	if resp.StatusCode != http.StatusOK {
+		return false, fmt.Errorf("%w: HTTP %d: %s", errGetFlag, resp.StatusCode, string(bodyBytes))
 	}
 
-	var nfsFlag NfsFlagResponse
+	var flagResponse NfsFlagResponse
 
-	unmarshalErr := json.Unmarshal(bodyBytes, &nfsFlag)
+	unmarshalErr := json.Unmarshal(bodyBytes, &flagResponse)
 	if unmarshalErr != nil {
-		return false, fmt.Errorf("%w: %w", errUnmarshalNfsFlag, unmarshalErr)
+		return false, fmt.Errorf("%w: %w (response body: %q)", errUnmarshalFlag, unmarshalErr, string(bodyBytes))
 	}
 
-	return nfsFlag.Status, nil
+	return flagResponse.Status, nil
+}
+
+// GetNFSFlag returns true if the project has NFS enabled.
+func GetNFSFlag(ctx context.Context, crusoeHTTPClient *http.Client, apiEndpoint, projectID string) (bool, error) {
+	nfsFlagRoute := fmt.Sprintf(nfsFlagRouteTemplate, apiEndpoint, projectID)
+
+	return getFlag(ctx, crusoeHTTPClient, nfsFlagRoute)
+}
+
+// GetVastUseSecondaryClusterFlag returns true if the project has the vast-use-secondary-cluster flag enabled.
+func GetVastUseSecondaryClusterFlag(
+	ctx context.Context,
+	crusoeHTTPClient *http.Client,
+	apiEndpoint, projectID string,
+) (bool, error) {
+	flagRoute := fmt.Sprintf(vastUseSecondaryClusterFlagRouteTemplate, apiEndpoint, projectID)
+
+	return getFlag(ctx, crusoeHTTPClient, flagRoute)
 }

internal/node/fs/fs_node.go

@@ -16,6 +16,12 @@ import (
 	"k8s.io/mount-utils"
 )
 
+const (
+	crusoeCloudDNSNFSHost = "nfs.crusoecloudcompute.com"
+	icatLocation          = "eu-iceland1-a"
+	dnsRemotePorts        = "dns"
+)
+
 type Node struct {
 	csi.UnimplementedNodeServer
 	CrusoeClient      *crusoeapi.APIClient
@@ -72,7 +78,19 @@ func (d *Node) NodePublishVolume(ctx context.Context, request *csi.NodePublishVo
 		mountOpts = append(mountOpts, node.ReadOnlyMountOption)
 	}
 
-	err = nodePublishVolume(d.Mounter, d.Resizer, mountOpts, nfsEnabled, d.NFSRemotePorts, d.NFSHost, request)
+	// Use DNS for ICAT locations instead of IP-based NFSHost
+	nfsHost := d.NFSHost
+	nfsRemotePorts := d.NFSRemotePorts
+	klog.Infof("Host instance location: %q, checking against icatLocation: %q", d.HostInstance.Location, icatLocation)
+	if d.useDNSForMount(ctx) {
+		klog.Infof("Using DNS-based NFS host for ICAT location: %s", crusoeCloudDNSNFSHost)
+		nfsHost = crusoeCloudDNSNFSHost
+		nfsRemotePorts = dnsRemotePorts
+	} else {
+		klog.Infof("Using IP-based NFS host: %s with remote ports: %s", nfsHost, nfsRemotePorts)
+	}
+
+	err = nodePublishVolume(d.Mounter, d.Resizer, mountOpts, nfsEnabled, nfsRemotePorts, nfsHost, request)
 	if err != nil {
 		klog.Errorf("failed to publish volume %s: %s", request.GetVolumeId(), err.Error())
 
@@ -84,6 +102,18 @@ func (d *Node) NodePublishVolume(ctx context.Context, request *csi.NodePublishVo
 	return &csi.NodePublishVolumeResponse{}, nil
 }
 
+func (d *Node) useDNSForMount(ctx context.Context) bool {
+	useSecondaryVast, err := crusoe.GetVastUseSecondaryClusterFlag(
+		ctx, d.CrusoeHTTPClient, d.CrusoeAPIEndpoint, d.HostInstance.ProjectId)
+	if err != nil {
+		klog.Errorf("failed to fetch VastUseSecondaryCluster flag: %s", err.Error())
+
+		return false
+	}
+
+	return useSecondaryVast && d.HostInstance.Location == icatLocation
+}
+
 func (d *Node) NodeUnpublishVolume(_ context.Context, request *csi.NodeUnpublishVolumeRequest) (
 	*csi.NodeUnpublishVolumeResponse,
 	error,