The WORKDIR instruction sets the working directory for all subsequent RUN, CMD, ENTRYPOINT,

COPY, and ADD instructions in the Dockerfile. This means that after specifying WORKDIR, all these

instructions will use the specified directory as their current working directory.

To authenticate with the Oracle Cloud Infrastructure Registry (Container Registry) when using the

Docker CLI, you need to use an Auth Token. The Auth Token is created in the OCI console and acts as

a password for the Docker login command, providing secure access to the container registry.

The OKE Cluster Autoscaler automatically adjusts the number of worker nodes in an OKE cluster

based on the resource requests made by Kubernetes pods. When there are not enough resources

available (e.g., CPU or memory) on existing nodes to accommodate pending pods, the Cluster

Autoscaler will create new nodes to meet the resource demand.

Step 1: Understanding the Requirement

The goal is to ensure reliable operations of Kubernetes at scale while minimizing the operational

overhead of managing worker node infrastructure. In this context, a solution is needed that abstracts

away the complexity of managing, scaling, and maintaining worker nodes.

Step 2: Explanation of the Options

A . Using OCI OKE managed nodes with cluster autoscalers

While this option provides managed node pools and uses cluster autoscalers to adjust resources

based on demand, it still requires some level of management for the underlying worker nodes (e.g.,

patching, upgrading, monitoring).

Operational overhead: Moderate.

B . Using OCI OKE virtual nodes

Virtual nodes in OCI OKE are a serverless option for running Kubernetes pods. They remove the need

to manage underlying worker nodes entirely.

OCI provisions resources dynamically, allowing scaling based purely on pod demand.

There’s no need for node management, patching, or infrastructure planning, which perfectly aligns

with the requirement to minimize operational overhead.

Operational overhead: Minimal.

Best Fit for This Scenario: Since the requirement emphasizes minimizing operational overhead, this is

the ideal solution.

C . Using Kubernetes cluster add-ons to automate worker node management

Kubernetes add-ons like Cluster Autoscaler or Node Problem Detector help in automating some

aspects of worker node management. However, this still requires managing worker node

infrastructure at the core level.

Operational overhead: Moderate to high.

D . Creating and managing worker nodes using OCI compute instances

This involves manually provisioning and managing compute instances for worker nodes, including

scaling, patching, and troubleshooting.

Operational overhead: High.

Not Suitable for the Requirement: This option contradicts the goal of minimizing operational

overhead.

Step 3: Why Virtual Nodes Are the Best Fit

Virtual Nodes in OCI OKE:

Virtual nodes provide serverless compute for Kubernetes pods, allowing users to run workloads

without provisioning or managing worker node infrastructure.

Scaling: Pods are automatically scheduled, and the required infrastructure is dynamically provisioned

behind the scenes.

Cost Efficiency: You only pay for the resources consumed by the running workloads.

Use Case Alignment: Eliminating the burden of worker node infrastructure management while

ensuring Kubernetes reliability at scale.

Step 4:

and OCI Resources

OCI Documentation:

OCI Kubernetes Virtual Nodes

OCI Container Engine for Kubernetes Overview

Best Practices for Kubernetes on OCI:

Best Practices for OCI Kubernetes Clusters

To run applications on GPU worker nodes in Oracle Kubernetes Engine (OKE), you need to:

Select a managed node pool and choose a GPU shape for the worker nodes.

Use a GPU image that has the necessary CUDA libraries pre-installed to ensure that GPU workloads

can be executed properly.

In the pod specification, specify the number of GPU resources required for the container to utilize the

GPU hardware during execution. This allows Kubernetes to schedule the pod on a node with an

available GPU.

The correct approach to upgrade an Oracle Container Engine for Kubernetes (OKE) cluster involves

first upgrading the Kubernetes control plane, followed by upgrading the node pools. The control

plane must be upgraded first to ensure compatibility with newer versions of Kubernetes, as node

pools rely on the control plane for orchestration and management.

After upgrading the control plane, each node pool is upgraded to match the new Kubernetes version.

This phased approach ensures the cluster remains in a stable state during the upgrade.

Essential cluster add-ons are required for the basic functioning of the Kubernetes cluster and cannot

be disabled during cluster creation. These add-ons provide necessary features such as core DNS,

networking, and other critical functionalities for the cluster's operation.

Virtual nodes in OKE provide a serverless experience for deploying Kubernetes workloads, which

means you do not have to manage or scale the underlying infrastructure. This solution is particularly

cost-efficient because you only pay for the resources used by the pods, and it provides strong

isolation for workloads.

Virtual nodes are well suited for AI/ML workloads as they allow users to easily scale compute

resources without being constrained by the limits of individual worker nodes.

By implementing each module as an independent service/process (which is a core feature of

microservices architecture), you can replace, update, or delete services without affecting the rest of

the application. This ensures deployment independence and makes it easier to adapt to architecture

changes or technology upgrades without major disruptions.

Microservices architecture allows each service to be built with the best-suited technology stack for

its specific function. This flexibility ensures that you are not tied to a single technology for the entire

application, making future technology upgrades easier and eliminating long-term technology

commitments.