apiVersion: resource.k8s.io/v1alpha3 kind: ResourceClaim metadata: name: small-white-cat-claim spec: devices: requests: - name: req-0 deviceClassName: resource.example.com selectors: - cel: expression: |- device.attributes[“resource-driver.example.com”].color == “white” && device.attributes[“resource-driver.example.com”].size == “small”
### **ResourceClaimTemplate**
ResourceClaimTemplate wird verwendet, um ResourceClaims zu erstellen. Es wird vom resourceclaim-Controller des kube-controller-managers verwaltet. Hier ist der Code-Ausschnitt zum Erstellen:
```go
func (ec *Controller) handleClaim(ctx context.Context, pod *v1.Pod, podClaim v1.PodResourceClaim, newPodClaims *map[string]string) error {
claimName, mustCheckOwner, err := resourceclaim.Name(pod, &podClaim)
switch {
case errors.Is(err, resourceclaim.ErrClaimNotFound):
......
}
// Before we create a new ResourceClaim, check if there is an orphaned one.
// This covers the case that the controller has created it, but then fails
// before it can update the pod status.
claim, err := ec.findPodResourceClaim(pod, podClaim)
if err != nil {
return fmt.Errorf("finding ResourceClaim for claim %s in pod %s/%s failed: %v", podClaim.Name, pod.Namespace, pod.Name, err)
}
if claim == nil {
template, err := ec.templateLister.ResourceClaimTemplates(pod.Namespace).Get(*templateName)
if err != nil {
return fmt.Errorf("resource claim template %q: %v", *templateName, err)
}
// Create the ResourceClaim with pod as owner, with a generated name that uses
// <pod>-<claim name> as base.
isTrue := true
annotations := template.Spec.ObjectMeta.Annotations
if annotations == nil {
annotations = make(map[string]string)
}
annotations[podResourceClaimAnnotation] = podClaim.Name
generateName := pod.Name + "-" + podClaim.Name + "-"
maxBaseLen := 57 // Leave space for hyphen and 5 random characters in a name with 63 characters.
if len(generateName) > maxBaseLen {
// We could leave truncation to the apiserver, but as
// it removes at the end, we would loose everything
// from the pod claim name when the pod name is long.
// We can do better and truncate both strings,
// proportional to their length.
generateName = pod.Name[0:len(pod.Name)*maxBaseLen/len(generateName)] +
"-" +
podClaim.Name[0:len(podClaim.Name)*maxBaseLen/len(generateName)]
}
claim = &resourceapi.ResourceClaim{
ObjectMeta: metav1.ObjectMeta{
GenerateName: generateName,
OwnerReferences: []metav1.OwnerReference{
{
APIVersion: "v1",
Kind: "Pod",
Name: pod.Name,
UID: pod.UID,
Controller: &isTrue,
BlockOwnerDeletion: &isTrue,
},
},
Annotations: annotations,
Labels: template.Spec.ObjectMeta.Labels,
},
Spec: template.Spec.Spec,
}
metrics.ResourceClaimCreateAttempts.Inc()
claimName := claim.Name
claim, err = ec.kubeClient.ResourceV1alpha3().ResourceClaims(pod.Namespace).Create(ctx, claim, metav1.CreateOptions{})
if err != nil {
metrics.ResourceClaimCreateFailures.Inc()
return fmt.Errorf("create ResourceClaim %s: %v", claimName, err)
}
logger.V(4).Info("Created ResourceClaim", "claim", klog.KObj(claim), "pod", klog.KObj(pod))
ec.claimCache.Mutation(claim)
}
Warum ResourceClaimTemplate einführen?
Betrachten Sie das folgende Beispiel innerhalb einer Pod-Spezifikation: Das Feld resourceClaims ermöglicht es Ihnen, entweder auf einen ResourceClaim oder eine ResourceClaimTemplate zu verweisen, aber nicht auf beides – sie schließen sich gegenseitig aus. Wenn Sie über resourceClaimName auf einen ResourceClaim verweisen, teilen sich alle Pods, die diese Pod-Spezifikation verwenden (z. B. in einem Deployment oder StatefulSet), dieselbe ResourceClaim-Instanz. Diese Instanz entspricht dem ResourceClaim mit dem durch resourceClaimName angegebenen Namen im selben Namespace wie der Pod.
Umgekehrt erhält jeder Pod seine eigene separate ResourceClaim-Instanz, wenn Sie über resourceClaimTemplateName auf eine ResourceClaimTemplate verweisen. Dies liegt daran, dass der resourceclaim-Controller des kube-controller-managers automatisch für jeden Pod einen separaten ResourceClaim erstellt.
Hier ist ein vereinfachtes Beispiel für eine Pod-Spezifikation:
–--
apiVersion: v1
kind: Pod
metadata:
name: pod-with-cats
spec:
containers:
- name: container0
image: ubuntu:20.04
command: ["sleep", "9999"]
resources:
claims:
- name: cat-0
- name: container1
image: ubuntu:20.04
command: ["sleep", "9999"]
resources:
claims:
- name: cat-1
resourceClaims:
- name: cat-0
resourceClaimName: small-white-cat-claim
- name: cat-1
resourceClaimTemplateName: large-black-cat-claim-template
DeviceClass
Die DeviceClass umfasst die Konfiguration und den Selektor für ein Gerät, wie unten definiert.
// +genclient
// +genclient:nonNamespaced
// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
// +k8s:prerelease-lifecycle-gen:introduced=1.31
// DeviceClass is a vendor- or admin-provided resource that contains
// device configuration and selectors. It can be referenced in
// the device requests of a claim to apply these presets.
// Cluster scoped.
//
// This is an alpha type and requires enabling the DynamicResourceAllocation
// feature gate.
type DeviceClass struct {
metav1.TypeMeta `json:",inline"`
// Standard object metadata
// +optional
metav1.ObjectMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
// Spec defines what can be allocated and how to configure it.
//
// This is mutable. Consumers have to be prepared for classes changing
// at any time, either because they get updated or replaced. Claim
// allocations are done once based on whatever was set in classes at
// the time of allocation.
//
// Changing the spec automatically increments the metadata.generation number.
Spec DeviceClassSpec `json:"spec" protobuf:"bytes,2,name=spec"`
}
// DeviceClassSpec is used in a [DeviceClass] to define what can be allocated
// and how to configure it.
type DeviceClassSpec struct {
// Each selector must be satisfied by a device which is claimed via this class.
//
// +optional
// +listType=atomic
Selectors []DeviceSelector `json:"selectors,omitempty" protobuf:"bytes,1,opt,name=selectors"`
// Config defines configuration parameters that apply to each device that is claimed via this class.
// Some classses may potentially be satisfied by multiple drivers, so each instance of a vendor
// configuration applies to exactly one driver.
//
// They are passed to the driver, but are not considered while allocating the claim.
//
// +optional
// +listType=atomic
Config []DeviceClassConfiguration `json:"config,omitempty" protobuf:"bytes,2,opt,name=config"`
// Only nodes matching the selector will be considered by the scheduler
// when trying to find a Node that fits a Pod when that Pod uses
// a claim that has not been allocated yet *and* that claim
// gets allocated through a control plane controller. It is ignored
// when the claim does not use a control plane controller
// for allocation.
//
// Setting this field is optional. If unset, all Nodes are candidates.
//
// This is an alpha field and requires enabling the DRAControlPlaneController
// feature gate.
//
// +optional
// +featureGate=DRAControlPlaneController
SuitableNodes *v1.NodeSelector `json:"suitableNodes,omitempty" protobuf:"bytes,3,opt,name=suitableNodes"`
}
Wenn Benutzer einen ResourceClaim oder eine ResourceClaimTemplate erstellen, müssen sie die entsprechende DeviceClass über die deviceClassName angeben. Der Scheduler weist Knoten Pods zu, indem er Geräte mithilfe des Selectors der DeviceClass abgleicht, und füllt schließlich die Gerätekonfiguration aus der DeviceClass in den Status der ResourceClaim-Instanz.
if requestData.class != nil {
match, err := alloc.selectorsMatch(r, device, deviceID, requestData.class, requestData.class.Spec.Selectors)
if err != nil {
return false, err
}
if !match {
alloc.deviceMatchesRequest[matchKey] = false
return false, nil
}
}
request := &alloc.claimsToAllocate[r.claimIndex].Spec.Devices.Requests[r.requestIndex]
match, err := alloc.selectorsMatch(r, device, deviceID, nil, request.Selectors)
for claimIndex, allocationResult := range alloc.result {
claim := alloc.claimsToAllocate[claimIndex]
// Populate configs.
for requestIndex := range claim.Spec.Devices.Requests {
class := alloc.requestData[requestIndices{claimIndex: claimIndex, requestIndex: requestIndex}].class
if class != nil {
for _, config := range class.Spec.Config {
allocationResult.Devices.Config = append(allocationResult.Devices.Config, resourceapi.DeviceAllocationConfiguration{
Source: resourceapi.AllocationConfigSourceClass,
Requests: nil, // All of them...
DeviceConfiguration: config.DeviceConfiguration,
})
}
}
}
Code-Pfad: pkg\scheduler\framework\plugins\dynamicresources\dynamicresources.go
func (pl *dynamicResources) bindClaim(ctx context.Context, state *stateData, index int, pod *v1.Pod, nodeName string) (patchedClaim *resourceapi.ResourceClaim, finalErr error) {
if allocation != nil {
if claim.Status.Allocation != nil {
return fmt.Errorf("claim %s got allocated elsewhere in the meantime", klog.KObj(claim))
}
......
claim.Status.Allocation = allocation
}
claim.Status.ReservedFor = append(claim.Status.ReservedFor, resourceapi.ResourceClaimConsumerReference{Resource: "pods", Name: pod.Name, UID: pod.UID})
updatedClaim, err := pl.clientset.ResourceV1alpha3().ResourceClaims(claim.Namespace).UpdateStatus(ctx, claim, metav1.UpdateOptions{})
ResourceSlice
Kubernetes 1.30 führt ResourceSlice als wichtige Verbesserungsfunktion für DRA mit strukturierten Parametern ein. Die Erstellung und Wartung von ResourceSlice-Instanzen erfolgt durch kubelet und die von den Anbietern bereitgestellten Ressourcentreiber. Darüber hinaus bestimmt der Scheduler den Scheduling-Knoten basierend auf ResourceClaim und ResourceSlice während der Pod-Planung und übernimmt damit effektiv die Verantwortung für die Ressourcenzuweisung.
Das kubelet ist hauptsächlich für das automatische Löschen des ResourceSlice auf dem Knoten beim Start, Neustart oder beim Entfernen eines kubelet-Plugins verantwortlich.
// NewPluginHandler returns new registration handler.
//
// Must only be called once per process because it manages global state.
// If a kubeClient is provided, then it synchronizes ResourceSlices
// with the resource information provided by plugins.
func NewRegistrationHandler(kubeClient kubernetes.Interface, getNode func() (*v1.Node, error)) *RegistrationHandler {
handler := &RegistrationHandler{
// The context and thus logger should come from the caller.
backgroundCtx: klog.NewContext(context.TODO(), klog.LoggerWithName(klog.TODO(), "DRA registration handler")),
kubeClient: kubeClient,
getNode: getNode,
}
// When kubelet starts up, no DRA driver has registered yet. None of
// the drivers are usable until they come back, which might not happen
// at all. Therefore it is better to not advertise any local resources
// because pods could get stuck on the node waiting for the driver
// to start up.
//
// This has to run in the background.
go handler.wipeResourceSlices("")
return handler
}
// DeRegisterPlugin is called when a plugin has removed its socket,
// signaling it is no longer available.
func (h *RegistrationHandler) DeRegisterPlugin(pluginName string) {
if p := draPlugins.delete(pluginName); p != nil {
logger := klog.FromContext(p.backgroundCtx)
logger.V(3).Info("Deregister DRA plugin", "endpoint", p.endpoint)
// Clean up the ResourceSlices for the deleted Plugin since it
// may have died without doing so itself and might never come
// back.
go h.wipeResourceSlices(pluginName)
return
}
logger := klog.FromContext(h.backgroundCtx)
logger.V(3).Info("Deregister DRA plugin not necessary, was already removed")
}
Ressourcentreiber, auch DRA-Treiber genannt
Der Ressourcentreiber, auch bekannt als DRA-Treiber, muss von den Anbietern oder Benutzern selbst entwickelt werden. Er ist hauptsächlich für die Veröffentlichung von ResourceSlice-Ressourcen verantwortlich und fungiert als kubelet-Plugin, das Ressourcenvorbereitungsanfragen verarbeitet, die von kubelet ausgelöst werden. Letztendlich werden die Ressourcen über CDI genutzt.
Unten ist der relevante Code für die Initiierung von Ressourcenvorbereitungsanfragen durch kubelet.
// PrepareResources attempts to prepare all of the required resources
// for the input container, issue NodePrepareResources rpc requests
// for each new resource requirement, process their responses and update the cached
// containerResources on success.
func (m *ManagerImpl) PrepareResources(pod *v1.Pod) error {
batches := make(map[string][]*drapb.Claim)
resourceClaims := make(map[types.UID]*resourceapi.ResourceClaim)
for i := range pod.Spec.ResourceClaims {
podClaim := &pod.Spec.ResourceClaims[i]
klog.V(3).InfoS("Processing resource", "pod", klog.KObj(pod), "podClaim", podClaim.Name)
claimName, mustCheckOwner, err := resourceclaim.Name(pod, podClaim)
......
resourceClaim, err := m.kubeClient.ResourceV1alpha3().ResourceClaims(pod.Namespace).Get(
context.TODO(),
*claimName,
metav1.GetOptions{})
......
// Atomically perform some operations on the claimInfo cache.
err = m.cache.withLock(func() error {
claimInfo, exists := m.cache.get(resourceClaim.Name, resourceClaim.Namespace)
......
// Loop through all drivers and prepare for calling NodePrepareResources.
claim := &drapb.Claim{
Namespace: claimInfo.Namespace,
UID: string(claimInfo.ClaimUID),
Name: claimInfo.ClaimName,
}
for driverName := range claimInfo.DriverState {
batches[driverName] = append(batches[driverName], claim)
}
return nil
})
if err != nil {
return fmt.Errorf("locked cache operation: %w", err)
}
}
// Call NodePrepareResources for all claims in each batch.
// If there is any error, processing gets aborted.
// We could try to continue, but that would make the code more complex.
for driverName, claims := range batches {
// Call NodePrepareResources RPC for all resource handles.
client, err := dra.NewDRAPluginClient(driverName)
if err != nil {
return fmt.Errorf("failed to get gRPC client for driver %s: %w", driverName, err)
}
response, err := client.NodePrepareResources(context.Background(), &drapb.NodePrepareResourcesRequest{Claims: claims})
......
}
Mängel des DRA-Ansatzes mit Control Plane Controller
Der Nachteil des DRA-Ansatzes mit Control Plane Controller besteht darin, dass der Scheduler während der Pod-Planung einen PodSchedulingContext erstellt und der Ressourcentreiber die Ressourcen zuweist. Da die Pod-Planung sequentiell erfolgt, erhöht dies zwangsläufig die Verzögerung für andere Pods, die in der Warteschlange auf die Planung warten.
Zur Optimierung wurden strukturierte Parameter eingeführt, die es dem Ressourcentreiber ermöglichen, ResourceSlices proaktiv zu melden, sodass der Scheduler während der Pod-Planung direkt aus den ResourceSlices Planungsentscheidungen treffen kann.
Zusammenfassung
Derzeit können KI-Training und Inferenz von Kubernetes wie normale CPU-Container geplant werden, dies wird jedoch durch bestehende Kubernetes-Erweiterungsmechanismen erreicht, ohne eine einheitliche Lösung. Darüber hinaus werden die Funktionen, die Benutzer selbst implementieren müssen, umso komplexer, je komplexer die GPU-Ressourcenzuweisungsszenarien sind. Kubernetes DRA bietet eine einheitliche Lösung, bei der Anbieter oder Benutzer nur den Ressourcentreiber implementieren und DriverClass-Instanzkonfigurationen bereitstellen müssen. Da es offiziell unterstützt wird, muss man sich keine Sorgen machen, dass eine Open-Source-Lösung für die GPU-Planung nicht mehr gewartet wird.
DRA ist noch nicht ausgereift und wird ständig verbessert. Lassen Sie uns die neuesten Entwicklungen in der Community im Auge behalten.
