DETAILED ACTION
Claims 1-20 are pending
Notice of Pre-AIA or AIA Status
The present application, filed on or after March 16, 2013, is being examined under the first inventor to file provisions of the AIA .
Examiner Notes
Examiner cites particular columns and line numbers in the references as applied to the claims below for convenience of the applicant. Although the specified citations are representative of the teachings in the art and are applied to the specific limitations within the individual claim, other passages and figures may apply as well. It is respectfully requested that, in preparing responses, the applicant fully consider the references cited in their entirety as potentially teaching all or part of the claimed invention, as well as the context of the passage as taught by the prior art or disclosed by the examiner.
Claim Rejections - 35 USC § 103
The following is a quotation of 35 U.S.C. 103 which forms the basis for all obviousness rejections set forth in this Office action:
A patent for a claimed invention may not be obtained, notwithstanding that the claimed invention is not identically disclosed as set forth in section 102, if the differences between the claimed invention and the prior art are such that the claimed invention as a whole would have been obvious before the effective filing date of the claimed invention to a person having ordinary skill in the art to which the claimed invention pertains. Patentability shall not be negated by the manner in which the invention was made.
This application currently names joint inventors. In considering patentability of the claims the examiner presumes that the subject matter of the various claims was commonly owned as of the effective filing date of the claimed invention(s) absent any evidence to the contrary. Applicant is advised of the obligation under 37 CFR 1.56 to point out the inventor and effective filing dates of each claim that was not commonly owned as of the effective filing date of the later invention in order for the examiner to consider the applicability of 35 U.S.C. 102(b)(2)(C) for any potential 35 U.S.C. 102(a)(2) prior art against the later invention.
Claims 1-10 and 12-20 are rejected under 35 U.S.C. 103 as being unpatentable over Li (U.S. Pub. No. 11915049 B2) in view of Garimella et al. (U.S. Pub. No. 2024/0095085 A1), hereinafter Garimella.
Regarding claim 1, Li teaches A method comprising:
selecting a pod to act as an arbiter pod that controls pod allocation for nodes from a plurality of candidate pods ([30] – “The autoscaling operations are driven by an operator 330 which may be implemented on a control plane or other node. […] The operator is also coupled to one or more implementations of control plane nodes 320 through a Kubernetes API server 318.”; [33] – “The operator 330 interacts with the Kubernetes API server 318 and an infrastructure API server 336 […] to manage corresponding infrastructure object lifecycles.”; [15] – “The worker nodes run containerized applications by hosting pods. Pods are the components of the application workload.”);
responsive to determining that a scaling operation is to be performed ([43] – “The operator 330 reads the expected value for the scale subresource 328 from its managed custom resource 326, and the current scale subresource number from the infrastructure 334. It is then able to reconcile the gap between the two scale subresource values by actively creating or destroying the corresponding infrastructure resource VMs 350, 352.”; [56] – “an operator […] sends an API request for the system metric values to the metric server”; [58] – “using the received values at block 410, the autoscaler compares the received current metric value […] to desired metric values”),
Li fails to expressly teach instructing the arbiter pod to generate a placeholder node while an assigned node is instantiated; instructing the arbiter pod to bind one or more particular pods to the placeholder node; and responsive to determining that the assigned node is instantiated, instructing the arbiter pod to clear the placeholder node.
However, Garimella teaches instructing the arbiter pod to generate a placeholder node while an assigned node is instantiated ([0013] – “the orchestration service receives a request to deploy, for a placeholder service, a placeholder container onto resources of the target environment. The deployment of the placeholder container is carried out in a second mode (e.g., a “provisioner” mode) in which the orchestration service allocates resources for the placeholder container's deployment”; [0019] – “A placeholder container 130, in various embodiments, is a container whose deployment allows for one or more application containers 120 to be deployed. A placeholder container 130 may include an application that provides a service, a dummy application that does not provide any meaningful functionality, or no application at all”; [0033] – “In some embodiments, a single deploy application request 142 causes the deployment of an application container 120 and a placeholder container 130”);
instructing the arbiter pod to bind one or more particular pods to the placeholder node ([0022] – “Orchestration service 140 may receive a deploy placeholder request 144 to deploy a placeholder container 130. Accordingly, orchestration service 140 may create (or receive) a deployment object 150 for the placeholder container 130. If the resources 115 that are requested for the placeholder container 130 are not available in target environment 110, then orchestration service 140 may allocate the requested resources 115 as the deployment mode 152 for the placeholder container 130 may facilitate it. Orchestration service 140 may then deploy the placeholder container 130 onto those allocated resources 115. In many cases, the allocated resources 115 include resources 115 requested for application container 120.”; [0028] – “In response, orchestration service 140 may determine if there are available resources 115 (e.g., by examining volume objects 220) on which to deploy the placeholder container 130. If there are sufficient resources 115, then orchestration service 140 may bind the placeholder container 130 to the desired resources 115 (e.g., bind deployment object 150A to a volume object 220) and then deploy it onto those resources 115.”; [0030] – “After receiving a provision resources request 305, in various embodiments, resource provisioner service 310 allocates a node 320 [...] to target environment 110.”);
and responsive to determining that the assigned node is instantiated, instructing the arbiter pod to clear the placeholder node ([0034] – “After deploying the application container 120, orchestration service 120 may update the state 154 of deployment object 150B to indicate that the application container 120 has been deployed and its deployment is no longer pending.”; [0035] – “Thus, in various embodiments, orchestration service 140 performs garbage collection in which it reviews containers 120 and 130 and their deployment objects 150 and volume objects 220 and deletes volume objects 220 that do not have a backing node 320 or external volume 330 anymore. Deleting a volume object 220 may include deleting the binding between that volume object 220 and a volume claim 230.”).
Li and Garimella are considered to be analogous art to the claimed invention because they are in the same field as the claimed invention of application containers. Therefore, it would have been obvious to one of ordinary skill in the art to have modified the methods of Li to incorporate the placeholder service such that the placeholder can reserve resources for the assigned service as taught by Garimella. Incorporating the methods of Garimella may enable data to be accessed more efficiently and prevent data loss (see Garimella: [0003]).
Regarding claim 2, the combination of Li in view of Garimella teaches The method of claim 1.
Li further teaches indicating identity metadata ([41] – ““metadata”: {. “name”: “edge-sample”, .., },”)
Li fails to expressly teach wherein instructing the arbiter pod to generate the placeholder node comprises,
for the assigned node to be used by the placeholder while the assigned node is instantiated
However, Garimella teaches wherein instructing the arbiter pod to generate the placeholder node comprises,
for the assigned node to be used by the placeholder while the assigned node is instantiated ([0011] – “When an application is being readied for deployment, Kubernetes may create the PVC for the application based on information provided for deploying that application. The PVC can include information specifying storage size, access mode (e.g., rw, ro, etc.), and references to a storage class that controls how to provision an external storage persistent volume.”; [0022] – “Orchestration service 140 may then deploy the placeholder container 130 onto those allocated resources 115. In many cases, the allocated resources 115 include resources 115 requested for the application container 120.”)
Li and Garimella are considered to be analogous art to the claimed invention because they are in the same field as the claimed invention of application containers. Therefore, it would have been obvious to one of ordinary skill in the art to have modified the methods of Li to incorporate the sharing data between the placeholder and assigned node such that the placeholder shares identifying data with the assigned node as taught by Garimella. Incorporating the methods of Garimella may enable data to be accessed more efficiently and prevent data loss (see Garimella: [0003]).
Regarding claim 3, the combination of Li in view of Garimella teaches The method of claim 1.
Garimella further teaches wherein the scaling operation defines resources to be allocated to the assigned node ([0014] – “The deployment of the placeholder container is carried out in a second mode (e.g., a “provisioner” mode) in which the orchestration service allocates resources for the placeholder container's deployment. Thus, the orchestration service may allocate an additional set of resources […] to the target environment […] on which to execute the placeholder container. In response to the additional set of resources being allocated, the orchestration service deploys the application container of the distributed service onto those additional resources for execution [...] Moreover, a storage service may be allocated to scale up as a placeholder service can be scaled in proportion to the storage service in order to provide additional VMs with local volumes that can be used by new deployments of storage applications of the storage service.”).
Li and Garimella are considered to be analogous art to the claimed invention because they are in the same field as the claimed invention of application containers. Therefore, it would have been obvious to one of ordinary skill in the art to have modified the methods of Li to incorporate the resources for the assigned node such that the scaling operation defines the resources as taught by Garimella. Incorporating the methods of Garimella may enable data to be accessed more efficiently and prevent data loss (see Garimella: [0003]).
Regarding claim 4, the combination of Li in view of Garimella teaches The method of claim 3.
Li further teaches based on an optimization of capacity of the one or more particular pods ([55] – “the metrics are status and scale subresources of a custom metric and these metrics are usage metrics […] The status and scale metrics provide usage information such as average utilization or average value for processing and memory resources of a system object”; [58] – “Using the received values at block 410, the autoscaler compares the received current metric value or values, if there are more than one, to desired metric values, such as a desired utilization. These desired values may be desired for optimal operation, resource allocation, or other purposes”).
Li fails to expressly teach wherein the one or more particular pods are selected for binding to the placeholder node relative to the resources to be allocated to the assigned node
However, Garimella teaches wherein the one or more particular pods are selected for binding to the placeholder node relative to the resources to be allocated to the assigned node ([0014] – “Moreover, a storage service may be allowed to scale up as a placeholder service can be scaled in proportion to the storage service in order to provide additional VMs with local volumes that can be used by new deployments of storage applications of the storage service”; [0025] – “volume objects 220 can allow for orchestration service 140 to determine what storage resources exist in target environment 110 and are available for use by containers 120 and 130 that have not yet been deployed”; [0026] – “If there is a set of available volumes 210 that satisfy that volume claim 230, then orchestration service 140 may bind the set volume objects 220 (representing those volumes 210) to volume claim 230 […] the container 120/130 may utilize the underlying set of volumes 210”).
Li and Garimella are considered to be analogous art to the claimed invention because they are in the same field as the claimed invention of application containers. Therefore, it would have been obvious to one of ordinary skill in the art to have modified the methods of Li to incorporate selecting a pod relative to the assigned node such that the node’s resource requirement is satisfied after binding as taught by Garimella. Incorporating the methods of Garimella may enable data to be accessed more efficiently and prevent data loss (see Garimella: [0003]).
Regarding claim 5, the combination of Li in view of Garimella teaches The method of claim 1.
Garimella further teaches wherein binding the one or more particular pods to the placeholder nodes while the assigned node is instantiated prevents cleanup of the one or more particular pods by a Kubernetes control plane ([0009] – “An issue arises, however, if the storage application crashes and is not coupled to the VM since Kubernetes is likely to deploy that storage application on a different VM with a different local storage. As a result, the work spent filling the local storage of the former VM is worthless as the storage application is not able to use that local storage anymore. It may thus be desirable to couple a storage application server to a VM”; [0035] – “orchestration service 140 performs garbage collection in which it reviews containers 120 and 130 and their deployment objects 150 and volumes objects 220 and deletes volume objects 220 that do not have a backing node 320 or external volume 330 anymore”).
Li and Garimella are considered to be analogous art to the claimed invention because they are in the same field as the claimed invention of application containers. Therefore, it would have been obvious to one of ordinary skill in the art to have modified the methods of Li to incorporate the prevention of Kubernetes control plane cleanup such that premature deletion of required resources is avoided as taught by Garimella. Incorporating the methods of Garimella may enable data to be accessed more efficiently and prevent data loss (see Garimella: [0003]).
Regarding claim 6, the combination of Li in view of Garimella teaches The method of claim 1.
Li further teaches wherein the arbiter pod executes on instructions by making application programming interface (API) calls to a Kubernetes control plane ([33] – “The operator 330 interacts with the Kubernetes API server 318 and an infrastructure API server 336”)
Li fails to expressly teach that effect generate, bind, and clear instructions.
However, Garimella teaches that effect generate, bind, and clear instructions ([0020] – “In various embodiments, deploy application requests 142 and deploy placeholder requests 144 are received (e.g., from users) via the API service.”; [0022] – “During operations, orchestration service 140 may receive a deploy application request 142 to deploy an application container 120. That request may specify characteristics pertaining to that application container 120, such as the application to deploy and the resources 115 to be used.”; [0028] – “As depicted, orchestration service 140 receives a deploy placeholder request 144. […] In response, orchestration service 140 may determine if there are available resources 115 (e.g., by examining volume objects 220) on which to deploy the placeholder container 130. If there are sufficient resources 115, then orchestration service 140 may bind the placeholder container 130 to the desired resources 115 (e.g., bind deployment object 150A to a volume object 220) and then deploy it onto those resources 115.”; [0035] – “deleting the binding between that volume object 220 and a volume claim 230 […] In response to deleting those bindings or as a part of deleting those bindings, orchestration service 140 may update the state 154 […] to indicate that the deployment of the placeholder container 130 […] has returned to the pending state”).
Li and Garimella are considered to be analogous art to the claimed invention because they are in the same field as the claimed invention of application containers. Therefore, it would have been obvious to one of ordinary skill in the art to have modified the methods of Li to incorporate the generate, bind and clear instructions such that the API service effects these instructions as taught by Garimella. Incorporating the methods of Garimella may enable data to be accessed more efficiently and prevent data loss (see Garimella: [0003]).
Regarding claim 7, the combination of Li in view of Garimella teaches The method of claim 6.
Li further teaches wherein the arbiter pod is within the Kubernetes control plane ([30] – “operator 330 which may be implemented on a control plane”; [54] – “the operator 330 may be implemented in the control plane 104”).
Regarding claim 8, the combination of Li in view of Garimella teaches The method of claim 7.
Li further teaches wherein the arbiter pod receives instructions from an entity acting outside of the Kubernetes control plane ([33] – “The operator 330 interacts with the Kubernetes API server 318 and an infrastructure API server 336”; FIG. 3).
Regarding claim 9, the combination of Li in view of Garimella teaches The method of claim 1.
Garimella further teaches wherein the placeholder node is instantiated and the one or more particular pods are bound in a timeframe that is faster than the assigned node being instantiated (FIG. 3A – 3C; [0019] – “the deployment of a placeholder container 130 can cause a set of additional resources 115 to be provisioned to target environment 110 on which to deploy an application container 120. [...] The difference in their deployment modes 152 causes resources 115 to be provisioned for a placeholder container 130 but not an application container 120 during their respective deployments”).
Li and Garimella are considered to be analogous art to the claimed invention because they are in the same field as the claimed invention of application containers. Therefore, it would have been obvious to one of ordinary skill in the art to have modified the methods of Li to incorporate the timeframe such that the placeholder node and resources are bound quicker than the assigned node is made available as taught by Garimella. Incorporating the methods of Garimella may enable data to be accessed more efficiently and prevent data loss (see Garimella: [0003]).
Regarding claim 10, the combination of Li in view of Garimella teaches The method of claim 1.
Li further teaches wherein determining that a scaling operation is to be performed comprises automatically detecting that an existing operation has experienced a load demand that requires one or more additional nodes ([52] – “The Edge Custom Resource, which has been defined to relate to a number of Edge VMs, will be scaled by the number for “externalmetric-A.” In this example, the “external metric-A” is set as less than or equal to 30 on average per Edge VM. In the example below, the “externalmetric-A” is aggregated and the result that is reported by the API to the control plane is 42. To achieve the target of 30, another Edge VM is needed. The autoscaler adjusts the value of the desired scale replica from 1 to 2”; [60] – “Using this comparison, at block 414, the autoscaler automatically scales a preselected system object as defined by the resource. The change in the preselected object may be made by an operator”).
Regarding claim 12, the combination of Li in view of Garimella teaches The method of claim 1.
Li further teaches wherein pod is a Kubernetes pod ([12] – “The Kubernetes (K8s) architecture for a server system is designed to be highly extensible and modular […] K8s operators are software extensions that make use of custom resources to manage applications and their components.””; Examiner notes that the operator is a software pattern/logic and a pod is a Kubernetes object that can run the operator process).
Regarding claim 13, Li teaches A non-transitory computer-readable medium comprising memory (system memories 216) with instructions thereon that, when executed by one or more processors (one or more processors 214), cause the one or more processors to perform operations, the instructions comprising instructions to: select a pod to act as an arbiter pod that controls pod allocation for nodes from a plurality of candidate pods ([30] – “The autoscaling operations are driven by an operator 330 which may be implemented on a control plane or other node. […] The operator is also coupled to one or more implementations of control plane nodes 320 through a Kubernetes API server 318.”; [33] – “The operator 330 interacts with the Kubernetes API server 318 and an infrastructure API server 336 […] to manage corresponding infrastructure object lifecycles.”; [15] – “The worker nodes run containerized applications by hosting pods. Pods are the components of the application workload.”);
responsive to determining that a scaling operation is to be performed ([43] – “The operator 330 reads the expected value for the scale subresource 328 from its managed custom resource 326, and the current scale subresource number from the infrastructure 334. It is then able to reconcile the gap between the two scale subresource values by actively creating or destroying the corresponding infrastructure resource VMs 350, 352.”; [56] – “an operator […] sends an API request for the system metric values to the metric server”; [58] – “using the received values at block 410, the autoscaler compares the received current metric value […] to desired metric values”),
Li fails to expressly teach instruct the arbiter pod to generate a placeholder node while an assigned node is instantiated;
instruct the arbiter pod to bind one or more particular pods to the placeholder node;
and responsive to determining that the assigned node is instantiated, instruct the arbiter pod to clear the placeholder node.
However, Garimella teaches instruct the arbiter pod to generate a placeholder node while an assigned node is instantiated ([0013] – “the orchestration service receives a request to deploy, for a placeholder service, a placeholder container onto resources of the target environment. The deployment of the placeholder container is carried out in a second mode (e.g., a “provisioner” mode) in which the orchestration service allocates resources for the placeholder container's deployment”; [0019] – “A placeholder container 130, in various embodiments, is a container whose deployment allows for one or more application containers 120 to be deployed. A placeholder container 130 may include an application that provides a service, a dummy application that does not provide any meaningful functionality, or no application at all”; [0033] – “In some embodiments, a single deploy application request 142 causes the deployment of an application container 120 and a placeholder container 130”);
instruct the arbiter pod to bind one or more particular pods to the placeholder node ([0022] – “Orchestration service 140 may receive a deploy placeholder request 144 to deploy a placeholder container 130. Accordingly, orchestration service 140 may create (or receive) a deployment object 150 for the placeholder container 130. If the resources 115 that are requested for the placeholder container 130 are not available in target environment 110, then orchestration service 140 may allocate the requested resources 115 as the deployment mode 152 for the placeholder container 130 may facilitate it. Orchestration service 140 may then deploy the placeholder container 130 onto those allocated resources 115. In many cases, the allocated resources 115 include resources 115 requested for application container 120.”; [0028] – “In response, orchestration service 140 may determine if there are available resources 115 (e.g., by examining volume objects 220) on which to deploy the placeholder container 130. If there are sufficient resources 115, then orchestration service 140 may bind the placeholder container 130 to the desired resources 115 (e.g., bind deployment object 150A to a volume object 220) and then deploy it onto those resources 115.”; [0030] – “After receiving a provision resources request 305, in various embodiments, resource provisioner service 310 allocates a node 320 [...] to target environment 110.”);
and responsive to determining that the assigned node is instantiated, instruct the arbiter pod to clear the placeholder node ([0034] – “After deploying the application container 120, orchestration service 120 may update the state 154 of deployment object 150B to indicate that the application container 120 has been deployed and its deployment is no longer pending.”; [0035] – “Thus, in various embodiments, orchestration service 140 performs garbage collection in which it reviews containers 120 and 130 and their deployment objects 150 and volume objects 220 and deletes volume objects 220 that do not have a backing node 320 or external volume 330 anymore. Deleting a volume object 220 may include deleting the binding between that volume object 220 and a volume claim 230.”).
Li and Garimella are considered to be analogous art to the claimed invention because they are in the same field as the claimed invention of application containers. Therefore, it would have been obvious to one of ordinary skill in the art to have modified the methods of Li to incorporate the placeholder service such that the placeholder can reserve resources for the assigned service as taught by Garimella. Incorporating the methods of Garimella may enable data to be accessed more efficiently and prevent data loss (see Garimella: [0003]).
Regarding claim 20, Li teaches A system ([22] – “FIG. 2 illustrates a distributed containerized processing system 200”) comprising: a non-transitory computer-readable medium comprising memory (system memories 216) with instructions encoded thereon; and one or more processors (one or more processors 214) that, when executing the instructions, are caused to perform operations comprising:
selecting a pod to act as an arbiter pod that controls pod allocation for nodes from a plurality of candidate pods ([30] – “The autoscaling operations are driven by an operator 330 which may be implemented on a control plane or other node. […] The operator is also coupled to one or more implementations of control plane nodes 320 through a Kubernetes API server 318.”; [33] – “The operator 330 interacts with the Kubernetes API server 318 and an infrastructure API server 336 […] to manage corresponding infrastructure object lifecycles.”; [15] – “The worker nodes run containerized applications by hosting pods. Pods are the components of the application workload.”);
responsive to determining that a scaling operation is to be performed ([43] – “The operator 330 reads the expected value for the scale subresource 328 from its managed custom resource 326, and the current scale subresource number from the infrastructure 334. It is then able to reconcile the gap between the two scale subresource values by actively creating or destroying the corresponding infrastructure resource VMs 350, 352.”; [56] – “an operator […] sends an API request for the system metric values to the metric server”; [58] – “using the received values at block 410, the autoscaler compares the received current metric value […] to desired metric values”),
Li fails to expressly teach instructing the arbiter pod to generate a placeholder node while an assigned node is instantiated;
instructing the arbiter pod to bind one or more particular pods to the placeholder node;
and responsive to determining that the assigned node is instantiated, instructing the arbiter pod to clear the placeholder node.
However, Garimella teaches instructing the arbiter pod to generate a placeholder node while an assigned node is instantiated ([0013] – “the orchestration service receives a request to deploy, for a placeholder service, a placeholder container onto resources of the target environment. The deployment of the placeholder container is carried out in a second mode (e.g., a “provisioner” mode) in which the orchestration service allocates resources for the placeholder container's deployment”; [0019] – “A placeholder container 130, in various embodiments, is a container whose deployment allows for one or more application containers 120 to be deployed. A placeholder container 130 may include an application that provides a service, a dummy application that does not provide any meaningful functionality, or no application at all”; [0033] – “In some embodiments, a single deploy application request 142 causes the deployment of an application container 120 and a placeholder container 130”);
instructing the arbiter pod to bind one or more particular pods to the placeholder node ([0022] – “Orchestration service 140 may receive a deploy placeholder request 144 to deploy a placeholder container 130. Accordingly, orchestration service 140 may create (or receive) a deployment object 150 for the placeholder container 130. If the resources 115 that are requested for the placeholder container 130 are not available in target environment 110, then orchestration service 140 may allocate the requested resources 115 as the deployment mode 152 for the placeholder container 130 may facilitate it. Orchestration service 140 may then deploy the placeholder container 130 onto those allocated resources 115. In many cases, the allocated resources 115 include resources 115 requested for application container 120.”; [0028] – “In response, orchestration service 140 may determine if there are available resources 115 (e.g., by examining volume objects 220) on which to deploy the placeholder container 130. If there are sufficient resources 115, then orchestration service 140 may bind the placeholder container 130 to the desired resources 115 (e.g., bind deployment object 150A to a volume object 220) and then deploy it onto those resources 115.”; [0030] – “After receiving a provision resources request 305, in various embodiments, resource provisioner service 310 allocates a node 320 [...] to target environment 110.”);
and responsive to determining that the assigned node is instantiated, instructing the arbiter pod to clear the placeholder node ([0034] – “After deploying the application container 120, orchestration service 120 may update the state 154 of deployment object 150B to indicate that the application container 120 has been deployed and its deployment is no longer pending.”; [0035] – “Thus, in various embodiments, orchestration service 140 performs garbage collection in which it reviews containers 120 and 130 and their deployment objects 150 and volume objects 220 and deletes volume objects 220 that do not have a backing node 320 or external volume 330 anymore. Deleting a volume object 220 may include deleting the binding between that volume object 220 and a volume claim 230.”).
Li and Garimella are considered to be analogous art to the claimed invention because they are in the same field as the claimed invention of application containers. Therefore, it would have been obvious to one of ordinary skill in the art to have modified the methods of Li to incorporate the placeholder service such that the placeholder can reserve resources for the assigned service as taught by Garimella. Incorporating the methods of Garimella may enable data to be accessed more efficiently and prevent data loss (see Garimella: [0003]).
Claims 14-19 recite substantially the same limitations as those recited in claims 2-7. As such, claims 14-19 are rejected as being unpatentable over Li in view of Garimella for the same reasons presented with respect to claims 2-7.
Claim 11 is rejected under 35 U.S.C. 103 as being unpatentable over Li in view of Garimella, and further in view of Mariappan et al. (U.S. Pub. No. 2022/0278927 A1), hereinafter Mariappan.
Regarding claim 11, the combination of Li in view of Garimella teaches The method of claim 1, wherein the assigned node was previously instantiated, and wherein the method further comprises:
Li fails to expressly teach instructing the arbiter pod to drain the one or more particular pods;
and instructing the arbiter pod to monitor for re-creation of the one or more particular pods using a webhook, wherein the arbiter pod, upon detecting re-creation of the one or more particular pods, pins the one or more particular pods to the assigned node upon re-creation.
However, Garimella teaches instructing the arbiter pod to drain the one or more particular pods ([0035] – “Thus, in various embodiments, orchestration service 140 performs garbage collection in which it reviews containers 120 and 130 and their deployment objects 150 and volume objects 220 and deletes volume objects 220 that do not have a backing node 320 or external volume 330 anymore. Deleting a volume object 220 may include deleting the binding between that volume object 220 and a volume claim 230. [...] In response to deleting those bindings or as a part of deleting those bindings, orchestration service 140 may update the state 154 of both deployment objects 150A and 150B to indicate that the deployment of the placeholder container 130 and the application container 120 has returned to the pending state”);
wherein the arbiter pod, upon detecting re-creation of the one or more particular pods, pins the one or more particular pods to the assigned node upon re-creation ([0022] – “Orchestration service 140 may detect that the application container 120 is pending and that its requested resources 115 are available. As such, orchestration service 140 may deploy the application container 120 onto the resources 115 that were provisioned for the placeholder container 130.”).
Li and Garimella are considered to be analogous art to the claimed invention because they are in the same field as the claimed invention of application containers. Therefore, it would have been obvious to one of ordinary skill in the art to have modified the methods of Li to incorporate the draining and pinning of pods upon re-creation such that the recreated pods are pinned to their assigned node as taught by Garimella. Incorporating the methods of Garimella may enable data to be accessed more efficiently and prevent data loss (see Garimella: [0003]).
However, Mariappan teaches and instructing the arbiter pod to monitor for re-creation of the one or more particular pods using a webhook ([0119] – “For instance, the components may implement an http callback with an API provided by kubernetes. The components may use a mutating admission webhook if it is intended to modify the resource object. […] The webhook is register with the API server 320 with rules, for an example rule: on a pod create. On an event, if there is a match to rules registered, API server 320 will initiate a call to the webhook defined and pass the resource object to defined handler function. Action on the kubernetes resource object will be taken as the webhook type used.”),
Li and Mariappan are considered to be analogous art to the claimed invention because they are in the same field as the claimed invention of containerization. Therefore, it would have been obvious to one of ordinary skill in the art to have modified the methods of Li to incorporate the webhook monitoring such that the arbiter pod uses a callback with rules to find created pods as taught by Mariappan. Incorporating the methods of Mariappan may simplify the definitions the user needs to do and reduce errors (see Mariappan: [0121]).
Conclusion
The prior art made of record and not relied upon is considered pertinent to applicant's disclosure.
Gonzalez et al. (US 2020/0310881 A1) teaches a method for automatically adding or removing compute machines based on how much work is waiting to run with a goal to react faster than traditional gradual auto-scalers (see [0004]-[0005], [0019])
CURTIS et al. (US 2019/0095253 A1) teaches a method for updating an application in a Kubernetes cluster without exposing the cluster to outside access using a short-lived temporary update-monitor pod (see [0006]-[0007], [0011])
Cai et al. (US 10831557 B2) teaches a method to manage task allocation in a distributed computing system by introducing a virtual node to reduce pressure on real nodes (see Abstract, [0053]-[0055])
Mašnauskas et al. (US 11595306 B2) teaches a method to run workloads across multiple cloud providers as if they were part of one connected environment (see Abstract, [0003]-[0004])
Wang et al. (US 2024/0086225 A1) teaches a method for scheduling groups of container pods in a Kubernetes-style cluster by grouping pods into equivalence classes: scheduling each pod group as a unit to improve efficiency (see Abstract, [0007], [0025])
MITKAR et al. (US 2023/0043336 A1) teaches a method for scaling backup workers in Kubernetes using a coordinator data agent inside the cluster where agents run as containers in pods (see Abstract, [0005]-[0007], [0096])
Any inquiry concerning this communication or earlier communications from the examiner should be directed to Julianne C. LaPointe whose telephone number is (571)270-5457. The examiner can normally be reached M - T: 7:30am - 5pm ET.
Examiner interviews are available via telephone, in-person, and video conferencing using a USPTO supplied web-based collaboration tool. To schedule an interview, applicant is encouraged to use the USPTO Automated Interview Request (AIR) at http://www.uspto.gov/interviewpractice.
If attempts to reach the examiner by telephone are unsuccessful, the examiner’s supervisor, Kevin Young can be reached at (571) 270-3180. The fax phone number for the organization where this application or proceeding is assigned is 571-273-8300.
Information regarding the status of published or unpublished applications may be obtained from Patent Center. Unpublished application information in Patent Center is available to registered users. To file and manage patent submissions in Patent Center, visit: https://patentcenter.uspto.gov. Visit https://www.uspto.gov/patents/apply/patent-center for more information about Patent Center and https://www.uspto.gov/patents/docx for information about filing in DOCX format. For additional questions, contact the Electronic Business Center (EBC) at 866-217-9197 (toll-free). If you would like assistance from a USPTO Customer Service Representative, call 800-786-9199 (IN USA OR CANADA) or 571-272-1000.
/JULIANNE CATHERINE LAPOINTE/Examiner, Art Unit 2194 /KEVIN L YOUNG/Supervisory Patent Examiner, Art Unit 2194
