Procedure

1. Gather a list of relevant container images to pull. See Section 2.7, “Review the default images cached by Image Puller”.

2. Define the memory requests and limits parameters to ensure pulled containers and the platform have enough memory to run.

   When defining the minimal value for CACHING_MEMORY_REQUEST or CACHING_MEMORY_LIMIT, consider the necessary amount of memory required to run each of the container images to pull.

   When defining the maximal value for CACHING_MEMORY_REQUEST or CACHING_MEMORY_LIMIT, consider the total memory allocated to the DaemonSet Pods in the cluster:

   (memory limit) * (number of images) * (number of nodes in the cluster)

   Copy code to clipboard

   Pulling 5 images on 20 nodes, with a container memory limit of 20Mi requires 2000Mi of memory.

3. Clone the Image Puller repository and get in the directory containing the OpenShift templates:

   git clone https://github.com/che-incubator/kubernetes-image-puller
   cd kubernetes-image-puller/deploy/openshift

   Copy code to clipboard

4. Configure the app.yaml, configmap.yaml, and serviceaccount.yaml OpenShift templates using the following parameters:

   Table 2.1. Image Puller OpenShift templates parameters in app.yaml

   Value	Usage	Default
   DEPLOYMENT_NAME	The value of DEPLOYMENT_NAME in the ConfigMap	kubernetes-image-puller
   IMAGE	Image used for the kubernetes-image-puller deployment	registry.redhat.io/devspaces/imagepuller-rhel8
   IMAGE_TAG	The image tag to pull	latest
   SERVICEACCOUNT_NAME	The name of the ServiceAccount created and used by the deployment	kubernetes-image-puller

   Table 2.2. Image Puller OpenShift templates parameters in configmap.yaml

   Value	Usage	Default
   CACHING_CPU_LIMIT	The value of CACHING_CPU_LIMIT in the ConfigMap	.2
   CACHING_CPU_REQUEST	The value of CACHING_CPU_REQUEST in the ConfigMap	.05
   CACHING_INTERVAL_HOURS	The value of CACHING_INTERVAL_HOURS in the ConfigMap	"1"
   CACHING_MEMORY_LIMIT	The value of CACHING_MEMORY_LIMIT in the ConfigMap	"20Mi"
   CACHING_MEMORY_REQUEST	The value of CACHING_MEMORY_REQUEST in the ConfigMap	"10Mi"
   DAEMONSET_NAME	The value of DAEMONSET_NAME in the ConfigMap	kubernetes-image-puller
   DEPLOYMENT_NAME	The value of DEPLOYMENT_NAME in the ConfigMap	kubernetes-image-puller
   IMAGES	The value of IMAGES in the ConfigMap	{}
   NAMESPACE	The value of NAMESPACE in the ConfigMap	k8s-image-puller
   NODE_SELECTOR	The value of NODE_SELECTOR in the ConfigMap	"{}"

   Table 2.3. Image Puller OpenShift templates parameters in serviceaccount.yaml

   Value	Usage	Default
   SERVICEACCOUNT_NAME	The name of the ServiceAccount created and used by the deployment	kubernetes-image-puller
   KIP_IMAGE	The image puller image to copy the sleep binary from	registry.redhat.io/devspaces/imagepuller-rhel8:latest

5. Create an OpenShift project to host the Image Puller:

   oc new-project <k8s-image-puller>

   Copy code to clipboard

6. Process and apply the templates to install the puller:

   oc process -f serviceaccount.yaml | oc apply -f -
   oc process -f configmap.yaml | oc apply -f -
   oc process -f app.yaml | oc apply -f -

   Copy code to clipboard

Verification

1. Verify the existence of a <kubernetes-image-puller> deployment and a <kubernetes-image-puller> DaemonSet. The DaemonSet needs to have a Pod for each node in the cluster:

   oc get deployment,daemonset,pod --namespace <k8s-image-puller>

   Copy code to clipboard

2. Verify the values of the <kubernetes-image-puller> ConfigMap.

   oc get configmap <kubernetes-image-puller> --output yaml

   Copy code to clipboard

Procedure

1. Install the Kubernetes Image Puller Operator. See This page is not included, but the link has been rewritten to point to the nearest parent document.Installing from OperatorHub using the web console.
2. Create a KubernetesImagePuller operand from the Kubernetes Image Puller Operator. See Creating applications from installed Operators.

Procedure

1. Configure the Image Puller to pre-pull OpenShift Dev Spaces images.

   oc patch checluster/devspaces \
       --namespace openshift-devspaces \
       --type='merge' \
       --patch '{
                 "spec": {
                   "components": {
                     "imagePuller": {
                       "enable": true
                     }
                   }
                 }
               }'

   Copy code to clipboard

Procedure

