From edbe2bc517f014e7293d042f426962758f522c16 Mon Sep 17 00:00:00 2001 From: Mauricio Poppe Date: Fri, 28 Oct 2022 04:33:35 +0000 Subject: [PATCH] KEP-3636 CSI Drivers in Windows as a HostProcess Pods --- .../README.md | 1233 +++++++++++++++++ .../csi-proxy-client-server.jpg | Bin 0 -> 59320 bytes .../csi-proxy-library.jpg | Bin 0 -> 22071 bytes .../csi-proxy-reuse-client-server-pod.jpg | Bin 0 -> 45206 bytes .../kep.yaml | 41 + 5 files changed, 1274 insertions(+) create mode 100644 keps/sig-windows/3636-windows-csi-host-process-pods/README.md create mode 100644 keps/sig-windows/3636-windows-csi-host-process-pods/csi-proxy-client-server.jpg create mode 100644 keps/sig-windows/3636-windows-csi-host-process-pods/csi-proxy-library.jpg create mode 100644 keps/sig-windows/3636-windows-csi-host-process-pods/csi-proxy-reuse-client-server-pod.jpg create mode 100644 keps/sig-windows/3636-windows-csi-host-process-pods/kep.yaml diff --git a/keps/sig-windows/3636-windows-csi-host-process-pods/README.md b/keps/sig-windows/3636-windows-csi-host-process-pods/README.md new file mode 100644 index 000000000000..cd5a4725d8cf --- /dev/null +++ b/keps/sig-windows/3636-windows-csi-host-process-pods/README.md @@ -0,0 +1,1233 @@ + +# KEP-3636: CSI Drivers in Windows as a HostProcess Pods + + + + +- [Release Signoff Checklist](#release-signoff-checklist) +- [Summary](#summary) + - [Glossary](#glossary) +- [Motivation](#motivation) + - [Goals](#goals) + - [Non-Goals](#non-goals) +- [Proposal](#proposal) + - [Notes/Constraints/Caveats](#notesconstraintscaveats) + - [Risks and Mitigations](#risks-and-mitigations) +- [Design Details](#design-details) + - [Prerequisite: Make CSI Proxy an embedded library without a server component](#prerequisite-make-csi-proxy-an-embedded-library-without-a-server-component) + - [Implementation idea 1: Update the conversion layer to use the server code gRPC](#implementation-idea-1-update-the-conversion-layer-to-use-the-server-code-grpc) + - [Implementation idea 2: Update the CSI Drivers to use the server code directly (preferred)](#implementation-idea-2-update-the-csi-drivers-to-use-the-server-code-directly-preferred) + - [Implementation idea 3: Convert CSI Proxy to a Library of Functions](#implementation-idea-3-convert-csi-proxy-to-a-library-of-functions) + - [Comparison Matrix](#comparison-matrix) + - [Maintainance of the new model and existing client/server model of CSI Proxy](#maintainance-of-the-new-model-and-existing-clientserver-model-of-csi-proxy) + - [Security analysis](#security-analysis) + - [Test Plan](#test-plan) + - [Unit tests](#unit-tests) + - [Integration tests](#integration-tests) + - [e2e tests](#e2e-tests) + - [Graduation Criteria](#graduation-criteria) + - [Upgrade / Downgrade Strategy](#upgrade--downgrade-strategy) + - [Version Skew Strategy](#version-skew-strategy) +- [Production Readiness Review Questionnaire](#production-readiness-review-questionnaire) + - [Feature Enablement and Rollback](#feature-enablement-and-rollback) + - [Rollout, Upgrade and Rollback Planning](#rollout-upgrade-and-rollback-planning) + - [Monitoring Requirements](#monitoring-requirements) + - [Dependencies](#dependencies) + - [Scalability](#scalability) + - [Troubleshooting](#troubleshooting) +- [Implementation History](#implementation-history) +- [Drawbacks](#drawbacks) +- [Alternatives](#alternatives) +- [Infrastructure Needed (Optional)](#infrastructure-needed-optional) + + +## Release Signoff Checklist + + + +Items marked with (R) are required *prior to targeting to a milestone / release*. + +- [ ] (R) Enhancement issue in release milestone, which links to KEP dir in [kubernetes/enhancements] (not the initial KEP PR) +- [ ] (R) KEP approvers have approved the KEP status as `implementable` +- [ ] (R) Design details are appropriately documented +- [ ] (R) Test plan is in place, giving consideration to SIG Architecture and SIG Testing input (including test refactors) + - [ ] e2e Tests for all Beta API Operations (endpoints) + - [ ] (R) Ensure GA e2e tests meet requirements for [Conformance Tests](https://github.com/kubernetes/community/blob/master/contributors/devel/sig-architecture/conformance-tests.md) + - [ ] (R) Minimum Two Week Window for GA e2e tests to prove flake free +- [ ] (R) Graduation criteria is in place + - [ ] (R) [all GA Endpoints](https://github.com/kubernetes/community/pull/1806) must be hit by [Conformance Tests](https://github.com/kubernetes/community/blob/master/contributors/devel/sig-architecture/conformance-tests.md) +- [ ] (R) Production readiness review completed +- [ ] (R) Production readiness review approved +- [ ] "Implementation History" section is up-to-date for milestone +- [ ] User-facing documentation has been created in [kubernetes/website], for publication to [kubernetes.io] +- [ ] Supporting documentation—e.g., additional design documents, links to mailing list discussions/SIG meetings, relevant PRs/issues, release notes + + + +[kubernetes.io]: https://kubernetes.io/ +[kubernetes/enhancements]: https://git.k8s.io/enhancements +[kubernetes/kubernetes]: https://git.k8s.io/kubernetes +[kubernetes/website]: https://git.k8s.io/website + +## Summary + + + +CSI enables third-party storage providers to write and deploy plugins without the need +to alter the core Kubernetes codebase. + +A CSI Driver in Kubernetes has two main components: a controller plugin which runs in +the control plane and a node plugin which runs on every node. + +The node component of a CSI Driver require direct access to the host for making block devices and/or filesystems +available to the kubelet, CSI Drivers use the [mkfs(8)](https://man7.org/linux/man-pages/man8/mkfs.8.html) and +[mount(8)](https://man7.org/linux/man-pages/man8/mount.8.html) commands format and mount filesystems. +CSI Drivers running in Windows nodes can't execute similar Windows commands due to the missing capability +of running privileged operations from a container. To workaround this issue a proxy binary called [CSI Proxy was +introduced](https://kubernetes.io/blog/2020/04/03/kubernetes-1-18-feature-windows-csi-support-alpha/) as a way to +perform privileged storage operations by relaying the execution of these privileged storage operations to it, CSI +Drivers connect to a gRPC API exposed by CSI Proxy as named pipes in the host and invoke the CSI Proxy API services +to execute privileged powershell commands to mount and format filesystems on behalf of the CSI Driver. [CSI Proxy +became GA in Kubernetes 1.22](https://kubernetes.io/blog/2021/08/09/csi-windows-support-with-csi-proxy-reaches-ga/). + +At around the same time, SIG Windows introduced [HostProcess containers](https://kubernetes.io/blog/2021/08/16/windows-hostprocess-containers/), +this feature enables running containers as a process in the host (hence the name), +with this feature CSI Drives can directly perform the same privileged storage operations +that CSI Proxy did, this KEP explains the process to transition CSI Drivers to become HostProcess containers. + +### Glossary + +A few terms for reference as this document is read: + +* API Group - A grouping of APIs in CSI Proxy by their purpose, for example the Volume API Group has API Methods related with volume interaction, [there are 4 API groups (Disk, Fileyste, Volume, SMB) in v1 status and 2 in v1beta status](https://github.com/kubernetes-csi/csi-proxy/blob/master/README.md#feature-status). +* API Version - an API Group can have multiple versions e.g. v1alpha1, v1beta1, v1, etc. [As of GA there are 4 API groups (Disk, Fileyste, Volume, SMB) in v1 status and 2 API Groups (iSCSI, System) in v1beta status](https://github.com/kubernetes-csi/csi-proxy/blob/master/README.md#feature-status). +* Conversion layer - Generated go code in CSI Proxy that transforms client versioned requests to server "version agnostic" requests. +* CSI Proxy client - The library that CSI Drivers and addons use to connect to the CSI Proxy server. +* CSI Proxy server - The CSI Proxy binary running in the host node. + +## Motivation + + + +CSI Proxy enabled running CSI in Windows nodes using a client/server model, the server is the CSI Proxy binary +running as a Windows service in the node, the client is the CSI Driver which communicates with CSI Proxy on +every CSI call done on the node plugin. While this model has worked fine it has a few drawbacks: + +- Different deployment model than Linux - Linux privileged containers are used to perform the privileged storage + operations (format/mount), Windows containers aren't privileged so as a workaround the CSI Driver is run as non-privileged + and privileged operations are relayed to CSI Proxy. In terms of manifests the Windows component needs to have an + additional section to do a hostpath mount of the named pipes exposed by CSI Proxy. +- Additional component in the host to maintain - The cluster administrator needs to install and run CSI Proxy + during the node bootstrap, the cluster administrator also needs to think about the upgrade scenario in addition to + upgrading the CSI Driver. +- Difficult releases of bugfixes & features - After a bugfix we create a new version of the CSI Proxy which needs + to be redeployed in the cluster, after a feature is merged in addition to redeploying a new version of CSI Proxy + the client needs to be updated with a new version of the CSI Proxy client and connect to the new version of the named pipes, + this workflow is not as simple as the Linux counterpart which only needs to update Go dependencies. +- Multiple API versions to maintain - As part of the original design of CSI Proxy it was decided to have different + protobuf versions whenever there were breaking changes (like updates in the protobuf services & messages), this lead + to having multiple versions of the API (v1alphaX, v1betaX, v1). In addition, if we want to add a new feature we'd need + to create a new API version e.g. v2alpha1 ([see this PR as an example of adding methods to the Volume API Group](https://github.com/kubernetes-csi/csi-proxy/pull/186)). + +In 1.22 SIG Windows introduced [HostProcess containers](https://kubernetes.io/blog/2021/08/16/windows-hostprocess-containers/) +as an alternative way to run containers, HostProcess containers run directly in the host +and have a behavior similar to that of a regular process. + +Using HostProcess containers in CSI Drivers enables CSI Drivers to perform the privileged storage operations +directly, most of the drawbacks in the client/server model are no longer present in the new model. + +### Goals + + + +- Identify the pros/cons of the different ways to transition CSI Drivers to become HostProcess containers - This + includes changes in dependent components like CSI Proxy, it also includes defining the changes in the CSI Drivers. +- Identify the security implications of running CSI Drivers as HostProcess containers - Like the Linux counterpart + the cluster needs to have security policies defining in which scenarios it should be enabled, we'll aim to make + a similar analysis for Windows. + +### Non-Goals + + +- Improve the performance of CSI Drivers in Windows - There should be an improvement in the performance by + removing the communication aspects between the CSI Driver and CSI Proxy (the protobuf serialization/deserialization, + the gRPC call through named pipes) however this improvement might not be noticeable, most of the latency + comes from doing the format/mount operations through powershell commands which is outside the scope of this change. +- Define security implementation details - A goal is to understand the security implications of enabling HostProcess + containers, we aim to provide guidelines but not implementation details about the components that need to be installed + in the cluster. + +## Proposal + + +As part of the transition of CSI Drivers to HostProcess containers we would like to: + +- Refactor the CSI Proxy codebase to become a Go library instead of the current client/server model. +- Define guidelines for the transition of CSI Drivers to HostProcess containers, both the changes in the Go code + and the way it's deployed and some considerations about security. + +### Notes/Constraints/Caveats + + +HostProcess containers run as processes in the host, one of the differences with a privileged Linux container +is that there's no filesystem isolation, this means that enabling HostProcess containers should be done for +system components only. This point will be expanded in the detailed design. + +### Risks and Mitigations + + + +Security implications of HostProcess containers will be reviewed by the SIG Windows team and the SIG Storage team +initially. + + +## Design Details + + + +The following paragraphs summarize the architecture of CSI Proxy, how CSI Drivers use it, the purpose of the conversion +layer of CSI Proxy that enables backward compatibility with previous API Versions and a description of the files +generated by the conversion layer used in CSI Proxy. + +CSI Proxy has a client/server design with two main components: + +* a binary that runs in the host (aka CSI Proxy server), this binary can execute privileged storage operations on the + host, once configured to run as a Windows service it creates named pipes on startup for all the versions of the API + Groups defined on the codebase. +* client go libraries that CSI Drivers and Addons import to connect to the CSI Proxy server, the methods and objects + available in the library are defined with [protobuf](https://github.com/kubernetes-csi/csi-proxy#feature-status), on + startup the CSI Driver initializes a client for each version of the API Groups required which will connect and issue + requests through gRPC to their pre-configured named pipes on the host. + +CSI Driver implementers can write a Windows specific implementation of the node component of the CSI Driver. In the +implementation a CSI Driver will make use of the imported CSI Proxy client libraries to issue privileged storage +operations, assuming that a volume was created and attached to a node by the controller component of the CSI Driver +the following CSI calls will be done by the kubelet to the CSI Driver. + +**Volume set up** + +* NodeStageVolume - Create a Windows volume, format it to NTFS, create a partition access path in the node (global mount). +* NodePublishVolume - Create a symlink from the kubelet Pod-PVC path to the global path (pod mount). + +**Volume tear down** + +* NodeUnpublishVolume - Remove the symlink created above. +* NodeUnstageVolume - Remove the partition access path. + +CSI Proxy is designed to be backwards compatible and a single binary running in the Windows node can serve requests from +multiple CSI Proxy client versions, we're able to do this because the CSI Proxy binary on startup will create named +pipes for all the versions available in every API Group (e.g. the Volume, Disk, Filesystem, SMB groups), in addition, +there's a conversion layer in the CSI Proxy binary that transform client version specific requests to server "version +agnostic" requests which are then processed by the CSI Proxy binary, the following diagram shows the conversion process +(from the [CSI Proxy development docs](https://github.com/kubernetes-csi/csi-proxy/blob/master/docs/DEVELOPMENT.md)): + +![csi-proxy-client-server](./csi-proxy-client-server.jpg) + +Understanding the conversion layer will help in the transition to HostProcess containers as most of the code that the +clients use to communicate with the CSI Proxy server is generated. The conversion layer objective is to generate go code +that maps the versioned client requests to server agnostic requests, it does so by analyzing the generated api.pb.go +files (generated through `protoc` from the protobuf files) for each version of the API Groups and generating multiple +files for different purposes (taking as example the Volume API Group): + + +* [\/server_generated.go](https://github.com/kubernetes-csi/csi-proxy/blob/master/pkg/server/volume/impl/v1beta3/server_generated.go) + - The gRPC server implementation of the methods of a versioned API Group, each method receives a versioned request and + expects a versioned response, the code generated follows this pattern: + +``` +func v1Foo(v1Request v1FooRequest) v1FooResponse { + + // convert versioned request to server request (version agnostic) + fooRequest = convertV1FooRequestToFooRequest(v1Request) + + // process request (server handler) + fooResponse = server.Foo(fooRequest) + + // convert server response (version agnostic) to versioned response + v1Response = convertFooResponseToV1FooResponse(fooResponse) + + return v1Response +} +``` + + +* [types_generated.go](https://github.com/kubernetes-csi/csi-proxy/blob/master/pkg/server/volume/impl/types_generated.go) + the idea is to collect all the methods available across all the versions of an API Group so that the server has a + corresponding implementation for it, the generator reads all the methods found across the + volume/<version>/api.pb.go files and generates an interface with all the methods found that the server must + implement, in the example above the server interface will have the `Foo` method +* [\/conversion_generated.go](https://github.com/kubernetes-csi/csi-proxy/blob/master/pkg/server/volume/impl/v1/conversion_generated.go) + The generated implementation of the conversion functions shown above (e.g. `convertV1FooRequestToFooRequest`, + `convertFooResponseToV1FooResponse`) in some cases it's possible that the conversion code generator generates a nested + data structure that's not built correctly, there's an additional file with overrides for the functions that were + generated incorrectly. +* client [\/\/client_generated.go](https://github.com/kubernetes-csi/csi-proxy/blob/master/client/groups/volume/v1/client_generated.go) + Generated in the client libraries to be used by users of the CSI Proxy client, it creates proxy methods corresponding + to the api.pb.go methods of the versioned API Group, this file defines the logic to create a connection to the + corresponding named pipe creating a gRPC client out of it and storing it for later usage, as a result, the proxy + methods don't need a reference to the gRPC client. + + +### Prerequisite: Make CSI Proxy an embedded library without a server component + +If we configure the Windows node component of a CSI Driver/Addon to be a Windows HostProcess pod then it'll be able to +use the same powershell commands that we use in the server code of CSI Proxy, the idea is to use the server code of CSI +Proxy as a library in CSI Drivers/Addons. With this, we also remove the server component. + +As described in the [Windows HostProcess Pod](https://kubernetes.io/docs/tasks/configure-pod-container/create-hostprocess-pod/) +guide we'd need to configure the PodSpec of node component of the CSI Driver/Addon that runs in Windows nodes with: + + +```yaml +spec: + securityContext: + windowsOptions: + hostProcess: true + runAsUserName: "NT AUTHORITY\\SYSTEM" +``` + + +### Implementation idea 1: Update the conversion layer to use the server code gRPC + +Modify the implementation of [\/\/client_generated.go](https://github.com/kubernetes-csi/csi-proxy/blob/master/client/groups/volume/v1/client_generated.go) +so that it calls the server implementation directly (which should be part of the imported go module), the current +implementation uses `w.client` which is the gRPC client: + + +```go +func (w *Client) GetVolumeStats( + context context.Context, + request *v1.GetVolumeStatsRequest, + opts ...grpc.CallOption +) (*v1.GetVolumeStatsResponse, error) { +        return w.client.GetVolumeStats(context, request, opts...) +} +``` + + +The new implementation should use the server code instead, in the server code `volumeserver` is the implementation agnostic server that's instantiated by every versioned client `volumeservervX` e.g. + + +```go +import  v1 "github.com/kubernetes-csi/csi-proxy/client/api/volume/v1" +import volumeserver "github.com/kubernetes-csi/csi-proxy/pkg/server/volume" +import volumeserverv1 "github.com/kubernetes-csi/csi-proxy/pkg/server/volume/v1" + +// initialize all the versioned volume servers i.e. do what cmd/csi-proxy does but on the client +serverImpl := volumeserver.NewServer() + +// shim that would need to be auto generated for every version +serverv1 := volumeserverv1.NewVersionedServer(serverImpl) + +// client still calls the conversion handler code +func (w *Client) GetVolumeStats( +  context context.Context, +  request *v1.GetVolumeStatsRequest +) (*v1.GetVolumeStatsResponse, error) { +        return serverv1.GetVolumeStats(context, request) +} +``` + +![csi-proxy-reuse-client-server-pod](./csi-proxy-reuse-client-server-pod.jpg) + +Pros: + +* We get to reuse the protobuf code. +* We would still support the client/server model as this is a new method that clients would use. +* We only need to change the client import paths to use the alternative version that doesn't connect to the server with + gRPC, which minimizes the changes necessary in the client code. + +Cons: + +* New APIs would need to be added to the protobuf file, and we would need to run the code generation tool again, with + the rule of not modifying already released API Groups. This means that we would also need to create another API Group + version for a new API. +* We still have two distinct concepts of version: the Go module version and the API version. Given that we want to use + CSI Proxy as a library, it makes sense to use the Go module version as the source of truth and implement a single API + version in each Go version. + +### Implementation idea 2: Update the CSI Drivers to use the server code directly (preferred) + +Modify the client code to use the server API handlers directly which would call the server implementation next, this +means that the concept of an "API version" is also removed from the codebase, the clients instead would import and use +the internal server structs (request and response objects). + +Currently, GCE PD CSI driver uses the v1 Filesystem API group as follows: + + +```go +// note the API version in the imports +import  fsapi "github.com/kubernetes-csi/csi-proxy/client/api/filesystem/v1" +import  fsclient "github.com/kubernetes-csi/csi-proxy/client/groups/filesystem/v1" +func NewCSIProxyMounterV1() (*CSIProxyMounterV1, error) { +        fsClient, err := fsclient.NewClient() +        if err != nil { +                return nil, err +        } +        return &CSIProxyMounterV1{ +                FsClient:     fsClient, +        }, nil +} + +// ExistsPath - Checks if a path exists. Unlike util ExistsPath, this call does not perform follow link. +func (mounter *CSIProxyMounterV1) PathExists(path string) (bool, error) { +        isExistsResponse, err := mounter.FsClient.PathExists(context.Background(), +                &fsapi.PathExistsRequest{ +                        Path: mount.NormalizeWindowsPath(path), +                }) +        if err != nil { +                return false, err +        } +        return isExistsResponse.Exists, err +} + +// usage +csiProxyV1, _ := NewCSIProxyMounterV1() +csiProxyV1.PathExists(path) +``` + + +Internally the PathExists call is in the file [\/\/client_generated.go](https://github.com/kubernetes-csi/csi-proxy/blob/master/client/groups/volume/v1/client_generated.go) +described above which performs the execution through gRPC, in the proposal we'd need to use the server implementation +instead + +```go +// note that there is no version in the import +import fsserver "github.com/kubernetes-csi/csi-proxy/pkg/server/filesystem" +import fsserverimpl "github.com/kubernetes-csi/csi-proxy/pkg/server/filesystem/impl" +import fsapi "github.com/kubernetes-csi/csi-proxy/pkg/os/filesystem" + +// no need to initialize a gRPC client, however the server handler impl is initialized instead +// no need for a versioned client + +func NewCSIProxyMounter() (*CSIProxyMounter, error) { + fsServer, err := fsserver.NewServer(fsapi.New()) +  if err != nil { +  return nil, err +  } +  return &CSIProxyMounter{ + FsServer: fsServer, + }, nil +} + +// ExistsPath - Checks if a path exists. Unlike util ExistsPath, this call does not perform follow link. +func (mounter *CSIProxyMounter) PathExists(path string) (bool, error) { +        isExistsResponse, err := mounter.FsServer.PathExists(context.Background(), +                &fsserverimpl.PathExistsRequest{ +                        Path: mount.NormalizeWindowsPath(path), +                }, + // 3rd arg is the version, remove the version here too! + ) +        if err != nil { +                return false, err +        } +        return isExistsResponse.Exists, err +} + +// usage +csiProxy, _ := NewCSIProxyMounter() +csiProxy.PathExists(path) +``` + +![csi-proxy-libary](./csi-proxy-library.jpg) + +Pros: + +* We remove the concept of API Version & the conversion layer and instead consider the go mod version as the API + version. This is how other libraries like k8s.io/mount-utils work. + * Version dependent server validation in the API handler layer is removed. + * Legacy structs for older API versions are removed. +* New APIs are easier to add. Only the server handler & impl code is modified, so there’s no need for the code + generation tool anymore. + +Cons: + +* The client goes through a bigger diff. Every occurrence of a call to a CSI Proxy method needs to be modified to use + the server handler & impl code, but this penalty is paid only once. + * Legacy interface implementations for the v1beta API in the CSI Drivers are removed. +* As we no longer use protobuf to define the API and use internal structs instead, we'd need to update the API docs to + be directly generated from source code (including the comments around server handler methods and internal server + structs). + +It is worth noting that at this point, the notion of a server is no longer valid, as CSI Proxy has become a +library. We can take this opportunity to reorganize the packages by (a) moving /pkg/server/\ and +/pkg/server/\/impl to /pkg/\ (b) moving /pkg/os/\ to /pkg/\/api. +The new structure looks like: + + +``` +pkg +├── disk +│ ├── api +│ │ ├── api.go +│ │ └── types.go +│ ├── disk.go +│ └── types.go +├── iscsi +│ ├── api +│ │ ├── api.go +│ │ └── types.go +│ ├── disk.go +│ └── types.go +``` + +There are also three minor details we can take care of while we’re migrating: + +1. The two structs under pkg/shared/disk/types.go are only ever referenced by pkg/os/disk, so they can be safely added + to pkg/disk/api/types.go. +2. The FS server receives workingDirs as an input, in addition to the OS API. It’s only used to sandbox what directories + the CSI Proxy is enabled to operate on. Now that control is part of the CSI Driver, we can safely remove it. +3. pkg/os/filesystem is no longer necessary, as the implementation just calls out to the Golang standard library os + package. We can deprecate it in release notes and remove in a future release. + +### Implementation idea 3: Convert CSI Proxy to a Library of Functions + +With the new changes, CSI Proxy is effectively just a library of Go functions mapping to Windows commands. The notion of +servers and clients is no longer relevant, so it makes sense to restructure the package into a library of functions, +with each API Group’s interfacing functions and types provided under pkg/\ (right now, these files sit at +pkg/server/\/server.go and pkg/server/\/impl/types.go). The OS-facing API at /pkg/os is kept +is, and the corresponding OS API struct is initialized globally inside each pkg/\ (to allow for subbing +during testing). All other code can be safely deleted. + +```go +// there is now only one single import +import fs "github.com/kubernetes-csi/csi-proxy/pkg/fs" + +// there is no longer a need to initialize a server +func NewCSIProxyMounter() *CSIProxyMounter { +  return &CSIProxyMounter{ + } +} + +// ExistsPath - Checks if a path exists. Unlike util ExistsPath, this call does not perform follow link. +func (*CSIProxyMounter) PathExists(path string) (bool, error) { + // both mounter.FsServer and fsserverimpl are changed to just fs +        isExistsResponse, err := fs.PathExists(context.Background(), +                &fs.PathExistsRequest{ +                        Path: mount.NormalizeWindowsPath(path), +                } + ) +        if err != nil { +                return false, err +        } +        return isExistsResponse.Exists, err +} + +// usage +csiProxy := NewCSIProxyMounter() +csiProxy.PathExists(path) + +// at test time +fs.UseAPI(mockAPI) +// run tests… +fs.ResetAPI() +``` + +This is the most invasive option of all three. Specifically, we combine the two imports into one and move to a pure +function paradigm. However, the method implementation sees very minimal changes, requiring only import path updates. + +Pros: + +* Like implementation idea 2, we switch to a single notion of version via Go modules. +* The pure function paradigm more accurately reflects the nature of the new design, which simplifies how clients use the + library. +* Like implementation idea 2, new APIs are easier to add by moving away from code generation. + +Cons: + +* There is now an implicit dependency on the os API package-level variable. Testing can still be done by subbing out the + variable with a mock implementation during test time. +* More work (2 imports -> 1, remove server initialization, replace function call and request type package names) needs + to be done by clients to adapt to the new change, though it’s not that much more than implementation idea 2. Again, + the price is only paid once. +* Like impl idea 2, we also need to transition our API doc generation to generate from Go source. + + +### Comparison Matrix + +| |Idea 1: Update the conversion layer to use the server code gRPC|Idea 2: Update the CSI Drivers to use the server code directly (preferred)|Idea 3: Convert CSI Proxy to a Library of Functions| +| --- |--- |--- |--- | +| Adoption cost|Minimal (only changing imports)|Considerate (imports and API calls)|Considerate (imports, API calls, and initialization)| +| Future development|Still need code generation and and protobuf|Directly add methods to Go code, but leaves legacy notion of “server”|Directly add functions to Go code. Code base cleaned up| +| Versioning|Both Go mod version and API version are maintained|Go mod version only|Go mod version only| +| Testing|Current tests should still work.|Current tests should still work.|OS API mocking needs to be subbed in, as we have an implicit dependency| +| Support for legacy client/server model|Still supported|Not supported|Not supported| + + +### Maintainance of the new model and existing client/server model of CSI Proxy + +The `library-development` branch will be used for the development of this model, `master` will have the existing +client/server mode. We plan to create alpha tags on the `library-development` branch and use it in CSI Drivers, +next once it's integrated we will create a v2 tag, make `library-deveopment` the new default (`master` will point +to the new implementation, `v1.x` will point to the existing one). + +`v1.x` will still be open for urgent bug fixes but new features should go into the new model. + +### Security analysis + +We suggest enabling HostProcess containers only for system workloads, one of the drawbacks of this new mode is the +lack of filesystem isolation which means that HostProcess containers have entire visibility of the host fileystem, +to prevent workloads from accessing specific paths in the host we recommend: + +- Creating a Windows user with limited permissions to create files under the kubelet controlled path `C:\var\lib\kubelet` +- Enabling PodSecurityAdmission on the namespace where system components run, note that this needs an additiona + admission webhook to be installed in the cluster. + +### Test Plan + +#### Unit tests + + + + + +For CSI Proxy we already have unit tests inside `pkg/\`, these tests +are run on presubmit on every PR. + +Examples: + +- [volume tests](https://github.com/kubernetes-csi/csi-proxy/blob/c0c6293490fd8aec269685bb4089be56d69921b1/pkg/volume/volume_test.go) +- [filesystem tests](https://github.com/kubernetes-csi/csi-proxy/blob/c0c6293490fd8aec269685bb4089be56d69921b1/pkg/filesystem/filesystem_test.go) + +#### Integration tests + + + +For CSI Proxy we already have integration tests inside `integrationtests`, these tests +are run on presubmit on every PR. + +Examples: + +- [volume integration tests](https://github.com/kubernetes-csi/csi-proxy/blob/c0c6293490fd8aec269685bb4089be56d69921b1/integrationtests/volume_test.go) +- [filesystem integration tests](https://github.com/kubernetes-csi/csi-proxy/blob/c0c6293490fd8aec269685bb4089be56d69921b1/integrationtests/filesystem_test.go) +- [iscsi integration tests](https://github.com/kubernetes-csi/csi-proxy/blob/c0c6293490fd8aec269685bb4089be56d69921b1/integrationtests/iscsi_test.go) +- [system integration tests](https://github.com/kubernetes-csi/csi-proxy/blob/c0c6293490fd8aec269685bb4089be56d69921b1/integrationtests/system_test.go) +- [smb integration tests](https://github.com/kubernetes-csi/csi-proxy/blob/c0c6293490fd8aec269685bb4089be56d69921b1/integrationtests/smb_test.go) +- [disk integration tests](https://github.com/kubernetes-csi/csi-proxy/blob/c0c6293490fd8aec269685bb4089be56d69921b1/integrationtests/disk_test.go) + +#### e2e tests + + + +OSS storage e2e tests run out of tree, we plan to migrate at least 1 CSI Driver to use the CSI Proxy library +and see the existing e2e tests passing. + +### Graduation Criteria + + +Most of the code used by CSI Drivers through CSI Proxy is already GA, this KEP is defining a new mechanism to run +the same code that the CSI Driver executes through CSI Proxy directly through the CSI Driver itself. + + +### Upgrade / Downgrade Strategy + + +The following is a list of items that need to happen in different components of CSI in Windows for CSI Drivers +to become HostProcess containers: + +**CSI Proxy** + +- Start a development branch for the upcoming work (`library-development`). +- Refactor the filesystem, disk, volume, system, iSCSI, SMB API Groups out of the current client/server. +- Remove the client/server code from the codebase. +- Update the unit and integration tests to work with the refactored code. +- Run the integration tests in a HostProcess container. +- Update the README and DEVELOPEMENT docs. +- Once the above items are completed we can create an alpha tag in the `library-development` branch to + use it in CSI Drivers. + +**CSI Driver** + +- Update the CSI Proxy library to the alpha tag from the `library-development` version. +- Update the codebase import to use the server impl directly instead of the client library. +- Update the CSI Driver deployment manifest with the HostProcess container fields in the PodSpec. +- Run the e2e tests. + +### Version Skew Strategy + + +Previously, CSI Proxy has a different release cycle than the CSI Driver where each binary had its own version and +supported different CSI Proxy clients. Once CSI Proxy becomes a library the version will be managed by the go module +version instead (similar to kubernetes/mount-utils). + +## Production Readiness Review Questionnaire + + + +### Feature Enablement and Rollback + + + +###### How can this feature be enabled / disabled in a live cluster? + + + +- [ ] Feature gate (also fill in values in `kep.yaml`) + - Feature gate name: + - Components depending on the feature gate: +- [ ] Other + - Describe the mechanism: + - Will enabling / disabling the feature require downtime of the control + plane? + - Will enabling / disabling the feature require downtime or reprovisioning + of a node? (Do not assume `Dynamic Kubelet Config` feature is enabled). + +###### Does enabling the feature change any default behavior? + + + +###### Can the feature be disabled once it has been enabled (i.e. can we roll back the enablement)? + + + +###### What happens if we reenable the feature if it was previously rolled back? + +###### Are there any tests for feature enablement/disablement? + + + +### Rollout, Upgrade and Rollback Planning + + + +###### How can a rollout or rollback fail? Can it impact already running workloads? + + + +###### What specific metrics should inform a rollback? + + + +###### Were upgrade and rollback tested? Was the upgrade->downgrade->upgrade path tested? + + + +###### Is the rollout accompanied by any deprecations and/or removals of features, APIs, fields of API types, flags, etc.? + + + +### Monitoring Requirements + + + +###### How can an operator determine if the feature is in use by workloads? + + + +###### How can someone using this feature know that it is working for their instance? + + + +- [ ] Events + - Event Reason: +- [ ] API .status + - Condition name: + - Other field: +- [ ] Other (treat as last resort) + - Details: + +###### What are the reasonable SLOs (Service Level Objectives) for the enhancement? + + + +###### What are the SLIs (Service Level Indicators) an operator can use to determine the health of the service? + + + +- [ ] Metrics + - Metric name: + - [Optional] Aggregation method: + - Components exposing the metric: +- [ ] Other (treat as last resort) + - Details: + +###### Are there any missing metrics that would be useful to have to improve observability of this feature? + + + +### Dependencies + + + +###### Does this feature depend on any specific services running in the cluster? + + + +### Scalability + + + +###### Will enabling / using this feature result in any new API calls? + + + +###### Will enabling / using this feature result in introducing new API types? + + + +###### Will enabling / using this feature result in any new calls to the cloud provider? + + + +###### Will enabling / using this feature result in increasing size or count of the existing API objects? + + + +###### Will enabling / using this feature result in increasing time taken by any operations covered by existing SLIs/SLOs? + + + +###### Will enabling / using this feature result in non-negligible increase of resource usage (CPU, RAM, disk, IO, ...) in any components? + + + +### Troubleshooting + + + +###### How does this feature react if the API server and/or etcd is unavailable? + +###### What are other known failure modes? + + + +###### What steps should be taken if SLOs are not being met to determine the problem? + +## Implementation History + + + +## Drawbacks + + + +## Alternatives + + + +## Infrastructure Needed (Optional) + + diff --git a/keps/sig-windows/3636-windows-csi-host-process-pods/csi-proxy-client-server.jpg b/keps/sig-windows/3636-windows-csi-host-process-pods/csi-proxy-client-server.jpg new file mode 100644 index 0000000000000000000000000000000000000000..656deb3868e26acc0ed0096c6c349bbf53866f1f GIT binary patch literal 59320 zcmeFZ1yo$!wk}w>YjAf6mf-HeLI~~YFB<^t_cHP_02o*R00#O6cv%KW0gw?9kq{A( zk&uv3P>@m4@i5TQ(9nr-Ut!^qlTcESlaP^7(Xlg9(Xi5zkumYTW_`=S&CN~8C?LYm zDa_8r&G}~%7!(u~bTo7#3=ASpYBFlh|Hq$~E&vWP%oq3tI2alLEDj7D4$Mn0fD*b+ z1em{l0RQ}ffrW!dKtw`DK}CZ;P>&6Og@J>Eg@;2xfQN@Z?F0Qi03HVcmzqNY@s)}( z5)BBCGaxPpnO3s88(($moQ})HDG&vffRKoogr0$s=`}Mq4=*3TfS}YnX&G5L`S)t- z8k$<#I=ZH2<`$M#Kx=0gS2uSLPp_aa!6Bhv!@}bez9l9lr+iP%&C4$+EGjN3t*Nc6 zZ)j|4Zu!~M+t)uZI5a#xGdnlGu($-?+}eih?C$L!99~>r{kp!nz59Lthb|ZZ+&_^8 z{r*pc{e>yP?hnralQmMn{H7xMB&Bg@8qZYLh3DQY)>1>%k+P zG8iEZXj4R7|AyMo15~1q;(W&b1aY2hV1iQ(A8DCnJv}}-F-ud`KIzBFovoyGe!eOT z@w>y}erU&?zS&*d(s7vE08oW0XVUWv{7xiec>#0Ju~!KhY0 zgRnk0WBakb0M^!WFNx-0Mm0#SA%0DpQgNwf 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 literal 0 HcmV?d00001 diff --git a/keps/sig-windows/3636-windows-csi-host-process-pods/csi-proxy-library.jpg b/keps/sig-windows/3636-windows-csi-host-process-pods/csi-proxy-library.jpg new file mode 100644 index 0000000000000000000000000000000000000000..9a708170e981fe024704ddd530fffa2d133ef35d GIT binary patch literal 22071 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 Ng7EL-PVzYOzW_OkYS{n) literal 0 HcmV?d00001 diff --git a/keps/sig-windows/3636-windows-csi-host-process-pods/csi-proxy-reuse-client-server-pod.jpg b/keps/sig-windows/3636-windows-csi-host-process-pods/csi-proxy-reuse-client-server-pod.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a7ed48292ea4c1016026daadad179f10ba37de2f GIT binary patch literal 45206 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 H@umM?guYh8 literal 0 HcmV?d00001 diff --git a/keps/sig-windows/3636-windows-csi-host-process-pods/kep.yaml b/keps/sig-windows/3636-windows-csi-host-process-pods/kep.yaml new file mode 100644 index 000000000000..93b3d2eaf95b --- /dev/null +++ b/keps/sig-windows/3636-windows-csi-host-process-pods/kep.yaml @@ -0,0 +1,41 @@ +title: CSI Drivers in Windows as a HostProcess Pods +kep-number: 3636 +authors: + - "@mauriciopoppe" +owning-sig: sig-storage +participating-sigs: + - sig-windows +status: implementable +creation-date: 2022-10-23 +reviewers: + - "@msau42" + - "@ddebroy" +approvers: + - "@msau42" + +see-also: + - "/keps/sig-windows/1122-windows-csi-support" +replaces: + - "/keps/sig-windows/1122-windows-csi-support" + +# The target maturity stage in the current dev cycle for this KEP. +stage: alpha + +# The most recent milestone for which work toward delivery of this KEP has been +# done. This can be the current (upcoming) milestone, if it is being actively +# worked on. +latest-milestone: "v1.26" + +# The milestone at which this feature was, or is targeted to be, at each stage. +milestone: + alpha: "v1.26" + beta: "v1.27" + stable: "v1.28" + +# The following PRR answers are required at alpha release +# List the feature gate name and the components for which it must be enabled +feature-gates: [] +disable-supported: true + +# The following PRR answers are required at beta release +metrics: []