1. Configure the Image Puller to pre-pull custom images.

   oc patch checluster/devspaces \
       --namespace openshift-devspaces \
       --type='merge' \
       --patch '{
                 "spec": {
                   "components": {
                     "imagePuller": {
                       "enable": true,
                       "spec": {
                         "images": "NAME-1=IMAGE-1;NAME-2=IMAGE-2"
                       }
                     }
                   }
                 }
               }'

   Copy code to clipboard

   where:

   images

   The semicolon-separated list of images in name=image format.

Procedure

1. Create k8s-image-puller namespace:

   oc create namespace k8s-image-puller

   Copy code to clipboard

2. Create KubernetesImagePuller Custom Resource:

   oc apply -f - <<EOF
   apiVersion: che.eclipse.org/v1alpha1
   kind: KubernetesImagePuller
   metadata:
     name: k8s-image-puller-images
     namespace: k8s-image-puller
   spec:
     images: "NAME-1=IMAGE-1;NAME-2=IMAGE-2"
   EOF

   Copy code to clipboard

   where:

   images

   The semicolon-separated list of images in name=image format.

Procedure

1. Determine the namespace where the OpenShift Dev Spaces Operator is deployed:

   OPERATOR_NAMESPACE=$(oc get pods -l app.kubernetes.io/component=devspaces-operator -o jsonpath={".items[0].metadata.namespace"} --all-namespaces)

   Copy code to clipboard

2. Determine the images that can be pre-pulled by the Image Puller:

   oc exec -n $OPERATOR_NAMESPACE deploy/devspaces-operator -- cat /tmp/external_images.txt

   Copy code to clipboard

Procedure

1. Create an HPA resource for a deployment, specifying the target metrics and desired replica count.

   apiVersion: autoscaling/v2
   kind: HorizontalPodAutoscaler
   metadata:
     name: scaler
     namespace: openshift-devspaces
   spec:
     scaleTargetRef:
       apiVersion: apps/v1
       kind: Deployment
       name: <deployment_name>
     ...

   Copy code to clipboard

   where:

   <deployment_name>

   One of the following deployments:

   • devspaces
   • che-gateway
   • devspaces-dashboard
   • plugin-registry

   • devfile-registry

     For example:

     apiVersion: autoscaling/v2
     kind: HorizontalPodAutoscaler
     metadata:
       name: devspaces-scaler
       namespace: openshift-devspaces
     spec:
       scaleTargetRef:
         apiVersion: apps/v1
         kind: Deployment
         name: devspaces
       minReplicas: 2
       maxReplicas: 5
       metrics:
         - type: Resource
           resource:
             name: cpu
             target:
               type: Utilization
               averageUtilization: 75

     Copy code to clipboard

     In this example, the HPA targets the devspaces deployment with a minimum of 2 replicas, a maximum of 5 replicas, and scales based on CPU utilization.

Procedure

1. Set the startup timeout and event handling in the CheCluster Custom Resource to handle autoscaler node additions:

   spec:
     devEnvironments:
       startTimeoutSeconds: 600
       ignoredUnrecoverableEvents:
         - FailedScheduling

   Copy code to clipboard

   where:

   startTimeoutSeconds

   Set to at least 600 seconds to allow time for a new node to be provisioned during workspace startup.

   ignoredUnrecoverableEvents

   Ignore the FailedScheduling event to allow workspace startup to continue when a new node is provisioned. This setting is enabled by default.

2. Add the safe-to-evict annotation to the CheCluster Custom Resource to prevent workspace pod eviction when the autoscaler removes a node:

   spec:
     devEnvironments:
       workspacesPodAnnotations:
         cluster-autoscaler.kubernetes.io/safe-to-evict: "false"

   Copy code to clipboard

Procedure

1. Verify that OpenShift Dev Spaces server components are running with the expected replica count:

   $ oc get deployment -n openshift-devspaces \
     -o custom-columns='NAME:.metadata.name,REPLICAS:.spec.replicas,AVAILABLE:.status.availableReplicas'

   Copy code to clipboard

   All components should show the configured number of replicas in the AVAILABLE column.

2. If you enabled the Kubernetes Image Puller, verify that the DaemonSet is running on all schedulable nodes:

   $ oc get daemonset -n openshift-devspaces -l app=kubernetes-image-puller

   Copy code to clipboard

   The DESIRED and READY columns should show the same number, matching your schedulable node count.

3. Verify that the pre-cached images are present on a node by checking the DaemonSet pod logs:

   $ oc logs -n openshift-devspaces -l app=kubernetes-image-puller --tail=5

   Copy code to clipboard
4. Start a workspace and observe the startup time. With image pre-caching enabled, workspaces on nodes that have the DaemonSet pod should start within 30 seconds.

5. Verify overall platform health:

   $ oc get pods -n openshift-devspaces -o custom-columns='NAME:.metadata.name,READY:.status.containerStatuses[*].ready,STATUS:.status.phase'

   Copy code to clipboard

   All pods should show Running status with all containers ready.